diff --git a/.prettierignore b/.prettierignore
index 189edadc..f803711c 100644
--- a/.prettierignore
+++ b/.prettierignore
@@ -4,6 +4,11 @@ coverage
 node_modules
 package-lock.json
 
+# Local per-task worktrees (git worktree add .worktrees/<name>) carry full
+# copies of the tree, each formatted against its own branch state; checking
+# them here makes format:check walk and flag four extra repos.
+.worktrees
+
 # Vendored Keycloak theme. `keycloakify sync-extensions` runs on every
 # `npm install` and rewrites everything except the handful of "owned" files
 # listed in src/keycloak-theme/.gitignore — formatting the rest is churn that
diff --git a/eslint.config.js b/eslint.config.js
index 5ca7c1ef..8053fb84 100644
--- a/eslint.config.js
+++ b/eslint.config.js
@@ -17,6 +17,7 @@ export default defineConfig([
     "public/keycloak-theme/**",
     "public/keycloakify-dev-resources/**",
     "storybook-static/**",
+    ".worktrees/**",
   ]),
 
   {
diff --git a/src/App.tsx b/src/App.tsx
index 1b858746..03b2f11f 100644
--- a/src/App.tsx
+++ b/src/App.tsx
@@ -108,7 +108,15 @@ function AppContent() {
         {/* `data-moment-stage`: the area the page-scoped moments (the
           onboarding launch and landing) cover, instead of the whole
           screen — see momentStage.ts in the moments feature. */}
-        <main data-moment-stage className="relative min-h-screen min-w-0 flex-1 pt-[64px] lg:pt-0">
+        <main
+          data-moment-stage
+          className={`relative min-h-screen min-w-0 flex-1 pt-[64px] lg:pt-0 ${
+            // The sidebar is `fixed` from `lg` up (see SideBar), so it is out of
+            // flow and the page has to leave its width free itself. In focus mode
+            // it slides away over the content, so the margin goes with it.
+            signedIn && !isFocused ? "lg:ml-[var(--app-sidebar-width)]" : ""
+          }`}
+        >
           <AppRouter />
         </main>
 
diff --git a/src/components/layout/DetailsSideDrawer.tsx b/src/components/layout/DetailsSideDrawer.tsx
index d008c528..f1659428 100644
--- a/src/components/layout/DetailsSideDrawer.tsx
+++ b/src/components/layout/DetailsSideDrawer.tsx
@@ -17,6 +17,7 @@ type DetailsSideDrawerProps = {
   contentClassName?: string;
   headerClassName?: string;
   closeAriaLabel?: string;
+  lockScroll?: boolean;
 };
 
 export function DetailsSideDrawer({
@@ -35,6 +36,7 @@ export function DetailsSideDrawer({
   contentClassName = "mx-3 px-3 pb-8 pt-4 sm:mx-5 sm:px-4 sm:pb-10 sm:pt-5 lg:px-5 lg:pt-6",
   headerClassName = "mx-3 px-3 pb-4 pt-4 sm:mx-5 sm:px-4 sm:pb-5 sm:pt-5 lg:px-5 lg:pt-6",
   closeAriaLabel = "Close details",
+  lockScroll = true,
 }: DetailsSideDrawerProps) {
   return (
     <SidePanel
@@ -52,6 +54,7 @@ export function DetailsSideDrawer({
       contentClassName={contentClassName}
       headerClassName={headerClassName}
       closeAriaLabel={closeAriaLabel}
+      lockScroll={lockScroll}
     >
       {children}
     </SidePanel>
diff --git a/src/components/layout/SideBar.tsx b/src/components/layout/SideBar.tsx
index 5a1f8764..b26492a3 100644
--- a/src/components/layout/SideBar.tsx
+++ b/src/components/layout/SideBar.tsx
@@ -460,7 +460,7 @@ export function SideBar() {
     <>
       <aside
         aria-label="Desktop Sidebar"
-        className="sticky top-0 hidden h-screen w-[286px] shrink-0 flex-col border-r border-app-border bg-app-bg lg:flex"
+        className="fixed top-0 bottom-0 left-0 hidden w-[var(--app-sidebar-width)] flex-col border-r border-app-border bg-app-bg lg:flex"
       >
         <SidebarContent
           aria-label="Desktop Navigation"
@@ -510,7 +510,7 @@ export function SideBar() {
         className={[
           // The cubic-bezier is the iOS sheet curve: fast out of the
           // gate, long soft settle — reads as gliding, not snapping.
-          "fixed top-0 bottom-0 left-0 z-[60] flex w-[286px] flex-col border-r border-app-border bg-app-bg transition-transform duration-[420ms] ease-[cubic-bezier(0.32,0.72,0,1)] lg:hidden",
+          "fixed top-0 bottom-0 left-0 z-[60] flex w-[var(--app-sidebar-width)] flex-col border-r border-app-border bg-app-bg transition-transform duration-[420ms] ease-[cubic-bezier(0.32,0.72,0,1)] lg:hidden",
           isMobileSidebarOpen ? "translate-x-0" : "-translate-x-full",
         ].join(" ")}
       >
diff --git a/src/components/ui/MultiSelectFilter.tsx b/src/components/ui/MultiSelectFilter.tsx
index d4141fee..1c23d880 100644
--- a/src/components/ui/MultiSelectFilter.tsx
+++ b/src/components/ui/MultiSelectFilter.tsx
@@ -7,11 +7,12 @@ import {
 } from "react";
 import { createPortal } from "react-dom";
 import { AnimatePresence, motion, useReducedMotion } from "framer-motion";
-import { ChevronDown, SlidersHorizontal } from "lucide-react";
+import { ChevronDown, Search, SlidersHorizontal } from "lucide-react";
 import { Badge } from "./Badge";
 import { Button } from "./Button";
 import { Checkbox } from "./Checkbox";
 import { Collapsible } from "./Collapsible";
+import { Input } from "./Input";
 import { buttonHoverMotion, buttonHoverMotionDisabled } from "../../styles/tokens";
 import { MENU_Z_INDEX, menuTransition, usePopoverMenu } from "./usePopoverMenu";
 
@@ -34,8 +35,24 @@ export type MultiSelectFilterSection<TValue extends string> = {
   id: string;
   label: string;
   options: MultiSelectFilterOption<TValue>[];
+  /**
+   * Adds a filter box above the options once the section holds more than
+   * {@link SECTION_SEARCH_THRESHOLD} of them. A repository list from a large
+   * organisation is otherwise a scroll hunt; a four-option list does not need one.
+   */
+  searchable?: boolean;
+  /**
+   * Shows only the first `visibleLimit` options until the reader presses
+   * "Show all". Ticked options are always shown, wherever they sit in the list,
+   * so a selection can never be hidden behind the fold. Ignored while the
+   * section's filter box holds text: then every match is shown.
+   */
+  visibleLimit?: number;
 };
 
+/** Sections with at most this many options never show a filter box, even when `searchable`. */
+export const SECTION_SEARCH_THRESHOLD = 8;
+
 /** Trigger height, on the same scale as `ui/Field` and `ui/Button`. */
 export type MultiSelectFilterSize = "sm" | "md";
 
@@ -66,6 +83,11 @@ type MultiSelectFilterProps<TValue extends string> = {
    * an inner dropdown/collapsible button.
    */
   collapsible?: boolean;
+  /**
+   * Muted line at the foot of the menu. For what the counts mean, which a
+   * reader otherwise has to guess ("is 12 the total, or what I would get?").
+   */
+  footnote?: string;
   className?: string;
   /** Prefix for the control's `data-testid`s. */
   testId?: string;
@@ -107,6 +129,7 @@ export function MultiSelectFilter<TValue extends string>({
   size = "sm",
   disabled = false,
   collapsible = true,
+  footnote,
   className = "",
   testId = "multiselect-filter",
 }: MultiSelectFilterProps<TValue>) {
@@ -119,6 +142,21 @@ export function MultiSelectFilter<TValue extends string>({
     new Set<string>(),
   );
 
+  // Per-section filter text and "Show all" state, keyed by section id. Both
+  // outlive a close/reopen on purpose: the filter box shows its text, so a
+  // narrowed list is never a mystery.
+  const [sectionQueries, setSectionQueries] = useState<Readonly<Record<string, string>>>({});
+  const [expandedSections, setExpandedSections] = useState<ReadonlySet<string>>(new Set<string>());
+
+  const setSectionExpanded = (sectionId: string, expanded: boolean) => {
+    setExpandedSections((current) => {
+      const next = new Set(current);
+      if (expanded) next.add(sectionId);
+      else next.delete(sectionId);
+      return next;
+    });
+  };
+
   const toggleSection = (sectionId: string) => {
     setCollapsedSections((current) => {
       const next = new Set(current);
@@ -278,6 +316,78 @@ export function MultiSelectFilter<TValue extends string>({
                   </label>
                 );
 
+                const renderSectionBody = () => {
+                  const query = sectionQueries[section.id] ?? "";
+                  const showSearch =
+                    section.searchable === true &&
+                    section.options.length > SECTION_SEARCH_THRESHOLD;
+                  const needle = showSearch ? query.trim().toLowerCase() : "";
+                  const matching = needle
+                    ? section.options.filter((option) =>
+                        option.label.toLowerCase().includes(needle),
+                      )
+                    : section.options;
+                  const limit = section.visibleLimit;
+                  const isOverLimit =
+                    limit !== undefined && needle === "" && matching.length > limit;
+                  const isExpanded = expandedSections.has(section.id);
+                  const visible =
+                    isOverLimit && !isExpanded
+                      ? matching.filter(
+                          (option, index) => index < limit || selected.has(option.value),
+                        )
+                      : matching;
+                  const sectionTestId = `${testId}-section-${section.id}`;
+
+                  return (
+                    <>
+                      {showSearch && (
+                        <div className="px-1 pb-1">
+                          <Input
+                            type="search"
+                            size="sm"
+                            value={query}
+                            onChange={(event) =>
+                              setSectionQueries((current) => ({
+                                ...current,
+                                [section.id]: event.target.value,
+                              }))
+                            }
+                            placeholder={`Filter ${section.label.toLowerCase()}…`}
+                            aria-label={`Filter ${section.label.toLowerCase()}`}
+                            icon={<Search className="h-3.5 w-3.5" />}
+                            data-testid={`${sectionTestId}-search`}
+                          />
+                        </div>
+                      )}
+
+                      {visible.map(renderOption)}
+
+                      {needle !== "" && visible.length === 0 && (
+                        <p
+                          className="px-2.5 py-1.5 text-sm text-app-text-muted"
+                          data-testid={`${sectionTestId}-no-matches`}
+                        >
+                          No matches
+                        </p>
+                      )}
+
+                      {isOverLimit && (
+                        <Button
+                          variant="ghost"
+                          size="xs"
+                          fullWidth
+                          aria-expanded={isExpanded}
+                          onClick={() => setSectionExpanded(section.id, !isExpanded)}
+                          data-testid={`${sectionTestId}-show-all`}
+                        >
+                          {isExpanded ? "Show fewer" : `Show all (${matching.length})`}
+                        </Button>
+                      )}
+                    </>
+                  );
+                };
+
                 if (!collapsible) {
                   return (
                     <div key={section.id} className="py-0.5">
@@ -287,7 +397,7 @@ export function MultiSelectFilter<TValue extends string>({
                         </div>
                       )}
                       <div role="group" aria-label={section.label}>
-                        {section.options.map(renderOption)}
+                        {renderSectionBody()}
                       </div>
                       {sectionIndex < sections.length - 1 && (
                         <div className="my-1 border-t border-app-border/40" />
@@ -326,12 +436,21 @@ export function MultiSelectFilter<TValue extends string>({
 
                     <Collapsible open={!isCollapsed}>
                       <div id={panelId} role="group" aria-labelledby={headerId}>
-                        {section.options.map(renderOption)}
+                        {renderSectionBody()}
                       </div>
                     </Collapsible>
                   </div>
                 );
               })}
+
+              {footnote && (
+                <p
+                  className="mt-1 border-t border-app-border/40 px-2.5 pt-2 pb-1 text-xs text-app-text-muted"
+                  data-testid={`${testId}-footnote`}
+                >
+                  {footnote}
+                </p>
+              )}
             </motion.div>
           )}
         </AnimatePresence>,
diff --git a/src/components/ui/SidePanel.tsx b/src/components/ui/SidePanel.tsx
index c2fc34fe..00b21286 100644
--- a/src/components/ui/SidePanel.tsx
+++ b/src/components/ui/SidePanel.tsx
@@ -4,6 +4,7 @@ import { useContext, useEffect, useId, useRef, type ReactNode } from "react";
 import { SWIPE_IGNORE_ATTRIBUTE } from "../../hooks/useHorizontalWheelNavigation";
 import { PanelPresenceContext } from "./panelPresenceContext";
 import { sidePanelSlideToken } from "../../styles/tokens";
+import { useScrollLock } from "./useScrollLock";
 
 type SidePanelProps = {
   isOpen: boolean;
@@ -27,6 +28,7 @@ type SidePanelProps = {
   footerClassName?: string;
   closeAriaLabel?: string;
   closeOnEscape?: boolean;
+  lockScroll?: boolean;
 };
 
 const focusableSelector = [
@@ -72,6 +74,7 @@ export function SidePanel({
   footerClassName = "border-t border-app-border bg-app-bg px-6 py-5",
   closeAriaLabel = "Close details",
   closeOnEscape = true,
+  lockScroll = true,
 }: SidePanelProps) {
   const panelRef = useRef<HTMLDivElement>(null);
   const previouslyFocusedElement = useRef<HTMLElement | null>(null);
@@ -83,12 +86,16 @@ export function SidePanel({
   const presence = useContext(PanelPresenceContext);
   const isOpen = presence ? presence.isOpen : isOpenProp;
 
+  // Freezes the background page (body and any scroll containers) while the
+  // panel is open so only the panel insides scroll under the pointer.
+  useScrollLock(isOpen && lockScroll);
+
   const prefersReducedMotion = useReducedMotion();
   const panelTransition = prefersReducedMotion ? { duration: 0 } : sidePanelSlideToken;
 
   useEffect(() => {
     if (!isOpen) {
-      previouslyFocusedElement.current?.focus();
+      previouslyFocusedElement.current?.focus({ preventScroll: true });
       return;
     }
 
@@ -100,7 +107,7 @@ export function SidePanel({
       if (!panel) return;
 
       const [firstFocusable] = getFocusableElements(panel);
-      (firstFocusable ?? panel).focus();
+      (firstFocusable ?? panel).focus({ preventScroll: true });
     });
 
     return () => {
@@ -252,7 +259,7 @@ export function SidePanel({
           </div>
         )}
 
-        <div className="flex-1 [scrollbar-gutter:auto] overflow-y-auto">
+        <div className="flex-1 [scrollbar-gutter:auto] overflow-y-auto overscroll-contain">
           <div className={contentClassName}>{children}</div>
         </div>
 
diff --git a/src/components/ui/useScrollLock.ts b/src/components/ui/useScrollLock.ts
index b93f174f..fec264da 100644
--- a/src/components/ui/useScrollLock.ts
+++ b/src/components/ui/useScrollLock.ts
@@ -19,6 +19,7 @@ let restoreStyles: (() => void) | null = null;
 function lockElement(element: HTMLElement, scrollbarWidth: number): () => void {
   const previousOverflow = element.style.overflow;
   const previousPaddingRight = element.style.paddingRight;
+  const initialScrollTop = element.scrollTop;
 
   element.style.overflow = "hidden";
 
@@ -30,9 +31,47 @@ function lockElement(element: HTMLElement, scrollbarWidth: number): () => void {
   return () => {
     element.style.overflow = previousOverflow;
     element.style.paddingRight = previousPaddingRight;
+    if (element.scrollTop !== initialScrollTop) {
+      element.scrollTop = initialScrollTop;
+    }
   };
 }
 
+/**
+ * Whether a scroll gesture starting at `target` has somewhere to go inside the
+ * overlay, so the lock can let it through. Shared by the wheel and touch
+ * handlers so the two cannot drift apart.
+ *
+ * - Walks up from `target` as an `Element`, not an `HTMLElement`: a gesture
+ *   over an icon starts on an SVG node, which is no HTMLElement.
+ * - Checks the axis the gesture mostly moves along. A sideways swipe over a
+ *   wide `overflow-x-auto` code block needs a horizontally scrollable
+ *   ancestor, not a vertical one — a short drawer has none of the latter.
+ * - A container already at its edge in the gesture's direction does not
+ *   count, so the scroll cannot chain out to the page behind.
+ */
+function canScrollFrom(target: EventTarget | null, deltaX: number, deltaY: number): boolean {
+  const horizontal = Math.abs(deltaX) > Math.abs(deltaY);
+  const delta = horizontal ? deltaX : deltaY;
+  let node: Element | null = target instanceof Element ? target : null;
+
+  while (node && node !== document.body && node !== document.documentElement) {
+    const style = window.getComputedStyle(node);
+    const overflow = horizontal ? style.overflowX : style.overflowY;
+    const scrollSize = horizontal ? node.scrollWidth : node.scrollHeight;
+    const clientSize = horizontal ? node.clientWidth : node.clientHeight;
+    const position = horizontal ? node.scrollLeft : node.scrollTop;
+
+    if ((overflow === "auto" || overflow === "scroll") && scrollSize > clientSize) {
+      const isAtStart = position <= 0 && delta < 0;
+      const isAtEnd = position + clientSize >= scrollSize - 1 && delta > 0;
+      if (!isAtStart && !isAtEnd) return true;
+    }
+    node = node.parentElement;
+  }
+  return false;
+}
+
 /**
  * Freezes the page behind an overlay while `locked` is true.
  *
@@ -51,6 +90,12 @@ function lockElement(element: HTMLElement, scrollbarWidth: number): () => void {
  * Deliberately not `position: fixed` on the body: that technique loses the
  * scroll position and has to restore it by hand, which reads as a jump on every
  * close.
+ *
+ * Note: the desktop sidebar uses `position: fixed` (not `sticky`) precisely
+ * because locking `<html>` with `overflow: hidden` collapses its scroll
+ * container, which would cause a `sticky` element to snap to document y=0
+ * and disappear above the viewport. Fixed elements are immune to this because
+ * they are positioned relative to the viewport, not any scroll container.
  */
 export function useScrollLock(locked: boolean) {
   useLayoutEffect(() => {
@@ -58,8 +103,57 @@ export function useScrollLock(locked: boolean) {
 
     if (lockCount === 0) {
       const scrollbarWidth = window.innerWidth - document.documentElement.clientWidth;
+      const initialScrollY = window.scrollY;
+
+      const restores = [
+        lockElement(document.documentElement, 0),
+        lockElement(document.body, scrollbarWidth),
+      ];
+
+      restores.push(() => {
+        if (window.scrollY !== initialScrollY) {
+          window.scrollTo(0, initialScrollY);
+        }
+      });
+
+      function handleWheel(event: WheelEvent) {
+        // Ctrl+wheel and trackpad pinch are browser zoom, not scrolling:
+        // blocking them would take zoom away while any panel is open.
+        if (event.ctrlKey) return;
+        if (!canScrollFrom(event.target, event.deltaX, event.deltaY)) {
+          event.preventDefault();
+        }
+      }
+
+      let touchStartX = 0;
+      let touchStartY = 0;
+
+      function handleTouchStart(event: TouchEvent) {
+        if (event.touches.length > 0) {
+          touchStartX = event.touches[0].clientX;
+          touchStartY = event.touches[0].clientY;
+        }
+      }
+
+      function handleTouchMove(event: TouchEvent) {
+        // Two or more fingers is a pinch zoom — the touch twin of Ctrl+wheel.
+        if (event.touches.length !== 1) return;
+        const deltaX = touchStartX - event.touches[0].clientX;
+        const deltaY = touchStartY - event.touches[0].clientY;
+        if (!canScrollFrom(event.target, deltaX, deltaY)) {
+          event.preventDefault();
+        }
+      }
+
+      window.addEventListener("wheel", handleWheel, { passive: false });
+      window.addEventListener("touchstart", handleTouchStart, { passive: true });
+      window.addEventListener("touchmove", handleTouchMove, { passive: false });
 
-      const restores = [lockElement(document.body, scrollbarWidth)];
+      restores.push(() => {
+        window.removeEventListener("wheel", handleWheel);
+        window.removeEventListener("touchstart", handleTouchStart);
+        window.removeEventListener("touchmove", handleTouchMove);
+      });
 
       document
         .querySelectorAll<HTMLElement>(`[${SCROLL_CONTAINER_ATTRIBUTE}]`)
diff --git a/src/features/knowledge-base/aiStatus.ts b/src/features/knowledge-base/aiStatus.ts
new file mode 100644
index 00000000..e682ad68
--- /dev/null
+++ b/src/features/knowledge-base/aiStatus.ts
@@ -0,0 +1,54 @@
+import { CheckCircle2, CircleDashed, Hourglass, XCircle, type LucideIcon } from "lucide-react";
+import type { BadgeVariant } from "../../components/ui/Badge";
+import type { ArtifactAiStatus } from "./types";
+
+/** How one AI status is drawn: text, icon and colour together, never colour alone. */
+export interface AiStatusChipSpec {
+  /** Visible chip text. */
+  label: string;
+  /** Spoken form, appended to the card's accessible name. */
+  spoken: string;
+  /**
+   * Tooltip. Says what the chip reports — the AI assistant's index record — and nothing more:
+   * a failed vector removal can leave the record at "indexed" for a while, so the chip must
+   * not promise the assistant can find the content.
+   */
+  meaning: string;
+  variant: BadgeVariant;
+  icon: LucideIcon;
+}
+
+const NOT_INDEXED: AiStatusChipSpec = {
+  label: "Not indexed",
+  spoken: "not indexed for the AI assistant",
+  meaning: "The AI assistant's index holds no record of this artifact.",
+  variant: "neutral",
+  icon: CircleDashed,
+};
+
+/** Chip per status, per kb-contract part 3. DEINDEXED and UNKNOWN read the same to a reader. */
+export const AI_STATUS_CHIPS: Readonly<Record<ArtifactAiStatus, AiStatusChipSpec>> = {
+  INDEXED: {
+    label: "Indexed",
+    spoken: "indexed for the AI assistant",
+    meaning: "The AI assistant's index records this artifact as indexed.",
+    variant: "success",
+    icon: CheckCircle2,
+  },
+  PROCESSING: {
+    label: "Indexing",
+    spoken: "being indexed for the AI assistant",
+    meaning: "The AI assistant's index records this artifact as being processed.",
+    variant: "brand",
+    icon: Hourglass,
+  },
+  FAILED: {
+    label: "Failed",
+    spoken: "indexing for the AI assistant failed",
+    meaning: "The AI assistant's index records that indexing this artifact failed.",
+    variant: "danger",
+    icon: XCircle,
+  },
+  DEINDEXED: NOT_INDEXED,
+  UNKNOWN: NOT_INDEXED,
+};
diff --git a/src/features/knowledge-base/components/AiStatusChip.tsx b/src/features/knowledge-base/components/AiStatusChip.tsx
new file mode 100644
index 00000000..b9c59969
--- /dev/null
+++ b/src/features/knowledge-base/components/AiStatusChip.tsx
@@ -0,0 +1,27 @@
+import { Badge } from "../../../components/ui/Badge";
+import { AI_STATUS_CHIPS } from "../aiStatus";
+import type { ArtifactAiStatus } from "../types";
+
+/** Props for {@link AiStatusChip}. */
+export interface AiStatusChipProps {
+  status: ArtifactAiStatus;
+}
+
+/**
+ * The AI assistant's index status for one artifact, as icon + text + colour.
+ *
+ * Sits inside the card's `role="button"`, whose children are presentational, so the spoken form
+ * travels in the card's aria-label (see {@link AI_STATUS_CHIPS}) and the icon is hidden here.
+ */
+export function AiStatusChip({ status }: AiStatusChipProps) {
+  const chip = AI_STATUS_CHIPS[status];
+  const Icon = chip.icon;
+  return (
+    <span className="shrink-0" data-testid="artifact-ai-status" data-status={status}>
+      <Badge variant={chip.variant} size="sm" title={chip.meaning} className="gap-1">
+        <Icon className="h-3 w-3" aria-hidden="true" />
+        {chip.label}
+      </Badge>
+    </span>
+  );
+}
diff --git a/src/features/knowledge-base/components/ArtifactBulkActions.tsx b/src/features/knowledge-base/components/ArtifactBulkActions.tsx
new file mode 100644
index 00000000..193e4515
--- /dev/null
+++ b/src/features/knowledge-base/components/ArtifactBulkActions.tsx
@@ -0,0 +1,237 @@
+import { useState } from "react";
+import { useMutation, useQueryClient } from "@tanstack/react-query";
+import { AlertTriangle, CheckCircle2, Trash2 } from "lucide-react";
+import { Badge } from "../../../components/ui/Badge";
+import { Button } from "../../../components/ui/Button";
+import { Modal } from "../../../components/ui/Modal";
+import { knowledgeService } from "../../../services/knowledgeService";
+import { queryKeys } from "../../../services/queryKeys";
+import type { Artifact } from "../types";
+
+/** Props for {@link ArtifactBulkActions}. */
+export interface ArtifactBulkActionsProps {
+  projectId: string;
+  /** Authenticated user id; null while the profile is unknown (delete refuses). */
+  removerId: string | null;
+  /** The ticked uploads that are on screen — never ids the reader cannot see. */
+  selected: readonly Artifact[];
+  onClearSelection: () => void;
+  /** After a request that reached the backend: ingestion ids actually deleted. */
+  onDeleted: (deletedArtifactIds: string[]) => void;
+  /**
+   * Identity of the list on screen (filters, page, size, order). A change drops
+   * the last delete report, which describes a list the reader has moved away from.
+   */
+  listScopeKey: string;
+}
+
+interface BulkDeleteReport {
+  deleted: number;
+  failures: { id: string; title: string; error: string }[];
+}
+
+/** "1 upload" / "3 uploads" — the toolbar says what kind of thing is selected. */
+function countUploads(count: number): string {
+  return `${count} ${count === 1 ? "upload" : "uploads"}`;
+}
+
+/**
+ * Maps the backend's upload-id outcome back to the rows the reader ticked, so
+ * failures are named by title. Ids the page could not resolve to an upload id
+ * are failures too — they were never sent.
+ */
+function buildReport(
+  selected: readonly Artifact[],
+  deletedUploadIds: readonly string[],
+  failed: readonly { artifactId: string; error: string }[],
+): BulkDeleteReport {
+  const bySourceId = new Map(selected.map((artifact) => [artifact.sourceId, artifact]));
+  const failures = failed.map(({ artifactId, error }) => {
+    const artifact = bySourceId.get(artifactId);
+    return { id: artifactId, title: artifact?.title ?? artifactId, error };
+  });
+  for (const artifact of selected) {
+    if (!artifact.sourceId) {
+      failures.push({
+        id: artifact.id,
+        title: artifact.title ?? artifact.id,
+        error: "Couldn't resolve the uploaded artifact id for deletion.",
+      });
+    }
+  }
+  return { deleted: deletedUploadIds.length, failures };
+}
+
+/**
+ * Toolbar, confirmation and outcome for deleting several uploads at once.
+ *
+ * One request for the whole selection (the endpoint batches), confirmed in an
+ * alertdialog with the drawer's consequence wording. The outcome is reported
+ * per item: "N deleted", and a visible danger message naming each upload that
+ * could not be deleted with the backend's reason.
+ */
+export function ArtifactBulkActions({
+  projectId,
+  removerId,
+  selected,
+  onClearSelection,
+  onDeleted,
+  listScopeKey,
+}: ArtifactBulkActionsProps) {
+  const queryClient = useQueryClient();
+  const [isConfirmOpen, setIsConfirmOpen] = useState(false);
+  const [requestError, setRequestError] = useState<string | null>(null);
+  const [report, setReport] = useState<BulkDeleteReport | null>(null);
+  // Snapshot taken when the dialog opens: what was confirmed is what is sent,
+  // and the dialog keeps its wording while the cleared selection animates out.
+  const [pending, setPending] = useState<readonly Artifact[]>([]);
+
+  // Render-phase reset ("adjust state when a prop changes"), not an effect:
+  // the stale report must not paint for one frame over the new list. A
+  // delete's own refetch keeps the key, so its report survives that.
+  const [reportScope, setReportScope] = useState(listScopeKey);
+  if (reportScope !== listScopeKey) {
+    setReportScope(listScopeKey);
+    setReport(null);
+  }
+
+  const mutation = useMutation({
+    mutationFn: (uploadIds: string[]) =>
+      knowledgeService.deleteUploads(projectId, uploadIds, removerId ?? ""),
+    // Prefix invalidation: list, facets and any open detail refetch at once.
+    onSuccess: () =>
+      queryClient.invalidateQueries({ queryKey: queryKeys.knowledgeBase.project(projectId) }),
+  });
+
+  const openConfirm = () => {
+    setRequestError(null);
+    setReport(null);
+    setPending(selected);
+    setIsConfirmOpen(true);
+  };
+
+  const confirmDelete = async () => {
+    if (!removerId) {
+      setRequestError("Could not resolve the authenticated user id.");
+      return;
+    }
+    const uploadIds = pending.map((artifact) => artifact.sourceId).filter(Boolean);
+    try {
+      const outcome =
+        uploadIds.length > 0
+          ? await mutation.mutateAsync(uploadIds)
+          : { deletedIds: [], failed: [] };
+      const deleted = new Set(outcome.deletedIds);
+      setReport(buildReport(pending, outcome.deletedIds, outcome.failed));
+      setIsConfirmOpen(false);
+      onDeleted(pending.filter((a) => deleted.has(a.sourceId)).map((a) => a.id));
+    } catch (error) {
+      // The request itself failed: nothing is known to be deleted, so the
+      // dialog stays open with the reason and the selection is kept for a retry.
+      setRequestError(error instanceof Error ? error.message : "Couldn't delete the uploads.");
+    }
+  };
+
+  const count = selected.length;
+  const isDeleting = mutation.isPending;
+
+  return (
+    <div className="space-y-3">
+      {count > 0 && (
+        <div
+          role="group"
+          aria-label="Selected uploads"
+          data-testid="kb-bulk-toolbar"
+          className="flex flex-wrap items-center gap-3 rounded-xl border border-app-border bg-app-surface px-4 py-2"
+        >
+          <Badge variant="brand">{countUploads(count)} selected</Badge>
+          <Button
+            variant="dangerSoft"
+            size="sm"
+            icon={<Trash2 className="h-4 w-4" aria-hidden="true" />}
+            onClick={openConfirm}
+            data-testid="kb-bulk-delete"
+          >
+            Delete
+          </Button>
+          <Button variant="ghost" size="sm" onClick={onClearSelection} data-testid="kb-bulk-clear">
+            Clear selection
+          </Button>
+        </div>
+      )}
+
+      {/* Always mounted, so the count is announced when it arrives. */}
+      <div aria-live="polite" aria-atomic="true">
+        {report && report.deleted > 0 && (
+          <p
+            data-testid="kb-bulk-deleted"
+            className="flex items-center gap-2 text-sm font-medium text-app-success-text"
+          >
+            <CheckCircle2 className="h-4 w-4 shrink-0" aria-hidden="true" />
+            {report.deleted} deleted
+          </p>
+        )}
+      </div>
+
+      {report && report.failures.length > 0 && (
+        <div
+          role="alert"
+          data-testid="kb-bulk-failed"
+          className="rounded-xl border border-app-danger-border bg-app-danger-bg px-4 py-3 text-sm text-app-danger-text"
+        >
+          <p className="flex items-center gap-2 font-semibold">
+            <AlertTriangle className="h-4 w-4 shrink-0" aria-hidden="true" />
+            {countUploads(report.failures.length)} could not be deleted
+          </p>
+          <ul className="mt-2 list-disc space-y-1 pl-6">
+            {report.failures.map((failure) => (
+              <li key={failure.id}>
+                <span className="font-medium">{failure.title}</span>: {failure.error}
+              </li>
+            ))}
+          </ul>
+        </div>
+      )}
+
+      <Modal
+        isOpen={isConfirmOpen}
+        onClose={() => setIsConfirmOpen(false)}
+        role="alertdialog"
+        title={`Delete ${countUploads(pending.length)}?`}
+        description={`This will permanently remove ${countUploads(pending.length)} and their indexed content. This cannot be undone.`}
+        size="sm"
+        isDismissDisabled={isDeleting}
+        errorMessage={requestError}
+        testId="kb-bulk-delete-dialog"
+        footer={
+          <>
+            <Button
+              variant="secondary"
+              onClick={() => setIsConfirmOpen(false)}
+              disabled={isDeleting}
+              data-testid="kb-bulk-cancel"
+            >
+              Cancel
+            </Button>
+            <Button
+              variant="danger"
+              loading={isDeleting}
+              onClick={() => void confirmDelete()}
+              data-testid="kb-bulk-confirm"
+            >
+              {isDeleting ? "Deleting..." : "Delete"}
+            </Button>
+          </>
+        }
+      >
+        <ul className="max-h-48 list-disc space-y-1 overflow-y-auto pl-6 text-sm text-app-text">
+          {pending.map((artifact) => (
+            <li key={artifact.id} className="truncate">
+              {artifact.title ?? "Untitled"}
+            </li>
+          ))}
+        </ul>
+      </Modal>
+    </div>
+  );
+}
diff --git a/src/features/knowledge-base/components/ArtifactDateRangeFilter.tsx b/src/features/knowledge-base/components/ArtifactDateRangeFilter.tsx
new file mode 100644
index 00000000..1aebd716
--- /dev/null
+++ b/src/features/knowledge-base/components/ArtifactDateRangeFilter.tsx
@@ -0,0 +1,166 @@
+import { useId, useState } from "react";
+import { X } from "lucide-react";
+import { Badge } from "../../../components/ui/Badge.tsx";
+import { Button } from "../../../components/ui/Button.tsx";
+import { Input } from "../../../components/ui/Input.tsx";
+import { Select } from "../../../components/ui/Select.tsx";
+import {
+  DATE_RANGE_PRESETS,
+  describeDateRange,
+  matchPreset,
+  resolvePreset,
+  type DateRange,
+} from "../dateRange.ts";
+import type { KnowledgeBaseHistoryMode } from "../hooks/useKnowledgeBaseUrlState.ts";
+
+const ANY = "ANY";
+const CUSTOM = "CUSTOM";
+
+/** Props for {@link ArtifactDateRangeFilter}. */
+export interface ArtifactDateRangeFilterProps {
+  /** The active window, `yyyy-MM-dd` each end, null when open. */
+  range: DateRange;
+  /**
+   * Fired with a valid, ordered range. `mode` is `"replace"` for typing into a date field (one edit,
+   * one history entry) and `"push"` for a preset or a clear.
+   */
+  onRangeChange: (range: DateRange, mode: KnowledgeBaseHistoryMode) => void;
+  /** Clock override for tests; presets resolve against it. */
+  now?: Date;
+}
+
+/**
+ * The "Updated" filter: a preset picker (Any time, Last 7/30/90 days, Custom range…) and, for a
+ * custom range, two native date fields. It filters on an artifact's last activity — its last
+ * content change, or its import date if it never changed.
+ *
+ * Presets are resolved to absolute dates when picked, so the URL holds a fixed window a link can
+ * share. The picker shows the preset a range still equals today, and "Custom range…" once it no
+ * longer does. A reversed custom pair is refused with a message rather than written: the backend
+ * answers `from > to` with a 400.
+ */
+export function ArtifactDateRangeFilter({
+  range,
+  onRangeChange,
+  now,
+}: ArtifactDateRangeFilterProps) {
+  const errorId = useId();
+  const [isCustomOpen, setIsCustomOpen] = useState(false);
+  const [draft, setDraft] = useState<DateRange>(range);
+  const [syncedRange, setSyncedRange] = useState<DateRange>(range);
+
+  // A range arriving from outside (Back, Clear filters, the chip) replaces whatever was drafted.
+  if (syncedRange.from !== range.from || syncedRange.to !== range.to) {
+    setSyncedRange(range);
+    setDraft(range);
+    if (!range.from && !range.to) setIsCustomOpen(false);
+  }
+
+  const hasRange = range.from !== null || range.to !== null;
+  const preset = hasRange ? matchPreset(range, now) : null;
+  const selectValue = isCustomOpen ? CUSTOM : !hasRange ? ANY : (preset?.id ?? CUSTOM);
+  const isDraftReversed = draft.from !== null && draft.to !== null && draft.from > draft.to;
+
+  const handlePresetChange = (value: string) => {
+    if (value === CUSTOM) {
+      setIsCustomOpen(true);
+      return;
+    }
+    setIsCustomOpen(false);
+    const picked = DATE_RANGE_PRESETS.find((option) => option.id === value);
+    onRangeChange(picked ? resolvePreset(picked, now) : { from: null, to: null }, "push");
+  };
+
+  const handleDraftChange = (next: DateRange) => {
+    setDraft(next);
+    if (next.from !== null && next.to !== null && next.from > next.to) return;
+    onRangeChange(next, "replace");
+  };
+
+  const chipLabel = describeDateRange(range);
+
+  return (
+    <div className="flex flex-wrap items-center gap-2" data-testid="kb-date-filter">
+      <div className="w-40 shrink-0">
+        <Select
+          size="sm"
+          value={selectValue}
+          onChange={(event) => handlePresetChange(event.target.value)}
+          aria-label="Filter by last update (changed, or added if never changed)"
+          data-testid="kb-date-preset"
+        >
+          <option value={ANY}>Any time</option>
+          {DATE_RANGE_PRESETS.map((option) => (
+            <option key={option.id} value={option.id}>
+              {option.label}
+            </option>
+          ))}
+          <option value={CUSTOM}>Custom range…</option>
+        </Select>
+      </div>
+
+      {selectValue === CUSTOM && (
+        <div
+          role="group"
+          aria-label="Custom date range"
+          className="flex flex-wrap items-center gap-2"
+        >
+          <div className="w-40">
+            <Input
+              type="date"
+              size="sm"
+              value={draft.from ?? ""}
+              max={draft.to ?? undefined}
+              onChange={(event) =>
+                handleDraftChange({ ...draft, from: event.target.value || null })
+              }
+              aria-label="Updated from"
+              invalid={isDraftReversed}
+              aria-describedby={isDraftReversed ? errorId : undefined}
+              data-testid="kb-date-from"
+            />
+          </div>
+          <span aria-hidden="true" className="text-sm text-app-text-muted">
+            –
+          </span>
+          <div className="w-40">
+            <Input
+              type="date"
+              size="sm"
+              value={draft.to ?? ""}
+              min={draft.from ?? undefined}
+              onChange={(event) => handleDraftChange({ ...draft, to: event.target.value || null })}
+              aria-label="Updated to"
+              invalid={isDraftReversed}
+              aria-describedby={isDraftReversed ? errorId : undefined}
+              data-testid="kb-date-to"
+            />
+          </div>
+          {isDraftReversed && (
+            <p id={errorId} className="text-xs text-app-danger-text" data-testid="kb-date-error">
+              The start date must be on or before the end date.
+            </p>
+          )}
+        </div>
+      )}
+
+      {chipLabel && (
+        <span className="inline-flex items-center gap-1" data-testid="kb-date-chip">
+          <Badge variant="brand" size="sm">
+            {chipLabel}
+          </Badge>
+          <Button
+            variant="ghost"
+            size="xs"
+            iconOnly
+            onClick={() => onRangeChange({ from: null, to: null }, "push")}
+            aria-label="Clear date range"
+            data-testid="kb-date-clear"
+          >
+            <X className="h-3.5 w-3.5" aria-hidden="true" />
+          </Button>
+        </span>
+      )}
+    </div>
+  );
+}
diff --git a/src/features/knowledge-base/components/ArtifactFilters.tsx b/src/features/knowledge-base/components/ArtifactFilters.tsx
index 318342e9..eea194cf 100644
--- a/src/features/knowledge-base/components/ArtifactFilters.tsx
+++ b/src/features/knowledge-base/components/ArtifactFilters.tsx
@@ -1,3 +1,4 @@
+import { useId } from "react";
 import type { ReactNode } from "react";
 import {
   BookOpen,
@@ -7,6 +8,8 @@ import {
   FolderGit2,
   GitBranch,
   Image as ImageIcon,
+  Languages,
+  ListChecks,
   RefreshCw,
   Search,
   Ticket,
@@ -14,6 +17,7 @@ import {
 } from "lucide-react";
 import { Button } from "../../../components/ui/Button";
 import { Input } from "../../../components/ui/Input";
+import { Select } from "../../../components/ui/Select.tsx";
 import {
   MultiSelectFilter,
   type MultiSelectFilterSection,
@@ -21,21 +25,31 @@ import {
 import { SegmentedTabs } from "../../../components/ui/SegmentedTabs";
 import type { FacetOption, TabOption } from "../hooks/useKnowledgeBase";
 import {
+  ARTIFACT_SORT_ORDER,
+  DEFAULT_ARTIFACT_SORT,
   DEFAULT_FORMAT_ORDER,
   DEFAULT_SOURCE_ORDER,
   FORMAT_LABELS,
+  SORT_LABELS,
   SOURCE_LABELS,
   type KnowledgeTab,
   type UploadFormat,
 } from "../tabs";
-import type { ArtifactType, SourceSystem } from "../types";
+import type { ArtifactSort, ArtifactType, SourceSystem } from "../types";
+import type { DateRange } from "../dateRange.ts";
+import type { KnowledgeBaseHistoryMode } from "../hooks/useKnowledgeBaseUrlState.ts";
+import { ArtifactDateRangeFilter } from "./ArtifactDateRangeFilter.tsx";
+import { formatResultRange } from "../resultRange.ts";
 
 export type { ArtifactType, KnowledgeTab, SourceSystem, TabOption };
 
 /** Props for {@link ArtifactFilters}. */
 export interface ArtifactFiltersProps {
   searchQuery: string;
-  /** Fired on every keystroke with the new search text. Resets pagination in the parent. */
+  /**
+   * Fired on every keystroke with the new search text. The parent debounces it before it reaches
+   * the URL and the server, and resets pagination once it does.
+   */
   onSearchChange: (query: string) => void;
   /** Currently active artifact type tab. */
   activeTab: KnowledgeTab;
@@ -64,16 +78,44 @@ export interface ArtifactFiltersProps {
   onToggleSource: (source: SourceSystem) => void;
   onToggleFormat: (format: UploadFormat) => void;
   onToggleRepository: (repository: string) => void;
+  /**
+   * Languages the project's artifacts are written in, with counts. Not gated on a
+   * source, and empty (section hidden) when the project has no language values.
+   * Optional so surfaces that predate the facet keep compiling; the page wires it.
+   */
+  languageOptions?: FacetOption<string>[];
+  selectedLanguages?: ReadonlySet<string>;
+  onToggleLanguage?: (language: string) => void;
   /** Total count of matching artifacts. */
   resultCount: number;
+  /**
+   * 1-based position of the first and last artifact on the current page, for the
+   * "1–20 of 412 artifacts" line. Omitted, the line falls back to the total alone.
+   */
+  resultRange?: { start: number; end: number };
   /** Whether any filter, facet, or search query is currently non-default. */
   hasActiveFilters: boolean;
   /** Clears all active filters, facets, and search query. */
   onClearFilters: () => void;
+  /** Current list order. Defaults to newest added. */
+  sort?: ArtifactSort;
+  /** Fired when the reader picks another order. The sort control is only shown when given. */
+  onSortChange?: (sort: ArtifactSort) => void;
+  /** The "Updated" window on last activity (last change, else import); open ends are null. */
+  dateRange?: DateRange;
+  /** Fired with a valid, ordered range. The date filter is only shown when given. */
+  onDateRangeChange?: (range: DateRange, mode: KnowledgeBaseHistoryMode) => void;
   /** Fired when the user clicks the refresh button. */
   onRefresh?: () => void;
   /** Whether a refresh is currently in progress. */
   isRefreshing?: boolean;
+  /** Whether upload checkboxes are showing (bulk delete). */
+  isSelectMode?: boolean;
+  /**
+   * Toggles select mode. The Select button is only shown when given, and the
+   * page gives it only to roles allowed to delete uploads — no dead control.
+   */
+  onSelectModeChange?: (on: boolean) => void;
 }
 
 const ICON_CLASS = "h-4 w-4 shrink-0 text-app-text-muted";
@@ -99,6 +141,7 @@ function summariseSources(
   sources: ReadonlySet<SourceSystem>,
   format: UploadFormat | null,
   repositories: ReadonlySet<string>,
+  languages: ReadonlySet<string>,
 ): string {
   const parts: string[] = [];
 
@@ -123,6 +166,12 @@ function summariseSources(
     parts.push(`${repositories.size} repositories`);
   }
 
+  if (languages.size === 1) {
+    parts.push([...languages][0]);
+  } else if (languages.size > 1) {
+    parts.push(`${languages.size} languages`);
+  }
+
   return parts.join(" · ");
 }
 
@@ -134,6 +183,27 @@ function isUploadFormat(value: string): value is UploadFormat {
   return (DEFAULT_FORMAT_ORDER as readonly string[]).includes(value);
 }
 
+/** Repositories shown before the section folds behind "Show all". */
+const REPOSITORY_VISIBLE_LIMIT = 10;
+
+/** Stable empty range, so an omitted prop does not re-sync the date filter every render. */
+const NO_DATE_RANGE: DateRange = { from: null, to: null };
+
+/**
+ * Prefix for language values inside the shared multi-select. Languages are free
+ * strings, so an unprefixed "Markdown" (reachable by a hand-typed URL) would be
+ * mistaken for the MARKDOWN format in the one selected set and in test ids.
+ */
+const LANGUAGE_VALUE_PREFIX = "lang:";
+const NO_LANGUAGES: ReadonlySet<string> = new Set();
+const NO_LANGUAGE_OPTIONS: FacetOption<string>[] = [];
+
+/**
+ * What the numbers beside each option mean. They are "what you would get if you
+ * added this", not a project total, and nothing on screen said so.
+ */
+const FACET_COUNT_FOOTNOTE = "Counts show what you would get if you added this option.";
+
 /**
  * ArtifactFilters
  *
@@ -158,12 +228,23 @@ export function ArtifactFilters({
   onToggleSource,
   onToggleFormat,
   onToggleRepository,
+  languageOptions = NO_LANGUAGE_OPTIONS,
+  selectedLanguages = NO_LANGUAGES,
+  onToggleLanguage,
   resultCount,
+  resultRange,
   hasActiveFilters,
   onClearFilters,
   onRefresh,
   isRefreshing,
+  sort = DEFAULT_ARTIFACT_SORT,
+  onSortChange,
+  dateRange = NO_DATE_RANGE,
+  onDateRangeChange,
+  isSelectMode = false,
+  onSelectModeChange,
 }: ArtifactFiltersProps) {
+  const searchHintId = useId();
   const sections: MultiSelectFilterSection<string>[] = [];
 
   if (sourceOptions.length > 0) {
@@ -202,20 +283,46 @@ export function ArtifactFilters({
         count: option.count,
         icon: <FolderGit2 className={ICON_CLASS} aria-hidden="true" />,
       })),
+      // A connected org can bring dozens of repositories; past the threshold the
+      // section gets a filter box and folds to the ten biggest (facets arrive
+      // count-descending), with ticked ones always kept in view.
+      searchable: true,
+      visibleLimit: REPOSITORY_VISIBLE_LIMIT,
+    });
+  }
+
+  if (languageOptions.length > 0) {
+    sections.push({
+      id: "languages",
+      label: "Language",
+      options: languageOptions.map((option) => ({
+        value: `${LANGUAGE_VALUE_PREFIX}${option.value}`,
+        label: option.label,
+        count: option.count,
+        icon: <Languages className={ICON_CLASS} aria-hidden="true" />,
+      })),
     });
   }
 
   const selectedValues = new Set<string>([...selectedSources]);
   if (selectedFormat !== null) selectedValues.add(selectedFormat);
   for (const repository of selectedRepositories) selectedValues.add(repository);
+  for (const language of selectedLanguages) {
+    selectedValues.add(`${LANGUAGE_VALUE_PREFIX}${language}`);
+  }
 
   const activeCount =
-    selectedSources.size + (selectedFormat !== null ? 1 : 0) + selectedRepositories.size;
+    selectedSources.size +
+    (selectedFormat !== null ? 1 : 0) +
+    selectedRepositories.size +
+    selectedLanguages.size;
 
   const repositoryValues = new Set(repositoryOptions.map((option) => option.value));
 
   const handleToggle = (value: string) => {
-    if (isSource(value)) {
+    if (value.startsWith(LANGUAGE_VALUE_PREFIX)) {
+      onToggleLanguage?.(value.slice(LANGUAGE_VALUE_PREFIX.length));
+    } else if (isSource(value)) {
       onToggleSource(value);
     } else if (isUploadFormat(value)) {
       onToggleFormat(value);
@@ -230,33 +337,44 @@ export function ArtifactFilters({
   return (
     <div className="mb-6 flex flex-col gap-5">
       {/* Tier 1: Search bar with integrated refresh button */}
-      <Input
-        type="text"
-        placeholder="Search knowledge base..."
-        value={searchQuery}
-        onChange={(event) => onSearchChange(event.target.value)}
-        data-testid="kb-search-input"
-        aria-label="Search knowledge base"
-        icon={<Search className="h-4 w-4" />}
-        trailing={
-          onRefresh && (
-            <Button
-              variant="ghost"
-              size="sm"
-              iconOnly
-              onClick={onRefresh}
-              disabled={isRefreshing}
-              title="Refresh Knowledge Base"
-              aria-label="Refresh knowledge base"
-              data-testid="kb-refresh"
-            >
-              <RefreshCw
-                className={`h-4 w-4 ${isRefreshing ? "animate-spin text-app-brand" : ""}`}
-              />
-            </Button>
-          )
-        }
-      />
+      <div className="flex flex-col gap-1.5">
+        <Input
+          type="text"
+          placeholder="Search knowledge base..."
+          value={searchQuery}
+          onChange={(event) => onSearchChange(event.target.value)}
+          data-testid="kb-search-input"
+          aria-label="Search knowledge base"
+          aria-describedby={searchHintId}
+          icon={<Search className="h-4 w-4" />}
+          trailing={
+            onRefresh && (
+              <Button
+                variant="ghost"
+                size="sm"
+                iconOnly
+                onClick={onRefresh}
+                disabled={isRefreshing}
+                title="Refresh Knowledge Base"
+                aria-label="Refresh knowledge base"
+                data-testid="kb-refresh"
+              >
+                <RefreshCw
+                  className={`h-4 w-4 ${isRefreshing ? "animate-spin text-app-brand" : ""}`}
+                />
+              </Button>
+            )
+          }
+        />
+        {/*
+        The backend matches the text against titles and source links only, never the content,
+        so the hint says so: otherwise a phrase from inside a document finding nothing reads as
+        "the knowledge base does not have it" rather than "search does not look there".
+      */}
+        <p id={searchHintId} className="text-xs text-app-text-muted" data-testid="kb-search-hint">
+          Searches titles and links
+        </p>
+      </div>
 
       {/* Tier 2: Tab switcher for artifact types */}
       <SegmentedTabs
@@ -278,7 +396,7 @@ export function ArtifactFilters({
           className="flex h-9 shrink-0 items-center text-sm leading-none font-medium whitespace-nowrap text-app-text-muted"
           data-testid="kb-result-count"
         >
-          {resultCount} {resultCount === 1 ? "result" : "results"}
+          {formatResultRange(resultCount, resultRange)}
         </p>
 
         <div className="ml-auto flex w-full items-center justify-end gap-3 sm:w-auto">
@@ -294,10 +412,53 @@ export function ArtifactFilters({
             </Button>
           )}
 
+          {onDateRangeChange && (
+            <ArtifactDateRangeFilter range={dateRange} onRangeChange={onDateRangeChange} />
+          )}
+
+          {onSortChange && (
+            // The field style is `w-full`, so the width lives on a wrapper, as the filter's does.
+            <div className="w-44 shrink-0">
+              <Select
+                size="sm"
+                value={sort}
+                onChange={(event) => onSortChange(event.target.value as ArtifactSort)}
+                aria-label="Sort artifacts"
+                data-testid="kb-sort"
+              >
+                {ARTIFACT_SORT_ORDER.map((option) => (
+                  <option key={option} value={option}>
+                    {SORT_LABELS[option]}
+                  </option>
+                ))}
+              </Select>
+            </div>
+          )}
+
+          {onSelectModeChange && (
+            <Button
+              variant={isSelectMode ? "primary" : "secondary"}
+              size="sm"
+              icon={<ListChecks className="h-4 w-4" aria-hidden="true" />}
+              aria-pressed={isSelectMode}
+              onClick={() => onSelectModeChange(!isSelectMode)}
+              data-testid="kb-select-toggle"
+              className="shrink-0"
+            >
+              {/* Constant label: a toggle's state is aria-pressed, not a changing name. */}
+              Select
+            </Button>
+          )}
+
           <div className="min-w-0 flex-1 sm:w-80 sm:flex-none">
             <MultiSelectFilter
               label="Filter sources"
-              summary={summariseSources(selectedSources, selectedFormat, selectedRepositories)}
+              summary={summariseSources(
+                selectedSources,
+                selectedFormat,
+                selectedRepositories,
+                selectedLanguages,
+              )}
               activeCount={activeCount}
               sections={sections}
               selected={selectedValues}
@@ -306,6 +467,7 @@ export function ArtifactFilters({
               testId="kb-filter"
               className="w-full"
               collapsible={false}
+              footnote={FACET_COUNT_FOOTNOTE}
             />
           </div>
         </div>
diff --git a/src/features/knowledge-base/components/ArtifactList.tsx b/src/features/knowledge-base/components/ArtifactList.tsx
index 134b18b4..5a065fef 100644
--- a/src/features/knowledge-base/components/ArtifactList.tsx
+++ b/src/features/knowledge-base/components/ArtifactList.tsx
@@ -9,12 +9,26 @@ import {
   FileText,
   GitPullRequest,
 } from "lucide-react";
-import type { Artifact, ArtifactType } from "../types";
+import type { Artifact, ArtifactAiStatus, ArtifactType } from "../types";
+import { AI_STATUS_CHIPS } from "../aiStatus";
+import { AiStatusChip } from "./AiStatusChip";
 import { getArtifactRepository } from "../githubMetadata";
+import { isUpload } from "../tabs";
 import { RepositoryBadge } from "./RepositoryBadge";
+import { Checkbox } from "../../../components/ui/Checkbox";
 import { SpotlightCard } from "../../../components/ui/SpotlightCard";
 import { centralSpringToken } from "../../../styles/tokens";
 
+/**
+ * Select mode for the bulk delete. Absent means no checkboxes at all: they are
+ * revealed by an explicit toggle, never permanent, so the card keeps being one
+ * button that opens the drawer.
+ */
+export interface ArtifactListSelection {
+  selectedIds: ReadonlySet<string>;
+  onToggle: (id: string) => void;
+}
+
 /**
  * Props for the ArtifactList component.
  * Includes callback triggered when a user selects a specific item to view details.
@@ -22,6 +36,12 @@ import { centralSpringToken } from "../../../styles/tokens";
 interface ArtifactListProps {
   artifacts: Artifact[];
   onSelect: (id: string) => void;
+  selection?: ArtifactListSelection;
+  /**
+   * AI index status per artifact id. Absent (the AI was unavailable, the request failed or has
+   * not answered) or missing an id means no chip for that card — never a guessed one.
+   */
+  aiStatuses?: ReadonlyMap<string, ArtifactAiStatus> | null;
 }
 
 const getIcon = (type: ArtifactType) => {
@@ -65,13 +85,18 @@ const formatDate = (iso: string): string => {
 interface ArtifactCardProps {
   artifact: Artifact;
   onSelect: (id: string) => void;
+  aiStatus?: ArtifactAiStatus;
 }
 
 /**
  * Single row in the artifact list. Memoized so filtering/pagination changes that
  * leave this card's props untouched don't re-render it.
  */
-const ArtifactCard = memo(function ArtifactCard({ artifact, onSelect }: ArtifactCardProps) {
+const ArtifactCard = memo(function ArtifactCard({
+  artifact,
+  onSelect,
+  aiStatus,
+}: ArtifactCardProps) {
   const repository = getArtifactRepository(artifact);
 
   return (
@@ -80,7 +105,9 @@ const ArtifactCard = memo(function ArtifactCard({ artifact, onSelect }: Artifact
       roundedClassName="rounded-xl"
       role="button"
       tabIndex={0}
-      aria-label={`View ${artifact.title ?? "artifact"}${repository ? ` from ${repository}` : ""}`}
+      aria-label={`View ${artifact.title ?? "artifact"}${repository ? ` from ${repository}` : ""}${
+        aiStatus ? `, ${AI_STATUS_CHIPS[aiStatus].spoken}` : ""
+      }`}
       data-testid="artifact-card"
       onClick={() => onSelect(artifact.id)}
       onKeyDown={(e) => {
@@ -98,9 +125,11 @@ const ArtifactCard = memo(function ArtifactCard({ artifact, onSelect }: Artifact
           {/* flex-wrap: on a phone the chips wrap below the title instead of the row
               overflowing; the title still ellipsizes within its line. */}
           <div className="mb-1 flex flex-wrap items-center gap-2">
-            <h3 className="min-w-0 truncate font-semibold text-app-text">
+            {/* h2: the cards sit directly under the page's h1, and a skipped level fails axe's
+                heading-order once the list is on screen. */}
+            <h2 className="min-w-0 truncate font-semibold text-app-text">
               {artifact.title ?? "Untitled"}
-            </h3>
+            </h2>
             <span className="shrink-0 rounded-md border border-app-border bg-app-bg-soft px-2 py-0.5 text-[10px] font-bold text-app-text-muted uppercase">
               {getTypeLabel(artifact.artifactType)}
             </span>
@@ -108,6 +137,7 @@ const ArtifactCard = memo(function ArtifactCard({ artifact, onSelect }: Artifact
               {artifact.sourceSystem}
             </span>
             {repository && <RepositoryBadge repository={repository} testId="artifact-repo-badge" />}
+            {aiStatus && <AiStatusChip status={aiStatus} />}
           </div>
           <div className="mt-2 flex items-center gap-4 text-xs font-medium text-app-text-muted">
             <span>Ingested: {formatDate(artifact.ingestedAt)}</span>
@@ -125,6 +155,31 @@ const ArtifactCard = memo(function ArtifactCard({ artifact, onSelect }: Artifact
   );
 });
 
+/**
+ * The checkbox column in select mode. Only uploads get a checkbox — the same
+ * rule as the drawer's delete (connector artifacts are removed by their sync,
+ * not by hand); every other row keeps an empty slot so the cards stay aligned.
+ * It sits beside the card, never inside it, so no control nests in the
+ * card's button.
+ */
+function SelectSlot({
+  artifact,
+  selection,
+}: {
+  artifact: Artifact;
+  selection: ArtifactListSelection;
+}) {
+  if (!isUpload(artifact)) return <span className="w-5 shrink-0" aria-hidden="true" />;
+  return (
+    <Checkbox
+      checked={selection.selectedIds.has(artifact.id)}
+      onChange={() => selection.onToggle(artifact.id)}
+      aria-label={`Select ${artifact.title ?? "upload"}`}
+      data-testid={`artifact-select-${artifact.id}`}
+    />
+  );
+}
+
 /**
  * ArtifactList
  *
@@ -132,7 +187,7 @@ const ArtifactCard = memo(function ArtifactCard({ artifact, onSelect }: Artifact
  * Uses Framer Motion's AnimatePresence to handle layout transitions as filters are applied
  * and items enter/exit the dashboard list.
  */
-export function ArtifactList({ artifacts, onSelect }: ArtifactListProps) {
+export function ArtifactList({ artifacts, onSelect, selection, aiStatuses }: ArtifactListProps) {
   if (artifacts.length === 0) {
     return (
       <div className="flex flex-col items-center justify-center py-12 text-app-text-muted">
@@ -153,8 +208,16 @@ export function ArtifactList({ artifacts, onSelect }: ArtifactListProps) {
             animate={{ opacity: 1, y: 0 }}
             exit={{ opacity: 0, scale: 0.95 }}
             transition={centralSpringToken}
+            className={selection ? "flex items-center gap-3" : undefined}
           >
-            <ArtifactCard key={artifact.id} artifact={artifact} onSelect={onSelect} />
+            {selection && <SelectSlot artifact={artifact} selection={selection} />}
+            <div className={selection ? "min-w-0 flex-1" : undefined}>
+              <ArtifactCard
+                artifact={artifact}
+                onSelect={onSelect}
+                aiStatus={aiStatuses?.get(artifact.id)}
+              />
+            </div>
           </motion.div>
         ))}
       </AnimatePresence>
diff --git a/src/features/knowledge-base/components/ArtifactPageSizeSelect.tsx b/src/features/knowledge-base/components/ArtifactPageSizeSelect.tsx
new file mode 100644
index 00000000..87c57626
--- /dev/null
+++ b/src/features/knowledge-base/components/ArtifactPageSizeSelect.tsx
@@ -0,0 +1,55 @@
+import { useId } from "react";
+import { Select } from "../../../components/ui/Select.tsx";
+import { PAGE_SIZE_OPTIONS } from "../hooks/useKnowledgeBaseUrlState.ts";
+
+/** Props for {@link ArtifactPageSizeSelect}. */
+export interface ArtifactPageSizeSelectProps {
+  /** Artifacts per page right now (`?size=`). */
+  pageSize: number;
+  /** Fired with the chosen size; the caller resets to page 1. */
+  onPageSizeChange: (size: number) => void;
+  className?: string;
+}
+
+/**
+ * "Per page" control beside the Knowledge Base pagination.
+ *
+ * A native `ui/Select` with a visible label rather than an icon-only picker: the
+ * number alone ("50") does not say what it counts. It lives next to `Pagination`
+ * instead of inside it because `Pagination` renders nothing on a single page, and
+ * a reader who picked 100 must still see what they picked.
+ */
+export function ArtifactPageSizeSelect({
+  pageSize,
+  onPageSizeChange,
+  className = "",
+}: ArtifactPageSizeSelectProps) {
+  const selectId = useId();
+  const sizes = PAGE_SIZE_OPTIONS.includes(pageSize)
+    ? PAGE_SIZE_OPTIONS
+    : [...PAGE_SIZE_OPTIONS, pageSize].sort((a, b) => a - b);
+
+  return (
+    <div className={`flex items-center gap-2 ${className}`}>
+      <label htmlFor={selectId} className="text-sm whitespace-nowrap text-app-text-muted">
+        Per page
+      </label>
+      {/* The field style is `w-full`; a `w-20` on the select itself would fight it. */}
+      <div className="w-20">
+        <Select
+          id={selectId}
+          size="sm"
+          value={String(pageSize)}
+          onChange={(event) => onPageSizeChange(Number(event.target.value))}
+          data-testid="kb-page-size"
+        >
+          {sizes.map((size) => (
+            <option key={size} value={size}>
+              {size}
+            </option>
+          ))}
+        </Select>
+      </div>
+    </div>
+  );
+}
diff --git a/src/features/knowledge-base/components/ArtifactViewerDrawer.tsx b/src/features/knowledge-base/components/ArtifactViewerDrawer.tsx
index 58741c5b..20ec752d 100644
--- a/src/features/knowledge-base/components/ArtifactViewerDrawer.tsx
+++ b/src/features/knowledge-base/components/ArtifactViewerDrawer.tsx
@@ -39,6 +39,7 @@ import {
 import { getArtifactRepository } from "../githubMetadata";
 import { knowledgeService } from "../../../services/knowledgeService";
 import { RepositoryBadge } from "./RepositoryBadge";
+import { SourceLinkBadge } from "./SourceLinkBadge";
 import { useToast } from "../../../context/useToast";
 import { Button } from "../../../components/ui/Button";
 import { ApiError } from "../../../services/apiClient";
@@ -64,6 +65,8 @@ interface ArtifactViewerDrawerProps {
   /** Called after a successful deletion so the parent can clear the selection
    *  and re-fetch the artifact list. */
   onDelete: (artifactId: string) => void;
+  /** Whether to lock background scrolling while the drawer is open. Defaults to true. */
+  lockScroll?: boolean;
 }
 
 type ViewMode = "raw" | "summary";
@@ -848,6 +851,7 @@ export function ArtifactViewerDrawer({
   highlightLines,
   canDelete,
   onDelete,
+  lockScroll = true,
 }: ArtifactViewerDrawerProps) {
   const { profile } = useAuth();
   const [state, dispatch] = useReducer(drawerReducer, initialState);
@@ -1085,10 +1089,10 @@ export function ArtifactViewerDrawer({
    * @remarks The delete endpoint expects the `UploadedArtifact`'s UUID, not
    * the ingestion `Artifact`'s UUID. The displayed artifact is usually the
    * ingestion mirror (its `id` is the ingestion UUID); the corresponding
-   * `UploadedArtifact` id is carried in `artifact.sourceId`, which
-   * `getUnifiedArtifacts` enriches via title-matching against the uploads
-   * list. When `sourceId` is missing (e.g. ingestion mirror without a
-   * matching upload), deletion is refused with a user-facing error.
+   * `UploadedArtifact` id is carried in `artifact.sourceId`, which the backend
+   * fills in from the upload row. When `sourceId` is missing (e.g. ingestion
+   * mirror without a matching upload), deletion is refused with a user-facing
+   * error.
    */
   const handleDelete = async () => {
     if (!artifact) return;
@@ -1259,24 +1263,38 @@ export function ArtifactViewerDrawer({
   // GitHub repo artifacts show their `owner/repository` in the header's badge
   // row; other kinds have no repository to name, so the badge stays unset.
   const repository = artifact ? getArtifactRepository(artifact) : null;
+  const hasSourceLink = Boolean(artifact?.sourceUrl?.trim()) && artifact?.sourceSystem !== "UPLOAD";
 
-  const repositoryBadge = repository ? (
-    <RepositoryBadge repository={repository} testId="artifact-drawer-repo-badge" />
-  ) : undefined;
+  const headerBadge =
+    repository || hasSourceLink ? (
+      <>
+        {repository && (
+          <RepositoryBadge repository={repository} testId="artifact-drawer-repo-badge" />
+        )}
+        {hasSourceLink && artifact?.sourceUrl && (
+          <SourceLinkBadge
+            sourceUrl={artifact.sourceUrl}
+            sourceSystem={artifact.sourceSystem}
+            testId="artifact-drawer-source-link"
+          />
+        )}
+      </>
+    ) : undefined;
 
   return (
     <SidePanel
       isOpen={!!artifact}
       onClose={onClose}
       title={titleContent}
-      badge={repositoryBadge}
+      badge={headerBadge}
       actions={actionsContent}
-      widthClassName="w-full max-w-[720px] md:w-[60%] lg:w-[70%]"
+      widthClassName="w-full max-w-5xl"
       zIndexClassName="z-50 md:z-30"
       panelClassName="border-l border-app-border shadow-2xl"
       panelBackgroundClassName="bg-app-surface"
       headerClassName="p-4 bg-app-bg"
       contentClassName="p-6"
+      lockScroll={lockScroll}
     >
       {error && viewMode === "raw" ? (
         <div className="rounded-2xl border border-app-danger-border bg-app-danger-bg p-4 text-app-danger-text">
diff --git a/src/features/knowledge-base/components/SourceLinkBadge.tsx b/src/features/knowledge-base/components/SourceLinkBadge.tsx
new file mode 100644
index 00000000..da5885a3
--- /dev/null
+++ b/src/features/knowledge-base/components/SourceLinkBadge.tsx
@@ -0,0 +1,57 @@
+import { ExternalLink } from "lucide-react";
+import type { SourceSystem } from "../types";
+
+/**
+ * Maps the artifact's source system to a user-friendly label for opening the resource.
+ */
+function getSourceSystemLabel(sourceSystem: SourceSystem): string {
+  switch (sourceSystem) {
+    case "GITHUB":
+      return "Open in GitHub";
+    case "JIRA":
+      return "Open in Jira";
+    case "CONFLUENCE":
+      return "Open in Confluence";
+    default:
+      return "Open source";
+  }
+}
+
+const BADGE_CLASSES =
+  "inline-flex min-w-0 items-center gap-1.5 rounded-md border border-app-border bg-app-bg-soft px-2 py-0.5 text-[10px] font-bold text-app-text-muted transition-colors hover:border-app-brand/50 hover:bg-app-surface-hover hover:text-app-brand focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-app-focus";
+
+interface SourceLinkBadgeProps {
+  /** The destination URL for the artifact. */
+  sourceUrl: string;
+  /** The origin system of the artifact. */
+  sourceSystem: SourceSystem;
+  /** Targeting hook for end-to-end and unit tests. */
+  testId?: string;
+}
+
+/**
+ * Renders an external source link chip shared in the viewer drawer header,
+ * styled identically in shape, typography, and borders to RepositoryBadge.
+ */
+export function SourceLinkBadge({
+  sourceUrl,
+  sourceSystem,
+  testId = "artifact-drawer-source-link",
+}: SourceLinkBadgeProps) {
+  const label = getSourceSystemLabel(sourceSystem);
+
+  return (
+    <a
+      href={sourceUrl}
+      target="_blank"
+      rel="noopener noreferrer"
+      data-testid={testId}
+      title={sourceUrl}
+      aria-label={`${label} (opens in a new tab)`}
+      className={BADGE_CLASSES}
+    >
+      <ExternalLink className="h-3 w-3 shrink-0" aria-hidden="true" />
+      <span className="truncate">{label}</span>
+    </a>
+  );
+}
diff --git a/src/features/knowledge-base/components/index.ts b/src/features/knowledge-base/components/index.ts
index 51de4e56..928de8bf 100644
--- a/src/features/knowledge-base/components/index.ts
+++ b/src/features/knowledge-base/components/index.ts
@@ -4,3 +4,5 @@ export * from "./ArtifactViewerDrawer";
 export * from "./CitationsList";
 export * from "./FileUploadZone";
 export * from "./UploadArtifactModal";
+export * from "./ArtifactBulkActions";
+export * from "./AiStatusChip";
diff --git a/src/features/knowledge-base/dateRange.ts b/src/features/knowledge-base/dateRange.ts
new file mode 100644
index 00000000..b2ddf726
--- /dev/null
+++ b/src/features/knowledge-base/dateRange.ts
@@ -0,0 +1,117 @@
+/**
+ * Date-range helpers for the Knowledge Base "Updated" filter (last activity: the last content
+ * change, or the import date for an artifact that never changed).
+ *
+ * The backend filters last activity (`lastChangedAt`, else `ingestedAt`)
+ * by whole days — `from` inclusive from the start of its day,
+ * `to` inclusive to the end of its day — and it cuts those days in UTC. Everything here therefore
+ * reasons in UTC calendar days and speaks `yyyy-MM-dd`, the only shape the endpoint accepts.
+ */
+
+/** A range as it lives in the URL and the request; either end may be open. */
+export interface DateRange {
+  from: string | null;
+  to: string | null;
+}
+
+/** A relative preset. It is resolved to absolute dates when picked (see {@link resolvePreset}). */
+export interface DateRangePreset {
+  id: string;
+  label: string;
+  /** Calendar days covered, today included. */
+  days: number;
+}
+
+/** The presets the filter offers, shortest first. */
+export const DATE_RANGE_PRESETS: readonly DateRangePreset[] = [
+  { id: "7d", label: "Last 7 days", days: 7 },
+  { id: "30d", label: "Last 30 days", days: 30 },
+  { id: "90d", label: "Last 90 days", days: 90 },
+];
+
+const ISO_DATE = /^\d{4}-\d{2}-\d{2}$/;
+const DAY_MS = 24 * 60 * 60 * 1000;
+
+/**
+ * Whether `value` is a real calendar date in `yyyy-MM-dd` form. `2026-02-30` is well-formed but
+ * not a date, and the backend would reject it, so the round trip through `Date` is the check.
+ */
+export function isIsoDate(value: string | null | undefined): value is string {
+  if (!value || !ISO_DATE.test(value)) return false;
+  const time = Date.parse(`${value}T00:00:00Z`);
+  return !Number.isNaN(time) && new Date(time).toISOString().slice(0, 10) === value;
+}
+
+/**
+ * Today as the server counts days (UTC). Not the local date: for a reader west of UTC the local
+ * date can be a day behind, and a `to` of that date would end before "now" and hide the newest
+ * artifacts. The UTC day containing now always contains now.
+ */
+export function todayUtc(now: Date = new Date()): string {
+  return now.toISOString().slice(0, 10);
+}
+
+/** `iso` moved by `days` calendar days (negative for the past). */
+export function shiftIsoDate(iso: string, days: number): string {
+  return new Date(Date.parse(`${iso}T00:00:00Z`) + days * DAY_MS).toISOString().slice(0, 10);
+}
+
+/**
+ * Resolves a preset to absolute dates at the moment it is picked. Absolute on purpose: the URL
+ * records `from=2026-09-18&to=2026-09-24`, so a link shared today shows the same window next week
+ * instead of silently sliding along with the calendar.
+ */
+export function resolvePreset(preset: DateRangePreset, now: Date = new Date()): DateRange {
+  const to = todayUtc(now);
+  return { from: shiftIsoDate(to, -(preset.days - 1)), to };
+}
+
+/** The preset a range is exactly equal to *today*, if any. */
+export function matchPreset(range: DateRange, now: Date = new Date()): DateRangePreset | null {
+  if (!range.from || !range.to) return null;
+  return (
+    DATE_RANGE_PRESETS.find((preset) => {
+      const resolved = resolvePreset(preset, now);
+      return resolved.from === range.from && resolved.to === range.to;
+    }) ?? null
+  );
+}
+
+/**
+ * Brings a range into the shape the backend accepts: invalid ends are dropped, and reversed ends
+ * are swapped — the backend answers `from > to` with a 400, and a reversed pair is far more likely
+ * a slip than a request for nothing.
+ */
+export function normalizeDateRange(range: DateRange): DateRange {
+  const from = isIsoDate(range.from) ? range.from : null;
+  const to = isIsoDate(range.to) ? range.to : null;
+  if (from && to && from > to) return { from: to, to: from };
+  return { from, to };
+}
+
+const DISPLAY_FORMAT = new Intl.DateTimeFormat(undefined, {
+  year: "numeric",
+  month: "short",
+  day: "numeric",
+  // The dates are UTC calendar days; formatting them in the local zone would show the day before
+  // for every reader west of UTC.
+  timeZone: "UTC",
+});
+
+/** `yyyy-MM-dd` for display, in the same style the artifact cards print their dates. */
+export function formatIsoDate(iso: string): string {
+  return DISPLAY_FORMAT.format(new Date(`${iso}T00:00:00Z`));
+}
+
+/** Words an active range for its chip: "Updated Sep 1, 2026 – Sep 24, 2026", "Updated since …". */
+export function describeDateRange(range: DateRange): string | null {
+  const { from, to } = range;
+  if (from && to) {
+    return from === to
+      ? `Updated ${formatIsoDate(from)}`
+      : `Updated ${formatIsoDate(from)} – ${formatIsoDate(to)}`;
+  }
+  if (from) return `Updated since ${formatIsoDate(from)}`;
+  if (to) return `Updated until ${formatIsoDate(to)}`;
+  return null;
+}
diff --git a/src/features/knowledge-base/githubMetadata.ts b/src/features/knowledge-base/githubMetadata.ts
index 0f361e4b..22077af7 100644
--- a/src/features/knowledge-base/githubMetadata.ts
+++ b/src/features/knowledge-base/githubMetadata.ts
@@ -88,14 +88,16 @@ export function parseGithubMetadata(
  *
  * @param artifact The artifact whose metadata should be interpreted.
  * @returns The `owner/repository` string, or `null`.
+ *
+ * Cached per artifact object through `repositoryInfoOf`: the card list, the
+ * drawer and the facet loop all call this on every render pass, and without
+ * the cache each call re-ran `JSON.parse` (and re-warned on a malformed
+ * payload) for the same metadata.
  */
 export function getArtifactRepository(
   artifact: Pick<Artifact, "sourceSystem" | "artifactType" | "metadata">,
 ): string | null {
-  if (artifact.sourceSystem !== "GITHUB" || artifact.artifactType === "ORG_METADATA") {
-    return null;
-  }
-  return parseGithubMetadata(artifact.metadata)?.repositoryFullName ?? null;
+  return repositoryInfoOf(artifact).repository;
 }
 
 /**
@@ -111,6 +113,25 @@ interface RepositoryInfo {
   orgLogin: string | null;
 }
 
+/** Uncached core both public readers share; see the WeakMap note below. */
+function computeRepositoryInfo(
+  artifact: Pick<Artifact, "sourceSystem" | "artifactType" | "metadata">,
+): RepositoryInfo {
+  const repository =
+    artifact.sourceSystem === "GITHUB" && artifact.artifactType !== "ORG_METADATA"
+      ? (parseGithubMetadata(artifact.metadata)?.repositoryFullName ?? null)
+      : null;
+  if (repository !== null) return { repository, orgLogin: null };
+
+  return {
+    repository: null,
+    orgLogin:
+      artifact.artifactType === "ORG_METADATA"
+        ? (parseOrgMetadata(artifact.metadata)?.login ?? null)
+        : null,
+  };
+}
+
 const repositoryInfoCache = new WeakMap<object, RepositoryInfo>();
 
 function repositoryInfoOf(
@@ -119,17 +140,7 @@ function repositoryInfoOf(
   const cached = repositoryInfoCache.get(artifact);
   if (cached !== undefined) return cached;
 
-  const repository = getArtifactRepository(artifact);
-  const info: RepositoryInfo =
-    repository !== null
-      ? { repository, orgLogin: null }
-      : {
-          repository: null,
-          orgLogin:
-            artifact.artifactType === "ORG_METADATA"
-              ? (parseOrgMetadata(artifact.metadata)?.login ?? null)
-              : null,
-        };
+  const info = computeRepositoryInfo(artifact);
   repositoryInfoCache.set(artifact, info);
   return info;
 }
diff --git a/src/features/knowledge-base/hooks/useArtifactAiStatus.ts b/src/features/knowledge-base/hooks/useArtifactAiStatus.ts
new file mode 100644
index 00000000..35f2238f
--- /dev/null
+++ b/src/features/knowledge-base/hooks/useArtifactAiStatus.ts
@@ -0,0 +1,58 @@
+import { useQuery } from "@tanstack/react-query";
+import { knowledgeService } from "../../../services/knowledgeService";
+import { queryKeys } from "../../../services/queryKeys";
+import type { ArtifactAiStatus, ArtifactAiStatusResponse } from "../types";
+
+/** How long a status is trusted before a remount refetches it. */
+export const AI_STATUS_STALE_MS = 5 * 60 * 1000;
+
+/** Poll interval while at least one artifact on the page is still being indexed. */
+export const AI_STATUS_POLL_MS = 10 * 1000;
+
+function isProcessing(data: ArtifactAiStatusResponse | undefined): boolean {
+  return data?.items.some((item) => item.status === "PROCESSING") ?? false;
+}
+
+/** `null` when the AI was unavailable: its all-UNKNOWN answer says nothing about the artifacts. */
+function toStatusMap(
+  response: ArtifactAiStatusResponse,
+): ReadonlyMap<string, ArtifactAiStatus> | null {
+  return response.aiAvailable
+    ? new Map(response.items.map((item) => [item.artifactId, item.status] as const))
+    : null;
+}
+
+/**
+ * AI index status for the artifacts on screen: one batched request per visible page, keyed on
+ * the page's ids.
+ *
+ * - No request for an empty page or without a project.
+ * - `retry: false` and a 5-minute stale time: the chip is a hint, it must never hammer the
+ *   backend or the AI when either is struggling.
+ * - Polls every 10 s only while some item is `PROCESSING`, and stops once none is.
+ *
+ * @param projectId Active project, or null before one is chosen.
+ * @param artifactIds Ingestion ids of the visible page, in any stable order.
+ * @returns Status per artifact id, or `null` when no chip may be drawn: the AI was unavailable
+ *   (`aiAvailable: false`), the request failed, or it has not answered yet. Ids missing from the
+ *   map (outside the project) get no chip either.
+ */
+export function useArtifactAiStatus(
+  projectId: string | null | undefined,
+  artifactIds: readonly string[],
+): ReadonlyMap<string, ArtifactAiStatus> | null {
+  const enabled = Boolean(projectId) && artifactIds.length > 0;
+  const { data, isError } = useQuery({
+    queryKey: queryKeys.knowledgeBase.aiStatus(projectId ?? "", artifactIds),
+    queryFn: () => knowledgeService.getArtifactAiStatus(projectId ?? "", artifactIds),
+    enabled,
+    retry: false,
+    staleTime: AI_STATUS_STALE_MS,
+    refetchInterval: (query) => (isProcessing(query.state.data) ? AI_STATUS_POLL_MS : false),
+    // Module-level, so React Query memoizes the map and memoized cards do not re-render.
+    select: toStatusMap,
+  });
+
+  if (!enabled || isError || !data) return null;
+  return data;
+}
diff --git a/src/features/knowledge-base/hooks/useArtifactById.ts b/src/features/knowledge-base/hooks/useArtifactById.ts
new file mode 100644
index 00000000..9fbbd490
--- /dev/null
+++ b/src/features/knowledge-base/hooks/useArtifactById.ts
@@ -0,0 +1,24 @@
+import { useQuery } from "@tanstack/react-query";
+import { knowledgeService } from "../../../services/knowledgeService";
+import { queryKeys } from "../../../services/queryKeys";
+import type { Artifact } from "../types";
+
+/**
+ * Loads a single artifact by its ID within a project scope.
+ * Used as a fallback when an artifact is requested (e.g. from a deep link or search)
+ * that is not currently present in the active page of artifacts.
+ *
+ * @param projectId UUID of the project.
+ * @param artifactId UUID of the artifact to load.
+ */
+export function useArtifactById(projectId: string | null, artifactId: string | null) {
+  return useQuery<Artifact | null>({
+    queryKey: queryKeys.knowledgeBase.detail(projectId ?? "", artifactId ?? ""),
+    queryFn: () => {
+      if (!projectId || !artifactId) return null;
+      return knowledgeService.getArtifactById(projectId, artifactId);
+    },
+    enabled: Boolean(projectId && artifactId),
+    staleTime: 60_000,
+  });
+}
diff --git a/src/features/knowledge-base/hooks/useKnowledgeBase.ts b/src/features/knowledge-base/hooks/useKnowledgeBase.ts
index 3dfcf061..806c993e 100644
--- a/src/features/knowledge-base/hooks/useKnowledgeBase.ts
+++ b/src/features/knowledge-base/hooks/useKnowledgeBase.ts
@@ -1,25 +1,31 @@
-import { useState, useMemo, useCallback, useDeferredValue } from "react";
-import { useQuery, useQueryClient } from "@tanstack/react-query";
+import { useState, useMemo, useCallback, useEffect, useRef } from "react";
+import { NavigationType, useNavigationType } from "react-router-dom";
+import { keepPreviousData, useQuery, useQueryClient } from "@tanstack/react-query";
 import { knowledgeService } from "../../../services/knowledgeService";
 import { queryKeys } from "../../../services/queryKeys";
-import type { Artifact, SourceSystem } from "../types";
+import type {
+  Artifact,
+  ArtifactFacets,
+  ArtifactPage,
+  ArtifactType,
+  KnowledgeListParams,
+  SourceSystem,
+  UploadFormat,
+} from "../types";
 import {
+  DEFAULT_ARTIFACT_SORT,
   DEFAULT_FORMAT_ORDER,
   DEFAULT_SOURCE_ORDER,
   FORMAT_LABELS,
   KNOWLEDGE_TABS,
   type KnowledgeTab,
   SOURCE_LABELS,
-  isUpload,
-  matchesFormat,
-  type UploadFormat,
 } from "../tabs";
-import { getArtifactRepository, matchesRepository } from "../githubMetadata";
+import { useDebouncedValue } from "../../../hooks/useDebouncedValue.ts";
+import { DEFAULT_PAGE_SIZE, useKnowledgeBaseUrlState } from "./useKnowledgeBaseUrlState.ts";
+import type { KnowledgeBaseUrlStateOptions } from "./useKnowledgeBaseUrlState.ts";
 
-const ITEMS_PER_PAGE = 20;
 const NO_ARTIFACTS: Artifact[] = [];
-const NO_SOURCES: ReadonlySet<SourceSystem> = new Set<SourceSystem>();
-const NO_REPOSITORIES: ReadonlySet<string> = new Set<string>();
 
 /** A single selectable option in a facet, with the count it would yield if added. */
 export interface FacetOption<TValue extends string> {
@@ -35,375 +41,385 @@ export interface TabOption {
   count: number;
 }
 
-/** The knowledge-base query's loader, shared with route prefetch so the two never drift apart. */
-export function loadKnowledgeBaseArtifacts(projectId: string): Promise<Artifact[]> {
-  return knowledgeService.getUnifiedArtifacts(projectId);
+/**
+ * Paginated query loader, shared with route prefetch. The prefetch warms the *default* state
+ * (page 1, default size, no filters); a filtered deep link simply fetches once on arrival.
+ */
+export function loadKnowledgeBasePage(
+  projectId: string,
+  params: KnowledgeListParams = { page: 1, size: DEFAULT_PAGE_SIZE },
+): Promise<ArtifactPage> {
+  return knowledgeService.getArtifactPage(projectId, params);
+}
+
+/** Facets query loader, shared with route prefetch. */
+export function loadKnowledgeBaseFacets(
+  projectId: string,
+  params: KnowledgeListParams = {},
+): Promise<ArtifactFacets> {
+  return knowledgeService.getArtifactFacets(projectId, params);
 }
 
+/**
+ * How long the search box must stay unchanged before its text reaches `?q=` and the server.
+ * 300 ms is below the pause people make between words but above the gap between keystrokes, so
+ * typing "readme" costs one list request and one facets request instead of six of each.
+ */
+export const KB_SEARCH_DEBOUNCE_MS = 300;
+
 /**
  * State + data layer for the Knowledge Base page.
  *
- * Owns artifact fetching, client-side filtering and pagination. Filtering is
- * three independent facets — sources, artifact types, and (for uploads only)
- * file format — combined with AND across facets and OR within one; an empty
- * facet means "everything", which is what makes a clear-all the same operation
- * as never having filtered. UI-only state (which drawer is open, which modal is
- * open) stays in the page.
+ * Owns artifact fetching, server-side pagination, and faceted search.
+ * Filtering supports sources, artifact types, file format, repository and language,
+ * backed by PostgreSQL indexes and projection queries.
+ *
+ * Every filter, the page, the page size and the open artifact live in the URL
+ * (see {@link useKnowledgeBaseUrlState}); this hook turns them into requests and
+ * facet options. The one piece of local state is the search *input*, because the
+ * router applies location changes inside a transition and a text field bound
+ * straight to the URL would lag behind the keyboard.
  *
  * @param projectId The project to scope artifact fetching to. When null, no
  *   fetch is attempted and the page should render its empty state.
+ * @param options Forwarded to {@link useKnowledgeBaseUrlState}; the page passes
+ *   `projectSettled` so the initial project resolution does not clear a shared link.
  */
-export function useKnowledgeBase(projectId: string | null) {
+export function useKnowledgeBase(
+  projectId: string | null,
+  options: KnowledgeBaseUrlStateOptions = {},
+) {
   const queryClient = useQueryClient();
-  const queryKey = queryKeys.knowledgeBase.byProject(projectId ?? "");
+  const navigationType = useNavigationType();
 
   const {
-    data,
-    isLoading: isQueryLoading,
-    isError,
-    refetch,
-  } = useQuery({
-    queryKey,
-    queryFn: () => loadKnowledgeBaseArtifacts(projectId as string),
-    enabled: projectId !== null,
-  });
-
-  const artifacts = projectId !== null ? (data ?? NO_ARTIFACTS) : NO_ARTIFACTS;
-  const isLoading = projectId !== null && isQueryLoading;
-  const fetchError = isError ? "Failed to load artifacts. Please try again." : null;
+    state: urlState,
+    scopeProjectId,
+    setTab,
+    setSearch,
+    toggleSource,
+    toggleFormat,
+    toggleRepository,
+    toggleLanguage,
+    setPage,
+    setSize,
+    setSort,
+    setDateRange,
+    clearFilters,
+    setArtifactId,
+  } = useKnowledgeBaseUrlState(projectId, options);
 
-  // A newer fetch (Refresh clicked twice, or projectId changing mid-flight) is
-  // meant to win over one already in flight; react-query only supersedes an
-  // in-flight fetch on its own once the query has data, which the very first
-  // load never does, so it is cancelled by hand first.
-  const fetchArtifacts = useCallback(async () => {
-    if (projectId === null) return;
-    await queryClient.cancelQueries({ queryKey });
-    await refetch();
-  }, [projectId, queryClient, queryKey, refetch]);
-
-  const [searchQuery, setSearchQuery] = useState("");
-  // Deferred so rapid typing doesn't re-filter the whole list on every keystroke;
-  // React batches the filter to a lower-priority render.
-  const deferredSearchQuery = useDeferredValue(searchQuery);
-
-  const [activeTab, setActiveTab] = useState<KnowledgeTab>("ALL");
-  const [selectedSources, setSelectedSources] = useState<ReadonlySet<SourceSystem>>(NO_SOURCES);
-  const [selectedFormat, setSelectedFormat] = useState<UploadFormat | null>(null);
-  const [selectedRepositories, setSelectedRepositories] =
-    useState<ReadonlySet<string>>(NO_REPOSITORIES);
-  const [currentPage, setCurrentPage] = useState(1);
-
-  // Helper to match text search across title, sourceId, and sourceUrl
-  const matchesSearch = useCallback((artifact: Artifact, query: string): boolean => {
-    if (!query) return true;
-    const searchableText = [artifact.title ?? "", artifact.sourceId, artifact.sourceUrl ?? ""]
-      .join(" ")
-      .toLowerCase();
-    return searchableText.includes(query.toLowerCase());
-  }, []);
+  const {
+    tab: activeTab,
+    sources: selectedSources,
+    format: selectedFormat,
+    repositories: selectedRepositories,
+    languages: selectedLanguages,
+    page: requestedPage,
+    size: pageSize,
+    sort,
+  } = urlState;
+
+  /*
+    The search input's own copy of `?q=`. It follows the URL only when the URL changed for a reason
+    other than this input: Back/Forward (a POP navigation) or a project switch. Every other change
+    of `?q=` was written *from* this state, so adopting it back could only ever be a stale echo -
+    one that, arriving a transition late, would eat the characters typed in between.
+  */
+  const [searchQuery, setSearchQuery] = useState(urlState.search);
+  const [syncedSearch, setSyncedSearch] = useState(urlState.search);
+  const [searchScope, setSearchScope] = useState(scopeProjectId);
+  if (searchScope !== scopeProjectId) {
+    setSearchScope(scopeProjectId);
+    setSyncedSearch(urlState.search);
+    setSearchQuery(urlState.search);
+  } else if (syncedSearch !== urlState.search) {
+    setSyncedSearch(urlState.search);
+    if (navigationType === NavigationType.Pop) setSearchQuery(urlState.search);
+  }
 
-  const passesTab = useCallback(
-    (artifact: Artifact): boolean => {
-      if (activeTab === "ALL") return true;
-      return artifact.artifactType === activeTab;
-    },
-    [activeTab],
+  /*
+    Only the settled text is written to `?q=` (with `replace`, so a typed word is one history
+    entry at most), and the queries read `?q=` - so a burst of keystrokes is one request, not one
+    per character. The ref remembers the last settled value this effect acted on: the effect also
+    re-runs when `?q=` itself changes, and without the guard a Back navigation (which moves `?q=`
+    before the debounced copy of the adopted text catches up) would be overwritten again with the
+    input's previous, now-stale settled value.
+  */
+  const debouncedSearch = useDebouncedValue(searchQuery, KB_SEARCH_DEBOUNCE_MS);
+  const lastSettledSearchRef = useRef(debouncedSearch);
+  useEffect(() => {
+    if (lastSettledSearchRef.current === debouncedSearch) return;
+    lastSettledSearchRef.current = debouncedSearch;
+    if (debouncedSearch !== urlState.search) setSearch(debouncedSearch);
+  }, [debouncedSearch, urlState.search, setSearch]);
+
+  const typesParam: ArtifactType[] | undefined = useMemo(() => {
+    if (activeTab === "ALL") return undefined;
+    return [activeTab];
+  }, [activeTab]);
+
+  const sourcesParam: SourceSystem[] | undefined = useMemo(() => {
+    if (selectedSources.size === 0) return undefined;
+    return Array.from(selectedSources);
+  }, [selectedSources]);
+
+  const repositoriesParam: string[] | undefined = useMemo(() => {
+    if (selectedRepositories.size === 0) return undefined;
+    return Array.from(selectedRepositories);
+  }, [selectedRepositories]);
+
+  const languagesParam: string[] | undefined = useMemo(() => {
+    if (selectedLanguages.size === 0) return undefined;
+    return Array.from(selectedLanguages);
+  }, [selectedLanguages]);
+
+  const searchParam = urlState.search.trim() || undefined;
+
+  const dateFrom = urlState.dateRange.from ?? undefined;
+  const dateTo = urlState.dateRange.to ?? undefined;
+
+  /*
+    The filter criteria, once, for both requests. The facets are counted over exactly this, and the
+    list pages through exactly this plus its own page, size and order: building the two from one
+    object is what keeps a facet count from describing a different predicate than the rows below.
+  */
+  const facetsParams: KnowledgeListParams = useMemo(
+    () => ({
+      search: searchParam,
+      types: typesParam,
+      sources: sourcesParam,
+      repositories: repositoriesParam,
+      format: selectedFormat ?? undefined,
+      languages: languagesParam,
+      from: dateFrom,
+      to: dateTo,
+    }),
+    [
+      searchParam,
+      typesParam,
+      sourcesParam,
+      repositoriesParam,
+      selectedFormat,
+      languagesParam,
+      dateFrom,
+      dateTo,
+    ],
   );
 
-  const passesSources = useCallback(
-    (artifact: Artifact): boolean => {
-      if (selectedSources.size === 0) return true;
-      return selectedSources.has(artifact.sourceSystem);
-    },
-    [selectedSources],
+  const listParams: KnowledgeListParams = useMemo(
+    () => ({
+      ...facetsParams,
+      page: requestedPage,
+      size: pageSize,
+      // The default order is left unsaid, so the default request (and its cache key, which the
+      // route prefetch warms) is byte-for-byte what it was before sorting existed.
+      sort: sort === DEFAULT_ARTIFACT_SORT ? undefined : sort,
+    }),
+    [facetsParams, requestedPage, pageSize, sort],
   );
 
-  const passesFormat = useCallback(
-    (artifact: Artifact): boolean => {
-      if (selectedFormat === null) return true;
-      return matchesFormat(artifact, selectedFormat);
-    },
-    [selectedFormat],
+  /**
+   * Identity of the list on screen: changes with every filter, the page, the size and the
+   * order. Selection state keys on it, so a ticked row never survives into a list where the
+   * reader can no longer see it.
+   */
+  const listScopeKey = useMemo(
+    () => JSON.stringify([projectId ?? "", listParams]),
+    [projectId, listParams],
   );
 
-  const passesRepository = useCallback(
-    (artifact: Artifact): boolean => matchesRepository(artifact, selectedRepositories),
-    [selectedRepositories],
-  );
+  const listQueryKey = queryKeys.knowledgeBase.list(projectId ?? "", listParams);
+  const facetsQueryKey = queryKeys.knowledgeBase.facets(projectId ?? "", facetsParams);
 
-  /**
-   * Top-level tabs for SegmentedTabs.
-   *
-   * Options are scoped to artifact types available from the selected sources
-   * (plus "ALL" and whatever tab is active, so an active tab never disappears).
-   * Each tab's count reflects the current search, source selection, and format facet.
-   */
-  const tabOptions = useMemo<TabOption[]>(() => {
-    const presentTypes = new Set(
-      artifacts.filter(passesSources).map((artifact) => artifact.artifactType),
-    );
-    const reachableTabs = KNOWLEDGE_TABS.filter(
-      (tab) =>
-        tab.id === "ALL" ||
-        tab.id === activeTab ||
-        (tab.type !== undefined && presentTypes.has(tab.type)),
-    );
+  const {
+    data: pageData,
+    isLoading: isListLoading,
+    isError: isListError,
+    isPlaceholderData,
+    refetch: refetchList,
+  } = useQuery({
+    queryKey: listQueryKey,
+    queryFn: () => knowledgeService.getArtifactPage(projectId as string, listParams),
+    enabled: projectId !== null,
+    placeholderData: keepPreviousData,
+  });
+
+  const {
+    data: facetsData,
+    isLoading: isFacetsLoading,
+    isError: isFacetsError,
+    refetch: refetchFacets,
+  } = useQuery({
+    queryKey: facetsQueryKey,
+    queryFn: () => knowledgeService.getArtifactFacets(projectId as string, facetsParams),
+    enabled: projectId !== null,
+    placeholderData: keepPreviousData,
+  });
+
+  const artifacts = projectId !== null ? (pageData?.items ?? NO_ARTIFACTS) : NO_ARTIFACTS;
+  const isLoading = projectId !== null && (isListLoading || isFacetsLoading);
+  const fetchError =
+    isListError || isFacetsError ? "Failed to load artifacts. Please try again." : null;
+
+  const pageMeta = pageData?.page;
+  const totalPages = Math.max(1, pageMeta?.totalPages ?? 1);
+  const totalElements = pageMeta?.totalElements ?? artifacts.length;
+
+  // Positions of the rows actually on screen, read from the page that produced
+  // them: while a new page loads the previous one stays visible (placeholder
+  // data), and the line must describe what the reader sees, not what is coming.
+  // `number` is 1-based: the backend echoes the requested `?page=` (see PageMetadata).
+  const resultRange = useMemo(() => {
+    if (!pageMeta || artifacts.length === 0) return undefined;
+    const start = (pageMeta.number - 1) * pageMeta.size + 1;
+    return { start, end: start + artifacts.length - 1 };
+  }, [pageMeta, artifacts.length]);
+
+  /*
+    A `?page=` past the end (a stale link, a result set that shrank) is pulled back into range.
+    The render already reports the clamped page; the URL is corrected afterwards with a `replace`,
+    because navigating during render is not allowed. Only an answer for *this* query can prove the
+    page is out of range - placeholder data still describes the previous one, and clamping against
+    it would, say, drag a Back navigation to page 3 down to the previous filter's single page.
+  */
+  const isPageOutOfRange =
+    pageData !== undefined && !isPlaceholderData && requestedPage > totalPages;
+  const currentPage = isPageOutOfRange ? totalPages : requestedPage;
+
+  useEffect(() => {
+    if (isPageOutOfRange) setPage(totalPages, "replace");
+  }, [isPageOutOfRange, totalPages, setPage]);
+
+  const fetchArtifacts = useCallback(async () => {
+    if (projectId === null) return;
+    await queryClient.cancelQueries({ queryKey: queryKeys.knowledgeBase.project(projectId) });
+    await Promise.all([refetchList(), refetchFacets()]);
+  }, [projectId, queryClient, refetchList, refetchFacets]);
+
+  const tabCounts = useMemo(() => {
+    const map = new Map<string, number>();
+    for (const t of facetsData?.types ?? []) {
+      map.set(t.value, t.count);
+    }
+    return map;
+  }, [facetsData?.types]);
 
-    return reachableTabs.map((tab) => ({
+  const tabOptions = useMemo<TabOption[]>(() => {
+    const totalAll = (facetsData?.types ?? []).reduce((acc, curr) => acc + curr.count, 0);
+    return KNOWLEDGE_TABS.filter(
+      (tab) => tab.id === "ALL" || tab.id === activeTab || (tabCounts.get(tab.id) ?? 0) > 0,
+    ).map((tab) => ({
       value: tab.id,
       label: tab.label,
-      count: artifacts.filter(
-        (artifact) =>
-          (tab.id === "ALL" || artifact.artifactType === tab.id) &&
-          matchesSearch(artifact, deferredSearchQuery) &&
-          passesSources(artifact) &&
-          passesFormat(artifact) &&
-          passesRepository(artifact),
-      ).length,
+      count: tab.id === "ALL" ? totalAll : (tabCounts.get(tab.id) ?? 0),
     }));
-  }, [
-    artifacts,
-    activeTab,
-    deferredSearchQuery,
-    matchesSearch,
-    passesSources,
-    passesFormat,
-    passesRepository,
-  ]);
-
-  /** Sources present in the project (plus any selected one, so a filter is never invisible). */
+  }, [activeTab, facetsData?.types, tabCounts]);
+
+  const sourceCounts = useMemo(() => {
+    const map = new Map<string, number>();
+    for (const s of facetsData?.sources ?? []) {
+      map.set(s.value, s.count);
+    }
+    return map;
+  }, [facetsData?.sources]);
+
   const sourceOptions = useMemo<FacetOption<SourceSystem>[]>(() => {
-    const present = new Set(artifacts.map((artifact) => artifact.sourceSystem));
     return DEFAULT_SOURCE_ORDER.filter(
-      (source) => present.has(source) || selectedSources.has(source),
+      (source) => sourceCounts.has(source) || selectedSources.has(source),
     ).map((source) => ({
       value: source,
       label: SOURCE_LABELS[source],
-      count: artifacts.filter(
-        (artifact) =>
-          artifact.sourceSystem === source &&
-          matchesSearch(artifact, deferredSearchQuery) &&
-          passesTab(artifact) &&
-          passesFormat(artifact) &&
-          passesRepository(artifact),
-      ).length,
+      count: sourceCounts.get(source) ?? 0,
     }));
-  }, [
-    artifacts,
-    deferredSearchQuery,
-    matchesSearch,
-    passesTab,
-    passesFormat,
-    passesRepository,
-    selectedSources,
-  ]);
+  }, [selectedSources, sourceCounts]);
+
+  const formatCounts = useMemo(() => {
+    const map = new Map<string, number>();
+    for (const f of facetsData?.formats ?? []) {
+      map.set(f.value, f.count);
+    }
+    return map;
+  }, [facetsData?.formats]);
 
-  /**
-   * File formats, offered only while Uploads is part of the source selection.
-   *
-   * Empty means "this facet does not apply right now", which is exactly the
-   * condition the filter UI renders the section on — so the rule lives here once
-   * instead of being re-derived by every caller.
-   */
   const formatOptions = useMemo<FacetOption<UploadFormat>[]>(() => {
     if (!selectedSources.has("UPLOAD")) return [];
-
-    // No passesRepository here: the candidates are uploads, and
-    // matchesRepository passes every non-GitHub artifact — the condition could
-    // never exclude anything, it only pulled a dependency in for nothing.
-    const uploads = artifacts.filter(
-      (artifact) =>
-        isUpload(artifact) && matchesSearch(artifact, deferredSearchQuery) && passesTab(artifact),
-    );
-
-    // Same rule as the types: a format no upload in scope can produce is not
-    // offered, but one the reader already chose stays so it can be unchosen.
     return DEFAULT_FORMAT_ORDER.filter(
-      (format) => selectedFormat === format || uploads.some((a) => matchesFormat(a, format)),
+      (format) => selectedFormat === format || (formatCounts.get(format) ?? 0) > 0,
     ).map((format) => ({
       value: format,
       label: FORMAT_LABELS[format],
-      count: uploads.filter((artifact) => matchesFormat(artifact, format)).length,
+      count: formatCounts.get(format) ?? 0,
     }));
-  }, [artifacts, deferredSearchQuery, matchesSearch, passesTab, selectedSources, selectedFormat]);
+  }, [selectedSources, selectedFormat, formatCounts]);
+
+  const repoCounts = useMemo(() => {
+    const map = new Map<string, number>();
+    for (const r of facetsData?.repositories ?? []) {
+      map.set(r.value, r.count);
+    }
+    return map;
+  }, [facetsData?.repositories]);
 
-  /**
-   * Repositories behind the project's GitHub artifacts, offered only while
-   * GitHub is part of the source selection.
-   *
-   * Same contract as `formatOptions`: empty means "this facet does not apply
-   * right now", which is the condition the filter UI renders the section on.
-   * Alphabetical because repository names are unbounded, unlike the fixed enum
-   * facets. A choice that no longer appears in scope stays so it can be
-   * unchosen.
-   */
   const repositoryOptions = useMemo<FacetOption<string>[]>(() => {
     if (!selectedSources.has("GITHUB")) return [];
-
-    // Candidates are the GitHub artifacts the current tab and search admit;
-    // the format facet cannot exclude them (matchesFormat passes every
-    // non-upload), so it is deliberately not applied here.
-    const githubCandidates = artifacts.filter(
-      (artifact) =>
-        artifact.sourceSystem === "GITHUB" &&
-        matchesSearch(artifact, deferredSearchQuery) &&
-        passesTab(artifact),
+    const repos = (facetsData?.repositories ?? []).map((r) => r.value);
+    const offered = Array.from(new Set([...repos, ...selectedRepositories])).sort((a, b) =>
+      a.localeCompare(b),
     );
+    return offered.map((repository) => ({
+      value: repository,
+      label: repository,
+      count: repoCounts.get(repository) ?? 0,
+    }));
+  }, [selectedSources, selectedRepositories, facetsData?.repositories, repoCounts]);
 
-    const repos = new Set<string>();
-    for (const artifact of githubCandidates) {
-      const repository = getArtifactRepository(artifact);
-      if (repository !== null) repos.add(repository);
+  /**
+   * Languages the project actually has, plus any the URL selects. Unlike repositories the section
+   * is not gated on a source: a language narrows every source. Matched ignoring case, like the
+   * backend, and a selected entry keeps the URL's spelling as its value so unticking hits it;
+   * alphabetical so ticking one never reshuffles the rest (counts move, positions don't).
+   */
+  const languageOptions = useMemo<FacetOption<string>[]>(() => {
+    const selectedByFold = new Map(
+      Array.from(selectedLanguages, (language) => [language.toLowerCase(), language]),
+    );
+    const offered = new Map<string, FacetOption<string>>();
+    for (const { value, count } of facetsData?.languages ?? []) {
+      const fold = value.toLowerCase();
+      const selected = selectedByFold.get(fold);
+      if (count > 0 || selected !== undefined) {
+        offered.set(fold, { value: selected ?? value, label: value, count });
+      }
     }
-
-    // Count through the predicate the list itself uses, one candidate selection
-    // at a time: bucketing on getArtifactRepository alone never counted the
-    // owning org's profile, so checking a repo delivered one more row (per
-    // owning org) than the number beside it promised.
-    const offered = new Set([...repos, ...selectedRepositories]);
-    return [...offered]
-      .sort((a, b) => a.localeCompare(b))
-      .map((repository) => ({
-        value: repository,
-        label: repository,
-        count: githubCandidates.filter((artifact) =>
-          matchesRepository(artifact, new Set([repository])),
-        ).length,
-      }));
-  }, [
-    artifacts,
-    deferredSearchQuery,
-    matchesSearch,
-    passesTab,
-    selectedSources,
-    selectedRepositories,
-  ]);
-
-  // Paging resets when the project scope changes. This deliberately does not live
-  // in `fetchArtifacts`: that function doubles as the Refresh handler, and hitting
-  // Refresh on page 3 should leave the reader on page 3 rather than snapping back.
-  const [pagedProjectId, setPagedProjectId] = useState(projectId);
-  if (pagedProjectId !== projectId) {
-    setPagedProjectId(projectId);
-    setCurrentPage(1);
-    setActiveTab("ALL");
-    setSelectedSources(NO_SOURCES);
-    setSelectedFormat(null);
-    setSelectedRepositories(NO_REPOSITORIES);
-  }
-
-  const filteredArtifacts = useMemo(
-    () =>
-      artifacts.filter(
-        (artifact) =>
-          matchesSearch(artifact, deferredSearchQuery) &&
-          passesTab(artifact) &&
-          passesSources(artifact) &&
-          passesFormat(artifact) &&
-          passesRepository(artifact),
-      ),
-    [
-      artifacts,
-      deferredSearchQuery,
-      matchesSearch,
-      passesTab,
-      passesSources,
-      passesFormat,
-      passesRepository,
-    ],
-  );
-
-  const totalPages = Math.max(1, Math.ceil(filteredArtifacts.length / ITEMS_PER_PAGE));
-
-  // Pull the page back into range when the result set shrinks -- deleting the last
-  // artifact on a page, or a filter narrowing while the reader is deep in the list.
-  // Without this the control keeps advertising a page the list no longer has, while
-  // the clamped slice below quietly shows a different one.
-  if (currentPage > totalPages) {
-    setCurrentPage(totalPages);
-  }
-
-  const paginatedArtifacts = useMemo(() => {
-    const safePage = Math.min(currentPage, totalPages);
-    const startIndex = (safePage - 1) * ITEMS_PER_PAGE;
-    return filteredArtifacts.slice(startIndex, startIndex + ITEMS_PER_PAGE);
-  }, [filteredArtifacts, currentPage, totalPages]);
+    for (const [fold, language] of selectedByFold) {
+      if (!offered.has(fold)) offered.set(fold, { value: language, label: language, count: 0 });
+    }
+    return Array.from(offered.values()).sort((a, b) => a.label.localeCompare(b.label));
+  }, [selectedLanguages, facetsData?.languages]);
 
   const handleSearchChange = useCallback((query: string) => {
     setSearchQuery(query);
-    setCurrentPage(1);
   }, []);
 
-  const handleTabChange = useCallback((tab: KnowledgeTab) => {
-    setActiveTab(tab);
-    setCurrentPage(1);
-  }, []);
+  const handleTabChange = useCallback((tab: KnowledgeTab) => setTab(tab), [setTab]);
 
-  const toggleSource = useCallback(
-    (source: SourceSystem) => {
-      const isRemoving = selectedSources.has(source);
-
-      setSelectedSources((current) => {
-        const next = new Set(current);
-        if (isRemoving) {
-          next.delete(source);
-        } else {
-          next.add(source);
-        }
-        return next;
-      });
-
-      // The format facet only describes uploads. With Uploads deselected its
-      // options are not rendered, so a surviving choice would be a filter the
-      // reader can neither see nor clear.
-      if (isRemoving && source === "UPLOAD") {
-        setSelectedFormat(null);
-      }
-
-      // Same rule for the repository facet, which only describes GitHub.
-      if (isRemoving && source === "GITHUB") {
-        setSelectedRepositories(NO_REPOSITORIES);
-      }
-
-      setCurrentPage(1);
-    },
-    [selectedSources],
-  );
-
-  const toggleFormat = useCallback((format: UploadFormat) => {
-    setSelectedFormat((current) => (current === format ? null : format));
-    setCurrentPage(1);
-  }, []);
-
-  const toggleRepository = useCallback((repository: string) => {
-    setSelectedRepositories((current) => {
-      const next = new Set(current);
-      if (next.has(repository)) {
-        next.delete(repository);
-      } else {
-        next.add(repository);
-      }
-      return next;
-    });
-    setCurrentPage(1);
-  }, []);
+  const setCurrentPage = useCallback((page: number) => setPage(page), [setPage]);
 
   const handleClearFilters = useCallback(() => {
     setSearchQuery("");
-    setActiveTab("ALL");
-    setSelectedSources(NO_SOURCES);
-    setSelectedFormat(null);
-    setSelectedRepositories(NO_REPOSITORIES);
-    setCurrentPage(1);
-  }, []);
+    clearFilters();
+  }, [clearFilters]);
 
   const hasActiveFilters =
     searchQuery !== "" ||
     activeTab !== "ALL" ||
     selectedSources.size > 0 ||
     selectedFormat !== null ||
-    selectedRepositories.size > 0;
+    selectedRepositories.size > 0 ||
+    selectedLanguages.size > 0 ||
+    dateFrom !== undefined ||
+    dateTo !== undefined;
 
   return {
     artifacts,
@@ -416,20 +432,39 @@ export function useKnowledgeBase(projectId: string | null) {
     sourceOptions,
     formatOptions,
     repositoryOptions,
+    /** Language facet options; empty when the project has no language values (section hidden). */
+    languageOptions,
     selectedSources,
     selectedFormat,
     selectedRepositories,
+    selectedLanguages,
     currentPage,
     totalPages,
-    filteredArtifacts,
-    paginatedArtifacts,
+    totalElements,
+    resultRange,
+    pageSize,
+    sort,
     handleSearchChange,
     handleTabChange,
     toggleSource,
     toggleFormat,
     toggleRepository,
+    /** Ticks or unticks one language (case-insensitive), resetting the page. */
+    toggleLanguage,
     setCurrentPage,
+    setPageSize: setSize,
+    /** Changes the list order; pushes history and starts the new order at page 1. */
+    setSort,
+    /** The "Updated" window (last activity) (`yyyy-MM-dd` ends, null when open); filters list and facets alike. */
+    dateRange: urlState.dateRange,
+    setDateRange,
     handleClearFilters,
     hasActiveFilters,
+    /** Changes whenever the visible list's filters, page, size or order change. */
+    listScopeKey,
+    /** The artifact open in the viewer drawer (`?artifact=`), or null. */
+    selectedArtifactId: urlState.artifactId,
+    /** Opens or closes the viewer drawer; `replace`s `?artifact=` so reading leaves no history. */
+    setSelectedArtifactId: setArtifactId,
   };
 }
diff --git a/src/features/knowledge-base/hooks/useKnowledgeBaseUrlState.ts b/src/features/knowledge-base/hooks/useKnowledgeBaseUrlState.ts
new file mode 100644
index 00000000..f24b2dfd
--- /dev/null
+++ b/src/features/knowledge-base/hooks/useKnowledgeBaseUrlState.ts
@@ -0,0 +1,539 @@
+import { useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState } from "react";
+import { useLocation, useNavigate } from "react-router-dom";
+import {
+  ARTIFACT_SORT_ORDER,
+  DEFAULT_ARTIFACT_SORT,
+  DEFAULT_FORMAT_ORDER,
+  DEFAULT_SOURCE_ORDER,
+  KNOWLEDGE_TAB_ORDER,
+} from "../tabs.ts";
+import type { KnowledgeTab } from "../tabs.ts";
+import type { ArtifactSort, SourceSystem, UploadFormat } from "../types.ts";
+import { normalizeDateRange, type DateRange } from "../dateRange.ts";
+
+/** Page size used when the URL names none. Mirrors the backend's list default. */
+export const DEFAULT_PAGE_SIZE = 20;
+
+/**
+ * Largest page size the list endpoint accepts (`@Max(MAX_PAGE_SIZE)` in the backend's
+ * `ArtifactController`). A hand-edited `?size=500` is clamped to it instead of being sent
+ * through to a guaranteed 400.
+ */
+export const MAX_PAGE_SIZE = 100;
+
+/**
+ * Page sizes the page-size control offers. All inside the backend's 1..100 bound;
+ * a hand-edited `?size=` outside this list still works (it is only clamped) and
+ * is shown as an extra option, so the control never lies about the current size.
+ */
+export const PAGE_SIZE_OPTIONS: readonly number[] = [DEFAULT_PAGE_SIZE, 50, MAX_PAGE_SIZE];
+
+/**
+ * Query-string keys the Knowledge Base page owns. Short, human-readable names, because these
+ * URLs are meant to be pasted into chats and tickets.
+ */
+export const KB_URL_PARAM = {
+  tab: "tab",
+  search: "q",
+  sources: "sources",
+  repositories: "repos",
+  format: "format",
+  languages: "languages",
+  page: "page",
+  size: "size",
+  sort: "sort",
+  from: "from",
+  to: "to",
+  artifact: "artifact",
+} as const;
+
+/**
+ * The params that describe *one project's* corpus. A project switch drops them: a repository or
+ * an open artifact from project A means nothing in project B, and the empty list it would produce
+ * reads as "this project has no knowledge". `size` and `sort` are deliberately not in here — they
+ * are reading preferences, not statements about the project's content.
+ */
+const PROJECT_SCOPED_PARAMS: readonly string[] = [
+  KB_URL_PARAM.tab,
+  KB_URL_PARAM.search,
+  KB_URL_PARAM.sources,
+  KB_URL_PARAM.repositories,
+  KB_URL_PARAM.format,
+  KB_URL_PARAM.languages,
+  KB_URL_PARAM.from,
+  KB_URL_PARAM.to,
+  KB_URL_PARAM.page,
+  KB_URL_PARAM.artifact,
+];
+
+/**
+ * Everything "Clear filters" resets. Unlike a project switch it keeps the open artifact, and like
+ * one it keeps `size` and `sort`: an order is not a filter, and clearing must not reshuffle.
+ */
+const FILTER_PARAMS: readonly string[] = [
+  KB_URL_PARAM.tab,
+  KB_URL_PARAM.search,
+  KB_URL_PARAM.sources,
+  KB_URL_PARAM.repositories,
+  KB_URL_PARAM.format,
+  KB_URL_PARAM.languages,
+  KB_URL_PARAM.from,
+  KB_URL_PARAM.to,
+  KB_URL_PARAM.page,
+];
+
+const TAB_VALUES: ReadonlySet<string> = new Set(KNOWLEDGE_TAB_ORDER);
+const SOURCE_VALUES: ReadonlySet<string> = new Set(DEFAULT_SOURCE_ORDER);
+const FORMAT_VALUES: ReadonlySet<string> = new Set(DEFAULT_FORMAT_ORDER);
+const SORT_VALUES: ReadonlySet<string> = new Set(ARTIFACT_SORT_ORDER);
+const NO_SOURCES: ReadonlySet<SourceSystem> = new Set<SourceSystem>();
+const NO_STRINGS: ReadonlySet<string> = new Set<string>();
+
+/** The Knowledge Base filter state as the URL describes it, already validated. */
+export interface KnowledgeBaseUrlState {
+  /** Artifact type tab; `"ALL"` when the URL names none (or names one that does not exist). */
+  tab: KnowledgeTab;
+  /** Search text exactly as written to `?q=`; trimming is the request builder's job. */
+  search: string;
+  sources: ReadonlySet<SourceSystem>;
+  /** Only ever non-empty while GitHub is among `sources` — see {@link parseKnowledgeBaseSearch}. */
+  repositories: ReadonlySet<string>;
+  /** Only ever non-null while Uploads is among `sources` — see {@link parseKnowledgeBaseSearch}. */
+  format: UploadFormat | null;
+  /**
+   * Language display names, first spelling kept, de-duplicated ignoring case (the backend matches
+   * case-insensitively, so `Kotlin` and `kotlin` are one filter). Independent of `sources`: a
+   * language narrows every source, unlike the upload-only format.
+   */
+  languages: ReadonlySet<string>;
+  /** 1-based. Not clamped to the result's page count here — the URL cannot know it. */
+  page: number;
+  size: number;
+  /** List order; {@link DEFAULT_ARTIFACT_SORT} when the URL names none or an unknown one. */
+  sort: ArtifactSort;
+  /**
+   * The "Updated" window on last activity (`lastChangedAt`, else `ingestedAt`),
+   * `yyyy-MM-dd` each end, open ends null. Always valid and
+   * ordered (see `normalizeDateRange`), so it can go to the backend as-is.
+   */
+  dateRange: DateRange;
+  /** The artifact open in the viewer drawer, if any. */
+  artifactId: string | null;
+}
+
+/**
+ * Reads a set-valued param. Accepts both `?sources=GITHUB,JIRA` (what this hook writes) and
+ * `?sources=GITHUB&sources=JIRA` (what a hand-built link or the backend's own style would use),
+ * de-duplicated in first-seen order.
+ */
+function readList(params: URLSearchParams, key: string): string[] {
+  const values = params
+    .getAll(key)
+    .flatMap((raw) => raw.split(","))
+    .map((value) => value.trim())
+    .filter((value) => value.length > 0);
+  return Array.from(new Set(values));
+}
+
+/**
+ * {@link readList} de-duplicated ignoring case, keeping the first spelling. For values the
+ * backend matches case-insensitively, where `?languages=Kotlin,kotlin` is one filter, not two.
+ */
+function readListIgnoringCase(params: URLSearchParams, key: string): string[] {
+  const seen = new Set<string>();
+  return readList(params, key).filter((value) => {
+    const folded = value.toLowerCase();
+    if (seen.has(folded)) return false;
+    seen.add(folded);
+    return true;
+  });
+}
+
+/** Reads an integer param clamped to `[1, max]`; anything that is not an integer is the fallback. */
+function readPositiveInt(raw: string | null, fallback: number, max: number): number {
+  if (raw === null || raw.trim() === "") return fallback;
+  const value = Number(raw);
+  if (!Number.isInteger(value)) return fallback;
+  return Math.min(Math.max(value, 1), max);
+}
+
+/**
+ * Parses the Knowledge Base query string into validated filter state.
+ *
+ * Validation is "drop what cannot be honoured", never "fail": an unknown tab, source or format is
+ * ignored (so `?tab=BOGUS` shows everything instead of sending `types=BOGUS` for a 400), page and
+ * size are clamped to what the backend accepts, and enum values are matched case-insensitively
+ * because people type URLs by hand.
+ *
+ * The two dependent facets keep the invariant the toggles enforce: a `format` only counts while
+ * Uploads is selected and `repos` only while GitHub is. Otherwise a shared link could carry a
+ * filter the panel does not even show — narrowing the list with no visible way to undo it.
+ *
+ * @param params The current `location.search`, parsed.
+ * @returns The state the page should render. Never throws.
+ */
+export function parseKnowledgeBaseSearch(params: URLSearchParams): KnowledgeBaseUrlState {
+  const rawTab = params.get(KB_URL_PARAM.tab)?.trim().toUpperCase() ?? "";
+  const tab: KnowledgeTab = TAB_VALUES.has(rawTab) ? (rawTab as KnowledgeTab) : "ALL";
+
+  const sourceList = readList(params, KB_URL_PARAM.sources)
+    .map((value) => value.toUpperCase())
+    .filter((value): value is SourceSystem => SOURCE_VALUES.has(value));
+  const sources: ReadonlySet<SourceSystem> =
+    sourceList.length > 0 ? new Set(sourceList) : NO_SOURCES;
+
+  const rawFormat = params.get(KB_URL_PARAM.format)?.trim().toUpperCase() ?? "";
+  const format =
+    sources.has("UPLOAD") && FORMAT_VALUES.has(rawFormat) ? (rawFormat as UploadFormat) : null;
+
+  const repositoryList = sources.has("GITHUB") ? readList(params, KB_URL_PARAM.repositories) : [];
+  const repositories: ReadonlySet<string> =
+    repositoryList.length > 0 ? new Set(repositoryList) : NO_STRINGS;
+
+  const languageList = readListIgnoringCase(params, KB_URL_PARAM.languages);
+  const languages: ReadonlySet<string> =
+    languageList.length > 0 ? new Set(languageList) : NO_STRINGS;
+
+  const dateRange = normalizeDateRange({
+    from: params.get(KB_URL_PARAM.from),
+    to: params.get(KB_URL_PARAM.to),
+  });
+
+  // An unknown order is dropped, not sent: the backend answers it with a 400.
+  const rawSort = params.get(KB_URL_PARAM.sort)?.trim().toUpperCase() ?? "";
+  const sort = SORT_VALUES.has(rawSort) ? (rawSort as ArtifactSort) : DEFAULT_ARTIFACT_SORT;
+
+  return {
+    tab,
+    search: params.get(KB_URL_PARAM.search) ?? "",
+    sources,
+    repositories,
+    format,
+    languages,
+    page: readPositiveInt(params.get(KB_URL_PARAM.page), 1, Number.MAX_SAFE_INTEGER),
+    size: readPositiveInt(params.get(KB_URL_PARAM.size), DEFAULT_PAGE_SIZE, MAX_PAGE_SIZE),
+    sort,
+    dateRange,
+    artifactId: params.get(KB_URL_PARAM.artifact) || null,
+  };
+}
+
+/**
+ * Serialises params back into a `location.search` string (`""` when empty). Commas and slashes
+ * are left readable — `?sources=GITHUB,JIRA&repos=acme/api` rather than `%2C`/`%2F` — both are
+ * legal in a query string and `URLSearchParams` reads them back unchanged.
+ */
+export function toKnowledgeBaseSearchString(params: URLSearchParams): string {
+  const query = params.toString().replace(/%2C/gi, ",").replace(/%2F/gi, "/");
+  return query ? `?${query}` : "";
+}
+
+/** Writes a set-valued param as one comma-separated value, or removes it when empty. */
+function writeList(params: URLSearchParams, key: string, values: Iterable<string>): void {
+  const list = Array.from(values);
+  if (list.length > 0) params.set(key, list.join(","));
+  else params.delete(key);
+}
+
+/** Adds `value` to the set-valued param `key` if absent, removes it if present. */
+function toggleInList(params: URLSearchParams, key: string, value: string): boolean {
+  const current = readList(params, key);
+  const isRemoving = current.includes(value);
+  writeList(
+    params,
+    key,
+    isRemoving ? current.filter((entry) => entry !== value) : [...current, value],
+  );
+  return isRemoving;
+}
+
+/** Removes every key in `keys` from a copy of `search`, returned as a search string. */
+function withoutParams(search: string, keys: readonly string[]): string {
+  const params = new URLSearchParams(search);
+  for (const key of keys) params.delete(key);
+  return toKnowledgeBaseSearchString(params);
+}
+
+/**
+ * How a write lands in the browser history. Discrete choices (a tab, a facet, a page) `push`, so
+ * Back undoes the last click instead of leaving the page; continuous or corrective writes (search
+ * typing, the drawer's `?artifact=`, clamping, a project switch) `replace`, so Back does not walk
+ * through every keystroke or through states nobody chose.
+ */
+export type KnowledgeBaseHistoryMode = "push" | "replace";
+
+/** Options for {@link useKnowledgeBaseUrlState}. */
+export interface KnowledgeBaseUrlStateOptions {
+  /**
+   * Whether `projectId` is final. The page resolves the project as "the global selection, else the
+   * user's first project" and the global selection is `""` until the project list has loaded, so
+   * during that window `projectId` can move from the fallback to the real selection. That move is
+   * not a project *switch* and must not wipe the filters of the link somebody just opened; only
+   * changes between two settled ids count. Defaults to `true`.
+   */
+  projectSettled?: boolean;
+}
+
+/** State and writers returned by {@link useKnowledgeBaseUrlState}. */
+export interface KnowledgeBaseUrlStateApi {
+  state: KnowledgeBaseUrlState;
+  /**
+   * The settled project the current filters belong to. Changes exactly when a project switch
+   * clears them, so a consumer holding derived local state (the search input) can reset with it.
+   */
+  scopeProjectId: string | null;
+  setTab: (tab: KnowledgeTab) => void;
+  /** Replace-mode write of `?q=`, resetting the page. */
+  setSearch: (search: string) => void;
+  toggleSource: (source: SourceSystem) => void;
+  toggleFormat: (format: UploadFormat) => void;
+  toggleRepository: (repository: string) => void;
+  /** Push-mode toggle of one language in `?languages=`, matched ignoring case, resetting the page. */
+  toggleLanguage: (language: string) => void;
+  setPage: (page: number, mode?: KnowledgeBaseHistoryMode) => void;
+  /** Push-mode write of `?size=`, resetting the page. */
+  setSize: (size: number) => void;
+  /** Push-mode write of `?sort=` (omitted at the default), resetting the page. */
+  setSort: (sort: ArtifactSort) => void;
+  /**
+   * Writes `?from=`/`?to=` (normalised; open ends removed), resetting the page. Presets and
+   * "clear" push; typing into a date field replaces, so one edit is one history entry.
+   */
+  setDateRange: (range: DateRange, mode?: KnowledgeBaseHistoryMode) => void;
+  /** Resets every filter (not size, not sort, not the open artifact) in one history entry. */
+  clearFilters: () => void;
+  /** Opens (`id`) or closes (`null`) the viewer drawer, in replace mode. */
+  setArtifactId: (artifactId: string | null) => void;
+}
+
+/**
+ * Makes the URL the single source of truth for the Knowledge Base filters, so a refresh keeps
+ * them, a link is shareable, and Back undoes the last filter click.
+ *
+ * This is the only writer of the page's query string — the drawer's `?artifact=` deep link lives
+ * here too, because two independent writers of one `URLSearchParams` overwrite each other.
+ *
+ * Writes go through a ref holding the latest search string rather than through the render's
+ * snapshot. React Router applies location changes inside `startTransition`, so two writes in one
+ * event (a test's `act`, a double click) would otherwise each start from the same stale snapshot
+ * and the second would silently undo the first.
+ *
+ * On a switch between two settled projects the project-scoped params are removed with a single
+ * `replace`. Until that navigation lands the hook already *reports* the cleared state, so no
+ * request is ever sent for project B with project A's filters.
+ *
+ * @param projectId The project the page is scoped to, or null while there is none.
+ * @param options See {@link KnowledgeBaseUrlStateOptions}.
+ */
+export function useKnowledgeBaseUrlState(
+  projectId: string | null,
+  { projectSettled = true }: KnowledgeBaseUrlStateOptions = {},
+): KnowledgeBaseUrlStateApi {
+  const location = useLocation();
+  const navigate = useNavigate();
+
+  const latestSearchRef = useRef(location.search);
+  useLayoutEffect(() => {
+    latestSearchRef.current = location.search;
+  }, [location.search]);
+
+  /*
+    Project-switch detection, derived during render (the same "adjust state when a prop changes"
+    pattern the old reset block used) so the very render that sees project B already reports B's
+    clean state. `staleSearch` remembers the query string that belonged to the previous project:
+    while the location still equals it, its project-scoped params are masked out; once the
+    clearing navigation lands the location differs and the mask retires itself.
+  */
+  const [scopeProjectId, setScopeProjectId] = useState<string | null>(null);
+  const [staleSearch, setStaleSearch] = useState<string | null>(null);
+  let activeStaleSearch = staleSearch;
+  if (projectSettled && projectId && projectId !== scopeProjectId) {
+    setScopeProjectId(projectId);
+    if (scopeProjectId !== null) {
+      setStaleSearch(location.search);
+      activeStaleSearch = location.search;
+    }
+  } else if (staleSearch !== null && location.search !== staleSearch) {
+    setStaleSearch(null);
+    activeStaleSearch = null;
+  }
+
+  const effectiveSearch =
+    activeStaleSearch !== null && location.search === activeStaleSearch
+      ? withoutParams(location.search, PROJECT_SCOPED_PARAMS)
+      : location.search;
+
+  const state = useMemo(
+    () => parseKnowledgeBaseSearch(new URLSearchParams(effectiveSearch)),
+    [effectiveSearch],
+  );
+
+  const commit = useCallback(
+    (mutate: (params: URLSearchParams) => void, mode: KnowledgeBaseHistoryMode) => {
+      const current = toKnowledgeBaseSearchString(new URLSearchParams(latestSearchRef.current));
+      const params = new URLSearchParams(latestSearchRef.current);
+      mutate(params);
+      const next = toKnowledgeBaseSearchString(params);
+      // A no-op write must not add a history entry: Back would then appear to do nothing.
+      if (next === current) return;
+      latestSearchRef.current = next;
+      void navigate({ search: next }, { replace: mode === "replace", preventScrollReset: true });
+    },
+    [navigate],
+  );
+
+  useEffect(() => {
+    if (staleSearch === null) return;
+    commit((params) => {
+      for (const key of PROJECT_SCOPED_PARAMS) params.delete(key);
+    }, "replace");
+  }, [staleSearch, commit]);
+
+  const setTab = useCallback(
+    (tab: KnowledgeTab) =>
+      commit((params) => {
+        if (tab === "ALL") params.delete(KB_URL_PARAM.tab);
+        else params.set(KB_URL_PARAM.tab, tab);
+        params.delete(KB_URL_PARAM.page);
+      }, "push"),
+    [commit],
+  );
+
+  const setSearch = useCallback(
+    (search: string) =>
+      commit((params) => {
+        if (search.trim() === "") params.delete(KB_URL_PARAM.search);
+        else params.set(KB_URL_PARAM.search, search);
+        params.delete(KB_URL_PARAM.page);
+      }, "replace"),
+    [commit],
+  );
+
+  const toggleSource = useCallback(
+    (source: SourceSystem) =>
+      commit((params) => {
+        const isRemoving = toggleInList(params, KB_URL_PARAM.sources, source);
+        // The dependent facets describe one source each; they go when their source goes.
+        if (isRemoving && source === "UPLOAD") params.delete(KB_URL_PARAM.format);
+        if (isRemoving && source === "GITHUB") params.delete(KB_URL_PARAM.repositories);
+        params.delete(KB_URL_PARAM.page);
+      }, "push"),
+    [commit],
+  );
+
+  const toggleFormat = useCallback(
+    (format: UploadFormat) =>
+      commit((params) => {
+        const current = params.get(KB_URL_PARAM.format)?.toUpperCase();
+        if (current === format) params.delete(KB_URL_PARAM.format);
+        else params.set(KB_URL_PARAM.format, format);
+        params.delete(KB_URL_PARAM.page);
+      }, "push"),
+    [commit],
+  );
+
+  const toggleRepository = useCallback(
+    (repository: string) =>
+      commit((params) => {
+        toggleInList(params, KB_URL_PARAM.repositories, repository);
+        params.delete(KB_URL_PARAM.page);
+      }, "push"),
+    [commit],
+  );
+
+  const toggleLanguage = useCallback(
+    (language: string) =>
+      commit((params) => {
+        // Case-folded, like the backend's match: unticking "Kotlin" must also drop a
+        // hand-typed "kotlin", or the reader could not undo the filter they see.
+        const folded = language.toLowerCase();
+        const current = readListIgnoringCase(params, KB_URL_PARAM.languages);
+        const kept = current.filter((entry) => entry.toLowerCase() !== folded);
+        writeList(
+          params,
+          KB_URL_PARAM.languages,
+          kept.length < current.length ? kept : [...current, language],
+        );
+        params.delete(KB_URL_PARAM.page);
+      }, "push"),
+    [commit],
+  );
+
+  const setPage = useCallback(
+    (page: number, mode: KnowledgeBaseHistoryMode = "push") =>
+      commit((params) => {
+        if (page <= 1) params.delete(KB_URL_PARAM.page);
+        else params.set(KB_URL_PARAM.page, String(page));
+      }, mode),
+    [commit],
+  );
+
+  const setSize = useCallback(
+    (size: number) =>
+      commit((params) => {
+        const clamped = Math.min(Math.max(Math.trunc(size), 1), MAX_PAGE_SIZE);
+        if (clamped === DEFAULT_PAGE_SIZE) params.delete(KB_URL_PARAM.size);
+        else params.set(KB_URL_PARAM.size, String(clamped));
+        params.delete(KB_URL_PARAM.page);
+      }, "push"),
+    [commit],
+  );
+
+  const setSort = useCallback(
+    (sort: ArtifactSort) =>
+      commit((params) => {
+        if (sort === DEFAULT_ARTIFACT_SORT) params.delete(KB_URL_PARAM.sort);
+        else params.set(KB_URL_PARAM.sort, sort);
+        // Page 3 of a different order is an arbitrary slice; start the new order at its top.
+        params.delete(KB_URL_PARAM.page);
+      }, "push"),
+    [commit],
+  );
+
+  const setDateRange = useCallback(
+    (range: DateRange, mode: KnowledgeBaseHistoryMode = "push") =>
+      commit((params) => {
+        const { from, to } = normalizeDateRange(range);
+        if (from) params.set(KB_URL_PARAM.from, from);
+        else params.delete(KB_URL_PARAM.from);
+        if (to) params.set(KB_URL_PARAM.to, to);
+        else params.delete(KB_URL_PARAM.to);
+        params.delete(KB_URL_PARAM.page);
+      }, mode),
+    [commit],
+  );
+
+  const clearFilters = useCallback(
+    () =>
+      commit((params) => {
+        for (const key of FILTER_PARAMS) params.delete(key);
+      }, "push"),
+    [commit],
+  );
+
+  const setArtifactId = useCallback(
+    (artifactId: string | null) =>
+      commit((params) => {
+        if (artifactId) params.set(KB_URL_PARAM.artifact, artifactId);
+        else params.delete(KB_URL_PARAM.artifact);
+      }, "replace"),
+    [commit],
+  );
+
+  return {
+    state,
+    scopeProjectId,
+    setTab,
+    setSearch,
+    toggleSource,
+    toggleFormat,
+    toggleRepository,
+    toggleLanguage,
+    setPage,
+    setSize,
+    setSort,
+    setDateRange,
+    clearFilters,
+    setArtifactId,
+  };
+}
diff --git a/src/features/knowledge-base/hooks/useUploadSelection.ts b/src/features/knowledge-base/hooks/useUploadSelection.ts
new file mode 100644
index 00000000..53cb59c2
--- /dev/null
+++ b/src/features/knowledge-base/hooks/useUploadSelection.ts
@@ -0,0 +1,54 @@
+import { useCallback, useState } from "react";
+
+const NO_IDS: ReadonlySet<string> = new Set();
+
+interface ScopedSelection {
+  scope: string;
+  ids: ReadonlySet<string>;
+}
+
+/**
+ * Select mode and the ticked artifact ids for the Knowledge Base bulk delete.
+ *
+ * The selection is tied to `scopeKey` — the identity of the list on screen
+ * (filters, page, size, sort). When the key changes the selection reads as
+ * empty in that same render, without an effect: a selection
+ * that survives a filter or page change is a trap, because the reader can no
+ * longer see what they are about to delete. `clear` covers the cases the key
+ * cannot see (refresh, a finished delete).
+ *
+ * Leaving select mode clears too, so re-entering never resurrects old ticks.
+ */
+export function useUploadSelection(scopeKey: string) {
+  const [isSelectMode, setIsSelectMode] = useState(false);
+  const [selection, setSelection] = useState<ScopedSelection>({ scope: scopeKey, ids: NO_IDS });
+
+  // The documented "adjust state while rendering" pattern: a new scope drops the old ticks for
+  // good, so returning to the previous page does not resurrect them.
+  if (selection.scope !== scopeKey) setSelection({ scope: scopeKey, ids: NO_IDS });
+
+  const selectedIds = selection.scope === scopeKey ? selection.ids : NO_IDS;
+
+  const toggle = useCallback(
+    (id: string) =>
+      setSelection((previous) => {
+        const ids = new Set(previous.scope === scopeKey ? previous.ids : NO_IDS);
+        if (ids.has(id)) ids.delete(id);
+        else ids.add(id);
+        return { scope: scopeKey, ids };
+      }),
+    [scopeKey],
+  );
+
+  const clear = useCallback(() => setSelection({ scope: scopeKey, ids: NO_IDS }), [scopeKey]);
+
+  const setSelectMode = useCallback(
+    (on: boolean) => {
+      setIsSelectMode(on);
+      if (!on) clear();
+    },
+    [clear],
+  );
+
+  return { isSelectMode, setSelectMode, selectedIds, toggle, clear };
+}
diff --git a/src/features/knowledge-base/orgMetadata.ts b/src/features/knowledge-base/orgMetadata.ts
index 1c4bbcab..9d553db3 100644
--- a/src/features/knowledge-base/orgMetadata.ts
+++ b/src/features/knowledge-base/orgMetadata.ts
@@ -80,7 +80,8 @@ export function parseOrgMetadata(
   }
 
   const p = parsed as Record<string, unknown>;
-  if (typeof p["login"] !== "string" || !Array.isArray(p["members"])) {
+  const login = p["login"];
+  if (typeof login !== "string" || login.trim() === "" || !Array.isArray(p["members"])) {
     return null;
   }
 
@@ -102,5 +103,8 @@ export function parseOrgMetadata(
     if (!everyTeamUsable) return null;
   }
 
-  return parsed as OrgMetadataArtifactMetadata;
+  // Same normalization as the repo parser applies to repositoryFullName: a
+  // padded login must not silently miss the owner-half match, which folds
+  // case but compares against a trimmed `owner/repo` string.
+  return { ...(parsed as OrgMetadataArtifactMetadata), login: login.trim() };
 }
diff --git a/src/features/knowledge-base/resultRange.ts b/src/features/knowledge-base/resultRange.ts
new file mode 100644
index 00000000..1777b92f
--- /dev/null
+++ b/src/features/knowledge-base/resultRange.ts
@@ -0,0 +1,14 @@
+/**
+ * Words the result line: "1–20 of 412 artifacts" while a page is known, the total
+ * alone otherwise. An empty result reads "No artifacts" rather than "0–0 of 0".
+ *
+ * @param total Matching artifacts across every page.
+ * @param range 1-based positions of the first and last artifact on this page.
+ */
+export function formatResultRange(total: number, range?: { start: number; end: number }): string {
+  const noun = total === 1 ? "artifact" : "artifacts";
+  if (total === 0) return "No artifacts";
+  if (!range || range.start < 1 || range.end < range.start) return `${total} ${noun}`;
+  if (range.start === 1 && range.end >= total) return `${total} ${noun}`;
+  return `${range.start}–${range.end} of ${total} ${noun}`;
+}
diff --git a/src/features/knowledge-base/tabs.ts b/src/features/knowledge-base/tabs.ts
index 390a0971..b9b141f3 100644
--- a/src/features/knowledge-base/tabs.ts
+++ b/src/features/knowledge-base/tabs.ts
@@ -1,4 +1,11 @@
-import type { Artifact, ArtifactType, SourceSystem } from "./types";
+import type { Artifact, ArtifactSort, ArtifactType, SourceSystem, UploadFormat } from "./types";
+
+/**
+ * Upload file formats the knowledge base classifies an upload into. Declared
+ * beside the artifact types they filter on, and re-exported from `./types` so
+ * the facet's labels and its values stay next to each other.
+ */
+export type { UploadFormat } from "./types";
 
 /**
  * Human-readable display names for the artifact sources (connectors).
@@ -80,8 +87,6 @@ export const KNOWLEDGE_TAB_ORDER: readonly KnowledgeTab[] = KNOWLEDGE_TABS.map((
  * for uploads, so this facet is offered only while `UPLOAD` is part of the
  * source selection (see `useKnowledgeBase`).
  */
-export type UploadFormat = "PDF" | "MARKDOWN" | "IMAGE" | "OTHER";
-
 /** Human-readable display names for the file-format facet. */
 export const FORMAT_LABELS: Record<UploadFormat, string> = {
   PDF: "PDFs",
@@ -93,6 +98,19 @@ export const FORMAT_LABELS: Record<UploadFormat, string> = {
 /** Standard order for the file-format facet. */
 export const DEFAULT_FORMAT_ORDER: UploadFormat[] = ["PDF", "MARKDOWN", "IMAGE", "OTHER"];
 
+/** The list order used when the URL names none — and the one the backend applies unasked. */
+export const DEFAULT_ARTIFACT_SORT: ArtifactSort = "ADDED_DESC";
+
+/** Display names for the sort control, phrased as what the reader sees first. */
+export const SORT_LABELS: Record<ArtifactSort, string> = {
+  ADDED_DESC: "Newest added",
+  CHANGED_DESC: "Recently changed",
+  TITLE_ASC: "Title A–Z",
+};
+
+/** Order of the options in the sort control. */
+export const ARTIFACT_SORT_ORDER: ArtifactSort[] = ["ADDED_DESC", "CHANGED_DESC", "TITLE_ASC"];
+
 /** Whether an artifact came from a direct upload rather than a connector. */
 export function isUpload(artifact: Artifact): boolean {
   return artifact.sourceSystem === "UPLOAD";
@@ -121,6 +139,12 @@ function isPdfArtifact(artifact: Artifact): boolean {
   );
 }
 
+/**
+ * `language` is the backend's display name from the file extension at ingestion
+ * (`"Markdown"`), sent since the language facet; compared lowercased so it
+ * classifies a Markdown upload even when its title carries no extension. Other
+ * languages (`"Kotlin"`, `"Plain Text"`) are no Markdown signal and fall to Other.
+ */
 function isMarkdownArtifact(artifact: Artifact): boolean {
   const title = artifact.title?.toLowerCase() ?? "";
   const sourceId = artifact.sourceId.toLowerCase();
diff --git a/src/features/knowledge-base/types.ts b/src/features/knowledge-base/types.ts
index 99d747d2..c73836d8 100644
--- a/src/features/knowledge-base/types.ts
+++ b/src/features/knowledge-base/types.ts
@@ -23,6 +23,10 @@ export interface Artifact {
   sourceId: string;
   sourceUrl: string | null;
   mime: string | null;
+  /**
+   * Display name derived from the file extension at ingestion (`"Kotlin"`, `"Markdown"`,
+   * `"Plain Text"`); null for PRs, issues, commits and anything without a known extension.
+   */
   language: string | null;
   /** When the artifact was first imported. Never moves on later updates. */
   ingestedAt: string;
@@ -86,3 +90,141 @@ export interface SummaryStreamHandlers {
   /** Called when an in-stream error event is received (non-HTTP failure). */
   onError?: (error: string) => void;
 }
+
+/**
+ * Filter classification for direct uploaded artifact formats.
+ */
+export type UploadFormat = "PDF" | "MARKDOWN" | "IMAGE" | "OTHER";
+
+/**
+ * Pagination metadata returned by Spring Boot Page response.
+ *
+ * `number` is **1-based**: the backend echoes the requested `page` query
+ * parameter (`ArtifactQueryService` builds `PageRequest.of(page - 1, …)` and
+ * reports `number = page`), not Spring's 0-based `Page.number`.
+ */
+export interface PageMetadata {
+  number: number;
+  size: number;
+  totalElements: number;
+  totalPages: number;
+  hasNext: boolean;
+  hasPrevious: boolean;
+}
+
+/**
+ * Paginated list response for artifacts from GET /api/v1/projects/{projectId}/artifacts.
+ */
+export interface ArtifactPage {
+  items: Artifact[];
+  /** Spring's `Page` envelope — the only shape the endpoint sends. */
+  page: PageMetadata;
+}
+
+/**
+ * Single facet entry value and matched artifact count.
+ */
+export interface FacetCount {
+  value: string;
+  count: number;
+}
+
+/**
+ * Aggregated facet breakdown for knowledge base artifacts in a project.
+ */
+export interface ArtifactFacets {
+  types: FacetCount[];
+  sources: FacetCount[];
+  formats: FacetCount[];
+  repositories: FacetCount[];
+  /**
+   * Programming languages as stored display names (`"Kotlin"`, `"C#"`), counted with every other
+   * filter applied but their own selection excluded. Document kinds (`Markdown`, `Plain Text`) are
+   * left out — the format facet covers them. Optional because a backend predating the language
+   * facet does not send it; absent reads as "no languages", so the section simply stays hidden.
+   */
+  languages?: FacetCount[];
+}
+
+/** One upload the backend could not delete, with a client-safe reason. */
+export interface DeleteUploadFailure {
+  /** The upload's UUID (`Artifact.sourceId`), as sent in the request. */
+  artifactId: string;
+  /** Human-readable reason; the backend never puts raw exception text here. */
+  error: string;
+}
+
+/**
+ * Per-item outcome of `DELETE /api/v1/uploads`. Every requested id lands in exactly one list: a
+ * batch can partially succeed, and the UI must report what happened rather than all-or-nothing.
+ */
+export interface DeleteUploadsResult {
+  deletedIds: string[];
+  failed: DeleteUploadFailure[];
+}
+
+/**
+ * Order of the artifact list (`?sort=` on the list endpoint; the facets endpoint has none).
+ *
+ * - `ADDED_DESC`: newest first by `ingestedAt` (the backend default).
+ * - `CHANGED_DESC`: most recently changed first, by `lastChangedAt` falling back to `ingestedAt`.
+ * - `TITLE_ASC`: title A–Z, case-insensitive, untitled artifacts last.
+ *
+ * Every order breaks ties on `id`, so paging never shows a row twice or skips one.
+ */
+export type ArtifactSort = "ADDED_DESC" | "CHANGED_DESC" | "TITLE_ASC";
+
+/**
+ * Query parameters for filtering and paginating knowledge base artifacts.
+ */
+export interface KnowledgeListParams {
+  page?: number;
+  size?: number;
+  search?: string;
+  types?: ArtifactType[];
+  sources?: SourceSystem[];
+  repositories?: string[];
+  format?: UploadFormat;
+  /**
+   * Language display names, matched case-insensitively by the backend. Sent to the list and the
+   * facets alike: it narrows the row set, so every count must respect it. A selected language
+   * hides rows that have none (PRs, issues, pages) — that is the honest reading of "only Kotlin".
+   */
+  languages?: string[];
+  /**
+   * List order. Sent by `getArtifactPage` only — counts do not depend on order, and the facets
+   * endpoint does not accept it. Omitted means the backend default (`ADDED_DESC`).
+   */
+  sort?: ArtifactSort;
+  /**
+   * Earliest ingestion day, `yyyy-MM-dd`, inclusive (UTC day boundaries on the server). Sent to
+   * the list and the facets alike.
+   */
+  from?: string;
+  /** Latest ingestion day, `yyyy-MM-dd`, inclusive. Sent to the list and the facets alike. */
+  to?: string;
+}
+
+/**
+ * What the AI assistant's metadata store records for an artifact. `UNKNOWN` means the AI answered
+ * but holds no record; it never means "the AI is down" — that is `aiAvailable: false`.
+ */
+export type ArtifactAiStatus = "INDEXED" | "PROCESSING" | "FAILED" | "DEINDEXED" | "UNKNOWN";
+
+/** One artifact's entry in {@link ArtifactAiStatusResponse}. */
+export interface ArtifactAiStatusItem {
+  artifactId: string;
+  status: ArtifactAiStatus;
+  updatedAt: string | null;
+  chunkCount: number | null;
+}
+
+/**
+ * Response of `GET /projects/{id}/artifacts/ai-status`. When `aiAvailable` is false every status is
+ * `UNKNOWN` by construction and says nothing about the artifact, so no chip may be drawn from it.
+ * Ids outside the project are omitted from `items`.
+ */
+export interface ArtifactAiStatusResponse {
+  aiAvailable: boolean;
+  items: ArtifactAiStatusItem[];
+}
diff --git a/src/hooks/useDebouncedValue.ts b/src/hooks/useDebouncedValue.ts
new file mode 100644
index 00000000..d33a36c6
--- /dev/null
+++ b/src/hooks/useDebouncedValue.ts
@@ -0,0 +1,26 @@
+import { useEffect, useState } from "react";
+
+/**
+ * Returns `value` once it has stopped changing for `delayMs` milliseconds.
+ *
+ * Meant for inputs whose every intermediate state would otherwise cost a request — a search box
+ * that queries the server, for example. The caller keeps rendering the live value (so the field
+ * never lags behind the keyboard) and hands only the settled one to the expensive consumer.
+ *
+ * The first render returns `value` unchanged: there is nothing to wait for before anything has
+ * been typed, and a deep-linked value must not be held back by a needless delay.
+ *
+ * @param value The live value, e.g. the current text of an input.
+ * @param delayMs How long `value` must stay unchanged before it is returned.
+ * @returns The last value that stayed unchanged for `delayMs`.
+ */
+export function useDebouncedValue<T>(value: T, delayMs: number): T {
+  const [debounced, setDebounced] = useState(value);
+
+  useEffect(() => {
+    const timer = setTimeout(() => setDebounced(value), delayMs);
+    return () => clearTimeout(timer);
+  }, [value, delayMs]);
+
+  return debounced;
+}
diff --git a/src/hooks/useScrollRestoration.ts b/src/hooks/useScrollRestoration.ts
index 04896039..eeef2906 100644
--- a/src/hooks/useScrollRestoration.ts
+++ b/src/hooks/useScrollRestoration.ts
@@ -64,17 +64,30 @@ export function useScrollRestoration(): void {
   const location = useLocation();
   const navigationType = useNavigationType();
   const pendingRestorationRef = useRef<PendingRestoration | null>(null);
+  const prevPathnameRef = useRef(location.pathname);
+  const isFirstRenderRef = useRef(true);
 
   useEffect(() => {
     history.scrollRestoration = "manual";
   }, []);
 
   useLayoutEffect(() => {
+    const isFirstRender = isFirstRenderRef.current;
+    isFirstRenderRef.current = false;
     const initialHost = getScrollHost();
+    const pathnameChanged = prevPathnameRef.current !== location.pathname;
+    prevPathnameRef.current = location.pathname;
 
     if (navigationType !== NavigationType.Pop) {
-      pendingRestorationRef.current = null;
-      scrollHostTo(initialHost, 0);
+      // Only a new page starts at the top. A navigation that changes nothing but
+      // the search string — the knowledge base writing `?artifact=<id>`, a filter
+      // landing in the URL — stays inside the page the reader is already on, so
+      // it keeps its position. (React Router's `preventScrollReset` option is not
+      // observable here: it rides the navigation, not `location.state`.)
+      if (pathnameChanged || isFirstRender) {
+        pendingRestorationRef.current = null;
+        scrollHostTo(initialHost, 0);
+      }
       return;
     }
 
@@ -151,7 +164,7 @@ export function useScrollRestoration(): void {
         pendingRestorationRef.current = null;
       }
     };
-  }, [location.key, navigationType]);
+  }, [location.key, location.pathname, navigationType]);
 
   // Keeps the current page's position current for whenever the reader comes back to it.
   useEffect(() => {
diff --git a/src/pages/KnowledgeBasePage.tsx b/src/pages/KnowledgeBasePage.tsx
index 717a1c59..11069c1c 100644
--- a/src/pages/KnowledgeBasePage.tsx
+++ b/src/pages/KnowledgeBasePage.tsx
@@ -1,8 +1,8 @@
-import { useEffect, useMemo, useState } from "react";
-import { useSearchParams } from "react-router-dom";
+import { useMemo } from "react";
 import { motion, useReducedMotion } from "framer-motion";
 import { BookOpen, AlertTriangle, RefreshCw } from "lucide-react";
 import {
+  ArtifactBulkActions,
   ArtifactFilters,
   ArtifactList,
   ArtifactViewerDrawer,
@@ -14,8 +14,16 @@ import { PageHeader } from "../components/layout/PageHeader";
 import { useAuth } from "../context/useAuth";
 import { PermissionGroup } from "../services/types";
 import { useKnowledgeBase } from "../features/knowledge-base/hooks/useKnowledgeBase";
+import { useArtifactById } from "../features/knowledge-base/hooks/useArtifactById";
+import { useUploadSelection } from "../features/knowledge-base/hooks/useUploadSelection";
+import { useArtifactAiStatus } from "../features/knowledge-base/hooks/useArtifactAiStatus";
+import { isUpload } from "../features/knowledge-base/tabs";
 import { useProjectContext } from "../features/projects/useProjectContext";
 import { useDelayedFlag } from "../hooks/useDelayedFlag";
+import { useDebouncedValue } from "../hooks/useDebouncedValue.ts";
+import { ArtifactPageSizeSelect } from "../features/knowledge-base/components/ArtifactPageSizeSelect.tsx";
+import { PAGE_SIZE_OPTIONS } from "../features/knowledge-base/hooks/useKnowledgeBaseUrlState.ts";
+import { formatResultRange } from "../features/knowledge-base/resultRange.ts";
 import { SkeletonBlock, SkeletonGroup, SkeletonLine } from "../components/ui/Skeleton";
 
 /** Placeholder for one `ArtifactCard`, matching its icon box, title/badge row and meta row. */
@@ -54,14 +62,18 @@ const DELETE_ALLOWED_GROUPS: ReadonlySet<PermissionGroup> = new Set([
   PermissionGroup.ADMIN,
 ]);
 
+/** How long the result total must hold still before the live region announces it. */
+const RESULTS_ANNOUNCE_DELAY_MS = 600;
+
 /**
  * Unified Knowledge Base view for project resources.
  *
  * Bound to the `/knowledge-base` route (accessible to all permission groups).
  * Displays all artifacts (uploads, github, etc.) in a filtered grid, with a side
- * drawer for viewing raw content and AI summaries. Artifacts are fetched via
- * `knowledgeService.getUnifiedArtifacts`, scoped to the globally selected
- * project.
+ * drawer for viewing raw content and AI summaries. Artifacts arrive one page at
+ * a time from `knowledgeService.getArtifactPage`, with the facet counts beside
+ * them from `knowledgeService.getArtifactFacets`, scoped to the globally
+ * selected project.
  *
  * Users without a project switcher fall back to their first assigned project,
  * which is what the global selection resolves to for them anyway.
@@ -84,26 +96,81 @@ export function KnowledgeBasePage() {
     sourceOptions,
     formatOptions,
     repositoryOptions,
+    languageOptions,
     selectedSources,
     selectedFormat,
     selectedRepositories,
+    selectedLanguages,
     currentPage,
     totalPages,
-    filteredArtifacts,
-    paginatedArtifacts,
+    totalElements,
+    resultRange,
+    pageSize,
+    setPageSize,
     handleSearchChange,
     handleTabChange,
     toggleSource,
     toggleFormat,
     toggleRepository,
+    toggleLanguage,
     setCurrentPage,
     handleClearFilters,
     hasActiveFilters,
-  } = useKnowledgeBase(projectId);
+    listScopeKey,
+    selectedArtifactId,
+    setSelectedArtifactId,
+    sort,
+    setSort,
+    dateRange,
+    setDateRange,
+  } = useKnowledgeBase(projectId, { projectSettled: !isProjectLoading });
 
   const isLoading = isProjectLoading || isArtifactsLoading;
   const showLoadingSkeleton = useDelayedFlag(isLoading);
 
+  const uploadSelection = useUploadSelection(listScopeKey);
+
+  /*
+    Bulk selection is offered only while the Uploads source is picked: only uploads can be
+    deleted, and in any other view the toggle only crowds the filter row.
+  */
+  const canBulkSelect = canDeleteUpload && selectedSources.has("UPLOAD");
+  if (!canBulkSelect && uploadSelection.isSelectMode) uploadSelection.setSelectMode(false);
+
+  /* One status request per visible page, keyed on exactly the ids on screen. */
+  const visibleArtifactIds = useMemo(() => artifacts.map((a) => a.id), [artifacts]);
+  const aiStatuses = useArtifactAiStatus(projectId, visibleArtifactIds);
+  /* Only ticked rows that are uploads on the page in view can be deleted: the selection is
+     re-read against the list itself, so nothing off screen is ever sent. */
+  const selectedUploads = useMemo(
+    () => artifacts.filter((a) => isUpload(a) && uploadSelection.selectedIds.has(a.id)),
+    [artifacts, uploadSelection.selectedIds],
+  );
+
+  /** Refresh drops the selection: the rows it named may no longer be the rows shown. */
+  const handleRefresh = () => {
+    uploadSelection.clear();
+    void fetchArtifacts();
+  };
+
+  /** After a bulk delete: nothing stays ticked, and a drawer showing a deleted row closes. */
+  const handleBulkDeleted = (deletedIds: string[]) => {
+    uploadSelection.clear();
+    if (selectedArtifactId && deletedIds.includes(selectedArtifactId)) {
+      setSelectedArtifactId(null);
+    }
+  };
+
+  /*
+    What a screen reader hears after a filter, search or page change: the new total, said once
+    the results have settled. Debounced so four quick facet clicks announce one number, not four,
+    and empty while loading or failed - the error banner speaks for itself (assertively).
+  */
+  const resultsAnnouncement = useDebouncedValue(
+    isLoading || fetchError ? "" : formatResultRange(totalElements),
+    RESULTS_ANNOUNCE_DELAY_MS,
+  );
+
   /*
     `?artifact=<id>` says which document is open, and it is in the URL the whole time one is.
 
@@ -121,34 +188,26 @@ export function KnowledgeBasePage() {
     closing one takes it away. `replace` throughout, so reading four documents does not leave four
     entries in the back button. The original intent survives it — a URL captured after the drawer is
     closed carries no id, so coming back later still does not reopen a document somebody shut.
+    The URL itself is now owned by `useKnowledgeBase` (every filter lives there too, and two
+    writers of one query string overwrite each other), which also drops `?artifact=` on a switch
+    between two settled projects - the id of project A's document means nothing in project B.
   */
-  const [searchParams, setSearchParams] = useSearchParams();
-  const [selectedArtifactId, setSelectedArtifactId] = useState<string | null>(() =>
-    searchParams.get("artifact"),
-  );
-  const [prevProjectId, setPrevProjectId] = useState(projectId);
-
-  useEffect(() => {
-    // Compared before writing, because this effect's own write comes back to it as a new
-    // `searchParams`: without the guard that is a loop rather than a synchronisation.
-    if ((searchParams.get("artifact") ?? null) === selectedArtifactId) return;
 
-    const next = new URLSearchParams(searchParams);
-    if (selectedArtifactId) next.set("artifact", selectedArtifactId);
-    else next.delete("artifact");
-
-    setSearchParams(next, { replace: true });
-  }, [selectedArtifactId, searchParams, setSearchParams]);
+  const isSelectedInPage = useMemo(
+    () => artifacts.some((a) => a.id === selectedArtifactId),
+    [artifacts, selectedArtifactId],
+  );
 
-  // Reset active drawer selection whenever the project scope changes.
-  if (prevProjectId !== projectId) {
-    setPrevProjectId(projectId);
-    setSelectedArtifactId(null);
-  }
+  const { data: fetchedArtifact } = useArtifactById(
+    projectId,
+    selectedArtifactId && !isSelectedInPage ? selectedArtifactId : null,
+  );
 
   const selectedArtifact = useMemo(
-    () => artifacts.find((a) => a.id === selectedArtifactId) ?? null,
-    [artifacts, selectedArtifactId],
+    () =>
+      artifacts.find((a) => a.id === selectedArtifactId) ??
+      (fetchedArtifact?.id === selectedArtifactId ? fetchedArtifact : null),
+    [artifacts, selectedArtifactId, fetchedArtifact],
   );
 
   const prefersReducedMotion = useReducedMotion();
@@ -162,7 +221,7 @@ export function KnowledgeBasePage() {
     connector. There is no index any more -- a multi-select selection has no direction, and a slide
     chosen from a set's iteration order would move left on a change the reader reads as forward.
   */
-  const facetKey = `${activeTab}|${[...selectedSources].sort().join(",")}|${selectedFormat ?? ""}|${[...selectedRepositories].sort().join(",")}`;
+  const facetKey = `${activeTab}|${[...selectedSources].sort().join(",")}|${selectedFormat ?? ""}|${[...selectedRepositories].sort().join(",")}|${[...selectedLanguages].sort().join(",")}`;
 
   return (
     <div className="flex min-h-screen flex-col text-app-text">
@@ -213,14 +272,49 @@ export function KnowledgeBasePage() {
                   repositoryOptions={repositoryOptions}
                   selectedRepositories={selectedRepositories}
                   onToggleRepository={toggleRepository}
-                  resultCount={filteredArtifacts.length}
+                  languageOptions={languageOptions}
+                  selectedLanguages={selectedLanguages}
+                  onToggleLanguage={toggleLanguage}
+                  resultCount={totalElements}
+                  resultRange={resultRange}
                   hasActiveFilters={hasActiveFilters}
                   onClearFilters={handleClearFilters}
-                  onRefresh={() => void fetchArtifacts()}
+                  sort={sort}
+                  onSortChange={setSort}
+                  dateRange={dateRange}
+                  onDateRangeChange={setDateRange}
+                  onRefresh={handleRefresh}
                   isRefreshing={isLoading}
+                  {...(canBulkSelect
+                    ? {
+                        isSelectMode: uploadSelection.isSelectMode,
+                        onSelectModeChange: uploadSelection.setSelectMode,
+                      }
+                    : {})}
                 />
+                <p
+                  className="sr-only"
+                  aria-live="polite"
+                  aria-atomic="true"
+                  data-testid="kb-results-announcement"
+                >
+                  {resultsAnnouncement}
+                </p>
               </motion.div>
 
+              {canBulkSelect && projectId && uploadSelection.isSelectMode && (
+                <div className="mb-4">
+                  <ArtifactBulkActions
+                    projectId={projectId}
+                    removerId={profile?.id ?? null}
+                    selected={selectedUploads}
+                    onClearSelection={uploadSelection.clear}
+                    onDeleted={handleBulkDeleted}
+                    listScopeKey={listScopeKey}
+                  />
+                </div>
+              )}
+
               {fetchError && !isLoading && (
                 <div
                   role="alert"
@@ -255,17 +349,44 @@ export function KnowledgeBasePage() {
                   animate={{ opacity: 1, y: 0 }}
                   transition={prefersReducedMotion ? { duration: 0 } : centralSpringToken}
                 >
-                  <ArtifactList artifacts={paginatedArtifacts} onSelect={setSelectedArtifactId} />
-                  {totalPages > 1 && (
-                    <Pagination
-                      currentPage={currentPage}
-                      totalPages={totalPages}
-                      onPageChange={(page) => {
-                        setCurrentPage(page);
-                        window.scrollTo({ top: 0, behavior: "smooth" });
-                      }}
-                      className="mt-8 mb-12"
-                    />
+                  <ArtifactList
+                    artifacts={artifacts}
+                    onSelect={setSelectedArtifactId}
+                    aiStatuses={aiStatuses}
+                    selection={
+                      uploadSelection.isSelectMode
+                        ? {
+                            selectedIds: uploadSelection.selectedIds,
+                            onToggle: uploadSelection.toggle,
+                          }
+                        : undefined
+                    }
+                  />
+                  {(totalPages > 1 || totalElements > PAGE_SIZE_OPTIONS[0]) && (
+                    // Both controls carry the same top margin (Pagination's own `mt-6`) so the row
+                    // lines up without overriding a primitive's classes.
+                    <div
+                      className="mb-12 flex flex-wrap items-center justify-center gap-x-6"
+                      data-testid="kb-list-footer"
+                    >
+                      {totalPages > 1 && (
+                        <Pagination
+                          currentPage={currentPage}
+                          totalPages={totalPages}
+                          onPageChange={(page) => {
+                            setCurrentPage(page);
+                            window.scrollTo({ top: 0, behavior: "smooth" });
+                          }}
+                        />
+                      )}
+                      {totalElements > PAGE_SIZE_OPTIONS[0] && (
+                        <ArtifactPageSizeSelect
+                          pageSize={pageSize}
+                          onPageSizeChange={setPageSize}
+                          className="mt-6"
+                        />
+                      )}
+                    </div>
                   )}
                 </motion.div>
               )}
diff --git a/src/services/knowledgeService.ts b/src/services/knowledgeService.ts
index 20db6bb0..ce8c8fa7 100644
--- a/src/services/knowledgeService.ts
+++ b/src/services/knowledgeService.ts
@@ -4,7 +4,12 @@ import { userService } from "./userService";
 import keycloak from "../config/keycloak";
 import type {
   Artifact,
+  ArtifactAiStatusResponse,
   ArtifactContent,
+  ArtifactFacets,
+  ArtifactPage,
+  DeleteUploadsResult,
+  KnowledgeListParams,
   SummaryStreamHandlers,
 } from "../features/knowledge-base/types";
 
@@ -30,6 +35,52 @@ type UploadResponseItem = {
   error?: string;
 };
 
+/**
+ * Serialises the *filter* half of {@link KnowledgeListParams} — the part the list and the facets
+ * endpoints share. One builder for both calls is the parity guarantee: a filter added here reaches
+ * the counts and the rows alike, so a facet can never promise "12" for a list that shows 30.
+ * Sets are repeated params (`types=A&types=B`), which is how Spring binds a `List` parameter.
+ */
+function buildFilterQuery(params: KnowledgeListParams): URLSearchParams {
+  const query = new URLSearchParams();
+  const search = params.search?.trim();
+  if (search) query.set("search", search);
+  for (const type of params.types ?? []) query.append("types", type);
+  for (const source of params.sources ?? []) query.append("sources", source);
+  for (const repository of params.repositories ?? []) query.append("repositories", repository);
+  if (params.format) query.set("format", params.format);
+  for (const language of params.languages ?? []) query.append("languages", language);
+  if (params.from) query.set("from", params.from);
+  if (params.to) query.set("to", params.to);
+  return query;
+}
+
+/** Reason recorded for an id the backend answered for in neither list. */
+const UNCONFIRMED_DELETE = "The server did not confirm this deletion.";
+
+/**
+ * Normalises a delete answer. No `deletedIds`/`failed` at all is the old
+ * backend's empty 204: every requested id is taken as deleted.
+ */
+function readDeleteOutcome(
+  requested: readonly string[],
+  body: Partial<DeleteUploadsResult> | undefined,
+): DeleteUploadsResult {
+  if (!body || (!Array.isArray(body.deletedIds) && !Array.isArray(body.failed))) {
+    return { deletedIds: [...requested], failed: [] };
+  }
+  const failed = body.failed ?? [];
+  const deleted = new Set(body.deletedIds ?? []);
+  const answered = new Set([...deleted, ...failed.map((item) => item.artifactId)]);
+  const unconfirmed = requested
+    .filter((id) => !answered.has(id))
+    .map((artifactId) => ({ artifactId, error: UNCONFIRMED_DELETE }));
+  return {
+    deletedIds: requested.filter((id) => deleted.has(id)),
+    failed: [...failed, ...unconfirmed],
+  };
+}
+
 export const knowledgeService = {
   /**
    * Whether the project has anything ingested at all -- what an onboarding path is built from.
@@ -52,9 +103,9 @@ export const knowledgeService = {
    * Fetches a single short page of project artifacts for at-a-glance views
    * such as the dashboard widget.
    *
-   * Deliberately separate from {@link knowledgeService.getUnifiedArtifacts},
-   * which pages through the entire project and additionally merges personal
-   * uploads — far more work than a preview card needs.
+   * Deliberately separate from {@link knowledgeService.getArtifactPage}: a
+   * preview card wants the newest handful of rows and nothing else, so it must
+   * not drag facet counts or a full page size along with it.
    *
    * @param projectId UUID of the project to scope the listing.
    * @param limit Maximum number of artifacts to return.
@@ -73,36 +124,77 @@ export const knowledgeService = {
   },
 
   /**
-   * Fetches all unified artifacts for a specific project.
+   * Fetches a paginated, server-side filtered page of artifacts for a project.
    *
-   * @param projectId UUID of the project to scope the artifact listing.
-   * @returns List of project-scoped artifacts.
-   * @throws ApiError when the backend request fails so callers can distinguish
-   *   between an empty project and a failed fetch.
+   * @param projectId UUID of the project.
+   * @param params Filter criteria (see `buildFilterQuery`) plus the list-only page, size and sort.
    */
-  async getUnifiedArtifacts(projectId: string): Promise<Artifact[]> {
-    let artifacts: Artifact[] = [];
-
-    interface PageResponse {
-      items: Artifact[];
-      page: {
-        totalPages: number;
-      };
-    }
+  async getArtifactPage(
+    projectId: string,
+    params: KnowledgeListParams = {},
+  ): Promise<ArtifactPage> {
+    const query = buildFilterQuery(params);
+    if (params.page !== undefined) query.set("page", String(params.page));
+    if (params.size !== undefined) query.set("size", String(params.size));
+    // List-only: order changes which rows a page holds, never how many match.
+    if (params.sort) query.set("sort", params.sort);
+
+    const queryString = query.toString();
+    const endpoint = `/api/v1/projects/${projectId}/artifacts${queryString ? `?${queryString}` : ""}`;
+    return apiClient.fetch<ArtifactPage>(endpoint);
+  },
 
-    let currentPage = 1;
-    let totalPages = 1;
+  /**
+   * Fetches faceted counts for artifact types, source systems, upload formats, repositories and
+   * languages.
+   *
+   * Sends exactly the filter criteria the list sends (see `buildFilterQuery`) and nothing of its
+   * paging or order: `page`, `size` and `sort` are ignored even when present in `params`, because
+   * a count must not depend on which page is on screen or how it is ordered.
+   *
+   * @param projectId UUID of the project.
+   * @param params Active filter criteria to calculate dynamic facet counts.
+   */
+  async getArtifactFacets(
+    projectId: string,
+    params: KnowledgeListParams = {},
+  ): Promise<ArtifactFacets> {
+    const queryString = buildFilterQuery(params).toString();
+    const endpoint = `/api/v1/projects/${projectId}/artifacts/facets${queryString ? `?${queryString}` : ""}`;
+    return apiClient.fetch<ArtifactFacets>(endpoint);
+  },
 
-    while (currentPage <= totalPages) {
-      const response = await apiClient.fetch<PageResponse>(
-        `/api/v1/projects/${projectId}/artifacts?page=${currentPage}&size=100`,
-      );
-      artifacts = [...artifacts, ...(response.items || [])];
-      totalPages = response.page?.totalPages ?? 1;
-      currentPage++;
-    }
+  /**
+   * Fetches the AI assistant's index status for a batch of artifacts (at most 100, the backend's
+   * cap and the largest page size, so one visible page is always one request).
+   *
+   * An empty `ids` list resolves locally without a request. A response without `aiAvailable`
+   * (older backend) is read as unavailable, so no status is ever guessed.
+   *
+   * @param projectId UUID of the project.
+   * @param artifactIds Ingestion ids of the artifacts on screen.
+   */
+  async getArtifactAiStatus(
+    projectId: string,
+    artifactIds: readonly string[],
+  ): Promise<ArtifactAiStatusResponse> {
+    if (artifactIds.length === 0) return { aiAvailable: true, items: [] };
+    const query = new URLSearchParams();
+    artifactIds.forEach((id) => query.append("ids", id));
+    const body = await apiClient.fetch<Partial<ArtifactAiStatusResponse>>(
+      `/api/v1/projects/${projectId}/artifacts/ai-status?${query.toString()}`,
+    );
+    return { aiAvailable: body?.aiAvailable === true, items: body?.items ?? [] };
+  },
 
-    return artifacts;
+  /**
+   * Fetches metadata for a single artifact by ID within a project.
+   *
+   * @param projectId UUID of the project.
+   * @param artifactId UUID of the artifact.
+   */
+  async getArtifactById(projectId: string, artifactId: string): Promise<Artifact> {
+    return apiClient.fetch<Artifact>(`/api/v1/projects/${projectId}/artifacts/${artifactId}`);
   },
 
   /**
@@ -263,9 +355,47 @@ export const knowledgeService = {
     }
   },
 
+  /**
+   * Deletes a batch of uploaded artifacts and reports what happened to each.
+   *
+   * Sends one multipart DELETE to `/api/v1/uploads` (`request` JSON part with
+   * `artifactIds`, `removerId`, `projectId`). The backend answers 200 with
+   * `{ deletedIds, failed }`; an older backend answers an empty 204, which is
+   * read as "every requested id deleted" — that was its only success signal.
+   *
+   * An id the new shape reports in neither list is counted as failed: a
+   * deletion nobody confirmed must not be shown as a success.
+   *
+   * @param uploadIds Upload UUIDs (`Artifact.sourceId`), not ingestion ids.
+   * @throws ApiError on a non-2xx response; per-item failures do not throw.
+   */
+  async deleteUploads(
+    projectId: string,
+    uploadIds: readonly string[],
+    removerId: string,
+  ): Promise<DeleteUploadsResult> {
+    const formData = new FormData();
+    const requestPayload = { artifactIds: [...uploadIds], removerId, projectId };
+    formData.append(
+      "request",
+      new Blob([JSON.stringify(requestPayload)], { type: "application/json" }),
+    );
+
+    const body = await apiClient.fetch<Partial<DeleteUploadsResult> | undefined>(
+      `/api/v1/uploads`,
+      { method: "DELETE", body: formData },
+    );
+    return readDeleteOutcome(uploadIds, body);
+  },
+
   /**
    * Deletes a single uploaded artifact by its id.
    *
+   * Delegates to {@link knowledgeService.deleteUploads} so the single and bulk
+   * paths cannot drift, and throws when the backend reports this id as failed —
+   * the batch endpoint answers 200 for per-item failures, which used to make a
+   * failed single delete look like a success.
+   *
    * Sends a multipart DELETE to `/api/v1/uploads` with a `request`
    * JSON part containing the artifactIds batch, the removerId (authenticated user)
    * and the projectId scope. The backend reads the deletion target(s)
@@ -284,23 +414,12 @@ export const knowledgeService = {
    *   which resolves the remover from the JWT subject.
    * @throws ApiError on a non-2xx response (e.g. 403 if the caller lacks access
    *   to the supplied projectId, 404 if the artifact does not exist).
+   * @throws Error carrying the backend's reason when the id is in `failed`.
    */
   async deleteUpload(projectId: string, artifactId: string, removerId: string): Promise<void> {
-    const formData = new FormData();
-    const requestPayload = {
-      artifactIds: [artifactId],
-      removerId,
-      projectId,
-    };
-    formData.append(
-      "request",
-      new Blob([JSON.stringify(requestPayload)], { type: "application/json" }),
-    );
-
-    await apiClient.fetch<void>(`/api/v1/uploads`, {
-      method: "DELETE",
-      body: formData,
-    });
+    const { failed } = await knowledgeService.deleteUploads(projectId, [artifactId], removerId);
+    const failure = failed.find((item) => item.artifactId === artifactId);
+    if (failure) throw new Error(failure.error);
   },
 
   /**
diff --git a/src/services/queryKeys.ts b/src/services/queryKeys.ts
index 74c2f209..66ca6c51 100644
--- a/src/services/queryKeys.ts
+++ b/src/services/queryKeys.ts
@@ -1,3 +1,5 @@
+import type { KnowledgeListParams } from "../features/knowledge-base/types";
+
 /**
  * Central query-key factory, shared by every migrated hook, invalidation call and
  * prefetch (sidebar hover/press). Keeping one factory is what makes those three
@@ -75,7 +77,19 @@ export const queryKeys = {
     pending: () => ["attestations", "pending"] as const,
   },
   knowledgeBase: {
-    byProject: (projectId: string) => ["knowledge-base", projectId] as const,
+    // Scope prefix for everything the Knowledge Base page holds: invalidating it
+    // clears the current page, the facet counts, and any open artifact's detail
+    // at once — React Query matches keys by prefix.
+    project: (projectId: string) => ["knowledge-base", projectId] as const,
+    list: (projectId: string, params: KnowledgeListParams = {}) =>
+      ["knowledge-base", projectId, "list", params] as const,
+    facets: (projectId: string, params: KnowledgeListParams = {}) =>
+      ["knowledge-base", projectId, "facets", params] as const,
+    detail: (projectId: string, artifactId: string) =>
+      ["knowledge-base", projectId, "detail", artifactId] as const,
+    // Under the project prefix, so a delete or refresh that invalidates the page drops it too.
+    aiStatus: (projectId: string, artifactIds: readonly string[]) =>
+      ["knowledge-base", projectId, "ai-status", artifactIds] as const,
   },
   faq: {
     groups: (projectId: string) => ["faq", "groups", projectId] as const,
diff --git a/src/services/routePrefetch.ts b/src/services/routePrefetch.ts
index eab66c72..a4850db4 100644
--- a/src/services/routePrefetch.ts
+++ b/src/services/routePrefetch.ts
@@ -2,7 +2,11 @@ import type { QueryClient } from "@tanstack/react-query";
 import { queryKeys } from "./queryKeys";
 import { knowledgeRequestService } from "./knowledgeRequestService";
 import { loadBoard } from "../features/board/hooks/useBoard";
-import { loadKnowledgeBaseArtifacts } from "../features/knowledge-base/hooks/useKnowledgeBase";
+import {
+  loadKnowledgeBasePage,
+  loadKnowledgeBaseFacets,
+} from "../features/knowledge-base/hooks/useKnowledgeBase";
+import { DEFAULT_PAGE_SIZE } from "../features/knowledge-base/hooks/useKnowledgeBaseUrlState";
 import { loadStarterWorkReviewQueue } from "../features/starter-work/hooks/useStarterWorkReview";
 
 /**
@@ -67,9 +71,15 @@ export function prefetchRoute(
   switch (path) {
     case "/knowledge-base":
       if (!projectId) return;
+      // The same first-page params the hook builds from an empty URL, so the
+      // key matches — a hard-coded size would silently miss if the default moved.
       void queryClient.prefetchQuery({
-        queryKey: queryKeys.knowledgeBase.byProject(projectId),
-        queryFn: () => loadKnowledgeBaseArtifacts(projectId),
+        queryKey: queryKeys.knowledgeBase.list(projectId, { page: 1, size: DEFAULT_PAGE_SIZE }),
+        queryFn: () => loadKnowledgeBasePage(projectId, { page: 1, size: DEFAULT_PAGE_SIZE }),
+      });
+      void queryClient.prefetchQuery({
+        queryKey: queryKeys.knowledgeBase.facets(projectId, {}),
+        queryFn: () => loadKnowledgeBaseFacets(projectId, {}),
       });
       return;
 
diff --git a/src/styles/index.css b/src/styles/index.css
index ea1bb9ed..56178878 100644
--- a/src/styles/index.css
+++ b/src/styles/index.css
@@ -24,6 +24,9 @@ body {
   --app-page-gutter: 1.25rem;
   --app-page-block-gutter: 1.25rem;
   --app-page-max-width: 80rem;
+  /* Width of the desktop sidebar. The sidebar itself and the margin the page
+     content leaves for it both read this, so the two can never disagree. */
+  --app-sidebar-width: 286px;
 
   /* Backgrounds */
   --bg: #f9fafb;
diff --git a/tests/unit/a11y/AiStatusChip.a11y.test.tsx b/tests/unit/a11y/AiStatusChip.a11y.test.tsx
new file mode 100644
index 00000000..30ef32ac
--- /dev/null
+++ b/tests/unit/a11y/AiStatusChip.a11y.test.tsx
@@ -0,0 +1,50 @@
+import { render } from "@testing-library/react";
+import { describe, expect, it, vi } from "vitest";
+import { axe } from "vitest-axe";
+import { ArtifactList } from "../../../src/features/knowledge-base/components/ArtifactList";
+import type { Artifact, ArtifactAiStatus } from "../../../src/features/knowledge-base/types";
+
+const STATUSES: ArtifactAiStatus[] = ["INDEXED", "PROCESSING", "FAILED", "DEINDEXED", "UNKNOWN"];
+
+function makeArtifact(id: string): Artifact {
+  return {
+    id,
+    title: `${id}.md`,
+    artifactType: "FILE",
+    sourceSystem: "UPLOAD",
+    sourceId: `up-${id}`,
+    sourceUrl: null,
+    mime: "text/markdown",
+    language: null,
+    ingestedAt: "2024-01-01T00:00:00Z",
+    lastChangedAt: null,
+    contentHash: null,
+    ingestionRunId: null,
+  };
+}
+
+describe("AI status chip a11y", () => {
+  it("has no violations with every status on screen, in and out of select mode", async () => {
+    const artifacts = STATUSES.map((status) => makeArtifact(status.toLowerCase()));
+    const aiStatuses = new Map(STATUSES.map((status) => [status.toLowerCase(), status]));
+
+    const { baseElement, rerender } = render(
+      <main>
+        <ArtifactList artifacts={artifacts} onSelect={vi.fn()} aiStatuses={aiStatuses} />
+      </main>,
+    );
+    expect(await axe(baseElement)).toHaveNoViolations();
+
+    rerender(
+      <main>
+        <ArtifactList
+          artifacts={artifacts}
+          onSelect={vi.fn()}
+          aiStatuses={aiStatuses}
+          selection={{ selectedIds: new Set(["failed"]), onToggle: vi.fn() }}
+        />
+      </main>,
+    );
+    expect(await axe(baseElement)).toHaveNoViolations();
+  });
+});
diff --git a/tests/unit/a11y/ArtifactBulkActions.a11y.test.tsx b/tests/unit/a11y/ArtifactBulkActions.a11y.test.tsx
new file mode 100644
index 00000000..ff74fed7
--- /dev/null
+++ b/tests/unit/a11y/ArtifactBulkActions.a11y.test.tsx
@@ -0,0 +1,64 @@
+import { render, screen, fireEvent } from "@testing-library/react";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { axe } from "vitest-axe";
+import { ArtifactList } from "../../../src/features/knowledge-base/components/ArtifactList";
+import { ArtifactBulkActions } from "../../../src/features/knowledge-base/components/ArtifactBulkActions";
+import type { Artifact } from "../../../src/features/knowledge-base/types";
+import { knowledgeService } from "../../../src/services/knowledgeService";
+
+function makeArtifact(id: string, title: string, sourceSystem: Artifact["sourceSystem"]): Artifact {
+  return {
+    id,
+    title,
+    artifactType: "FILE",
+    sourceSystem,
+    sourceId: `up-${id}`,
+    sourceUrl: null,
+    mime: null,
+    language: null,
+    ingestedAt: "2026-09-01T10:00:00Z",
+    lastChangedAt: null,
+    contentHash: null,
+    ingestionRunId: null,
+  };
+}
+
+const upload = makeArtifact("u1", "notes.pdf", "UPLOAD");
+const other = makeArtifact("u2", "plan.md", "UPLOAD");
+
+afterEach(() => vi.restoreAllMocks());
+
+describe("bulk delete a11y", () => {
+  it("has no violations in select mode, with the toolbar and a mixed outcome", async () => {
+    vi.spyOn(knowledgeService, "deleteUploads").mockResolvedValue({
+      deletedIds: ["up-u1"],
+      failed: [{ artifactId: "up-u2", error: "Artifact could not be deleted." }],
+    });
+    const github = makeArtifact("g1", "gh.md", "GITHUB");
+    const { baseElement } = render(
+      <main>
+        <ArtifactBulkActions
+          projectId="p1"
+          removerId="user-1"
+          selected={[upload, other]}
+          onClearSelection={vi.fn()}
+          onDeleted={vi.fn()}
+          listScopeKey="scope-1"
+        />
+        <ArtifactList
+          artifacts={[upload, other, github]}
+          onSelect={vi.fn()}
+          selection={{ selectedIds: new Set(["u1", "u2"]), onToggle: vi.fn() }}
+        />
+      </main>,
+    );
+    expect(await axe(baseElement)).toHaveNoViolations();
+
+    fireEvent.click(screen.getByTestId("kb-bulk-delete"));
+    expect(await axe(baseElement)).toHaveNoViolations();
+
+    fireEvent.click(screen.getByTestId("kb-bulk-confirm"));
+    await screen.findByTestId("kb-bulk-failed");
+    expect(await axe(baseElement)).toHaveNoViolations();
+  });
+});
diff --git a/tests/unit/a11y/ArtifactDateRangeFilter.a11y.test.tsx b/tests/unit/a11y/ArtifactDateRangeFilter.a11y.test.tsx
new file mode 100644
index 00000000..a4b27d2d
--- /dev/null
+++ b/tests/unit/a11y/ArtifactDateRangeFilter.a11y.test.tsx
@@ -0,0 +1,20 @@
+import { render, screen, fireEvent } from "@testing-library/react";
+import { describe, it, expect, vi } from "vitest";
+import { axe } from "vitest-axe";
+import { ArtifactDateRangeFilter } from "../../../src/features/knowledge-base/components/ArtifactDateRangeFilter.tsx";
+
+describe("ArtifactDateRangeFilter a11y", () => {
+  it("has no violations with a custom range open and a reversed-range error shown", async () => {
+    const { container } = render(
+      <ArtifactDateRangeFilter
+        range={{ from: "2026-09-10", to: null }}
+        onRangeChange={vi.fn()}
+        now={new Date("2026-09-24T10:00:00Z")}
+      />,
+    );
+    fireEvent.change(screen.getByLabelText("Updated to"), { target: { value: "2026-09-01" } });
+    expect(screen.getByTestId("kb-date-error")).toBeInTheDocument();
+
+    expect(await axe(container)).toHaveNoViolations();
+  });
+});
diff --git a/tests/unit/a11y/KnowledgeBasePage.a11y.test.tsx b/tests/unit/a11y/KnowledgeBasePage.a11y.test.tsx
index 7a6e00ae..97535c6a 100644
--- a/tests/unit/a11y/KnowledgeBasePage.a11y.test.tsx
+++ b/tests/unit/a11y/KnowledgeBasePage.a11y.test.tsx
@@ -31,38 +31,85 @@ vi.mock("../../../src/context/useAuth", () => ({
   }),
 }));
 
+const { mockArtifacts } = vi.hoisted(() => ({
+  mockArtifacts: [
+    {
+      id: "a1",
+      title: "Add feature",
+      artifactType: "PULL_REQUEST",
+      sourceSystem: "GITHUB",
+      sourceId: "42",
+      sourceUrl: null,
+      mime: null,
+      language: null,
+      ingestedAt: "2024-01-01",
+      lastChangedAt: null,
+      contentHash: null,
+      ingestionRunId: null,
+    },
+    {
+      id: "a2",
+      title: "manual.pdf",
+      artifactType: "FILE",
+      sourceSystem: "UPLOAD",
+      sourceId: "f47ac10b-58cc-4372-a567-0e02b2c3d479",
+      sourceUrl: null,
+      mime: null,
+      language: null,
+      ingestedAt: "2024-01-01",
+      lastChangedAt: null,
+      contentHash: null,
+      ingestionRunId: null,
+    },
+  ],
+}));
+
 vi.mock("../../../src/services/knowledgeService", () => ({
   knowledgeService: {
-    getUnifiedArtifacts: vi.fn().mockResolvedValue([
-      {
-        id: "a1",
-        title: "Add feature",
-        artifactType: "PULL_REQUEST",
-        sourceSystem: "GITHUB",
-        sourceId: "42",
-        sourceUrl: null,
-        mime: null,
-        language: null,
-        ingestedAt: "2024-01-01",
-        lastChangedAt: null,
-        contentHash: null,
-        ingestionRunId: null,
+    getArtifactPage: vi.fn().mockResolvedValue({
+      items: mockArtifacts,
+      page: {
+        number: 1,
+        size: 20,
+        totalElements: mockArtifacts.length,
+        totalPages: 1,
+        hasNext: false,
+        hasPrevious: false,
       },
-      {
-        id: "a2",
-        title: "manual.pdf",
-        artifactType: "FILE",
-        sourceSystem: "UPLOAD",
-        sourceId: "f47ac10b-58cc-4372-a567-0e02b2c3d479",
-        sourceUrl: null,
-        mime: null,
-        language: null,
-        ingestedAt: "2024-01-01",
-        lastChangedAt: null,
-        contentHash: null,
-        ingestionRunId: null,
+      metadata: {
+        pageNumber: 1,
+        pageSize: 20,
+        totalElements: mockArtifacts.length,
+        totalPages: 1,
+        isFirst: true,
+        isLast: true,
+        hasNext: false,
+        hasPrevious: false,
       },
-    ]),
+    }),
+    getArtifactFacets: vi.fn().mockResolvedValue({
+      types: [
+        { value: "PULL_REQUEST", count: 1 },
+        { value: "FILE", count: 1 },
+      ],
+      sources: [
+        { value: "GITHUB", count: 1 },
+        { value: "UPLOAD", count: 1 },
+      ],
+      formats: [{ value: "PDF", count: 1 }],
+      repositories: [],
+    }),
+    // Chips on both cards, so axe checks them on the real page.
+    getArtifactAiStatus: vi.fn().mockResolvedValue({
+      aiAvailable: true,
+      items: [
+        { artifactId: "a1", status: "INDEXED", updatedAt: null, chunkCount: 3 },
+        { artifactId: "a2", status: "FAILED", updatedAt: null, chunkCount: null },
+      ],
+    }),
+    getArtifactById: vi.fn().mockImplementation((_pid: string, id: string) => {
+      return Promise.resolve(mockArtifacts.find((a) => a.id === id) ?? null);
+    }),
   },
 }));
 
@@ -102,4 +149,18 @@ describe("KnowledgeBasePage Accessibility", () => {
 
     expect(await axe(baseElement)).toHaveNoViolations();
   });
+
+  it("should not have any a11y violations with AI status chips on the cards", async () => {
+    const { baseElement } = render(
+      <MemoryRouter>
+        <KnowledgeBasePage />
+      </MemoryRouter>,
+    );
+
+    await waitFor(() => {
+      expect(screen.getAllByTestId("artifact-ai-status")).toHaveLength(2);
+    });
+
+    expect(await axe(baseElement)).toHaveNoViolations();
+  });
 });
diff --git a/tests/unit/a11y/MultiSelectFilter.a11y.test.tsx b/tests/unit/a11y/MultiSelectFilter.a11y.test.tsx
new file mode 100644
index 00000000..db550ae4
--- /dev/null
+++ b/tests/unit/a11y/MultiSelectFilter.a11y.test.tsx
@@ -0,0 +1,40 @@
+import { render, screen, fireEvent } from "@testing-library/react";
+import { describe, it, expect, vi } from "vitest";
+import { axe } from "vitest-axe";
+import { MultiSelectFilter } from "../../../src/components/ui/MultiSelectFilter.tsx";
+
+const REPOS = Array.from({ length: 12 }, (_, i) => ({
+  value: `org/repo-${i}`,
+  label: `org/repo-${i}`,
+  count: 12 - i,
+}));
+
+describe("MultiSelectFilter a11y", () => {
+  it("has no violations with a searchable, folded section and a footnote open", async () => {
+    const { baseElement } = render(
+      <MultiSelectFilter<string>
+        label="Filter sources"
+        summary="All sources"
+        activeCount={0}
+        sections={[
+          {
+            id: "repositories",
+            label: "Repositories",
+            options: REPOS,
+            searchable: true,
+            visibleLimit: 10,
+          },
+        ]}
+        selected={new Set<string>()}
+        onToggle={vi.fn()}
+        testId="kb-filter"
+        footnote="Counts show what you would get if you added this option."
+      />,
+    );
+
+    fireEvent.click(screen.getByTestId("kb-filter-trigger"));
+    expect(screen.getByTestId("kb-filter-section-repositories-search")).toBeInTheDocument();
+
+    expect(await axe(baseElement)).toHaveNoViolations();
+  });
+});
diff --git a/tests/unit/components/ui/MultiSelectFilter.test.tsx b/tests/unit/components/ui/MultiSelectFilter.test.tsx
index 85b8a619..2c7eb014 100644
--- a/tests/unit/components/ui/MultiSelectFilter.test.tsx
+++ b/tests/unit/components/ui/MultiSelectFilter.test.tsx
@@ -139,3 +139,123 @@ describe("MultiSelectFilter", () => {
     expect(screen.getByRole("checkbox", { name: /PDFs/ })).toBeInTheDocument();
   });
 });
+
+describe("MultiSelectFilter long sections", () => {
+  // Twelve repositories: past both the filter-box threshold and a visible limit of 10.
+  const REPOS = Array.from({ length: 12 }, (_, i) => ({
+    value: `org/repo-${String(i).padStart(2, "0")}`,
+    label: `org/repo-${String(i).padStart(2, "0")}`,
+    count: 12 - i,
+  }));
+
+  function renderLong(
+    section: Partial<{ searchable: boolean; visibleLimit: number }> = {},
+    selected: ReadonlySet<string> = new Set<string>(),
+  ) {
+    render(
+      <MultiSelectFilter<string>
+        label="Filter artifacts"
+        summary="All sources"
+        activeCount={selected.size}
+        sections={[{ id: "repositories", label: "Repositories", options: REPOS, ...section }]}
+        selected={selected}
+        onToggle={vi.fn()}
+        testId="kb-filter"
+      />,
+    );
+    fireEvent.click(screen.getByTestId("kb-filter-trigger"));
+  }
+
+  it("filters a searchable section by label, case-insensitively", () => {
+    renderLong({ searchable: true });
+
+    fireEvent.change(screen.getByTestId("kb-filter-section-repositories-search"), {
+      target: { value: "REPO-1" },
+    });
+
+    const ids = screen.getAllByRole("checkbox").map((box) => box.getAttribute("data-testid"));
+    expect(ids).toEqual(["kb-filter-option-org/repo-10", "kb-filter-option-org/repo-11"]);
+  });
+
+  it("says so when the filter text matches nothing", () => {
+    renderLong({ searchable: true });
+
+    fireEvent.change(screen.getByTestId("kb-filter-section-repositories-search"), {
+      target: { value: "nope" },
+    });
+
+    expect(screen.queryAllByRole("checkbox")).toHaveLength(0);
+    expect(screen.getByTestId("kb-filter-section-repositories-no-matches")).toHaveTextContent(
+      "No matches",
+    );
+  });
+
+  it("offers no filter box to a short section even when searchable", () => {
+    render(
+      <MultiSelectFilter<Value>
+        label="Filter artifacts"
+        summary="All sources"
+        activeCount={0}
+        sections={[{ ...SECTIONS[0], searchable: true }]}
+        selected={new Set<Value>()}
+        onToggle={vi.fn()}
+        testId="kb-filter"
+      />,
+    );
+    fireEvent.click(screen.getByTestId("kb-filter-trigger"));
+
+    expect(screen.queryByTestId("kb-filter-section-sources-search")).not.toBeInTheDocument();
+  });
+
+  it("folds a long section to its limit and unfolds it on Show all", () => {
+    renderLong({ visibleLimit: 10 });
+
+    expect(screen.getAllByRole("checkbox")).toHaveLength(10);
+    const showAll = screen.getByTestId("kb-filter-section-repositories-show-all");
+    expect(showAll).toHaveTextContent("Show all (12)");
+    expect(showAll).toHaveAttribute("aria-expanded", "false");
+
+    fireEvent.click(showAll);
+    expect(screen.getAllByRole("checkbox")).toHaveLength(12);
+    expect(showAll).toHaveTextContent("Show fewer");
+    expect(showAll).toHaveAttribute("aria-expanded", "true");
+  });
+
+  it("never hides a ticked option behind the fold", () => {
+    renderLong({ visibleLimit: 10 }, new Set(["org/repo-11"]));
+
+    expect(screen.getAllByRole("checkbox")).toHaveLength(11);
+    expect(screen.getByTestId("kb-filter-option-org/repo-11")).toBeChecked();
+  });
+
+  it("shows every match while filtering, ignoring the limit", () => {
+    renderLong({ searchable: true, visibleLimit: 3 });
+
+    fireEvent.change(screen.getByTestId("kb-filter-section-repositories-search"), {
+      target: { value: "org/" },
+    });
+
+    expect(screen.getAllByRole("checkbox")).toHaveLength(12);
+    expect(screen.queryByTestId("kb-filter-section-repositories-show-all")).not.toBeInTheDocument();
+  });
+
+  it("prints the footnote at the foot of the menu", () => {
+    render(
+      <MultiSelectFilter<Value>
+        label="Filter artifacts"
+        summary="All sources"
+        activeCount={0}
+        sections={SECTIONS}
+        selected={new Set<Value>()}
+        onToggle={vi.fn()}
+        footnote="Counts show what you would get if you added this option."
+        testId="kb-filter"
+      />,
+    );
+    fireEvent.click(screen.getByTestId("kb-filter-trigger"));
+
+    expect(screen.getByTestId("kb-filter-footnote")).toHaveTextContent(
+      "Counts show what you would get if you added this option.",
+    );
+  });
+});
diff --git a/tests/unit/components/ui/SidePanel.test.tsx b/tests/unit/components/ui/SidePanel.test.tsx
index 2a26b7fd..9ee348f6 100644
--- a/tests/unit/components/ui/SidePanel.test.tsx
+++ b/tests/unit/components/ui/SidePanel.test.tsx
@@ -1,7 +1,7 @@
 import { useState } from "react";
-import { render, screen, within, waitFor } from "@testing-library/react";
+import { render, screen, within, waitFor, cleanup } from "@testing-library/react";
 import userEvent from "@testing-library/user-event";
-import { describe, it, expect } from "vitest";
+import { describe, it, expect, afterEach } from "vitest";
 import { SidePanel } from "../../../../src/components/ui/SidePanel";
 
 function SidePanelHarness({
@@ -15,6 +15,7 @@ function SidePanelHarness({
   actions,
   footer,
   children,
+  lockScroll = true,
 }: {
   showOverlay?: boolean;
   closeOnEscape?: boolean;
@@ -26,6 +27,7 @@ function SidePanelHarness({
   actions?: React.ReactNode;
   footer?: React.ReactNode;
   children?: React.ReactNode;
+  lockScroll?: boolean;
 }) {
   const [isOpen, setIsOpen] = useState(false);
   return (
@@ -45,6 +47,7 @@ function SidePanelHarness({
         showOverlay={showOverlay}
         closeOnEscape={closeOnEscape}
         closeAriaLabel={closeAriaLabel}
+        lockScroll={lockScroll}
       >
         {children ?? <p>Panel content</p>}
       </SidePanel>
@@ -52,6 +55,13 @@ function SidePanelHarness({
   );
 }
 
+afterEach(() => {
+  cleanup();
+  document.documentElement.style.overflow = "";
+  document.body.style.overflow = "";
+  document.body.style.paddingRight = "";
+});
+
 describe("SidePanel", () => {
   it("renders the dialog with aria-hidden and inert when closed", () => {
     render(<SidePanelHarness />);
@@ -178,4 +188,42 @@ describe("SidePanel", () => {
 
     await waitFor(() => expect(dialog).toHaveAttribute("aria-hidden", "true"));
   });
+
+  it("locks document body scrolling when opened and restores it when closed", async () => {
+    const user = userEvent.setup();
+    render(<SidePanelHarness />);
+
+    expect(document.documentElement.style.overflow).toBe("");
+    expect(document.body.style.overflow).toBe("");
+
+    await user.click(screen.getByRole("button", { name: "Open" }));
+    expect(document.documentElement.style.overflow).toBe("hidden");
+    expect(document.body.style.overflow).toBe("hidden");
+
+    await user.keyboard("{Escape}");
+    await waitFor(() => {
+      expect(document.documentElement.style.overflow).toBe("");
+      expect(document.body.style.overflow).toBe("");
+    });
+  });
+
+  it("does not lock scrolling when lockScroll is false", async () => {
+    const user = userEvent.setup();
+    render(<SidePanelHarness lockScroll={false} />);
+
+    await user.click(screen.getByRole("button", { name: "Open" }));
+    expect(document.documentElement.style.overflow).toBe("");
+    expect(document.body.style.overflow).toBe("");
+  });
+
+  it("applies overscroll-contain to the internal scroll container", async () => {
+    const user = userEvent.setup();
+    render(<SidePanelHarness />);
+
+    await user.click(screen.getByRole("button", { name: "Open" }));
+    const dialog = screen.getByRole("dialog");
+    const scrollContainer = dialog.querySelector(".overflow-y-auto");
+    expect(scrollContainer).toBeInTheDocument();
+    expect(scrollContainer).toHaveClass("overscroll-contain");
+  });
 });
diff --git a/tests/unit/components/ui/useScrollLock.test.tsx b/tests/unit/components/ui/useScrollLock.test.tsx
index 139db57a..2cc5cc4a 100644
--- a/tests/unit/components/ui/useScrollLock.test.tsx
+++ b/tests/unit/components/ui/useScrollLock.test.tsx
@@ -12,6 +12,7 @@ function Locker({ locked = true }: { locked?: boolean }) {
 
 afterEach(() => {
   cleanup();
+  document.documentElement.style.overflow = "";
   document.body.style.overflow = "";
   document.body.style.paddingRight = "";
 });
@@ -19,9 +20,11 @@ afterEach(() => {
 describe("useScrollLock", () => {
   it("freezes the page while locked and restores it afterwards", () => {
     const view = render(<Locker />);
+    expect(document.documentElement.style.overflow).toBe("hidden");
     expect(document.body.style.overflow).toBe("hidden");
 
     view.unmount();
+    expect(document.documentElement.style.overflow).toBe("");
     expect(document.body.style.overflow).toBe("");
   });
 
@@ -68,4 +71,83 @@ describe("useScrollLock", () => {
     view.unmount();
     expect(document.body.style.overflow).toBe("auto");
   });
+
+  it("prevents wheel events on non-scrollable background elements while locked", () => {
+    const view = render(<Locker />);
+    const event = new WheelEvent("wheel", { bubbles: true, cancelable: true, deltaY: 100 });
+    document.body.dispatchEvent(event);
+    expect(event.defaultPrevented).toBe(true);
+
+    view.unmount();
+    const eventAfter = new WheelEvent("wheel", { bubbles: true, cancelable: true, deltaY: 100 });
+    document.body.dispatchEvent(eventAfter);
+    expect(eventAfter.defaultPrevented).toBe(false);
+  });
+
+  it("lets a wheel over an SVG icon scroll the panel that contains it", () => {
+    // An icon is an SVGElement, not an HTMLElement: the walk up to the
+    // scrollable panel must still start at it, or hovering an icon blocks scroll.
+    const panel = document.createElement("div");
+    panel.style.overflowY = "auto";
+    Object.defineProperty(panel, "scrollHeight", { configurable: true, value: 500 });
+    Object.defineProperty(panel, "clientHeight", { configurable: true, value: 100 });
+    const icon = document.createElementNS("http://www.w3.org/2000/svg", "svg");
+    panel.appendChild(icon);
+    document.body.appendChild(panel);
+
+    const view = render(<Locker />);
+    const event = new WheelEvent("wheel", { bubbles: true, cancelable: true, deltaY: 100 });
+    icon.dispatchEvent(event);
+    expect(event.defaultPrevented).toBe(false);
+
+    view.unmount();
+    panel.remove();
+  });
+
+  it("leaves Ctrl+wheel (browser zoom) alone while locked", () => {
+    const view = render(<Locker />);
+    const event = new WheelEvent("wheel", {
+      bubbles: true,
+      cancelable: true,
+      deltaY: 100,
+      ctrlKey: true,
+    });
+    document.body.dispatchEvent(event);
+    expect(event.defaultPrevented).toBe(false);
+    view.unmount();
+  });
+
+  it("lets a sideways wheel scroll a horizontally scrollable block in a short panel", () => {
+    // Nothing here scrolls vertically: only the horizontal axis may decide.
+    const block = document.createElement("pre");
+    block.style.overflowX = "auto";
+    Object.defineProperty(block, "scrollWidth", { configurable: true, value: 800 });
+    Object.defineProperty(block, "clientWidth", { configurable: true, value: 200 });
+    document.body.appendChild(block);
+
+    const view = render(<Locker />);
+    const sideways = new WheelEvent("wheel", { bubbles: true, cancelable: true, deltaX: 80 });
+    block.dispatchEvent(sideways);
+    expect(sideways.defaultPrevented).toBe(false);
+
+    const down = new WheelEvent("wheel", { bubbles: true, cancelable: true, deltaY: 80 });
+    block.dispatchEvent(down);
+    expect(down.defaultPrevented).toBe(true);
+
+    view.unmount();
+    block.remove();
+  });
+
+  it("leaves a two-finger pinch alone while locked", () => {
+    const view = render(<Locker />);
+    const touch = (y: number) => ({ clientX: 0, clientY: y }) as Touch;
+    const pinch = new TouchEvent("touchmove", {
+      bubbles: true,
+      cancelable: true,
+      touches: [touch(10), touch(50)],
+    });
+    document.body.dispatchEvent(pinch);
+    expect(pinch.defaultPrevented).toBe(false);
+    view.unmount();
+  });
 });
diff --git a/tests/unit/features/knowledge-base/components/ArtifactBulkActions.test.tsx b/tests/unit/features/knowledge-base/components/ArtifactBulkActions.test.tsx
new file mode 100644
index 00000000..e2b7536d
--- /dev/null
+++ b/tests/unit/features/knowledge-base/components/ArtifactBulkActions.test.tsx
@@ -0,0 +1,135 @@
+import { render, screen, fireEvent, waitFor } from "@testing-library/react";
+import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
+import type { ReactElement } from "react";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { ArtifactBulkActions } from "../../../../../src/features/knowledge-base/components/ArtifactBulkActions";
+import type { Artifact } from "../../../../../src/features/knowledge-base/types";
+import { knowledgeService } from "../../../../../src/services/knowledgeService";
+
+function makeUpload(id: string, title: string): Artifact {
+  return {
+    id,
+    title,
+    artifactType: "FILE",
+    sourceSystem: "UPLOAD",
+    sourceId: `up-${id}`,
+    sourceUrl: null,
+    mime: null,
+    language: null,
+    ingestedAt: "2026-09-01T10:00:00Z",
+    lastChangedAt: null,
+    contentHash: null,
+    ingestionRunId: null,
+  };
+}
+
+const selected = [makeUpload("a1", "notes.pdf"), makeUpload("a2", "plan.md")];
+
+function renderActions(ui: ReactElement) {
+  const client = new QueryClient({ defaultOptions: { mutations: { retry: false } } });
+  const invalidate = vi.spyOn(client, "invalidateQueries");
+  const view = render(<QueryClientProvider client={client}>{ui}</QueryClientProvider>);
+  const rerender = (next: ReactElement) =>
+    view.rerender(<QueryClientProvider client={client}>{next}</QueryClientProvider>);
+  return { invalidate, rerender };
+}
+
+function props(overrides: Partial<Parameters<typeof ArtifactBulkActions>[0]> = {}) {
+  return {
+    projectId: "p1",
+    removerId: "user-1",
+    selected,
+    onClearSelection: vi.fn(),
+    onDeleted: vi.fn(),
+    listScopeKey: "scope-1",
+    ...overrides,
+  };
+}
+
+afterEach(() => vi.restoreAllMocks());
+
+describe("ArtifactBulkActions", () => {
+  it("shows no toolbar while nothing is ticked", () => {
+    renderActions(<ArtifactBulkActions {...props({ selected: [] })} />);
+    expect(screen.queryByTestId("kb-bulk-toolbar")).not.toBeInTheDocument();
+  });
+
+  it("says how many uploads are ticked and clears on request", () => {
+    const onClearSelection = vi.fn();
+    renderActions(<ArtifactBulkActions {...props({ onClearSelection })} />);
+
+    expect(screen.getByTestId("kb-bulk-toolbar")).toHaveTextContent("2 uploads selected");
+    fireEvent.click(screen.getByTestId("kb-bulk-clear"));
+    expect(onClearSelection).toHaveBeenCalledTimes(1);
+  });
+
+  it("deletes every ticked upload in one request and reports the count", async () => {
+    const deleteUploads = vi
+      .spyOn(knowledgeService, "deleteUploads")
+      .mockResolvedValue({ deletedIds: ["up-a1", "up-a2"], failed: [] });
+    const onDeleted = vi.fn();
+    const { invalidate } = renderActions(<ArtifactBulkActions {...props({ onDeleted })} />);
+
+    fireEvent.click(screen.getByTestId("kb-bulk-delete"));
+    const dialog = screen.getByRole("alertdialog");
+    expect(dialog).toHaveTextContent("and their indexed content");
+    fireEvent.click(screen.getByTestId("kb-bulk-confirm"));
+
+    expect(await screen.findByTestId("kb-bulk-deleted")).toHaveTextContent("2 deleted");
+    expect(deleteUploads).toHaveBeenCalledWith("p1", ["up-a1", "up-a2"], "user-1");
+    expect(invalidate).toHaveBeenCalledWith({ queryKey: ["knowledge-base", "p1"] });
+    expect(onDeleted).toHaveBeenCalledWith(["a1", "a2"]);
+    expect(screen.queryByTestId("kb-bulk-failed")).not.toBeInTheDocument();
+  });
+
+  it("drops the delete report once the reader moves to another list", async () => {
+    vi.spyOn(knowledgeService, "deleteUploads").mockResolvedValue({
+      deletedIds: ["up-a1"],
+      failed: [{ artifactId: "up-a2", error: "Locked" }],
+    });
+    const { rerender } = renderActions(<ArtifactBulkActions {...props()} />);
+
+    fireEvent.click(screen.getByTestId("kb-bulk-delete"));
+    fireEvent.click(screen.getByTestId("kb-bulk-confirm"));
+    expect(await screen.findByTestId("kb-bulk-deleted")).toHaveTextContent("1 deleted");
+
+    // Same list (the delete's own refetch): the report stays.
+    rerender(<ArtifactBulkActions {...props()} />);
+    expect(screen.getByTestId("kb-bulk-failed")).toBeInTheDocument();
+
+    rerender(<ArtifactBulkActions {...props({ listScopeKey: "scope-2" })} />);
+    expect(screen.queryByTestId("kb-bulk-deleted")).not.toBeInTheDocument();
+    expect(screen.queryByTestId("kb-bulk-failed")).not.toBeInTheDocument();
+  });
+
+  it("names each upload that could not be deleted, with its reason", async () => {
+    vi.spyOn(knowledgeService, "deleteUploads").mockResolvedValue({
+      deletedIds: ["up-a1"],
+      failed: [{ artifactId: "up-a2", error: "Artifact could not be deleted." }],
+    });
+    const onDeleted = vi.fn();
+    renderActions(<ArtifactBulkActions {...props({ onDeleted })} />);
+
+    fireEvent.click(screen.getByTestId("kb-bulk-delete"));
+    fireEvent.click(screen.getByTestId("kb-bulk-confirm"));
+
+    const failed = await screen.findByRole("alert");
+    expect(failed).toHaveTextContent("1 upload could not be deleted");
+    expect(failed).toHaveTextContent("plan.md: Artifact could not be deleted.");
+    expect(screen.getByTestId("kb-bulk-deleted")).toHaveTextContent("1 deleted");
+    expect(onDeleted).toHaveBeenCalledWith(["a1"]);
+  });
+
+  it("keeps the dialog open with the reason when the request itself fails", async () => {
+    vi.spyOn(knowledgeService, "deleteUploads").mockRejectedValue(new Error("Forbidden"));
+    const onDeleted = vi.fn();
+    renderActions(<ArtifactBulkActions {...props({ onDeleted })} />);
+
+    fireEvent.click(screen.getByTestId("kb-bulk-delete"));
+    fireEvent.click(screen.getByTestId("kb-bulk-confirm"));
+
+    await waitFor(() => expect(screen.getByRole("alertdialog")).toHaveTextContent("Forbidden"));
+    expect(onDeleted).not.toHaveBeenCalled();
+    expect(screen.queryByTestId("kb-bulk-deleted")).not.toBeInTheDocument();
+  });
+});
diff --git a/tests/unit/features/knowledge-base/components/ArtifactDateRangeFilter.test.tsx b/tests/unit/features/knowledge-base/components/ArtifactDateRangeFilter.test.tsx
new file mode 100644
index 00000000..79e1ed12
--- /dev/null
+++ b/tests/unit/features/knowledge-base/components/ArtifactDateRangeFilter.test.tsx
@@ -0,0 +1,87 @@
+import { render, screen, fireEvent } from "@testing-library/react";
+import { describe, expect, it, vi } from "vitest";
+import { ArtifactDateRangeFilter } from "../../../../../src/features/knowledge-base/components/ArtifactDateRangeFilter.tsx";
+import type { DateRange } from "../../../../../src/features/knowledge-base/dateRange.ts";
+
+const NOW = new Date("2026-09-24T10:00:00Z");
+const OPEN: DateRange = { from: null, to: null };
+
+function renderFilter(range: DateRange = OPEN) {
+  const onRangeChange = vi.fn();
+  const view = render(
+    <ArtifactDateRangeFilter range={range} onRangeChange={onRangeChange} now={NOW} />,
+  );
+  return { onRangeChange, ...view };
+}
+
+describe("ArtifactDateRangeFilter", () => {
+  it("resolves a preset to absolute dates when it is picked, and pushes it", () => {
+    const { onRangeChange } = renderFilter();
+
+    fireEvent.change(screen.getByTestId("kb-date-preset"), { target: { value: "7d" } });
+
+    expect(onRangeChange).toHaveBeenCalledWith({ from: "2026-09-18", to: "2026-09-24" }, "push");
+  });
+
+  it("shows the preset a range still equals, and Custom once it does not", () => {
+    const { rerender } = renderFilter({ from: "2026-09-18", to: "2026-09-24" });
+    expect(screen.getByTestId("kb-date-preset")).toHaveValue("7d");
+
+    rerender(
+      <ArtifactDateRangeFilter
+        range={{ from: "2026-01-01", to: "2026-02-01" }}
+        onRangeChange={vi.fn()}
+        now={NOW}
+      />,
+    );
+    expect(screen.getByTestId("kb-date-preset")).toHaveValue("CUSTOM");
+    expect(screen.getByTestId("kb-date-from")).toHaveValue("2026-01-01");
+  });
+
+  it("reveals two date fields for a custom range and replaces on each edit", () => {
+    const { onRangeChange } = renderFilter();
+
+    fireEvent.change(screen.getByTestId("kb-date-preset"), { target: { value: "CUSTOM" } });
+    expect(onRangeChange).not.toHaveBeenCalled();
+
+    fireEvent.change(screen.getByLabelText("Updated from"), { target: { value: "2026-09-01" } });
+    expect(onRangeChange).toHaveBeenLastCalledWith({ from: "2026-09-01", to: null }, "replace");
+  });
+
+  it("refuses a reversed custom range with a message instead of writing it", () => {
+    const { onRangeChange } = renderFilter({ from: "2026-09-10", to: null });
+
+    fireEvent.change(screen.getByLabelText("Updated to"), { target: { value: "2026-09-01" } });
+
+    expect(onRangeChange).not.toHaveBeenCalled();
+    const error = screen.getByTestId("kb-date-error");
+    expect(error).toHaveTextContent("on or before");
+    expect(screen.getByLabelText("Updated to")).toHaveAttribute("aria-describedby", error.id);
+    expect(screen.getByLabelText("Updated to")).toHaveAttribute("aria-invalid", "true");
+  });
+
+  it("names the active range in a chip whose button clears it", () => {
+    const { onRangeChange } = renderFilter({ from: "2026-09-01", to: null });
+
+    expect(screen.getByTestId("kb-date-chip")).toHaveTextContent(/Updated since/);
+    fireEvent.click(screen.getByRole("button", { name: "Clear date range" }));
+
+    expect(onRangeChange).toHaveBeenCalledWith({ from: null, to: null }, "push");
+  });
+
+  it("shows no chip and Any time while no range is set", () => {
+    renderFilter();
+    expect(screen.getByTestId("kb-date-preset")).toHaveValue("ANY");
+    expect(screen.queryByTestId("kb-date-chip")).not.toBeInTheDocument();
+  });
+
+  it("goes back to Any time when the range is cleared from outside", () => {
+    const { rerender } = renderFilter({ from: "2026-01-01", to: "2026-02-01" });
+    expect(screen.getByTestId("kb-date-preset")).toHaveValue("CUSTOM");
+
+    rerender(<ArtifactDateRangeFilter range={OPEN} onRangeChange={vi.fn()} now={NOW} />);
+
+    expect(screen.getByTestId("kb-date-preset")).toHaveValue("ANY");
+    expect(screen.queryByTestId("kb-date-from")).not.toBeInTheDocument();
+  });
+});
diff --git a/tests/unit/features/knowledge-base/components/ArtifactFilters.test.tsx b/tests/unit/features/knowledge-base/components/ArtifactFilters.test.tsx
index 08102828..7a25b4c7 100644
--- a/tests/unit/features/knowledge-base/components/ArtifactFilters.test.tsx
+++ b/tests/unit/features/knowledge-base/components/ArtifactFilters.test.tsx
@@ -68,7 +68,7 @@ describe("ArtifactFilters", () => {
     expect(screen.getByTestId("kb-search-input")).toBeInTheDocument();
     expect(screen.getByRole("button", { name: /all/i })).toBeInTheDocument();
     expect(screen.getByRole("button", { name: /pull requests/i })).toBeInTheDocument();
-    expect(screen.getByTestId("kb-result-count")).toHaveTextContent("10 results");
+    expect(screen.getByTestId("kb-result-count")).toHaveTextContent("10 artifacts");
     expect(screen.getByTestId("kb-filter-trigger")).toHaveTextContent("All sources");
 
     fireEvent.click(screen.getByTestId("kb-refresh"));
@@ -178,6 +178,18 @@ describe("ArtifactFilters", () => {
     expect(onSearchChange).toHaveBeenCalledWith("readme");
   });
 
+  it("says what the search looks at and ties the hint to the field", () => {
+    render(<ArtifactFilters {...buildProps()} />);
+
+    const hint = screen.getByTestId("kb-search-hint");
+    expect(hint).toHaveTextContent("Searches titles and links");
+    const input = screen.getByTestId("kb-search-input");
+    expect(input.getAttribute("aria-describedby")).toContain(hint.id);
+    expect(
+      screen.getByRole("textbox", { name: "Search knowledge base" }),
+    ).toHaveAccessibleDescription("Searches titles and links");
+  });
+
   it("renders the repositories section only when repository options are provided", () => {
     const { unmount } = render(<ArtifactFilters {...buildProps()} />);
 
@@ -240,4 +252,167 @@ describe("ArtifactFilters", () => {
 
     expect(screen.getByTestId("kb-filter-trigger")).toHaveTextContent("2 repositories");
   });
+
+  it("words the result line as a range of the total", () => {
+    render(
+      <ArtifactFilters
+        {...buildProps({ resultCount: 412, resultRange: { start: 21, end: 40 } })}
+      />,
+    );
+    expect(screen.getByTestId("kb-result-count")).toHaveTextContent("21–40 of 412 artifacts");
+  });
+
+  it("says No artifacts instead of a zero range", () => {
+    render(<ArtifactFilters {...buildProps({ resultCount: 0 })} />);
+    expect(screen.getByTestId("kb-result-count")).toHaveTextContent("No artifacts");
+  });
+
+  it("explains what the facet counts mean inside the menu", () => {
+    render(<ArtifactFilters {...buildProps()} />);
+    fireEvent.click(screen.getByTestId("kb-filter-trigger"));
+    expect(screen.getByTestId("kb-filter-footnote")).toHaveTextContent(
+      "Counts show what you would get if you added this option.",
+    );
+  });
+
+  it("gives a long repository list a filter box and folds it to ten", () => {
+    const manyRepos = Array.from({ length: 14 }, (_, i) => ({
+      value: `acme/repo-${i}`,
+      label: `acme/repo-${i}`,
+      count: 20 - i,
+    }));
+    render(
+      <ArtifactFilters
+        {...buildProps({
+          repositoryOptions: manyRepos,
+          selectedSources: new Set<SourceSystem>(["GITHUB"]),
+        })}
+      />,
+    );
+    fireEvent.click(screen.getByTestId("kb-filter-trigger"));
+
+    expect(screen.getByTestId("kb-filter-section-repositories-search")).toBeInTheDocument();
+    expect(screen.getByTestId("kb-filter-section-repositories-show-all")).toHaveTextContent(
+      "Show all (14)",
+    );
+    expect(screen.queryByTestId("kb-filter-option-acme/repo-13")).not.toBeInTheDocument();
+
+    fireEvent.change(screen.getByTestId("kb-filter-section-repositories-search"), {
+      target: { value: "repo-13" },
+    });
+    expect(screen.getByTestId("kb-filter-option-acme/repo-13")).toBeInTheDocument();
+  });
+  it("offers the three list orders and reports a pick", () => {
+    const onSortChange = vi.fn();
+    render(<ArtifactFilters {...buildProps({ sort: "ADDED_DESC", onSortChange })} />);
+
+    const select = screen.getByTestId<HTMLSelectElement>("kb-sort");
+    expect(select).toHaveAccessibleName("Sort artifacts");
+    expect(Array.from(select.options).map((option) => option.textContent)).toEqual([
+      "Newest added",
+      "Recently changed",
+      "Title A–Z",
+    ]);
+
+    fireEvent.change(select, { target: { value: "CHANGED_DESC" } });
+    expect(onSortChange).toHaveBeenCalledWith("CHANGED_DESC");
+  });
+
+  it("renders no sort control when the parent does not handle one", () => {
+    render(<ArtifactFilters {...buildProps()} />);
+    expect(screen.queryByTestId("kb-sort")).not.toBeInTheDocument();
+  });
+});
+
+describe("ArtifactFilters languages", () => {
+  const LANGUAGE_OPTIONS: FacetOption<string>[] = [
+    { value: "Kotlin", label: "Kotlin", count: 4 },
+    { value: "Markdown", label: "Markdown", count: 1 },
+  ];
+
+  it("renders no language section when the project has no language values", () => {
+    render(<ArtifactFilters {...buildProps()} />);
+    fireEvent.click(screen.getByTestId("kb-filter-trigger"));
+    expect(screen.queryByText("Language")).not.toBeInTheDocument();
+  });
+
+  it("lists languages without needing a source and reports the raw value on toggle", () => {
+    const onToggleLanguage = vi.fn();
+    render(
+      <ArtifactFilters {...buildProps({ languageOptions: LANGUAGE_OPTIONS, onToggleLanguage })} />,
+    );
+
+    fireEvent.click(screen.getByTestId("kb-filter-trigger"));
+    expect(screen.getByText("Language")).toBeInTheDocument();
+    fireEvent.click(screen.getByTestId("kb-filter-option-lang:kotlin"));
+    expect(onToggleLanguage).toHaveBeenCalledWith("Kotlin");
+  });
+
+  it("keeps a Markdown language apart from the MARKDOWN format", () => {
+    const onToggleFormat = vi.fn();
+    const onToggleLanguage = vi.fn();
+    render(
+      <ArtifactFilters
+        {...buildProps({
+          selectedSources: new Set<SourceSystem>(["UPLOAD"]),
+          formatOptions: FORMAT_OPTIONS,
+          selectedFormat: "MARKDOWN",
+          languageOptions: LANGUAGE_OPTIONS,
+          onToggleFormat,
+          onToggleLanguage,
+        })}
+      />,
+    );
+
+    fireEvent.click(screen.getByTestId("kb-filter-trigger"));
+    expect(screen.getByTestId("kb-filter-option-markdown")).toBeChecked();
+    expect(screen.getByTestId("kb-filter-option-lang:markdown")).not.toBeChecked();
+    fireEvent.click(screen.getByTestId("kb-filter-option-lang:markdown"));
+    expect(onToggleLanguage).toHaveBeenCalledWith("Markdown");
+    expect(onToggleFormat).not.toHaveBeenCalled();
+  });
+
+  it("checks selected languages, counts them and names them in the trigger", () => {
+    render(
+      <ArtifactFilters
+        {...buildProps({
+          languageOptions: LANGUAGE_OPTIONS,
+          selectedLanguages: new Set<string>(["Kotlin"]),
+        })}
+      />,
+    );
+
+    const trigger = screen.getByTestId("kb-filter-trigger");
+    expect(trigger).toHaveTextContent("Kotlin");
+    fireEvent.click(trigger);
+    expect(screen.getByTestId("kb-filter-option-lang:kotlin")).toBeChecked();
+  });
+
+  it("summarises several languages by count", () => {
+    render(
+      <ArtifactFilters {...buildProps({ selectedLanguages: new Set<string>(["Kotlin", "Go"]) })} />,
+    );
+    expect(screen.getByTestId("kb-filter-trigger")).toHaveTextContent("2 languages");
+  });
+});
+
+describe("ArtifactFilters select toggle", () => {
+  it("renders no Select button unless the parent handles select mode", () => {
+    render(<ArtifactFilters {...buildProps()} />);
+    expect(screen.queryByTestId("kb-select-toggle")).not.toBeInTheDocument();
+  });
+
+  it("is a pressed-state toggle with a constant name", () => {
+    const onSelectModeChange = vi.fn();
+    const { rerender } = render(
+      <ArtifactFilters {...buildProps({ isSelectMode: false, onSelectModeChange })} />,
+    );
+    const toggle = screen.getByRole("button", { name: "Select" });
+    expect(toggle).toHaveAttribute("aria-pressed", "false");
+    fireEvent.click(toggle);
+    expect(onSelectModeChange).toHaveBeenCalledWith(true);
+
+    rerender(<ArtifactFilters {...buildProps({ isSelectMode: true, onSelectModeChange })} />);
+    expect(screen.getByRole("button", { name: "Select" })).toHaveAttribute("aria-pressed", "true");
+  });
 });
diff --git a/tests/unit/features/knowledge-base/components/ArtifactList.test.tsx b/tests/unit/features/knowledge-base/components/ArtifactList.test.tsx
index 4958e712..d7799ff7 100644
--- a/tests/unit/features/knowledge-base/components/ArtifactList.test.tsx
+++ b/tests/unit/features/knowledge-base/components/ArtifactList.test.tsx
@@ -1,8 +1,8 @@
-import { render, screen } from "@testing-library/react";
+import { fireEvent, render, screen } from "@testing-library/react";
 import { describe, expect, it, vi } from "vitest";
 
 import { ArtifactList } from "../../../../../src/features/knowledge-base/components/ArtifactList";
-import type { Artifact } from "../../../../../src/features/knowledge-base/types";
+import type { Artifact, ArtifactAiStatus } from "../../../../../src/features/knowledge-base/types";
 
 function makeArtifact(overrides: Partial<Artifact> = {}): Artifact {
   return {
@@ -117,3 +117,96 @@ describe("ArtifactList", () => {
     expect(screen.queryByTestId("artifact-repo-badge")).not.toBeInTheDocument();
   });
 });
+
+describe("ArtifactList select mode", () => {
+  const upload = makeArtifact({ id: "u1", title: "notes.pdf", sourceSystem: "UPLOAD" });
+  const github = makeArtifact({ id: "g1", title: "Main.kt" });
+
+  it("renders no checkbox at all outside select mode", () => {
+    render(<ArtifactList artifacts={[upload, github]} onSelect={vi.fn()} />);
+    expect(screen.queryByRole("checkbox")).not.toBeInTheDocument();
+  });
+
+  it("gives only upload cards a checkbox", () => {
+    const selection = { selectedIds: new Set(["u1"]), onToggle: vi.fn() };
+    render(<ArtifactList artifacts={[upload, github]} onSelect={vi.fn()} selection={selection} />);
+
+    expect(screen.getAllByRole("checkbox")).toHaveLength(1);
+    expect(screen.getByRole("checkbox", { name: "Select notes.pdf" })).toBeChecked();
+    expect(screen.queryByTestId("artifact-select-g1")).not.toBeInTheDocument();
+  });
+
+  it("toggles on the checkbox and still opens the drawer from the card", () => {
+    const onSelect = vi.fn();
+    const onToggle = vi.fn();
+    render(
+      <ArtifactList
+        artifacts={[upload]}
+        onSelect={onSelect}
+        selection={{ selectedIds: new Set(), onToggle }}
+      />,
+    );
+
+    fireEvent.click(screen.getByTestId("artifact-select-u1"));
+    expect(onToggle).toHaveBeenCalledWith("u1");
+    expect(onSelect).not.toHaveBeenCalled();
+
+    fireEvent.click(screen.getByTestId("artifact-card"));
+    expect(onSelect).toHaveBeenCalledWith("u1");
+  });
+});
+
+describe("ArtifactList AI status chip", () => {
+  const cases: [ArtifactAiStatus, string, string][] = [
+    ["INDEXED", "Indexed", "indexed for the AI assistant"],
+    ["PROCESSING", "Indexing", "being indexed for the AI assistant"],
+    ["FAILED", "Failed", "indexing for the AI assistant failed"],
+    ["DEINDEXED", "Not indexed", "not indexed for the AI assistant"],
+    ["UNKNOWN", "Not indexed", "not indexed for the AI assistant"],
+  ];
+
+  it.each(cases)(
+    "draws %s as %s, with text and an icon, and speaks it",
+    (status, label, spoken) => {
+      render(
+        <ArtifactList
+          artifacts={[makeArtifact({ id: "a1", title: "notes.md" })]}
+          onSelect={vi.fn()}
+          aiStatuses={new Map([["a1", status]])}
+        />,
+      );
+
+      const chip = screen.getByTestId("artifact-ai-status");
+      expect(chip).toHaveAttribute("data-status", status);
+      expect(chip).toHaveTextContent(label);
+      // Never colour alone: the chip carries an icon next to its text.
+      expect(chip.querySelector("svg")).not.toBeNull();
+      // The tooltip describes the index record, not a promise the assistant finds the content.
+      expect(chip.querySelector("[title]")?.getAttribute("title")).toMatch(/AI assistant's index/);
+      expect(screen.getByTestId("artifact-card")).toHaveAttribute(
+        "aria-label",
+        `View notes.md, ${spoken}`,
+      );
+    },
+  );
+
+  it("draws no chip without statuses, or for an id the response omitted", () => {
+    const { rerender } = render(
+      <ArtifactList
+        artifacts={[makeArtifact({ id: "a1", title: "notes.md" })]}
+        onSelect={vi.fn()}
+      />,
+    );
+    expect(screen.queryByTestId("artifact-ai-status")).not.toBeInTheDocument();
+    expect(screen.getByTestId("artifact-card")).toHaveAttribute("aria-label", "View notes.md");
+
+    rerender(
+      <ArtifactList
+        artifacts={[makeArtifact({ id: "a1", title: "notes.md" })]}
+        onSelect={vi.fn()}
+        aiStatuses={new Map([["other", "INDEXED"]])}
+      />,
+    );
+    expect(screen.queryByTestId("artifact-ai-status")).not.toBeInTheDocument();
+  });
+});
diff --git a/tests/unit/features/knowledge-base/components/ArtifactPageSizeSelect.test.tsx b/tests/unit/features/knowledge-base/components/ArtifactPageSizeSelect.test.tsx
new file mode 100644
index 00000000..46225e63
--- /dev/null
+++ b/tests/unit/features/knowledge-base/components/ArtifactPageSizeSelect.test.tsx
@@ -0,0 +1,30 @@
+import { render, screen, fireEvent } from "@testing-library/react";
+import { describe, expect, it, vi } from "vitest";
+import { ArtifactPageSizeSelect } from "../../../../../src/features/knowledge-base/components/ArtifactPageSizeSelect.tsx";
+
+describe("ArtifactPageSizeSelect", () => {
+  it("offers 20, 50 and 100 behind a visible label", () => {
+    render(<ArtifactPageSizeSelect pageSize={20} onPageSizeChange={vi.fn()} />);
+
+    const select = screen.getByLabelText("Per page");
+    expect(select).toHaveValue("20");
+    const values = Array.from((select as HTMLSelectElement).options).map((o) => o.value);
+    expect(values).toEqual(["20", "50", "100"]);
+  });
+
+  it("reports the chosen size as a number", () => {
+    const onPageSizeChange = vi.fn();
+    render(<ArtifactPageSizeSelect pageSize={20} onPageSizeChange={onPageSizeChange} />);
+
+    fireEvent.change(screen.getByTestId("kb-page-size"), { target: { value: "50" } });
+    expect(onPageSizeChange).toHaveBeenCalledWith(50);
+  });
+
+  it("shows a hand-edited size as its own option instead of misreporting it", () => {
+    render(<ArtifactPageSizeSelect pageSize={35} onPageSizeChange={vi.fn()} />);
+
+    const select = screen.getByTestId<HTMLSelectElement>("kb-page-size");
+    expect(select).toHaveValue("35");
+    expect(Array.from(select.options).map((o) => o.value)).toEqual(["20", "35", "50", "100"]);
+  });
+});
diff --git a/tests/unit/features/knowledge-base/components/ArtifactViewerDrawer.test.tsx b/tests/unit/features/knowledge-base/components/ArtifactViewerDrawer.test.tsx
index 499f68bb..2678bd29 100644
--- a/tests/unit/features/knowledge-base/components/ArtifactViewerDrawer.test.tsx
+++ b/tests/unit/features/knowledge-base/components/ArtifactViewerDrawer.test.tsx
@@ -50,15 +50,17 @@ vi.mock("../../../../../src/components/ui/SidePanel", () => ({
     actions,
     badge,
     children,
+    lockScroll,
   }: {
     isOpen: boolean;
     title: React.ReactNode;
     actions: React.ReactNode;
     badge?: React.ReactNode;
     children: React.ReactNode;
+    lockScroll?: boolean;
   }) =>
     isOpen ? (
-      <div data-testid="side-panel">
+      <div data-testid="side-panel" data-lock-scroll={lockScroll !== false}>
         <div data-testid="panel-header">{title}</div>
         {badge && <div data-testid="panel-badge">{badge}</div>}
         <div data-testid="panel-actions">{actions}</div>
@@ -174,6 +176,96 @@ describe("ArtifactViewerDrawer", () => {
     });
   });
 
+  describe("external source link", () => {
+    it("shows the source link alongside the repository badge for a GitHub artifact with repo metadata and sourceUrl", () => {
+      const sourceUrl = "https://github.com/sprintstart/sprintstart-backend/blob/main/README.md";
+      renderDrawer(
+        createArtifact({
+          sourceSystem: "GITHUB",
+          sourceUrl,
+          metadata: JSON.stringify({
+            repositoryId: "r1",
+            repositoryFullName: "sprintstart/sprintstart-backend",
+          }),
+        }),
+      );
+
+      expect(screen.getByTestId("artifact-drawer-repo-badge")).toHaveTextContent(
+        "sprintstart/sprintstart-backend",
+      );
+      const link = screen.getByTestId("artifact-drawer-source-link");
+      expect(link).toBeInTheDocument();
+      expect(link).toHaveTextContent("Open in GitHub");
+      expect(link).toHaveAttribute("href", sourceUrl);
+      expect(link).toHaveAttribute("target", "_blank");
+      expect(link).toHaveAttribute("rel", "noopener noreferrer");
+      expect(link).toHaveAttribute("title", sourceUrl);
+    });
+
+    it("shows the source link in place of the repository badge for a Jira artifact", () => {
+      const sourceUrl = "https://team.atlassian.net/browse/PROJ-123";
+      renderDrawer(
+        createArtifact({
+          sourceSystem: "JIRA",
+          sourceUrl,
+        }),
+      );
+
+      expect(screen.queryByTestId("artifact-drawer-repo-badge")).not.toBeInTheDocument();
+      const link = screen.getByTestId("artifact-drawer-source-link");
+      expect(link).toBeInTheDocument();
+      expect(link).toHaveTextContent("Open in Jira");
+      expect(link).toHaveAttribute("href", sourceUrl);
+    });
+
+    it("shows the source link for a Confluence artifact", () => {
+      const sourceUrl = "https://team.atlassian.net/wiki/spaces/DEV/pages/456";
+      renderDrawer(
+        createArtifact({
+          sourceSystem: "CONFLUENCE",
+          sourceUrl,
+        }),
+      );
+
+      expect(screen.queryByTestId("artifact-drawer-repo-badge")).not.toBeInTheDocument();
+      const link = screen.getByTestId("artifact-drawer-source-link");
+      expect(link).toBeInTheDocument();
+      expect(link).toHaveTextContent("Open in Confluence");
+      expect(link).toHaveAttribute("href", sourceUrl);
+    });
+
+    it("shows no source link for an uploaded artifact even if sourceUrl is present", () => {
+      renderDrawer(
+        createArtifact({
+          sourceSystem: "UPLOAD",
+          sourceUrl: "https://example.com/uploads/doc.pdf",
+        }),
+      );
+
+      expect(screen.queryByTestId("artifact-drawer-source-link")).not.toBeInTheDocument();
+      expect(screen.queryByTestId("artifact-drawer-repo-badge")).not.toBeInTheDocument();
+      expect(screen.queryByTestId("panel-badge")).not.toBeInTheDocument();
+    });
+
+    it("shows no source link when sourceUrl is null or whitespace", () => {
+      renderDrawer(
+        createArtifact({
+          sourceSystem: "GITHUB",
+          sourceUrl: null,
+        }),
+      );
+      expect(screen.queryByTestId("artifact-drawer-source-link")).not.toBeInTheDocument();
+
+      renderDrawer(
+        createArtifact({
+          sourceSystem: "GITHUB",
+          sourceUrl: "   ",
+        }),
+      );
+      expect(screen.queryByTestId("artifact-drawer-source-link")).not.toBeInTheDocument();
+    });
+  });
+
   it("shows a spinner while fetching the summary", async () => {
     const { knowledgeService } = await import("../../../../../src/services/knowledgeService");
     vi.mocked(knowledgeService.streamArtifactSummary).mockReturnValue(new Promise(() => {}));
@@ -999,4 +1091,10 @@ describe("ArtifactViewerDrawer", () => {
 
     vi.restoreAllMocks();
   });
+
+  it("enables background scroll locking by default on the rendered SidePanel", () => {
+    renderDrawer();
+    const panel = screen.getByTestId("side-panel");
+    expect(panel).toHaveAttribute("data-lock-scroll", "true");
+  });
 });
diff --git a/tests/unit/features/knowledge-base/components/SourceLinkBadge.test.tsx b/tests/unit/features/knowledge-base/components/SourceLinkBadge.test.tsx
new file mode 100644
index 00000000..9bd61755
--- /dev/null
+++ b/tests/unit/features/knowledge-base/components/SourceLinkBadge.test.tsx
@@ -0,0 +1,66 @@
+import { render, screen } from "@testing-library/react";
+import { describe, it, expect } from "vitest";
+import { SourceLinkBadge } from "../../../../../src/features/knowledge-base/components/SourceLinkBadge";
+
+describe("SourceLinkBadge", () => {
+  it("renders GitHub link badge with appropriate label and security attributes", () => {
+    render(
+      <SourceLinkBadge
+        sourceUrl="https://github.com/org/repo/blob/main/doc.md"
+        sourceSystem="GITHUB"
+      />,
+    );
+
+    const link = screen.getByTestId("artifact-drawer-source-link");
+    expect(link).toBeInTheDocument();
+    expect(link).toHaveTextContent("Open in GitHub");
+    expect(link).toHaveAttribute("href", "https://github.com/org/repo/blob/main/doc.md");
+    expect(link).toHaveAttribute("target", "_blank");
+    expect(link).toHaveAttribute("rel", "noopener noreferrer");
+    expect(link).toHaveAttribute("aria-label", "Open in GitHub (opens in a new tab)");
+    expect(link).toHaveAttribute("title", "https://github.com/org/repo/blob/main/doc.md");
+  });
+
+  it("renders Jira link badge", () => {
+    render(
+      <SourceLinkBadge sourceUrl="https://jira.example.com/browse/KEY-123" sourceSystem="JIRA" />,
+    );
+
+    const link = screen.getByTestId("artifact-drawer-source-link");
+    expect(link).toHaveTextContent("Open in Jira");
+    expect(link).toHaveAttribute("href", "https://jira.example.com/browse/KEY-123");
+  });
+
+  it("renders Confluence link badge", () => {
+    render(
+      <SourceLinkBadge
+        sourceUrl="https://confluence.example.com/wiki/page/123"
+        sourceSystem="CONFLUENCE"
+      />,
+    );
+
+    const link = screen.getByTestId("artifact-drawer-source-link");
+    expect(link).toHaveTextContent("Open in Confluence");
+  });
+
+  it("falls back to generic label for other source systems", () => {
+    render(
+      <SourceLinkBadge sourceUrl="https://example.com/custom" sourceSystem={"OTHER" as never} />,
+    );
+
+    const link = screen.getByTestId("artifact-drawer-source-link");
+    expect(link).toHaveTextContent("Open source");
+  });
+
+  it("respects custom testId prop", () => {
+    render(
+      <SourceLinkBadge
+        sourceUrl="https://github.com/org/repo"
+        sourceSystem="GITHUB"
+        testId="custom-source-link"
+      />,
+    );
+
+    expect(screen.getByTestId("custom-source-link")).toBeInTheDocument();
+  });
+});
diff --git a/tests/unit/features/knowledge-base/dateRange.test.ts b/tests/unit/features/knowledge-base/dateRange.test.ts
new file mode 100644
index 00000000..1f492bd7
--- /dev/null
+++ b/tests/unit/features/knowledge-base/dateRange.test.ts
@@ -0,0 +1,75 @@
+import { describe, expect, it } from "vitest";
+import {
+  DATE_RANGE_PRESETS,
+  describeDateRange,
+  isIsoDate,
+  matchPreset,
+  normalizeDateRange,
+  resolvePreset,
+  shiftIsoDate,
+  todayUtc,
+} from "../../../../src/features/knowledge-base/dateRange.ts";
+
+const NOW = new Date("2026-09-24T10:00:00Z");
+const [LAST_7, LAST_30] = DATE_RANGE_PRESETS;
+
+describe("dateRange", () => {
+  it("accepts only real yyyy-MM-dd calendar dates", () => {
+    expect(isIsoDate("2026-09-24")).toBe(true);
+    expect(isIsoDate("2024-02-29")).toBe(true);
+    expect(isIsoDate("2026-02-30")).toBe(false);
+    expect(isIsoDate("2026-9-24")).toBe(false);
+    expect(isIsoDate("24.09.2026")).toBe(false);
+    expect(isIsoDate(null)).toBe(false);
+  });
+
+  it("counts today in UTC, the zone the server cuts days in", () => {
+    // 20:00 in UTC-8 is already the next day in UTC; a `to` of the local date would end too early.
+    expect(todayUtc(new Date("2026-09-24T20:00:00-08:00"))).toBe("2026-09-25");
+  });
+
+  it("shifts dates across month and year boundaries", () => {
+    expect(shiftIsoDate("2026-03-01", -1)).toBe("2026-02-28");
+    expect(shiftIsoDate("2026-12-31", 1)).toBe("2027-01-01");
+  });
+
+  it("resolves a preset to an absolute window that includes today", () => {
+    expect(resolvePreset(LAST_7, NOW)).toEqual({ from: "2026-09-18", to: "2026-09-24" });
+    expect(resolvePreset(LAST_30, NOW)).toEqual({ from: "2026-08-26", to: "2026-09-24" });
+  });
+
+  it("recognises a range as a preset only while it still equals one today", () => {
+    expect(matchPreset({ from: "2026-09-18", to: "2026-09-24" }, NOW)?.id).toBe("7d");
+    // The same link a day later is a fixed, custom window.
+    expect(
+      matchPreset({ from: "2026-09-18", to: "2026-09-24" }, new Date("2026-09-25T10:00:00Z")),
+    ).toBeNull();
+    expect(matchPreset({ from: "2026-09-18", to: null }, NOW)).toBeNull();
+  });
+
+  it("drops invalid ends and swaps a reversed pair instead of sending a 400", () => {
+    expect(normalizeDateRange({ from: "2026-09-30", to: "2026-09-01" })).toEqual({
+      from: "2026-09-01",
+      to: "2026-09-30",
+    });
+    expect(normalizeDateRange({ from: "nope", to: "2026-09-01" })).toEqual({
+      from: null,
+      to: "2026-09-01",
+    });
+  });
+
+  it("describes closed, open and single-day ranges", () => {
+    expect(describeDateRange({ from: null, to: null })).toBeNull();
+    expect(describeDateRange({ from: "2026-09-01", to: "2026-09-24" })).toMatch(
+      /^Updated .+ – .+$/,
+    );
+    expect(describeDateRange({ from: "2026-09-01", to: null })).toMatch(/^Updated since .*2026/);
+    expect(describeDateRange({ from: null, to: "2026-09-24" })).toMatch(/^Updated until .*2026/);
+    expect(describeDateRange({ from: "2026-09-24", to: "2026-09-24" })).not.toContain("–");
+  });
+
+  it("prints the UTC calendar day, not the local day before it", () => {
+    // `Date` parses a bare date as UTC midnight; a local-zone format would say Aug 31 west of UTC.
+    expect(describeDateRange({ from: "2026-09-01", to: null })).toMatch(/\b1\b/);
+  });
+});
diff --git a/tests/unit/features/knowledge-base/githubMetadata.test.ts b/tests/unit/features/knowledge-base/githubMetadata.test.ts
index fc873c6b..2769435f 100644
--- a/tests/unit/features/knowledge-base/githubMetadata.test.ts
+++ b/tests/unit/features/knowledge-base/githubMetadata.test.ts
@@ -178,12 +178,16 @@ describe("matchesRepository", () => {
       ),
     ).toBe(false);
     // Repo-scoped artifacts with unusable metadata have no repository to match.
+    // The malformed blob makes the parser warn — silence it here like the parse
+    // tests do, so the real warnings stay visible in the output.
+    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
     expect(
       matchesRepository(
         { sourceSystem: "GITHUB", artifactType: "FILE", metadata: "{not json" },
         new Set(["owner/repo"]),
       ),
     ).toBe(false);
+    expect(warn).toHaveBeenCalled();
   });
 
   it("matches owner halves case-insensitively", () => {
diff --git a/tests/unit/features/knowledge-base/hooks/useArtifactAiStatus.test.tsx b/tests/unit/features/knowledge-base/hooks/useArtifactAiStatus.test.tsx
new file mode 100644
index 00000000..691f9b4f
--- /dev/null
+++ b/tests/unit/features/knowledge-base/hooks/useArtifactAiStatus.test.tsx
@@ -0,0 +1,157 @@
+import { act, renderHook, waitFor } from "@testing-library/react";
+import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
+import type { ReactNode } from "react";
+import { http, HttpResponse } from "msw";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import {
+  AI_STATUS_POLL_MS,
+  useArtifactAiStatus,
+} from "../../../../../src/features/knowledge-base/hooks/useArtifactAiStatus";
+import type {
+  ArtifactAiStatus,
+  ArtifactAiStatusResponse,
+} from "../../../../../src/features/knowledge-base/types";
+import { server } from "../../../setup/vitest.setup";
+
+const STATUS_URL = "/api/v1/projects/:projectId/artifacts/ai-status";
+
+function item(artifactId: string, status: ArtifactAiStatus) {
+  return { artifactId, status, updatedAt: null, chunkCount: null };
+}
+
+/** Records every request's ids and answers with whatever `respond` returns at that moment. */
+function recordStatusRequests(respond: () => ArtifactAiStatusResponse) {
+  const requests: string[][] = [];
+  server.use(
+    http.get(STATUS_URL, ({ request }) => {
+      requests.push(new URL(request.url).searchParams.getAll("ids"));
+      return HttpResponse.json(respond());
+    }),
+  );
+  return requests;
+}
+
+function wrapper() {
+  const client = new QueryClient({ defaultOptions: { queries: { gcTime: 0 } } });
+  return function Wrapper({ children }: { children: ReactNode }) {
+    return <QueryClientProvider client={client}>{children}</QueryClientProvider>;
+  };
+}
+
+afterEach(() => {
+  vi.useRealTimers();
+});
+
+describe("useArtifactAiStatus", () => {
+  it("sends no request for an empty page or without a project", async () => {
+    const requests = recordStatusRequests(() => ({ aiAvailable: true, items: [] }));
+
+    const empty = renderHook(() => useArtifactAiStatus("p1", []), { wrapper: wrapper() });
+    const noProject = renderHook(() => useArtifactAiStatus(null, ["a1"]), { wrapper: wrapper() });
+    await new Promise((resolve) => setTimeout(resolve, 50));
+
+    expect(requests).toEqual([]);
+    expect(empty.result.current).toBeNull();
+    expect(noProject.result.current).toBeNull();
+  });
+
+  it("asks once per visible page, with that page's ids, and maps status by id", async () => {
+    const requests = recordStatusRequests(() => ({
+      aiAvailable: true,
+      items: [item("a1", "INDEXED"), item("a2", "FAILED"), item("a3", "INDEXED")],
+    }));
+
+    const { result, rerender } = renderHook(({ ids }) => useArtifactAiStatus("p1", ids), {
+      wrapper: wrapper(),
+      initialProps: { ids: ["a1", "a2"] },
+    });
+
+    await waitFor(() => expect(result.current?.get("a1")).toBe("INDEXED"));
+    expect(result.current?.get("a2")).toBe("FAILED");
+    expect(requests).toEqual([["a1", "a2"]]);
+
+    // A new array with the same ids is the same page: no second request.
+    rerender({ ids: ["a1", "a2"] });
+    // The next page is one more request, for exactly its ids.
+    rerender({ ids: ["a3"] });
+    await waitFor(() => expect(requests).toEqual([["a1", "a2"], ["a3"]]));
+  });
+
+  it("gives no statuses when the AI was unavailable", async () => {
+    const requests = recordStatusRequests(() => ({
+      aiAvailable: false,
+      items: [item("a1", "UNKNOWN")],
+    }));
+
+    const { result } = renderHook(() => useArtifactAiStatus("p1", ["a1"]), { wrapper: wrapper() });
+
+    await waitFor(() => expect(requests).toHaveLength(1));
+    await new Promise((resolve) => setTimeout(resolve, 20));
+    expect(result.current).toBeNull();
+  });
+
+  it("gives no statuses when the request fails, and does not retry", async () => {
+    let calls = 0;
+    server.use(
+      http.get(STATUS_URL, () => {
+        calls += 1;
+        return HttpResponse.json({ message: "boom" }, { status: 500 });
+      }),
+    );
+
+    const { result } = renderHook(() => useArtifactAiStatus("p1", ["a1"]), { wrapper: wrapper() });
+
+    await waitFor(() => expect(calls).toBe(1));
+    await new Promise((resolve) => setTimeout(resolve, 100));
+    expect(calls).toBe(1);
+    expect(result.current).toBeNull();
+  });
+
+  it("polls every 10 s while an item is PROCESSING, and stops once none is", async () => {
+    // Only the interval is faked: requests and React Query's own scheduling stay real. RTL's
+    // waitFor polls with setInterval, so these two tests use vi.waitFor instead.
+    vi.useFakeTimers({ toFake: ["setInterval", "clearInterval"] });
+    let status: ArtifactAiStatus = "PROCESSING";
+    const requests = recordStatusRequests(() => ({
+      aiAvailable: true,
+      items: [item("a1", status), item("a2", "INDEXED")],
+    }));
+
+    const { result } = renderHook(() => useArtifactAiStatus("p1", ["a1", "a2"]), {
+      wrapper: wrapper(),
+    });
+    await vi.waitFor(() => expect(result.current?.get("a1")).toBe("PROCESSING"));
+    expect(requests).toHaveLength(1);
+
+    // Still processing: the next tick polls.
+    await act(() => vi.advanceTimersByTimeAsync(AI_STATUS_POLL_MS));
+    await vi.waitFor(() => expect(requests).toHaveLength(2));
+
+    // Indexing finished: this poll sees INDEXED, and after it the polling stops.
+    status = "INDEXED";
+    await act(() => vi.advanceTimersByTimeAsync(AI_STATUS_POLL_MS));
+    await vi.waitFor(() => expect(result.current?.get("a1")).toBe("INDEXED"));
+    expect(requests).toHaveLength(3);
+
+    await act(() => vi.advanceTimersByTimeAsync(AI_STATUS_POLL_MS * 3));
+    await new Promise((resolve) => setTimeout(resolve, 20));
+    expect(requests).toHaveLength(3);
+  });
+
+  it("never polls a page with nothing PROCESSING", async () => {
+    vi.useFakeTimers({ toFake: ["setInterval", "clearInterval"] });
+    const requests = recordStatusRequests(() => ({
+      aiAvailable: true,
+      items: [item("a1", "INDEXED"), item("a2", "FAILED")],
+    }));
+
+    const { result } = renderHook(() => useArtifactAiStatus("p1", ["a1", "a2"]), {
+      wrapper: wrapper(),
+    });
+    await vi.waitFor(() => expect(result.current?.get("a1")).toBe("INDEXED"));
+
+    await act(() => vi.advanceTimersByTimeAsync(AI_STATUS_POLL_MS * 3));
+    await new Promise((resolve) => setTimeout(resolve, 20));
+    expect(requests).toHaveLength(1);
+  });
+});
diff --git a/tests/unit/features/knowledge-base/hooks/useKnowledgeBase.test.ts b/tests/unit/features/knowledge-base/hooks/useKnowledgeBase.test.ts
index a0ffb93d..c131679a 100644
--- a/tests/unit/features/knowledge-base/hooks/useKnowledgeBase.test.ts
+++ b/tests/unit/features/knowledge-base/hooks/useKnowledgeBase.test.ts
@@ -1,11 +1,23 @@
 import { renderHook, act, waitFor } from "@testing-library/react";
 import { describe, it, expect, vi, beforeEach } from "vitest";
+import { createElement, type ReactNode } from "react";
+import { MemoryRouter, useLocation, useNavigate } from "react-router-dom";
 import { useKnowledgeBase } from "../../../../../src/features/knowledge-base/hooks/useKnowledgeBase";
-import type { Artifact } from "../../../../../src/features/knowledge-base/types";
+import type {
+  Artifact,
+  ArtifactPage,
+  KnowledgeListParams,
+} from "../../../../../src/features/knowledge-base/types";
+import { matchesFormat } from "../../../../../src/features/knowledge-base/tabs";
+import {
+  getArtifactRepository,
+  matchesRepository,
+} from "../../../../../src/features/knowledge-base/githubMetadata";
 
 vi.mock("../../../../../src/services/knowledgeService", () => ({
   knowledgeService: {
-    getUnifiedArtifacts: vi.fn(),
+    getArtifactPage: vi.fn(),
+    getArtifactFacets: vi.fn(),
   },
 }));
 
@@ -106,15 +118,205 @@ function makeRepoFixture(): Artifact[] {
   ];
 }
 
+/** The backend's language predicate: case-insensitive, and an artifact with no language fails. */
+function matchesLanguages(a: Artifact, languages: string[] | undefined): boolean {
+  if (!languages || languages.length === 0) return true;
+  const own = a.language?.toLowerCase();
+  return own !== undefined && languages.some((language) => language.toLowerCase() === own);
+}
+
+/** Code files in two languages, a Markdown upload and a PR without a language. */
+function makeLanguageFixture(): Artifact[] {
+  const withLanguage = (artifact: Artifact, language: string | null): Artifact => ({
+    ...artifact,
+    language,
+  });
+  return [
+    withLanguage(makeArtifact("k1", "Main.kt"), "Kotlin"),
+    withLanguage(makeArtifact("k2", "Util.kt"), "Kotlin"),
+    withLanguage(makeArtifact("t1", "app.ts"), "TypeScript"),
+    withLanguage(makeArtifact("m1", "README.md"), "Markdown"),
+    withLanguage(makeArtifact("p1", "Fix login", "PULL_REQUEST"), null),
+  ];
+}
+
+function mockArtifactQuery(artifacts: Artifact[]) {
+  const getArtifactPage = vi
+    .fn()
+    .mockImplementation((_pid: string, params: KnowledgeListParams = {}) => {
+      const filtered = artifacts.filter((a) => {
+        if (params.search) {
+          const q = params.search.toLowerCase();
+          const text = [a.title ?? "", a.sourceId, a.sourceUrl ?? ""].join(" ").toLowerCase();
+          if (!text.includes(q)) return false;
+        }
+        if (params.types && params.types.length > 0) {
+          if (!params.types.includes(a.artifactType)) return false;
+        }
+        if (params.sources && params.sources.length > 0) {
+          if (!params.sources.includes(a.sourceSystem)) return false;
+        }
+        if (params.format) {
+          if (!matchesFormat(a, params.format)) return false;
+        }
+        if (params.repositories && params.repositories.length > 0) {
+          if (!matchesRepository(a, new Set(params.repositories))) return false;
+        }
+        if (!matchesLanguages(a, params.languages)) return false;
+        return true;
+      });
+
+      const page = params.page ?? 1;
+      const size = params.size ?? 20;
+      const totalElements = filtered.length;
+      const totalPages = Math.max(1, Math.ceil(totalElements / size));
+      const start = (page - 1) * size;
+      const items = filtered.slice(start, start + size);
+
+      return Promise.resolve({
+        items,
+        page: {
+          number: page,
+          size,
+          totalElements,
+          totalPages,
+          hasNext: page < totalPages,
+          hasPrevious: page > 1,
+        },
+        metadata: {
+          pageNumber: page,
+          pageSize: size,
+          totalElements,
+          totalPages,
+          isFirst: page === 1,
+          isLast: page === totalPages,
+          hasNext: page < totalPages,
+          hasPrevious: page > 1,
+        },
+      });
+    });
+
+  const getArtifactFacets = vi
+    .fn()
+    .mockImplementation((_pid: string, params: KnowledgeListParams = {}) => {
+      const matchesAllExcept = (
+        a: Artifact,
+        excludeFacet: "types" | "sources" | "format" | "repositories" | "languages",
+      ) => {
+        if (excludeFacet !== "languages" && !matchesLanguages(a, params.languages)) return false;
+        if (params.search) {
+          const q = params.search.toLowerCase();
+          const text = [a.title ?? "", a.sourceId, a.sourceUrl ?? ""].join(" ").toLowerCase();
+          if (!text.includes(q)) return false;
+        }
+        if (excludeFacet !== "types" && params.types && params.types.length > 0) {
+          if (!params.types.includes(a.artifactType)) return false;
+        }
+        if (excludeFacet !== "sources" && params.sources && params.sources.length > 0) {
+          if (!params.sources.includes(a.sourceSystem)) return false;
+        }
+        if (excludeFacet !== "format" && params.format) {
+          if (!matchesFormat(a, params.format)) return false;
+        }
+        if (
+          excludeFacet !== "repositories" &&
+          params.repositories &&
+          params.repositories.length > 0
+        ) {
+          if (!matchesRepository(a, new Set(params.repositories))) return false;
+        }
+        return true;
+      };
+
+      const typeCandidates = artifacts.filter((a) => matchesAllExcept(a, "types"));
+      const typeCounts = new Map<string, number>();
+      for (const a of typeCandidates) {
+        typeCounts.set(a.artifactType, (typeCounts.get(a.artifactType) ?? 0) + 1);
+      }
+      const types = Array.from(typeCounts.entries()).map(([value, count]) => ({ value, count }));
+
+      const presentSources = new Set(artifacts.map((a) => a.sourceSystem));
+      const sourceCandidates = artifacts.filter((a) => matchesAllExcept(a, "sources"));
+      const sourceCounts = new Map<string, number>();
+      for (const s of presentSources) {
+        sourceCounts.set(s, 0);
+      }
+      for (const a of sourceCandidates) {
+        sourceCounts.set(a.sourceSystem, (sourceCounts.get(a.sourceSystem) ?? 0) + 1);
+      }
+      const sources = Array.from(sourceCounts.entries()).map(([value, count]) => ({
+        value,
+        count,
+      }));
+
+      const formatCandidates = artifacts.filter((a) => matchesAllExcept(a, "format"));
+      const formatCounts = new Map<string, number>();
+      for (const a of formatCandidates) {
+        for (const fmt of ["PDF", "MARKDOWN", "IMAGE", "OTHER"] as const) {
+          if (matchesFormat(a, fmt)) {
+            formatCounts.set(fmt, (formatCounts.get(fmt) ?? 0) + 1);
+          }
+        }
+      }
+      const formats = Array.from(formatCounts.entries()).map(([value, count]) => ({
+        value,
+        count,
+      }));
+
+      const repoCandidates = artifacts.filter(
+        (a) => matchesAllExcept(a, "repositories") && a.sourceSystem === "GITHUB",
+      );
+      const distinctRepos = new Set<string>();
+      for (const a of repoCandidates) {
+        const repo = getArtifactRepository(a);
+        if (repo) distinctRepos.add(repo);
+      }
+      const repositories = Array.from(distinctRepos).map((repo) => ({
+        value: repo,
+        count: repoCandidates.filter((a) => matchesRepository(a, new Set([repo]))).length,
+      }));
+
+      // Backend contract: own dimension excluded, null and document kinds left out, a
+      // selected value with no match still returned at 0.
+      const languageCounts = new Map<string, number>();
+      for (const a of artifacts.filter((x) => matchesAllExcept(x, "languages"))) {
+        if (!a.language || ["markdown", "plain text"].includes(a.language.toLowerCase())) continue;
+        languageCounts.set(a.language, (languageCounts.get(a.language) ?? 0) + 1);
+      }
+      for (const selected of params.languages ?? []) {
+        const known = [...languageCounts.keys()].some(
+          (v) => v.toLowerCase() === selected.toLowerCase(),
+        );
+        if (!known) languageCounts.set(selected, 0);
+      }
+      const languages = Array.from(languageCounts, ([value, count]) => ({ value, count }));
+
+      return Promise.resolve({ types, sources, formats, repositories, languages });
+    });
+
+  return { getArtifactPage, getArtifactFacets };
+}
+
 /** Renders the hook against a fixed artifact list and waits for the fetch to land. */
+/** The hook keeps its filters in the URL, so every render needs a router around it. */
+function RouterWrapper({ children }: { children: ReactNode }) {
+  return createElement(MemoryRouter, null, children);
+}
+
 async function renderWith(artifacts: Artifact[]) {
   const { knowledgeService } = await import("../../../../../src/services/knowledgeService");
-  vi.mocked(knowledgeService.getUnifiedArtifacts).mockResolvedValue(artifacts);
+  const { getArtifactPage, getArtifactFacets } = mockArtifactQuery(artifacts);
+  vi.mocked(knowledgeService.getArtifactPage).mockImplementation(getArtifactPage);
+  vi.mocked(knowledgeService.getArtifactFacets).mockImplementation(getArtifactFacets);
 
-  const { result } = renderHook(() => useKnowledgeBase("proj-1"));
+  const { result } = renderHook(() => useKnowledgeBase("proj-1"), { wrapper: RouterWrapper });
 
   await waitFor(() => {
-    expect(result.current.artifacts).toHaveLength(artifacts.length);
+    if (artifacts.length > 0) {
+      expect(result.current.artifacts.length).toBeGreaterThan(0);
+    } else {
+      expect(result.current.isLoading).toBe(false);
+    }
   });
 
   return result;
@@ -127,11 +329,13 @@ describe("useKnowledgeBase", () => {
 
   it("loads artifacts on mount", async () => {
     const { knowledgeService } = await import("../../../../../src/services/knowledgeService");
-    vi.mocked(knowledgeService.getUnifiedArtifacts).mockResolvedValue([
+    const { getArtifactPage, getArtifactFacets } = mockArtifactQuery([
       makeArtifact("a1", "first.md"),
     ]);
+    vi.mocked(knowledgeService.getArtifactPage).mockImplementation(getArtifactPage);
+    vi.mocked(knowledgeService.getArtifactFacets).mockImplementation(getArtifactFacets);
 
-    const { result } = renderHook(() => useKnowledgeBase("proj-1"));
+    const { result } = renderHook(() => useKnowledgeBase("proj-1"), { wrapper: RouterWrapper });
 
     await waitFor(() => {
       expect(result.current.artifacts).toHaveLength(1);
@@ -143,17 +347,29 @@ describe("useKnowledgeBase", () => {
 
   it("a newer fetch overwrites a stale one, not the other way around", async () => {
     const { knowledgeService } = await import("../../../../../src/services/knowledgeService");
-    const mockFn = vi.mocked(knowledgeService.getUnifiedArtifacts);
+    const mockFn = vi.mocked(knowledgeService.getArtifactPage);
+
+    const makePage = (title: string): ArtifactPage => ({
+      items: [makeArtifact("a", title)],
+      page: {
+        number: 1,
+        size: 20,
+        totalElements: 1,
+        totalPages: 1,
+        hasNext: false,
+        hasPrevious: false,
+      },
+    });
 
-    let resolveFirst: (value: Artifact[]) => void = () => {};
-    const firstPromise = new Promise<Artifact[]>((resolve) => {
+    let resolveFirst: (value: ArtifactPage) => void = () => {};
+    const firstPromise = new Promise<ArtifactPage>((resolve) => {
       resolveFirst = resolve;
     });
 
     mockFn.mockReturnValueOnce(firstPromise);
-    mockFn.mockResolvedValueOnce([makeArtifact("a2", "newer.md")]);
+    mockFn.mockResolvedValueOnce(makePage("newer.md"));
 
-    const { result } = renderHook(() => useKnowledgeBase("proj-1"));
+    const { result } = renderHook(() => useKnowledgeBase("proj-1"), { wrapper: RouterWrapper });
 
     await act(async () => {
       void result.current.fetchArtifacts();
@@ -168,7 +384,7 @@ describe("useKnowledgeBase", () => {
     });
 
     await act(async () => {
-      resolveFirst([makeArtifact("a1", "stale.md")]);
+      resolveFirst(makePage("stale.md"));
       await Promise.resolve();
     });
 
@@ -177,9 +393,9 @@ describe("useKnowledgeBase", () => {
 
   it("sets fetchError when the fetch rejects", async () => {
     const { knowledgeService } = await import("../../../../../src/services/knowledgeService");
-    vi.mocked(knowledgeService.getUnifiedArtifacts).mockRejectedValue(new Error("Server down"));
+    vi.mocked(knowledgeService.getArtifactPage).mockRejectedValue(new Error("Server down"));
 
-    const { result } = renderHook(() => useKnowledgeBase("proj-1"));
+    const { result } = renderHook(() => useKnowledgeBase("proj-1"), { wrapper: RouterWrapper });
 
     await waitFor(() => {
       expect(result.current.fetchError).not.toBeNull();
@@ -199,9 +415,11 @@ describe("useKnowledgeBase", () => {
       result.current.handleSearchChange("readme");
     });
 
-    expect(result.current.filteredArtifacts).toHaveLength(1);
-    expect(result.current.filteredArtifacts[0].title).toBe("readme.md");
-    expect(result.current.currentPage).toBe(1);
+    await waitFor(() => {
+      expect(result.current.artifacts).toHaveLength(1);
+      expect(result.current.artifacts[0].title).toBe("readme.md");
+      expect(result.current.currentPage).toBe(1);
+    });
   });
 
   it("resets to page 1 when search changes", async () => {
@@ -215,12 +433,16 @@ describe("useKnowledgeBase", () => {
     act(() => {
       result.current.setCurrentPage(2);
     });
-    expect(result.current.currentPage).toBe(2);
+    await waitFor(() => {
+      expect(result.current.currentPage).toBe(2);
+    });
 
     act(() => {
       result.current.handleSearchChange("file-0");
     });
-    expect(result.current.currentPage).toBe(1);
+    await waitFor(() => {
+      expect(result.current.currentPage).toBe(1);
+    });
   });
 
   it("narrows to a single source", async () => {
@@ -230,9 +452,11 @@ describe("useKnowledgeBase", () => {
       result.current.toggleSource("UPLOAD");
     });
 
-    expect(result.current.filteredArtifacts).toHaveLength(1);
-    expect(result.current.filteredArtifacts[0].sourceSystem).toBe("UPLOAD");
-    expect(result.current.hasActiveFilters).toBe(true);
+    await waitFor(() => {
+      expect(result.current.artifacts).toHaveLength(1);
+      expect(result.current.artifacts[0].sourceSystem).toBe("UPLOAD");
+      expect(result.current.hasActiveFilters).toBe(true);
+    });
   });
 
   it("unions several sources instead of replacing the last one", async () => {
@@ -243,12 +467,14 @@ describe("useKnowledgeBase", () => {
       result.current.toggleSource("JIRA");
     });
 
-    expect(result.current.selectedSources.size).toBe(2);
-    expect(result.current.filteredArtifacts.map((artifact) => artifact.id).sort()).toEqual([
-      "gh-issue",
-      "gh-pr",
-      "jira-issue",
-    ]);
+    await waitFor(() => {
+      expect(result.current.selectedSources.size).toBe(2);
+      expect(result.current.artifacts.map((artifact) => artifact.id).sort()).toEqual([
+        "gh-issue",
+        "gh-pr",
+        "jira-issue",
+      ]);
+    });
   });
 
   it("ANDs the tab filter with the source facet", async () => {
@@ -259,8 +485,10 @@ describe("useKnowledgeBase", () => {
       result.current.handleTabChange("PULL_REQUEST");
     });
 
-    expect(result.current.filteredArtifacts).toHaveLength(1);
-    expect(result.current.filteredArtifacts[0].id).toBe("gh-pr");
+    await waitFor(() => {
+      expect(result.current.artifacts).toHaveLength(1);
+      expect(result.current.artifacts[0].id).toBe("gh-pr");
+    });
   });
 
   it("matches one type across every source, so Issues covers GitHub and Jira alike", async () => {
@@ -270,14 +498,15 @@ describe("useKnowledgeBase", () => {
       result.current.handleTabChange("ISSUE");
     });
 
-    expect(result.current.filteredArtifacts.map((artifact) => artifact.id).sort()).toEqual([
-      "gh-issue",
-      "jira-issue",
-    ]);
-
-    const tabValues = result.current.tabOptions.map((option) => option.value);
-    expect(tabValues).toContain("ISSUE");
-    expect(tabValues).toContain("ALL");
+    await waitFor(() => {
+      expect(result.current.artifacts.map((artifact) => artifact.id).sort()).toEqual([
+        "gh-issue",
+        "jira-issue",
+      ]);
+      const tabValues = result.current.tabOptions.map((option) => option.value);
+      expect(tabValues).toContain("ISSUE");
+      expect(tabValues).toContain("ALL");
+    });
   });
 
   it("offers the file-format facet only while Uploads is selected", async () => {
@@ -289,8 +518,10 @@ describe("useKnowledgeBase", () => {
       result.current.toggleSource("UPLOAD");
     });
 
-    // The fixture holds one PDF upload, so that is the only format worth offering.
-    expect(result.current.formatOptions.map((option) => option.value)).toEqual(["PDF"]);
+    await waitFor(() => {
+      // The fixture holds one PDF upload, so that is the only format worth offering.
+      expect(result.current.formatOptions.map((option) => option.value)).toEqual(["PDF"]);
+    });
   });
 
   it("narrows only the uploads when a format is chosen", async () => {
@@ -304,12 +535,14 @@ describe("useKnowledgeBase", () => {
       result.current.toggleFormat("PDF");
     });
 
-    // The format facet describes uploads; it must not hide the GitHub artifacts.
-    expect(result.current.filteredArtifacts.map((artifact) => artifact.id).sort()).toEqual([
-      "gh-issue",
-      "gh-pr",
-      "up-pdf",
-    ]);
+    await waitFor(() => {
+      // The format facet describes uploads; it must not hide the GitHub artifacts.
+      expect(result.current.artifacts.map((artifact) => artifact.id).sort()).toEqual([
+        "gh-issue",
+        "gh-pr",
+        "up-pdf",
+      ]);
+    });
   });
 
   it("clears the format selection when Uploads is deselected", async () => {
@@ -321,17 +554,19 @@ describe("useKnowledgeBase", () => {
     act(() => {
       result.current.toggleFormat("PDF");
     });
-    expect(result.current.selectedFormat).toBe("PDF");
+    await waitFor(() => {
+      expect(result.current.selectedFormat).toBe("PDF");
+    });
 
     act(() => {
       result.current.toggleSource("UPLOAD");
     });
 
-    // Otherwise a hidden facet keeps filtering and the trigger badge counts
-    // something the reader can no longer see or clear.
-    expect(result.current.selectedFormat).toBeNull();
-    expect(result.current.formatOptions).toHaveLength(0);
-    expect(result.current.filteredArtifacts).toHaveLength(5);
+    await waitFor(() => {
+      expect(result.current.selectedFormat).toBeNull();
+      expect(result.current.formatOptions).toHaveLength(0);
+      expect(result.current.artifacts).toHaveLength(5);
+    });
   });
 
   it("offers the repository facet only while GitHub is selected", async () => {
@@ -343,17 +578,17 @@ describe("useKnowledgeBase", () => {
       result.current.toggleSource("GITHUB");
     });
 
-    // Alphabetical; counts come from the repo-scoped artifacts only, so the
-    // org artifact (not repo-scoped) contributes to neither option.
-    expect(result.current.repositoryOptions.map((option) => option.value)).toEqual([
-      "sprintstart/sprintstart-backend",
-      "sprintstart/sprintstart-frontend",
-    ]);
-    expect(
-      result.current.repositoryOptions.find(
-        (option) => option.value === "sprintstart/sprintstart-frontend",
-      )?.count,
-    ).toBe(3);
+    await waitFor(() => {
+      expect(result.current.repositoryOptions.map((option) => option.value)).toEqual([
+        "sprintstart/sprintstart-backend",
+        "sprintstart/sprintstart-frontend",
+      ]);
+      expect(
+        result.current.repositoryOptions.find(
+          (option) => option.value === "sprintstart/sprintstart-frontend",
+        )?.count,
+      ).toBe(3);
+    });
   });
 
   it("promises with its count exactly what choosing the repository delivers", async () => {
@@ -363,19 +598,22 @@ describe("useKnowledgeBase", () => {
       result.current.toggleSource("GITHUB");
     });
 
-    // The owning org's profile counts toward the repo it owns — the number is
-    // a promise about what clicking does, so the list the reader gets must
-    // have exactly that many rows.
-    const frontend = result.current.repositoryOptions.find(
-      (option) => option.value === "sprintstart/sprintstart-frontend",
-    );
-    expect(frontend?.count).toBe(3);
+    let frontendCount = 0;
+    await waitFor(() => {
+      const frontend = result.current.repositoryOptions.find(
+        (option) => option.value === "sprintstart/sprintstart-frontend",
+      );
+      expect(frontend?.count).toBe(3);
+      frontendCount = frontend?.count ?? 0;
+    });
 
     act(() => {
       result.current.toggleRepository("sprintstart/sprintstart-frontend");
     });
 
-    expect(result.current.filteredArtifacts).toHaveLength(frontend?.count ?? -1);
+    await waitFor(() => {
+      expect(result.current.artifacts).toHaveLength(frontendCount);
+    });
   });
 
   it("narrows only the github artifacts when a repository is chosen", async () => {
@@ -389,15 +627,14 @@ describe("useKnowledgeBase", () => {
       result.current.toggleRepository("sprintstart/sprintstart-frontend");
     });
 
-    // The repository facet narrows repo-scoped GitHub artifacts; it must not
-    // hide the upload (outside the facet's reach), it hides the unrelated org's
-    // profile, and it keeps the profile of the org that owns the chosen repo.
-    expect(result.current.filteredArtifacts.map((artifact) => artifact.id).sort()).toEqual([
-      "gh-fe-1",
-      "gh-fe-2",
-      "gh-org",
-      "up-pdf",
-    ]);
+    await waitFor(() => {
+      expect(result.current.artifacts.map((artifact) => artifact.id).sort()).toEqual([
+        "gh-fe-1",
+        "gh-fe-2",
+        "gh-org",
+        "up-pdf",
+      ]);
+    });
   });
 
   it("shows the owning org profile under a checked repository, never an unrelated one", async () => {
@@ -410,12 +647,12 @@ describe("useKnowledgeBase", () => {
       result.current.toggleRepository("sprintstart/sprintstart-backend");
     });
 
-    // The org profile belongs to the checked repo's owner org; the unrelated
-    // org's profile does not.
-    expect(result.current.filteredArtifacts.map((artifact) => artifact.id).sort()).toEqual([
-      "gh-be-1",
-      "gh-org",
-    ]);
+    await waitFor(() => {
+      expect(result.current.artifacts.map((artifact) => artifact.id).sort()).toEqual([
+        "gh-be-1",
+        "gh-org",
+      ]);
+    });
   });
 
   it("unions several repositories instead of replacing the choice", async () => {
@@ -429,13 +666,15 @@ describe("useKnowledgeBase", () => {
       result.current.toggleRepository("sprintstart/sprintstart-backend");
     });
 
-    expect(result.current.selectedRepositories.size).toBe(2);
-    expect(result.current.filteredArtifacts.map((artifact) => artifact.id).sort()).toEqual([
-      "gh-be-1",
-      "gh-fe-1",
-      "gh-fe-2",
-      "gh-org",
-    ]);
+    await waitFor(() => {
+      expect(result.current.selectedRepositories.size).toBe(2);
+      expect(result.current.artifacts.map((artifact) => artifact.id).sort()).toEqual([
+        "gh-be-1",
+        "gh-fe-1",
+        "gh-fe-2",
+        "gh-org",
+      ]);
+    });
   });
 
   it("clears the repository selection when GitHub is deselected", async () => {
@@ -447,17 +686,19 @@ describe("useKnowledgeBase", () => {
     act(() => {
       result.current.toggleRepository("sprintstart/sprintstart-frontend");
     });
-    expect(result.current.selectedRepositories.size).toBe(1);
+    await waitFor(() => {
+      expect(result.current.selectedRepositories.size).toBe(1);
+    });
 
     act(() => {
       result.current.toggleSource("GITHUB");
     });
 
-    // Same rule as the format facet: a hidden facet may not keep filtering and
-    // the trigger badge may not count what the reader can no longer see.
-    expect(result.current.selectedRepositories.size).toBe(0);
-    expect(result.current.repositoryOptions).toHaveLength(0);
-    expect(result.current.filteredArtifacts).toHaveLength(6);
+    await waitFor(() => {
+      expect(result.current.selectedRepositories.size).toBe(0);
+      expect(result.current.repositoryOptions).toHaveLength(0);
+      expect(result.current.artifacts).toHaveLength(6);
+    });
   });
 
   it("counts each option against the other facets, not just the search", async () => {
@@ -469,14 +710,15 @@ describe("useKnowledgeBase", () => {
       result.current.handleTabChange("ISSUE");
     });
 
-    // With Issues on, GitHub can only contribute one artifact — the count has to
-    // say so, or the number promises rows that clicking will not deliver.
-    expect(result.current.sourceOptions.find((option) => option.value === "GITHUB")?.count).toBe(1);
-    expect(
-      result.current.sourceOptions.find((option) => option.value === "CONFLUENCE")?.count,
-    ).toBe(0);
-    // Tab options reflect the available types and their counts
-    expect(result.current.tabOptions.find((option) => option.value === "PAGE")?.count).toBe(1);
+    await waitFor(() => {
+      expect(result.current.sourceOptions.find((option) => option.value === "GITHUB")?.count).toBe(
+        1,
+      );
+      expect(
+        result.current.sourceOptions.find((option) => option.value === "CONFLUENCE")?.count,
+      ).toBe(0);
+      expect(result.current.tabOptions.find((option) => option.value === "PAGE")?.count).toBe(1);
+    });
   });
 
   it("resets to page 1 when a tab is changed", async () => {
@@ -488,13 +730,17 @@ describe("useKnowledgeBase", () => {
     act(() => {
       result.current.setCurrentPage(2);
     });
-    expect(result.current.currentPage).toBe(2);
+    await waitFor(() => {
+      expect(result.current.currentPage).toBe(2);
+    });
 
     act(() => {
       result.current.handleTabChange("FILE");
     });
 
-    expect(result.current.currentPage).toBe(1);
+    await waitFor(() => {
+      expect(result.current.currentPage).toBe(1);
+    });
   });
 
   it("clears the search and every facet at once", async () => {
@@ -520,11 +766,11 @@ describe("useKnowledgeBase", () => {
     expect(result.current.selectedFormat).toBeNull();
     expect(result.current.selectedRepositories.size).toBe(0);
     expect(result.current.searchQuery).toBe("");
-    expect(result.current.filteredArtifacts).toHaveLength(5);
+    expect(result.current.artifacts).toHaveLength(5);
   });
 
   it("does not fetch when projectId is null", () => {
-    const { result } = renderHook(() => useKnowledgeBase(null));
+    const { result } = renderHook(() => useKnowledgeBase(null), { wrapper: RouterWrapper });
 
     expect(result.current.isLoading).toBe(false);
     expect(result.current.artifacts).toHaveLength(0);
@@ -532,12 +778,15 @@ describe("useKnowledgeBase", () => {
 
   it("resets artifacts and loading state when projectId transitions to null", async () => {
     const { knowledgeService } = await import("../../../../../src/services/knowledgeService");
-    vi.mocked(knowledgeService.getUnifiedArtifacts).mockResolvedValue([
+    const { getArtifactPage, getArtifactFacets } = mockArtifactQuery([
       makeArtifact("a1", "first.md"),
     ]);
+    vi.mocked(knowledgeService.getArtifactPage).mockImplementation(getArtifactPage);
+    vi.mocked(knowledgeService.getArtifactFacets).mockImplementation(getArtifactFacets);
 
     const initialProps: { pid: string | null } = { pid: "proj-1" };
     const { result, rerender } = renderHook(({ pid }) => useKnowledgeBase(pid), {
+      wrapper: RouterWrapper,
       initialProps,
     });
 
@@ -559,15 +808,18 @@ describe("useKnowledgeBase", () => {
       makeArtifact(`a${i}`, `file-${i}.md`),
     );
     const { knowledgeService } = await import("../../../../../src/services/knowledgeService");
-    vi.mocked(knowledgeService.getUnifiedArtifacts).mockResolvedValue(artifacts);
+    const { getArtifactPage, getArtifactFacets } = mockArtifactQuery(artifacts);
+    vi.mocked(knowledgeService.getArtifactPage).mockImplementation(getArtifactPage);
+    vi.mocked(knowledgeService.getArtifactFacets).mockImplementation(getArtifactFacets);
 
     const initialProps: { pid: string | null } = { pid: "proj-1" };
     const { result, rerender } = renderHook(({ pid }) => useKnowledgeBase(pid), {
+      wrapper: RouterWrapper,
       initialProps,
     });
 
     await waitFor(() => {
-      expect(result.current.artifacts).toHaveLength(25);
+      expect(result.current.artifacts).toHaveLength(20);
     });
 
     act(() => {
@@ -587,7 +839,23 @@ describe("useKnowledgeBase", () => {
     });
   });
 
-  it("safely indexes paginatedArtifacts when totalPages decreases", async () => {
+  it("reports the on-screen range from the 1-based page number", async () => {
+    const artifacts: Artifact[] = Array.from({ length: 25 }, (_, i) =>
+      makeArtifact(`a${i}`, `file-${i}.md`),
+    );
+    const result = await renderWith(artifacts);
+
+    expect(result.current.resultRange).toEqual({ start: 1, end: 20 });
+
+    act(() => {
+      result.current.setCurrentPage(2);
+    });
+    await waitFor(() => {
+      expect(result.current.resultRange).toEqual({ start: 21, end: 25 });
+    });
+  });
+
+  it("safely indexes the page items when totalPages decreases", async () => {
     const artifacts: Artifact[] = Array.from({ length: 25 }, (_, i) =>
       makeArtifact(`a${i}`, `file-${i}.md`),
     );
@@ -596,16 +864,20 @@ describe("useKnowledgeBase", () => {
     act(() => {
       result.current.setCurrentPage(2);
     });
-    expect(result.current.currentPage).toBe(2);
-    expect(result.current.paginatedArtifacts).toHaveLength(5);
+    await waitFor(() => {
+      expect(result.current.currentPage).toBe(2);
+      expect(result.current.artifacts).toHaveLength(5);
+    });
 
     // Narrow to a source with 0 items.
     act(() => {
       result.current.toggleSource("UPLOAD");
     });
 
-    expect(result.current.currentPage).toBe(1);
-    expect(result.current.paginatedArtifacts).toHaveLength(0);
+    await waitFor(() => {
+      expect(result.current.currentPage).toBe(1);
+      expect(result.current.artifacts).toHaveLength(0);
+    });
   });
 
   it("resets currentPage to 1 when switching projectId", async () => {
@@ -613,21 +885,26 @@ describe("useKnowledgeBase", () => {
       makeArtifact(`a${i}`, `file-${i}.md`),
     );
     const { knowledgeService } = await import("../../../../../src/services/knowledgeService");
-    vi.mocked(knowledgeService.getUnifiedArtifacts).mockResolvedValue(artifacts);
+    const { getArtifactPage, getArtifactFacets } = mockArtifactQuery(artifacts);
+    vi.mocked(knowledgeService.getArtifactPage).mockImplementation(getArtifactPage);
+    vi.mocked(knowledgeService.getArtifactFacets).mockImplementation(getArtifactFacets);
 
     const initialProps: { pid: string | null } = { pid: "proj-1" };
     const { result, rerender } = renderHook(({ pid }) => useKnowledgeBase(pid), {
+      wrapper: RouterWrapper,
       initialProps,
     });
 
     await waitFor(() => {
-      expect(result.current.artifacts).toHaveLength(25);
+      expect(result.current.artifacts).toHaveLength(20);
     });
 
     act(() => {
       result.current.setCurrentPage(2);
     });
-    expect(result.current.currentPage).toBe(2);
+    await waitFor(() => {
+      expect(result.current.currentPage).toBe(2);
+    });
 
     rerender({ pid: "proj-2" });
 
@@ -645,14 +922,18 @@ describe("useKnowledgeBase", () => {
     act(() => {
       result.current.setCurrentPage(2);
     });
-    expect(result.current.currentPage).toBe(2);
+    await waitFor(() => {
+      expect(result.current.currentPage).toBe(2);
+    });
 
     await act(async () => {
       await result.current.fetchArtifacts();
     });
 
-    expect(result.current.currentPage).toBe(2);
-    expect(result.current.paginatedArtifacts).toHaveLength(5);
+    await waitFor(() => {
+      expect(result.current.currentPage).toBe(2);
+      expect(result.current.artifacts).toHaveLength(5);
+    });
   });
 
   it("pulls the current page back into range when it exceeds the available pages", async () => {
@@ -666,10 +947,12 @@ describe("useKnowledgeBase", () => {
       result.current.setCurrentPage(5);
     });
 
-    // Without the clamp the control would report page 5 while the slice runs off
-    // the end of the list and renders nothing.
-    expect(result.current.currentPage).toBe(2);
-    expect(result.current.paginatedArtifacts).toHaveLength(5);
+    await waitFor(() => {
+      // Without the clamp the control would report page 5 while the slice runs off
+      // the end of the list and renders nothing.
+      expect(result.current.currentPage).toBe(2);
+      expect(result.current.artifacts).toHaveLength(5);
+    });
   });
 
   it("combines the source, type and format facets with a search query", async () => {
@@ -681,17 +964,21 @@ describe("useKnowledgeBase", () => {
       result.current.handleTabChange("ISSUE");
     });
 
-    expect(result.current.filteredArtifacts.map((artifact) => artifact.id).sort()).toEqual([
-      "gh-issue",
-      "jira-issue",
-    ]);
+    await waitFor(() => {
+      expect(result.current.artifacts.map((artifact) => artifact.id).sort()).toEqual([
+        "gh-issue",
+        "jira-issue",
+      ]);
+    });
 
     act(() => {
       result.current.handleSearchChange("ticket");
     });
 
-    expect(result.current.filteredArtifacts).toHaveLength(1);
-    expect(result.current.filteredArtifacts[0].id).toBe("jira-issue");
+    await waitFor(() => {
+      expect(result.current.artifacts).toHaveLength(1);
+      expect(result.current.artifacts[0].id).toBe("jira-issue");
+    });
   });
 
   it("identifies uploaded PDFs, Markdown and images with a UUID sourceId and no mime", async () => {
@@ -729,23 +1016,29 @@ describe("useKnowledgeBase", () => {
     const countOf = (value: string) =>
       result.current.formatOptions.find((option) => option.value === value)?.count;
 
-    // The filename is the only dependable signal: `mime` is null and `sourceId`
-    // is a UUID, so an extension check on `sourceId` would have counted zero here.
-    expect(countOf("PDF")).toBe(1);
-    expect(countOf("MARKDOWN")).toBe(1);
-    expect(countOf("IMAGE")).toBe(1);
-    expect(countOf("OTHER")).toBe(1);
+    await waitFor(() => {
+      // The filename is the only dependable signal: `mime` is null and `sourceId`
+      // is a UUID, so an extension check on `sourceId` would have counted zero here.
+      expect(countOf("PDF")).toBe(1);
+      expect(countOf("MARKDOWN")).toBe(1);
+      expect(countOf("IMAGE")).toBe(1);
+      expect(countOf("OTHER")).toBe(1);
+    });
 
     act(() => {
       result.current.toggleFormat("IMAGE");
     });
-    expect(result.current.filteredArtifacts[0].title).toBe("wireframe.png");
+    await waitFor(() => {
+      expect(result.current.artifacts[0].title).toBe("wireframe.png");
+    });
 
     act(() => {
       result.current.toggleFormat("OTHER");
     });
-    // "Other" no longer swallows images — that is what the Images option is for.
-    expect(result.current.filteredArtifacts[0].title).toBe("archive.tar.gz");
+    await waitFor(() => {
+      // "Other" no longer swallows images — that is what the Images option is for.
+      expect(result.current.artifacts[0].title).toBe("archive.tar.gz");
+    });
   });
 
   it("offers tab options for types available from the selected sources plus ALL", async () => {
@@ -763,9 +1056,11 @@ describe("useKnowledgeBase", () => {
       result.current.toggleSource("JIRA");
     });
 
-    // Jira carries issues and nothing else, so unrelated artifact-type tabs disappear.
-    expect(result.current.tabOptions.map((option) => option.value)).toEqual(["ALL", "ISSUE"]);
-    expect(result.current.tabOptions.find((option) => option.value === "ISSUE")?.count).toBe(1);
+    await waitFor(() => {
+      // Jira carries issues and nothing else, so unrelated artifact-type tabs disappear.
+      expect(result.current.tabOptions.map((option) => option.value)).toEqual(["ALL", "ISSUE"]);
+      expect(result.current.tabOptions.find((option) => option.value === "ISSUE")?.count).toBe(1);
+    });
   });
 
   it("keeps an active tab visible even if chosen sources cannot produce it", async () => {
@@ -776,12 +1071,15 @@ describe("useKnowledgeBase", () => {
       result.current.toggleSource("GITHUB");
     });
 
-    const page = result.current.tabOptions.find((option) => option.value === "PAGE");
+    await waitFor(() => {
+      const page = result.current.tabOptions.find((option) => option.value === "PAGE");
 
-    expect(page).toBeDefined();
-    expect(page?.count).toBe(0);
-    expect(result.current.filteredArtifacts).toHaveLength(0);
+      expect(page).toBeDefined();
+      expect(page?.count).toBe(0);
+      expect(result.current.artifacts).toHaveLength(0);
+    });
   });
+
   it("keeps a chosen format visible after the uploads that matched it are gone", async () => {
     const result = await renderWith(makeFacetFixture());
 
@@ -792,12 +1090,15 @@ describe("useKnowledgeBase", () => {
       result.current.toggleFormat("IMAGE");
     });
 
-    const image = result.current.formatOptions.find((option) => option.value === "IMAGE");
+    await waitFor(() => {
+      const image = result.current.formatOptions.find((option) => option.value === "IMAGE");
 
-    expect(image).toBeDefined();
-    expect(image?.count).toBe(0);
-    expect(result.current.filteredArtifacts).toHaveLength(0);
+      expect(image).toBeDefined();
+      expect(image?.count).toBe(0);
+      expect(result.current.artifacts).toHaveLength(0);
+    });
   });
+
   it("keeps a chosen repository visible after its artifacts are gone", async () => {
     const result = await renderWith(makeRepoFixture());
 
@@ -809,15 +1110,312 @@ describe("useKnowledgeBase", () => {
       result.current.handleTabChange("ISSUE");
     });
 
-    // None of the repo-scoped GitHub artifacts is an ISSUE, so the backend repo
-    // can no longer be produced in scope — but the reader chose it, so the
-    // option stays offered with count 0 and can still be unchosen.
-    const backend = result.current.repositoryOptions.find(
-      (option) => option.value === "sprintstart/sprintstart-backend",
+    await waitFor(() => {
+      // None of the repo-scoped GitHub artifacts is an ISSUE, so the backend repo
+      // can no longer be produced in scope — but the reader chose it, so the
+      // option stays offered with count 0 and can still be unchosen.
+      const backend = result.current.repositoryOptions.find(
+        (option) => option.value === "sprintstart/sprintstart-backend",
+      );
+
+      expect(backend).toBeDefined();
+      expect(backend?.count).toBe(0);
+      expect(result.current.artifacts).toHaveLength(0);
+    });
+  });
+});
+
+/** Renders the hook at a given URL, with the router's location alongside for assertions. */
+async function renderAt(entries: string[], artifacts: Artifact[], projectId = "proj-1") {
+  const { knowledgeService } = await import("../../../../../src/services/knowledgeService");
+  const { getArtifactPage, getArtifactFacets } = mockArtifactQuery(artifacts);
+  vi.mocked(knowledgeService.getArtifactPage).mockImplementation(getArtifactPage);
+  vi.mocked(knowledgeService.getArtifactFacets).mockImplementation(getArtifactFacets);
+
+  function Wrapper({ children }: { children: ReactNode }) {
+    return createElement(
+      MemoryRouter,
+      { initialEntries: entries, initialIndex: entries.length - 1 },
+      children,
+    );
+  }
+  const view = renderHook(
+    ({ pid }: { pid: string }) => ({
+      kb: useKnowledgeBase(pid),
+      location: useLocation(),
+      navigate: useNavigate(),
+    }),
+    { wrapper: Wrapper, initialProps: { pid: projectId } },
+  );
+  await waitFor(() => expect(view.result.current.kb.isLoading).toBe(false));
+  return { ...view, getArtifactPage: vi.mocked(knowledgeService.getArtifactPage) };
+}
+
+describe("useKnowledgeBase URL state", () => {
+  it("requests exactly what a shared link describes", async () => {
+    const { result, getArtifactPage } = await renderAt(
+      [
+        "/kb?tab=PULL_REQUEST&sources=GITHUB&repos=sprintstart/sprintstart-frontend&q=feature&page=1",
+      ],
+      makeFacetFixture(),
+    );
+
+    expect(result.current.kb.activeTab).toBe("PULL_REQUEST");
+    expect(result.current.kb.searchQuery).toBe("feature");
+    expect([...result.current.kb.selectedRepositories]).toEqual([
+      "sprintstart/sprintstart-frontend",
+    ]);
+    expect(getArtifactPage).toHaveBeenCalledWith(
+      "proj-1",
+      expect.objectContaining({
+        page: 1,
+        size: 20,
+        search: "feature",
+        types: ["PULL_REQUEST"],
+        sources: ["GITHUB"],
+        repositories: ["sprintstart/sprintstart-frontend"],
+      }),
+    );
+  });
+
+  it("writes a clamped page back to the URL without adding a history entry", async () => {
+    const artifacts = Array.from({ length: 25 }, (_, i) => makeArtifact(`a${i}`, `f-${i}.md`));
+    const { result } = await renderAt(["/start", "/kb?page=9"], artifacts);
+
+    await waitFor(() => {
+      expect(result.current.kb.currentPage).toBe(2);
+      expect(result.current.location.search).toBe("?page=2");
+    });
+
+    act(() => void result.current.navigate(-1));
+    expect(result.current.location.pathname).toBe("/start");
+  });
+
+  it("restores filters and the search input on Back", async () => {
+    const { result } = await renderAt(["/kb"], makeFacetFixture());
+
+    act(() => result.current.kb.handleSearchChange("Add"));
+    // The text reaches the URL once it settles; only then does the next click get its own entry.
+    await waitFor(() => expect(result.current.location.search).toBe("?q=Add"));
+    act(() => result.current.kb.toggleSource("GITHUB"));
+    await waitFor(() => expect(result.current.location.search).toBe("?q=Add&sources=GITHUB"));
+
+    act(() => result.current.kb.handleSearchChange(""));
+    await waitFor(() => expect(result.current.location.search).toBe("?sources=GITHUB"));
+
+    act(() => void result.current.navigate(-1));
+    await waitFor(() => {
+      expect(result.current.kb.searchQuery).toBe("Add");
+      expect(result.current.kb.selectedSources.size).toBe(0);
+    });
+  });
+
+  it("opens and closes the drawer through ?artifact=", async () => {
+    const { result } = await renderAt(["/kb?artifact=a1"], [makeArtifact("a1", "readme.md")]);
+    expect(result.current.kb.selectedArtifactId).toBe("a1");
+
+    act(() => result.current.kb.setSelectedArtifactId(null));
+    expect(result.current.location.search).toBe("");
+    act(() => result.current.kb.setSelectedArtifactId("a1"));
+    expect(result.current.location.search).toBe("?artifact=a1");
+  });
+
+  it("empties the search input on a project switch", async () => {
+    const { result, rerender } = await renderAt(
+      ["/kb?q=readme"],
+      [makeArtifact("a1", "readme.md")],
+    );
+    expect(result.current.kb.searchQuery).toBe("readme");
+
+    rerender({ pid: "proj-2" });
+    await waitFor(() => {
+      expect(result.current.kb.searchQuery).toBe("");
+      expect(result.current.location.search).toBe("");
+    });
+  });
+});
+
+describe("useKnowledgeBase debounced search", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("sends one request for a burst of keystrokes, with the settled text", async () => {
+    const { knowledgeService } = await import("../../../../../src/services/knowledgeService");
+    const { result } = await renderAt(["/kb"], [makeArtifact("a1", "readme.md")]);
+
+    for (const text of ["r", "re", "rea", "read", "readm"]) {
+      act(() => result.current.kb.handleSearchChange(text));
+    }
+    // The field follows every keystroke; the URL and the server see none of them yet.
+    expect(result.current.kb.searchQuery).toBe("readm");
+    expect(result.current.kb.hasActiveFilters).toBe(true);
+    expect(result.current.location.search).toBe("");
+
+    await waitFor(() => expect(result.current.location.search).toBe("?q=readm"));
+    await waitFor(() => expect(result.current.kb.artifacts).toHaveLength(1));
+
+    const searches = vi
+      .mocked(knowledgeService.getArtifactPage)
+      .mock.calls.map(([, params]) => params?.search)
+      .filter((search) => search !== undefined);
+    expect(searches).toEqual(["readm"]);
+    const facetSearches = vi
+      .mocked(knowledgeService.getArtifactFacets)
+      .mock.calls.map(([, params]) => params?.search)
+      .filter((search) => search !== undefined);
+    expect(facetSearches).toEqual(["readm"]);
+  });
+
+  it("keeps the text Back restored instead of re-writing the stale settled value", async () => {
+    const { result } = await renderAt(["/kb"], [makeArtifact("a1", "readme.md")]);
+
+    act(() => result.current.kb.handleSearchChange("readme"));
+    await waitFor(() => expect(result.current.location.search).toBe("?q=readme"));
+    act(() => result.current.kb.toggleSource("UPLOAD"));
+    act(() => result.current.kb.handleSearchChange(""));
+    await waitFor(() => expect(result.current.location.search).toBe("?sources=UPLOAD"));
+
+    act(() => {
+      void result.current.navigate(-1);
+    });
+    await waitFor(() => expect(result.current.location.search).toBe("?q=readme"));
+    expect(result.current.kb.searchQuery).toBe("readme");
+
+    // Well past the debounce window: nothing may have written the old "" back over it.
+    await new Promise((resolve) => setTimeout(resolve, 400));
+    expect(result.current.location.search).toBe("?q=readme");
+    expect(result.current.kb.searchQuery).toBe("readme");
+  });
+});
+
+describe("useKnowledgeBase sort", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("asks the list for the chosen order and keeps it out of the facets request", async () => {
+    const { result } = await renderAt(["/kb"], makeFacetFixture());
+    const { knowledgeService } = await import("../../../../../src/services/knowledgeService");
+
+    act(() => result.current.kb.setSort("TITLE_ASC"));
+
+    await waitFor(() => {
+      const calls = vi.mocked(knowledgeService.getArtifactPage).mock.calls;
+      expect(calls.at(-1)?.[1]).toMatchObject({ sort: "TITLE_ASC", page: 1 });
+    });
+    for (const [, params] of vi.mocked(knowledgeService.getArtifactFacets).mock.calls) {
+      expect(params).not.toHaveProperty("sort");
+    }
+    expect(result.current.kb.sort).toBe("TITLE_ASC");
+    expect(result.current.location.search).toBe("?sort=TITLE_ASC");
+  });
+
+  it("does not send the default order, so the default request is what it always was", async () => {
+    const { getArtifactPage } = await renderAt(["/kb"], makeFacetFixture());
+
+    expect(getArtifactPage.mock.calls[0][1]).toEqual(
+      expect.objectContaining({ page: 1, size: 20, sort: undefined }),
+    );
+  });
+
+  it("does not count an order as an active filter", async () => {
+    const { result } = await renderAt(["/kb?sort=CHANGED_DESC"], makeFacetFixture());
+    expect(result.current.kb.hasActiveFilters).toBe(false);
+  });
+});
+
+describe("useKnowledgeBase date range", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("filters the list and the facets by the same window", async () => {
+    const { result } = await renderAt(["/kb"], makeFacetFixture());
+    const { knowledgeService } = await import("../../../../../src/services/knowledgeService");
+
+    act(() => result.current.kb.setDateRange({ from: "2026-09-01", to: "2026-09-24" }));
+
+    await waitFor(() => {
+      const list = vi.mocked(knowledgeService.getArtifactPage).mock.calls.at(-1)?.[1];
+      const facets = vi.mocked(knowledgeService.getArtifactFacets).mock.calls.at(-1)?.[1];
+      expect(list).toMatchObject({ from: "2026-09-01", to: "2026-09-24", page: 1 });
+      expect(facets).toMatchObject({ from: "2026-09-01", to: "2026-09-24" });
+    });
+    expect(result.current.kb.dateRange).toEqual({ from: "2026-09-01", to: "2026-09-24" });
+  });
+
+  it("counts a date range as an active filter that Clear filters removes", async () => {
+    const { result } = await renderAt(["/kb?from=2026-09-01"], makeFacetFixture());
+    expect(result.current.kb.hasActiveFilters).toBe(true);
+
+    act(() => result.current.kb.handleClearFilters());
+
+    expect(result.current.kb.hasActiveFilters).toBe(false);
+    expect(result.current.kb.dateRange).toEqual({ from: null, to: null });
+  });
+});
+
+describe("useKnowledgeBase languages", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("offers the project's languages alphabetically, without document kinds or a source gate", async () => {
+    const { result } = await renderAt(["/kb"], makeLanguageFixture());
+
+    await waitFor(() => expect(result.current.kb.languageOptions.length).toBeGreaterThan(0));
+    expect(result.current.kb.languageOptions).toEqual([
+      { value: "Kotlin", label: "Kotlin", count: 2 },
+      { value: "TypeScript", label: "TypeScript", count: 1 },
+    ]);
+  });
+
+  it("sends the languages to the list and the facets alike", async () => {
+    const { result } = await renderAt(["/kb"], makeLanguageFixture());
+    const { knowledgeService } = await import("../../../../../src/services/knowledgeService");
+
+    act(() => result.current.kb.toggleLanguage("Kotlin"));
+
+    await waitFor(() => {
+      const list = vi.mocked(knowledgeService.getArtifactPage).mock.calls.at(-1)?.[1];
+      const facets = vi.mocked(knowledgeService.getArtifactFacets).mock.calls.at(-1)?.[1];
+      expect(list).toMatchObject({ languages: ["Kotlin"], page: 1 });
+      expect(facets).toMatchObject({ languages: ["Kotlin"] });
+    });
+    await waitFor(() => expect(result.current.kb.artifacts.map((a) => a.id)).toEqual(["k1", "k2"]));
+    // Own dimension excluded: TypeScript still counts what adding it would bring.
+    expect(result.current.kb.languageOptions.find((o) => o.value === "TypeScript")?.count).toBe(1);
+  });
+
+  it("keeps a hand-typed casing as the value so unticking it works, labelled as stored", async () => {
+    const { result } = await renderAt(["/kb?languages=kotlin"], makeLanguageFixture());
+
+    await waitFor(() =>
+      expect(result.current.kb.languageOptions).toContainEqual({
+        value: "kotlin",
+        label: "Kotlin",
+        count: 2,
+      }),
+    );
+    expect(result.current.kb.hasActiveFilters).toBe(true);
+  });
+
+  it("keeps a selected language visible at 0 after its artifacts are gone", async () => {
+    const { result } = await renderAt(["/kb?languages=Rust"], makeLanguageFixture());
+
+    await waitFor(() =>
+      expect(result.current.kb.languageOptions).toContainEqual({
+        value: "Rust",
+        label: "Rust",
+        count: 0,
+      }),
     );
+    expect(result.current.kb.artifacts).toEqual([]);
+  });
 
-    expect(backend).toBeDefined();
-    expect(backend?.count).toBe(0);
-    expect(result.current.filteredArtifacts).toHaveLength(0);
+  it("offers no languages when no artifact has one, so the section stays hidden", async () => {
+    const { result } = await renderAt(["/kb"], makeFacetFixture());
+    expect(result.current.kb.languageOptions).toEqual([]);
   });
 });
diff --git a/tests/unit/features/knowledge-base/hooks/useKnowledgeBaseUrlState.test.ts b/tests/unit/features/knowledge-base/hooks/useKnowledgeBaseUrlState.test.ts
new file mode 100644
index 00000000..e3c308d7
--- /dev/null
+++ b/tests/unit/features/knowledge-base/hooks/useKnowledgeBaseUrlState.test.ts
@@ -0,0 +1,398 @@
+import { renderHook, act } from "@testing-library/react";
+import { describe, it, expect } from "vitest";
+import { createElement, type ReactNode } from "react";
+import { MemoryRouter, useLocation, useNavigate } from "react-router-dom";
+import {
+  DEFAULT_PAGE_SIZE,
+  MAX_PAGE_SIZE,
+  parseKnowledgeBaseSearch,
+  toKnowledgeBaseSearchString,
+  useKnowledgeBaseUrlState,
+} from "../../../../../src/features/knowledge-base/hooks/useKnowledgeBaseUrlState";
+
+const parse = (search: string) => parseKnowledgeBaseSearch(new URLSearchParams(search));
+
+describe("parseKnowledgeBaseSearch", () => {
+  it("returns the defaults for an empty query string", () => {
+    const state = parse("");
+    expect(state.tab).toBe("ALL");
+    expect(state.search).toBe("");
+    expect(state.sources.size).toBe(0);
+    expect(state.repositories.size).toBe(0);
+    expect(state.format).toBeNull();
+    expect(state.page).toBe(1);
+    expect(state.size).toBe(DEFAULT_PAGE_SIZE);
+    expect(state.artifactId).toBeNull();
+  });
+
+  it("reads every param it owns", () => {
+    const state = parse(
+      "?tab=FILE&q=auth%20flow&sources=GITHUB,UPLOAD&repos=acme/api&format=PDF&page=3&size=50&artifact=a-1",
+    );
+    expect(state.tab).toBe("FILE");
+    expect(state.search).toBe("auth flow");
+    expect([...state.sources]).toEqual(["GITHUB", "UPLOAD"]);
+    expect([...state.repositories]).toEqual(["acme/api"]);
+    expect(state.format).toBe("PDF");
+    expect(state.page).toBe(3);
+    expect(state.size).toBe(50);
+    expect(state.artifactId).toBe("a-1");
+  });
+
+  it("accepts repeated set params as well as comma lists, de-duplicated", () => {
+    const state = parse("?sources=GITHUB&sources=JIRA,GITHUB");
+    expect([...state.sources]).toEqual(["GITHUB", "JIRA"]);
+  });
+
+  it("drops unknown enum values instead of forwarding them to the API", () => {
+    const state = parse("?tab=BOGUS&sources=GITHUB,NOPE&format=EXE");
+    expect(state.tab).toBe("ALL");
+    expect([...state.sources]).toEqual(["GITHUB"]);
+    expect(state.format).toBeNull();
+  });
+
+  it("matches enum values case-insensitively", () => {
+    const state = parse("?tab=pull_request&sources=upload&format=pdf");
+    expect(state.tab).toBe("PULL_REQUEST");
+    expect([...state.sources]).toEqual(["UPLOAD"]);
+    expect(state.format).toBe("PDF");
+  });
+
+  it("ignores a format without Uploads and repositories without GitHub", () => {
+    const state = parse("?sources=JIRA&format=PDF&repos=acme/api");
+    expect(state.format).toBeNull();
+    expect(state.repositories.size).toBe(0);
+  });
+
+  it.each([
+    ["page=0", 1],
+    ["page=-4", 1],
+    ["page=abc", 1],
+    ["page=2.5", 1],
+    ["page=7", 7],
+  ])("clamps %s to page %i", (query, expected) => {
+    expect(parse(`?${query}`).page).toBe(expected);
+  });
+
+  it.each([
+    ["size=0", 1],
+    ["size=500", MAX_PAGE_SIZE],
+    ["size=abc", DEFAULT_PAGE_SIZE],
+    ["size=50", 50],
+  ])("clamps %s to size %i", (query, expected) => {
+    expect(parse(`?${query}`).size).toBe(expected);
+  });
+});
+
+describe("toKnowledgeBaseSearchString", () => {
+  it("keeps commas and slashes readable and returns an empty string when empty", () => {
+    const params = new URLSearchParams();
+    params.set("sources", "GITHUB,JIRA");
+    params.set("repos", "acme/api");
+    expect(toKnowledgeBaseSearchString(params)).toBe("?sources=GITHUB,JIRA&repos=acme/api");
+    expect(toKnowledgeBaseSearchString(new URLSearchParams())).toBe("");
+  });
+});
+
+interface HarnessProps {
+  projectId: string | null;
+  projectSettled?: boolean;
+}
+
+/** Renders the hook together with the router's view of the location and a navigate handle. */
+function renderUrlState(initialEntries: string[], initialProps: HarnessProps) {
+  function Wrapper({ children }: { children: ReactNode }) {
+    return createElement(
+      MemoryRouter,
+      { initialEntries, initialIndex: initialEntries.length - 1 },
+      children,
+    );
+  }
+  return renderHook(
+    ({ projectId, projectSettled }: HarnessProps) => ({
+      api: useKnowledgeBaseUrlState(projectId, { projectSettled }),
+      location: useLocation(),
+      navigate: useNavigate(),
+    }),
+    { wrapper: Wrapper, initialProps },
+  );
+}
+
+describe("useKnowledgeBaseUrlState", () => {
+  it("restores the filters of a shared link on first render", () => {
+    const { result } = renderUrlState(["/kb?sources=GITHUB&repos=acme/api&tab=FILE&page=2"], {
+      projectId: "p1",
+    });
+    expect([...result.current.api.state.sources]).toEqual(["GITHUB"]);
+    expect([...result.current.api.state.repositories]).toEqual(["acme/api"]);
+    expect(result.current.api.state.tab).toBe("FILE");
+    expect(result.current.api.state.page).toBe(2);
+  });
+
+  it("omits defaults from the URL", () => {
+    const { result } = renderUrlState(["/kb?tab=FILE&page=3&size=50"], { projectId: "p1" });
+    act(() => result.current.api.setTab("ALL"));
+    act(() => result.current.api.setSize(DEFAULT_PAGE_SIZE));
+    expect(result.current.location.search).toBe("");
+  });
+
+  it("pushes discrete choices so Back undoes the last click", () => {
+    const { result } = renderUrlState(["/start", "/kb"], { projectId: "p1" });
+    act(() => result.current.api.toggleSource("GITHUB"));
+    act(() => result.current.api.setTab("FILE"));
+    expect(result.current.location.search).toBe("?sources=GITHUB&tab=FILE");
+
+    act(() => void result.current.navigate(-1));
+    expect(result.current.location.search).toBe("?sources=GITHUB");
+    expect(result.current.api.state.tab).toBe("ALL");
+    expect([...result.current.api.state.sources]).toEqual(["GITHUB"]);
+  });
+
+  it("replaces for search typing and the drawer, so Back leaves the page", () => {
+    const { result } = renderUrlState(["/start", "/kb"], { projectId: "p1" });
+    act(() => result.current.api.setSearch("a"));
+    act(() => result.current.api.setSearch("ab"));
+    act(() => result.current.api.setArtifactId("art-1"));
+    expect(result.current.location.search).toBe("?q=ab&artifact=art-1");
+
+    act(() => void result.current.navigate(-1));
+    expect(result.current.location.pathname).toBe("/start");
+  });
+
+  it("does not add a history entry for a write that changes nothing", () => {
+    const { result } = renderUrlState(["/start", "/kb?tab=FILE"], { projectId: "p1" });
+    act(() => result.current.api.setTab("FILE"));
+    act(() => void result.current.navigate(-1));
+    expect(result.current.location.pathname).toBe("/start");
+  });
+
+  it("builds several writes in one event on each other", () => {
+    const { result } = renderUrlState(["/kb"], { projectId: "p1" });
+    act(() => {
+      result.current.api.toggleSource("UPLOAD");
+      result.current.api.toggleFormat("PDF");
+      result.current.api.toggleSource("GITHUB");
+      result.current.api.toggleRepository("acme/api");
+    });
+    expect(result.current.location.search).toBe("?sources=UPLOAD,GITHUB&format=PDF&repos=acme/api");
+  });
+
+  it("drops the dependent facet together with its source", () => {
+    const { result } = renderUrlState(["/kb?sources=UPLOAD,GITHUB&format=PDF&repos=acme/api"], {
+      projectId: "p1",
+    });
+    act(() => result.current.api.toggleSource("UPLOAD"));
+    expect(result.current.location.search).toBe("?sources=GITHUB&repos=acme/api");
+    act(() => result.current.api.toggleSource("GITHUB"));
+    expect(result.current.location.search).toBe("");
+  });
+
+  it("resets the page on every filter change and keeps other params", () => {
+    const { result } = renderUrlState(["/kb?page=4&size=50&projectId=x"], { projectId: "p1" });
+    act(() => result.current.api.toggleSource("JIRA"));
+    expect(result.current.location.search).toBe("?size=50&projectId=x&sources=JIRA");
+  });
+
+  it("clears every filter but keeps the page size and the open artifact", () => {
+    const { result } = renderUrlState(
+      ["/kb?tab=FILE&q=x&sources=GITHUB&repos=a/b&page=2&size=50&artifact=a-1"],
+      { projectId: "p1" },
+    );
+    act(() => result.current.api.clearFilters());
+    expect(result.current.location.search).toBe("?size=50&artifact=a-1");
+  });
+});
+
+describe("useKnowledgeBaseUrlState project switches", () => {
+  const SHARED = "/kb?tab=FILE&q=x&sources=GITHUB&repos=a/b&page=2&size=50&artifact=a-1";
+
+  it("keeps a shared link's filters while the project resolves from nothing", () => {
+    const { result, rerender } = renderUrlState([SHARED], { projectId: null });
+    rerender({ projectId: "p1" });
+    expect(result.current.location.search).toBe(SHARED.slice(3));
+    expect(result.current.api.state.tab).toBe("FILE");
+  });
+
+  it("keeps a shared link's filters while the project context is still loading", () => {
+    const { result, rerender } = renderUrlState([SHARED], {
+      projectId: "fallback",
+      projectSettled: false,
+    });
+    rerender({ projectId: "stored-selection", projectSettled: true });
+    expect(result.current.location.search).toBe(SHARED.slice(3));
+    expect(result.current.api.state.page).toBe(2);
+  });
+
+  it("clears project-scoped params on a switch between two settled projects", () => {
+    const { result, rerender } = renderUrlState(["/start", SHARED], { projectId: "p1" });
+    rerender({ projectId: "p2" });
+    expect(result.current.location.search).toBe("?size=50");
+    expect(result.current.api.state.tab).toBe("ALL");
+    expect(result.current.api.state.sources.size).toBe(0);
+    expect(result.current.api.state.artifactId).toBeNull();
+    expect(result.current.api.scopeProjectId).toBe("p2");
+
+    // The clean-up replaced the entry instead of pushing one.
+    act(() => void result.current.navigate(-1));
+    expect(result.current.location.pathname).toBe("/start");
+  });
+
+  it("reports the cleared state in the very render that sees the new project", () => {
+    const seen: string[] = [];
+    function Wrapper({ children }: { children: ReactNode }) {
+      return createElement(MemoryRouter, { initialEntries: [SHARED] }, children);
+    }
+    const { rerender } = renderHook(
+      ({ projectId }: { projectId: string }) => {
+        const { state } = useKnowledgeBaseUrlState(projectId);
+        seen.push(`${projectId}:${state.tab}`);
+      },
+      { wrapper: Wrapper, initialProps: { projectId: "p1" } },
+    );
+    seen.length = 0;
+    rerender({ projectId: "p2" });
+    expect(seen).not.toContain("p2:FILE");
+    expect(seen).toContain("p2:ALL");
+  });
+
+  it("lets new filters be chosen right after a switch", () => {
+    const { result, rerender } = renderUrlState(["/kb?tab=FILE"], { projectId: "p1" });
+    rerender({ projectId: "p2" });
+    expect(result.current.location.search).toBe("");
+    act(() => result.current.api.setTab("FILE"));
+    expect(result.current.api.state.tab).toBe("FILE");
+    expect(result.current.location.search).toBe("?tab=FILE");
+  });
+});
+
+describe("useKnowledgeBaseUrlState sort", () => {
+  it("parses a known order case-insensitively and drops an unknown one", () => {
+    expect(parse("?sort=title_asc").sort).toBe("TITLE_ASC");
+    expect(parse("?sort=CHANGED_DESC").sort).toBe("CHANGED_DESC");
+    // The backend answers an unknown order with a 400; the URL must never be able to cause one.
+    expect(parse("?sort=POPULAR").sort).toBe("ADDED_DESC");
+    expect(parse("").sort).toBe("ADDED_DESC");
+  });
+
+  it("writes a non-default order, omits the default, and restarts at page 1", () => {
+    const { result } = renderUrlState(["/kb?page=4"], { projectId: "p1" });
+
+    act(() => result.current.api.setSort("CHANGED_DESC"));
+    expect(result.current.location.search).toBe("?sort=CHANGED_DESC");
+
+    act(() => result.current.api.setSort("ADDED_DESC"));
+    expect(result.current.location.search).toBe("");
+  });
+
+  it("pushes a sort change so Back restores the previous order", () => {
+    const { result } = renderUrlState(["/kb"], { projectId: "p1" });
+
+    act(() => result.current.api.setSort("TITLE_ASC"));
+    act(() => void result.current.navigate(-1));
+
+    expect(result.current.api.state.sort).toBe("ADDED_DESC");
+  });
+
+  it("keeps the order through Clear filters and a project switch", () => {
+    const { result, rerender } = renderUrlState(["/kb?sort=TITLE_ASC&sources=JIRA"], {
+      projectId: "p1",
+    });
+
+    act(() => result.current.api.clearFilters());
+    expect(result.current.location.search).toBe("?sort=TITLE_ASC");
+
+    rerender({ projectId: "p2" });
+    expect(result.current.api.state.sort).toBe("TITLE_ASC");
+  });
+});
+
+describe("useKnowledgeBaseUrlState date range", () => {
+  it("reads a valid range, drops invalid ends and swaps a reversed pair", () => {
+    expect(parse("?from=2026-09-01&to=2026-09-24").dateRange).toEqual({
+      from: "2026-09-01",
+      to: "2026-09-24",
+    });
+    expect(parse("?from=2026-02-30&to=2026-09-24").dateRange).toEqual({
+      from: null,
+      to: "2026-09-24",
+    });
+    // The backend 400s on from > to; a hand-edited link must not be able to trigger it.
+    expect(parse("?from=2026-09-24&to=2026-09-01").dateRange).toEqual({
+      from: "2026-09-01",
+      to: "2026-09-24",
+    });
+    expect(parse("").dateRange).toEqual({ from: null, to: null });
+  });
+
+  it("writes the range, restarts at page 1, and removes an open end", () => {
+    const { result } = renderUrlState(["/kb?page=3"], { projectId: "p1" });
+
+    act(() => result.current.api.setDateRange({ from: "2026-09-01", to: "2026-09-24" }));
+    expect(result.current.location.search).toBe("?from=2026-09-01&to=2026-09-24");
+
+    act(() => result.current.api.setDateRange({ from: "2026-09-01", to: null }));
+    expect(result.current.location.search).toBe("?from=2026-09-01");
+  });
+
+  it("pushes by default and replaces when asked", () => {
+    const { result } = renderUrlState(["/start", "/kb"], { projectId: "p1" });
+
+    act(() => result.current.api.setDateRange({ from: "2026-09-01", to: null }));
+    act(() => result.current.api.setDateRange({ from: "2026-09-02", to: null }, "replace"));
+    act(() => void result.current.navigate(-1));
+
+    // One push, one replace: Back leaves the range entirely instead of stepping through edits.
+    expect(result.current.location.pathname).toBe("/kb");
+    expect(result.current.api.state.dateRange.from).toBeNull();
+  });
+
+  it("is cleared by Clear filters and by a project switch", () => {
+    const { result, rerender } = renderUrlState(["/kb?from=2026-09-01&to=2026-09-24"], {
+      projectId: "p1",
+    });
+
+    act(() => result.current.api.clearFilters());
+    expect(result.current.location.search).toBe("");
+
+    act(() => result.current.api.setDateRange({ from: "2026-09-01", to: null }));
+    rerender({ projectId: "p2" });
+    expect(result.current.api.state.dateRange).toEqual({ from: null, to: null });
+  });
+});
+
+describe("useKnowledgeBaseUrlState languages", () => {
+  it("reads a comma or repeated list, de-duplicated ignoring case, independent of sources", () => {
+    const state = parse("?languages=Kotlin,kotlin&languages=C%23");
+    expect([...state.languages]).toEqual(["Kotlin", "C#"]);
+    expect(state.sources.size).toBe(0);
+  });
+
+  it("toggles a language, restarting at page 1, and unticks any casing of it", () => {
+    const { result } = renderUrlState(["/kb?page=3&languages=kotlin"], { projectId: "p1" });
+
+    act(() => result.current.api.toggleLanguage("TypeScript"));
+    expect(result.current.location.search).toBe("?languages=kotlin,TypeScript");
+
+    act(() => result.current.api.toggleLanguage("Kotlin"));
+    expect(result.current.location.search).toBe("?languages=TypeScript");
+  });
+
+  it("pushes a toggle so Back restores the previous selection", () => {
+    const { result } = renderUrlState(["/kb"], { projectId: "p1" });
+    act(() => result.current.api.toggleLanguage("Go"));
+    act(() => void result.current.navigate(-1));
+    expect(result.current.api.state.languages.size).toBe(0);
+  });
+
+  it("is cleared by Clear filters and by a project switch", () => {
+    const { result, rerender } = renderUrlState(["/kb?languages=Go&size=50"], {
+      projectId: "p1",
+    });
+    act(() => result.current.api.clearFilters());
+    expect(result.current.location.search).toBe("?size=50");
+
+    act(() => result.current.api.toggleLanguage("Rust"));
+    rerender({ projectId: "p2" });
+    expect(result.current.api.state.languages.size).toBe(0);
+  });
+});
diff --git a/tests/unit/features/knowledge-base/hooks/useUploadSelection.test.ts b/tests/unit/features/knowledge-base/hooks/useUploadSelection.test.ts
new file mode 100644
index 00000000..9a6a4d68
--- /dev/null
+++ b/tests/unit/features/knowledge-base/hooks/useUploadSelection.test.ts
@@ -0,0 +1,38 @@
+import { act, renderHook } from "@testing-library/react";
+import { describe, expect, it } from "vitest";
+import { useUploadSelection } from "../../../../../src/features/knowledge-base/hooks/useUploadSelection";
+
+describe("useUploadSelection", () => {
+  it("toggles ids on and off", () => {
+    const { result } = renderHook(() => useUploadSelection("scope-1"));
+    act(() => result.current.toggle("a"));
+    act(() => result.current.toggle("b"));
+    act(() => result.current.toggle("a"));
+    expect([...result.current.selectedIds]).toEqual(["b"]);
+  });
+
+  it("reads as empty as soon as the list's scope changes", () => {
+    const { result, rerender } = renderHook(({ scope }) => useUploadSelection(scope), {
+      initialProps: { scope: "page-1" },
+    });
+    act(() => result.current.toggle("a"));
+    rerender({ scope: "page-2" });
+    expect(result.current.selectedIds.size).toBe(0);
+    // Going back does not resurrect the old ticks either.
+    rerender({ scope: "page-1" });
+    expect(result.current.selectedIds.size).toBe(0);
+  });
+
+  it("clears on demand and when select mode is left", () => {
+    const { result } = renderHook(() => useUploadSelection("scope-1"));
+    act(() => result.current.setSelectMode(true));
+    act(() => result.current.toggle("a"));
+    act(() => result.current.clear());
+    expect(result.current.selectedIds.size).toBe(0);
+
+    act(() => result.current.toggle("b"));
+    act(() => result.current.setSelectMode(false));
+    expect(result.current.isSelectMode).toBe(false);
+    expect(result.current.selectedIds.size).toBe(0);
+  });
+});
diff --git a/tests/unit/features/knowledge-base/orgMetadata.test.ts b/tests/unit/features/knowledge-base/orgMetadata.test.ts
index 84903b99..0b26236e 100644
--- a/tests/unit/features/knowledge-base/orgMetadata.test.ts
+++ b/tests/unit/features/knowledge-base/orgMetadata.test.ts
@@ -124,4 +124,11 @@ describe("parseOrgMetadata", () => {
     // login is the primary key — an object without it must be rejected.
     expect(parseOrgMetadata(JSON.stringify({ members: [] }))).toBeNull();
   });
+
+  it("trims a padded login and rejects a blank one", () => {
+    // The repository facet compares the login against a trimmed owner half, so a
+    // padded login would silently never match its own repositories.
+    expect(parseOrgMetadata(JSON.stringify({ login: "  org \n", members: [] }))?.login).toBe("org");
+    expect(parseOrgMetadata(JSON.stringify({ login: "   ", members: [] }))).toBeNull();
+  });
 });
diff --git a/tests/unit/features/knowledge-base/resultRange.test.ts b/tests/unit/features/knowledge-base/resultRange.test.ts
new file mode 100644
index 00000000..d2caae85
--- /dev/null
+++ b/tests/unit/features/knowledge-base/resultRange.test.ts
@@ -0,0 +1,26 @@
+import { describe, expect, it } from "vitest";
+import { formatResultRange } from "../../../../src/features/knowledge-base/resultRange.ts";
+
+describe("formatResultRange", () => {
+  it("reads a middle page as a range of the total", () => {
+    expect(formatResultRange(412, { start: 21, end: 40 })).toBe("21–40 of 412 artifacts");
+  });
+
+  it("drops the range when one page holds everything", () => {
+    expect(formatResultRange(12, { start: 1, end: 12 })).toBe("12 artifacts");
+  });
+
+  it("uses the singular for a single artifact", () => {
+    expect(formatResultRange(1, { start: 1, end: 1 })).toBe("1 artifact");
+  });
+
+  it("says No artifacts for an empty result", () => {
+    expect(formatResultRange(0, { start: 1, end: 0 })).toBe("No artifacts");
+    expect(formatResultRange(0)).toBe("No artifacts");
+  });
+
+  it("falls back to the total without a usable range", () => {
+    expect(formatResultRange(50)).toBe("50 artifacts");
+    expect(formatResultRange(50, { start: 0, end: 0 })).toBe("50 artifacts");
+  });
+});
diff --git a/tests/unit/features/knowledge-base/tabs.test.ts b/tests/unit/features/knowledge-base/tabs.test.ts
new file mode 100644
index 00000000..2ae69e65
--- /dev/null
+++ b/tests/unit/features/knowledge-base/tabs.test.ts
@@ -0,0 +1,41 @@
+import { describe, expect, it } from "vitest";
+import { matchesFormat } from "../../../../src/features/knowledge-base/tabs";
+import type { Artifact } from "../../../../src/features/knowledge-base/types";
+
+/** An upload as the backend sends it: no mime, UUID source id, title + language only. */
+function upload(title: string, language: string | null): Artifact {
+  return {
+    id: title,
+    title,
+    artifactType: "FILE",
+    sourceSystem: "UPLOAD",
+    sourceId: "4b1c7a2e-0000-0000-0000-000000000000",
+    sourceUrl: null,
+    mime: null,
+    language,
+    ingestedAt: "2026-09-01T00:00:00Z",
+    lastChangedAt: null,
+    contentHash: null,
+    ingestionRunId: null,
+  };
+}
+
+describe("matchesFormat with the backend's language", () => {
+  it("classifies a Markdown upload by language when the title has no extension", () => {
+    const notes = upload("Team notes", "Markdown");
+    expect(matchesFormat(notes, "MARKDOWN")).toBe(true);
+    expect(matchesFormat(notes, "OTHER")).toBe(false);
+  });
+
+  it("files code and plain text under Other, not Markdown", () => {
+    for (const artifact of [upload("Main.kt", "Kotlin"), upload("todo.txt", "Plain Text")]) {
+      expect(matchesFormat(artifact, "MARKDOWN")).toBe(false);
+      expect(matchesFormat(artifact, "OTHER")).toBe(true);
+    }
+  });
+
+  it("still classifies by extension when the language is missing", () => {
+    expect(matchesFormat(upload("README.md", null), "MARKDOWN")).toBe(true);
+    expect(matchesFormat(upload("spec.pdf", null), "PDF")).toBe(true);
+  });
+});
diff --git a/tests/unit/hooks/useDebouncedValue.test.ts b/tests/unit/hooks/useDebouncedValue.test.ts
new file mode 100644
index 00000000..854974e1
--- /dev/null
+++ b/tests/unit/hooks/useDebouncedValue.test.ts
@@ -0,0 +1,72 @@
+import { renderHook, act } from "@testing-library/react";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { useDebouncedValue } from "../../../src/hooks/useDebouncedValue";
+
+describe("useDebouncedValue", () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it("returns the initial value immediately", () => {
+    const { result } = renderHook(() => useDebouncedValue("seed", 300));
+    expect(result.current).toBe("seed");
+  });
+
+  it("only returns a new value after it has been stable for the delay", () => {
+    const { result, rerender } = renderHook(({ value }) => useDebouncedValue(value, 300), {
+      initialProps: { value: "" },
+    });
+
+    rerender({ value: "a" });
+    act(() => {
+      vi.advanceTimersByTime(299);
+    });
+    expect(result.current).toBe("");
+
+    act(() => {
+      vi.advanceTimersByTime(1);
+    });
+    expect(result.current).toBe("a");
+  });
+
+  it("restarts the wait on every change and emits only the last value", () => {
+    const seen: string[] = [];
+    const { rerender } = renderHook(
+      ({ value }) => {
+        const debounced = useDebouncedValue(value, 300);
+        seen.push(debounced);
+        return debounced;
+      },
+      { initialProps: { value: "" } },
+    );
+
+    for (const value of ["r", "re", "rea", "read", "readm"]) {
+      rerender({ value });
+      act(() => {
+        vi.advanceTimersByTime(100);
+      });
+    }
+    act(() => {
+      vi.advanceTimersByTime(300);
+    });
+
+    expect(new Set(seen)).toEqual(new Set(["", "readm"]));
+  });
+
+  it("drops a pending update on unmount", () => {
+    const { rerender, unmount } = renderHook(({ value }) => useDebouncedValue(value, 300), {
+      initialProps: { value: "" },
+    });
+    rerender({ value: "late" });
+    unmount();
+    expect(() =>
+      act(() => {
+        vi.advanceTimersByTime(300);
+      }),
+    ).not.toThrow();
+  });
+});
diff --git a/tests/unit/hooks/useScrollRestoration.test.tsx b/tests/unit/hooks/useScrollRestoration.test.tsx
index 9983a5f1..33f615ea 100644
--- a/tests/unit/hooks/useScrollRestoration.test.tsx
+++ b/tests/unit/hooks/useScrollRestoration.test.tsx
@@ -47,4 +47,62 @@ describe("useScrollRestoration", () => {
 
     await waitFor(() => expect(scrollHost?.scrollTop).toBe(700));
   });
+
+  it("does not reset scroll to 0 when search params change on the same pathname", async () => {
+    const { useSearchParams } = await import("react-router-dom");
+    const { default: userEvent } = await import("@testing-library/user-event");
+    const { screen } = await import("@testing-library/react");
+
+    function SearchParamsPage() {
+      useScrollRestoration();
+      const [searchParams, setSearchParams] = useSearchParams();
+      return (
+        <main
+          {...{ [SCROLL_CONTAINER_ATTRIBUTE]: "" }}
+          ref={(node) => {
+            if (!node) return;
+            node.scrollTo = (xOrOptions?: ScrollToOptions | number, y?: number) => {
+              const target = typeof xOrOptions === "number" ? (y ?? 0) : (xOrOptions?.top ?? 0);
+              node.scrollTop = target;
+            };
+          }}
+        >
+          <span data-testid="artifact-param">{searchParams.get("artifact") ?? ""}</span>
+          <button
+            data-testid="open-btn"
+            onClick={() => setSearchParams({ artifact: "art-1" }, { replace: true })}
+          >
+            Open
+          </button>
+          <button data-testid="close-btn" onClick={() => setSearchParams({}, { replace: true })}>
+            Close
+          </button>
+        </main>
+      );
+    }
+
+    const { container } = render(
+      <MemoryRouter initialEntries={["/knowledge-base"]}>
+        <SearchParamsPage />
+      </MemoryRouter>,
+    );
+
+    const scrollHost = container.querySelector("main")!;
+    // Simulate user scrolled down
+    scrollHost.scrollTop = 500;
+
+    // User opens artifact
+    const openBtn = screen.getByTestId("open-btn");
+    await userEvent.click(openBtn);
+
+    expect(screen.getByTestId("artifact-param")).toHaveTextContent("art-1");
+    expect(scrollHost.scrollTop).toBe(500);
+
+    // User closes artifact
+    const closeBtn = screen.getByTestId("close-btn");
+    await userEvent.click(closeBtn);
+
+    expect(screen.getByTestId("artifact-param")).toHaveTextContent("");
+    expect(scrollHost.scrollTop).toBe(500);
+  });
 });
diff --git a/tests/unit/pages/DataIngestionPage.test.tsx b/tests/unit/pages/DataIngestionPage.test.tsx
index ff2b5392..939ec2b7 100644
--- a/tests/unit/pages/DataIngestionPage.test.tsx
+++ b/tests/unit/pages/DataIngestionPage.test.tsx
@@ -57,7 +57,6 @@ const {
   mockUpdateGithubRepository,
   mockGetAccessibleProject,
   mockGetIngestionSourceStatuses,
-  mockGetUnifiedArtifacts,
   mockListConnectors,
   mockConfigureAllGithubRepositories,
 } = vi.hoisted(() => ({
@@ -70,7 +69,6 @@ const {
   mockUpdateGithubRepository: vi.fn(),
   mockGetAccessibleProject: vi.fn(),
   mockGetIngestionSourceStatuses: vi.fn(),
-  mockGetUnifiedArtifacts: vi.fn(),
   mockListConnectors: vi.fn(),
   mockConfigureAllGithubRepositories: vi.fn(),
 }));
@@ -124,7 +122,7 @@ vi.mock("../../../src/services/knowledgeService", async (importOriginal) => {
   const actual = await importOriginal<typeof import("../../../src/services/knowledgeService")>();
   return {
     ...actual,
-    knowledgeService: { ...actual.knowledgeService, getUnifiedArtifacts: mockGetUnifiedArtifacts },
+    knowledgeService: { ...actual.knowledgeService },
   };
 });
 
@@ -155,7 +153,6 @@ describe("DataIngestionPage", () => {
     mockUpdateJiraInstance.mockResolvedValue({ transactionId: "jira-tx" });
     mockConfigureAllGithubRepositories.mockResolvedValue(undefined);
     mockConfigureAllJiraInstances.mockResolvedValue(undefined);
-    mockGetUnifiedArtifacts.mockResolvedValue([]);
     mockListConnectors.mockResolvedValue([]);
     selectProject();
   });
diff --git a/tests/unit/pages/KnowledgeBasePage.test.tsx b/tests/unit/pages/KnowledgeBasePage.test.tsx
index a0ae4b22..d624de46 100644
--- a/tests/unit/pages/KnowledgeBasePage.test.tsx
+++ b/tests/unit/pages/KnowledgeBasePage.test.tsx
@@ -1,6 +1,6 @@
-import { render, screen, waitFor } from "@testing-library/react";
+import { render, screen, waitFor, fireEvent } from "@testing-library/react";
 import userEvent from "@testing-library/user-event";
-import { describe, it, expect, vi, beforeEach } from "vitest";
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
 import { MemoryRouter } from "react-router-dom";
 import { KnowledgeBasePage } from "../../../src/pages/KnowledgeBasePage";
 import type { Artifact } from "../../../src/features/knowledge-base/types";
@@ -36,16 +36,69 @@ vi.mock("../../../src/context/useAuth", () => ({
   useAuth: () => ({ profile: mockProfileRef.current }),
 }));
 
-const { mockGetUnifiedArtifacts } = vi.hoisted(() => ({
-  mockGetUnifiedArtifacts: vi.fn(),
+const { mockGetArtifactPage, mockGetArtifactFacets, mockGetArtifactById } = vi.hoisted(() => ({
+  mockGetArtifactPage: vi.fn(),
+  mockGetArtifactFacets: vi.fn(),
+  mockGetArtifactById: vi.fn(),
 }));
 
 vi.mock("../../../src/services/knowledgeService", () => ({
   knowledgeService: {
-    getUnifiedArtifacts: mockGetUnifiedArtifacts,
+    getArtifactPage: mockGetArtifactPage,
+    getArtifactFacets: mockGetArtifactFacets,
+    getArtifactById: mockGetArtifactById,
+    getArtifactAiStatus: () => Promise.resolve({ aiAvailable: true, items: [] }),
   },
 }));
 
+function setupMockArtifacts(artifacts: Artifact[]) {
+  mockGetArtifactPage.mockImplementation(
+    (_pid: string, params: { search?: string; sources?: string[] } = {}) => {
+      let filtered = artifacts;
+      if (params.search) {
+        filtered = filtered.filter((a) =>
+          (a.title ?? "").toLowerCase().includes(params.search!.toLowerCase()),
+        );
+      }
+      if (params.sources && params.sources.length > 0) {
+        filtered = filtered.filter((a) => params.sources!.includes(a.sourceSystem));
+      }
+      return Promise.resolve({
+        items: filtered,
+        page: {
+          number: 1,
+          size: 20,
+          totalElements: filtered.length,
+          totalPages: 1,
+          hasNext: false,
+          hasPrevious: false,
+        },
+        metadata: {
+          pageNumber: 1,
+          pageSize: 20,
+          totalElements: filtered.length,
+          totalPages: 1,
+          isFirst: true,
+          isLast: true,
+          hasNext: false,
+          hasPrevious: false,
+        },
+      });
+    },
+  );
+
+  mockGetArtifactFacets.mockResolvedValue({
+    types: [],
+    sources: [],
+    formats: [],
+    repositories: [],
+  });
+
+  mockGetArtifactById.mockImplementation((_pid: string, id: string) => {
+    return Promise.resolve(artifacts.find((a) => a.id === id) ?? null);
+  });
+}
+
 vi.mock("../../../src/features/knowledge-base/components", () => ({
   ArtifactFilters: ({
     searchQuery,
@@ -53,12 +106,16 @@ vi.mock("../../../src/features/knowledge-base/components", () => ({
     selectedSources,
     onToggleSource,
     onRefresh,
+    isSelectMode,
+    onSelectModeChange,
   }: {
     searchQuery: string;
     onSearchChange: (q: string) => void;
     selectedSources?: ReadonlySet<string>;
     onToggleSource?: (source: string) => void;
     onRefresh?: () => void;
+    isSelectMode?: boolean;
+    onSelectModeChange?: (on: boolean) => void;
   }) => (
     <div data-testid="artifact-filters">
       <input
@@ -73,17 +130,40 @@ vi.mock("../../../src/features/knowledge-base/components", () => ({
         Refresh
       </button>
       <span data-testid="active-facets">{[...(selectedSources ?? [])].join(",")}</span>
+      {onSelectModeChange && (
+        <button data-testid="kb-select-toggle" onClick={() => onSelectModeChange(!isSelectMode)}>
+          Select
+        </button>
+      )}
     </div>
   ),
-  ArtifactList: ({ artifacts }: { artifacts: Artifact[] }) => (
+  ArtifactList: ({
+    artifacts,
+    selection,
+  }: {
+    artifacts: Artifact[];
+    selection?: { selectedIds: ReadonlySet<string>; onToggle: (id: string) => void };
+  }) => (
     <div data-testid="artifact-list">
       {artifacts.map((a) => (
         <div key={a.id} data-testid="artifact-card">
+          {selection && (
+            <input
+              type="checkbox"
+              aria-label={`Select ${a.title}`}
+              data-testid={`artifact-select-${a.id}`}
+              checked={selection.selectedIds.has(a.id)}
+              onChange={() => selection.onToggle(a.id)}
+            />
+          )}
           {a.title}
         </div>
       ))}
     </div>
   ),
+  ArtifactBulkActions: ({ selected }: { selected: Artifact[] }) => (
+    <div data-testid="bulk-actions">{selected.map((a) => a.id).join(",")}</div>
+  ),
   // Reports which artifact it was handed, so a test can tell "the viewer is mounted" apart
   // from "the viewer is showing the right document".
   ArtifactViewerDrawer: ({ artifact }: { artifact: { id: string } | null }) => (
@@ -114,7 +194,7 @@ function makeArtifact(overrides: Partial<Artifact> = {}): Artifact {
 describe("KnowledgeBasePage", () => {
   beforeEach(async () => {
     vi.clearAllMocks();
-    mockGetUnifiedArtifacts.mockResolvedValue([]);
+    setupMockArtifacts([]);
 
     const { createProjectContextValue, createSelectableProject } =
       await import("../setup/projectContext");
@@ -132,7 +212,7 @@ describe("KnowledgeBasePage", () => {
 
   it("renders the artifact list after loading artifacts", async () => {
     const artifacts: Artifact[] = [makeArtifact({ id: "a1", title: "readme.md" })];
-    mockGetUnifiedArtifacts.mockResolvedValue(artifacts);
+    setupMockArtifacts(artifacts);
 
     render(
       <MemoryRouter>
@@ -150,7 +230,7 @@ describe("KnowledgeBasePage", () => {
     there used to land on the bare page and the reader had to find the document again.
   */
   it("opens the artifact named in the URL", async () => {
-    mockGetUnifiedArtifacts.mockResolvedValue([
+    setupMockArtifacts([
       makeArtifact({ id: "a1", title: "readme.md" }),
       makeArtifact({ id: "a2", title: "runbook.md" }),
     ]);
@@ -167,7 +247,7 @@ describe("KnowledgeBasePage", () => {
   });
 
   it("opens no artifact without the parameter", async () => {
-    mockGetUnifiedArtifacts.mockResolvedValue([makeArtifact({ id: "a1", title: "readme.md" })]);
+    setupMockArtifacts([makeArtifact({ id: "a1", title: "readme.md" })]);
 
     render(
       <MemoryRouter>
@@ -180,6 +260,101 @@ describe("KnowledgeBasePage", () => {
     });
   });
 
+  /*
+    While the project list loads, the page falls back to the user's first project and only then
+    learns the stored selection. That hop is not a project switch: treating it as one wiped the
+    filters of every shared link on arrival.
+  */
+  it("keeps a shared link's filters while the project context resolves", async () => {
+    const { createProjectContextValue, createSelectableProject } =
+      await import("../setup/projectContext");
+    const project = createSelectableProject({ id: "proj1" });
+    mockUseProjectContext.mockReturnValue(
+      createProjectContextValue({ projects: [], selectedProjectId: "", isLoading: true }),
+    );
+    setupMockArtifacts([makeArtifact({ id: "a1", title: "readme.md" })]);
+
+    const view = render(
+      <MemoryRouter initialEntries={["/knowledge-base?q=readme&sources=UPLOAD"]}>
+        <KnowledgeBasePage />
+      </MemoryRouter>,
+    );
+
+    mockUseProjectContext.mockReturnValue(
+      createProjectContextValue({
+        projects: [project],
+        selectedProject: project,
+        selectedProjectId: "proj1",
+        isLoading: false,
+      }),
+    );
+    view.rerender(
+      <MemoryRouter initialEntries={["/knowledge-base?q=readme&sources=UPLOAD"]}>
+        <KnowledgeBasePage />
+      </MemoryRouter>,
+    );
+
+    await waitFor(() => {
+      expect(mockGetArtifactPage).toHaveBeenCalledWith(
+        "proj1",
+        expect.objectContaining({ search: "readme", sources: ["UPLOAD"] }),
+      );
+    });
+  });
+
+  it("announces the settled result total in a polite live region", async () => {
+    setupMockArtifacts([
+      makeArtifact({ id: "a1", title: "readme.md" }),
+      makeArtifact({ id: "a2", title: "runbook.md" }),
+    ]);
+
+    render(
+      <MemoryRouter>
+        <KnowledgeBasePage />
+      </MemoryRouter>,
+    );
+
+    const region = screen.getByTestId("kb-results-announcement");
+    expect(region).toHaveAttribute("aria-live", "polite");
+    await waitFor(() => expect(region).toHaveTextContent("2 artifacts"), { timeout: 3000 });
+  });
+
+  it("offers a page size once results outgrow a page, and requests the chosen size", async () => {
+    const artifacts = Array.from({ length: 20 }, (_, i) =>
+      makeArtifact({ id: `a${i}`, title: `doc-${i}.md` }),
+    );
+    setupMockArtifacts(artifacts);
+    mockGetArtifactPage.mockImplementation((_pid: string, params: { size?: number } = {}) =>
+      Promise.resolve({
+        items: artifacts,
+        page: {
+          number: 1,
+          size: params.size ?? 20,
+          totalElements: 45,
+          totalPages: Math.ceil(45 / (params.size ?? 20)),
+          hasNext: true,
+          hasPrevious: false,
+        },
+      }),
+    );
+
+    render(
+      <MemoryRouter>
+        <KnowledgeBasePage />
+      </MemoryRouter>,
+    );
+
+    const select = await screen.findByTestId("kb-page-size");
+    fireEvent.change(select, { target: { value: "50" } });
+
+    await waitFor(() => {
+      expect(mockGetArtifactPage).toHaveBeenLastCalledWith(
+        "proj1",
+        expect.objectContaining({ page: 1, size: 50 }),
+      );
+    });
+  });
+
   it("shows loading spinner when project context is loading", async () => {
     const { createProjectContextValue } = await import("../setup/projectContext");
     mockUseProjectContext.mockReturnValue(
@@ -205,7 +380,7 @@ describe("KnowledgeBasePage", () => {
   });
 
   it("no longer offers uploading here — that moved into the Add source wizard", async () => {
-    mockGetUnifiedArtifacts.mockResolvedValue([makeArtifact({ id: "a1", title: "readme.md" })]);
+    setupMockArtifacts([makeArtifact({ id: "a1", title: "readme.md" })]);
 
     render(
       <MemoryRouter>
@@ -226,7 +401,7 @@ describe("KnowledgeBasePage", () => {
       makeArtifact({ id: "a1", title: "readme.md" }),
       makeArtifact({ id: "a2", title: "contributing.md", sourceId: "src2" }),
     ];
-    mockGetUnifiedArtifacts.mockResolvedValue(artifacts);
+    setupMockArtifacts(artifacts);
 
     render(
       <MemoryRouter>
@@ -251,7 +426,7 @@ describe("KnowledgeBasePage", () => {
       makeArtifact({ id: "a1", title: "github-file.md", sourceSystem: "GITHUB" }),
       makeArtifact({ id: "a2", title: "uploaded-file.pdf", sourceSystem: "UPLOAD" }),
     ];
-    mockGetUnifiedArtifacts.mockResolvedValue(artifacts);
+    setupMockArtifacts(artifacts);
 
     render(
       <MemoryRouter>
@@ -271,8 +446,8 @@ describe("KnowledgeBasePage", () => {
     });
   });
 
-  it("shows the fetch error banner when getUnifiedArtifacts rejects", async () => {
-    mockGetUnifiedArtifacts.mockRejectedValue(new Error("Server down"));
+  it("shows the fetch error banner when getArtifactPage rejects", async () => {
+    mockGetArtifactPage.mockRejectedValue(new Error("Server down"));
 
     render(
       <MemoryRouter>
@@ -289,10 +464,8 @@ describe("KnowledgeBasePage", () => {
   });
 
   it("re-fetches when the retry button is clicked after an error", async () => {
-    mockGetUnifiedArtifacts.mockRejectedValueOnce(new Error("Server down"));
-    mockGetUnifiedArtifacts.mockResolvedValueOnce([
-      makeArtifact({ id: "a1", title: "recovered.md" }),
-    ]);
+    mockGetArtifactPage.mockRejectedValueOnce(new Error("Server down"));
+    setupMockArtifacts([makeArtifact({ id: "a1", title: "recovered.md" })]);
 
     render(
       <MemoryRouter>
@@ -312,10 +485,7 @@ describe("KnowledgeBasePage", () => {
   });
 
   it("re-fetches when the refresh button is clicked", async () => {
-    mockGetUnifiedArtifacts.mockResolvedValueOnce([]);
-    mockGetUnifiedArtifacts.mockResolvedValueOnce([
-      makeArtifact({ id: "a1", title: "after-refresh.md" }),
-    ]);
+    setupMockArtifacts([]);
 
     render(
       <MemoryRouter>
@@ -327,10 +497,91 @@ describe("KnowledgeBasePage", () => {
       expect(screen.getByTestId("kb-refresh")).toBeInTheDocument();
     });
 
+    setupMockArtifacts([makeArtifact({ id: "a1", title: "after-refresh.md" })]);
+
     await userEvent.click(screen.getByTestId("kb-refresh"));
 
     await waitFor(() => {
       expect(screen.getByText("after-refresh.md")).toBeInTheDocument();
     });
   });
+
+  describe("bulk select", () => {
+    const uploads: Artifact[] = [
+      makeArtifact({ id: "u1", title: "one.pdf", sourceSystem: "UPLOAD", sourceId: "up-1" }),
+      makeArtifact({ id: "g1", title: "gh.md", sourceSystem: "GITHUB" }),
+    ];
+
+    function renderAs(group: UserProfile["permissionGroup"]) {
+      mockProfileRef.current = { ...mockProfileRef.current, permissionGroup: group };
+      setupMockArtifacts(uploads);
+      render(
+        <MemoryRouter>
+          <KnowledgeBasePage />
+        </MemoryRouter>,
+      );
+    }
+
+    afterEach(() => {
+      mockProfileRef.current = { ...mockProfileRef.current, permissionGroup: "USER" };
+    });
+
+    it("offers no Select toggle to roles that cannot delete uploads", async () => {
+      renderAs("USER");
+      await waitFor(() => expect(screen.getAllByTestId("artifact-card")).toHaveLength(2));
+      expect(screen.queryByTestId("kb-select-toggle")).not.toBeInTheDocument();
+    });
+
+    it("lets a PM tick uploads and hands only those to the bulk actions", async () => {
+      renderAs("PM");
+      await waitFor(() => expect(screen.getAllByTestId("artifact-card")).toHaveLength(2));
+      // Keep serving the mixed page after Uploads is picked, to prove the page's own guard.
+      const mixedPage: unknown = await mockGetArtifactPage.mock.results[0]?.value;
+      mockGetArtifactPage.mockResolvedValue(mixedPage);
+
+      await userEvent.click(screen.getByTestId("kb-filter-upload"));
+      await userEvent.click(await screen.findByTestId("kb-select-toggle"));
+      await userEvent.click(screen.getByTestId("artifact-select-u1"));
+      // A non-upload ticked through the mock list is still filtered out by the page.
+      await userEvent.click(screen.getByTestId("artifact-select-g1"));
+
+      expect(screen.getByTestId("bulk-actions")).toHaveTextContent(/^u1$/);
+    });
+
+    it("clears the selection on a filter change and on refresh", async () => {
+      renderAs("ADMIN");
+      await waitFor(() => expect(screen.getAllByTestId("artifact-card")).toHaveLength(2));
+      await userEvent.click(screen.getByTestId("kb-filter-upload"));
+      await userEvent.click(await screen.findByTestId("kb-select-toggle"));
+
+      await userEvent.click(screen.getByTestId("artifact-select-u1"));
+      expect(screen.getByTestId("bulk-actions")).toHaveTextContent("u1");
+      await userEvent.type(screen.getByTestId("kb-search-input"), "one");
+      await waitFor(() => expect(screen.getByTestId("bulk-actions")).toBeEmptyDOMElement());
+
+      await userEvent.click(await screen.findByTestId("artifact-select-u1"));
+      expect(screen.getByTestId("bulk-actions")).toHaveTextContent("u1");
+      await userEvent.click(screen.getByTestId("kb-refresh"));
+      expect(screen.getByTestId("bulk-actions")).toBeEmptyDOMElement();
+    });
+
+    it("offers Select only while Uploads is picked, and unpicking it leaves select mode", async () => {
+      renderAs("PM");
+      await waitFor(() => expect(screen.getAllByTestId("artifact-card")).toHaveLength(2));
+      expect(screen.queryByTestId("kb-select-toggle")).not.toBeInTheDocument();
+
+      await userEvent.click(screen.getByTestId("kb-filter-upload"));
+      await userEvent.click(await screen.findByTestId("kb-select-toggle"));
+      expect(screen.getByTestId("bulk-actions")).toBeInTheDocument();
+
+      await userEvent.click(screen.getByTestId("kb-filter-upload"));
+      await waitFor(() => expect(screen.queryByTestId("kb-select-toggle")).not.toBeInTheDocument());
+      expect(screen.queryByTestId("bulk-actions")).not.toBeInTheDocument();
+
+      // Re-picking Uploads brings the toggle back, not the old select mode.
+      await userEvent.click(screen.getByTestId("kb-filter-upload"));
+      await screen.findByTestId("kb-select-toggle");
+      expect(screen.queryByTestId("bulk-actions")).not.toBeInTheDocument();
+    });
+  });
 });
diff --git a/tests/unit/services/knowledgeService.test.ts b/tests/unit/services/knowledgeService.test.ts
index 414a976b..86b29364 100644
--- a/tests/unit/services/knowledgeService.test.ts
+++ b/tests/unit/services/knowledgeService.test.ts
@@ -114,6 +114,66 @@ describe("knowledgeService", () => {
         knowledgeService.deleteUpload("proj-1", "up-1", "remover-1"),
       ).rejects.toMatchObject({ name: "ApiError", status: 403 });
     });
+
+    it("rejects with the backend's reason when the one id comes back failed", async () => {
+      server.use(
+        http.delete("/api/v1/uploads", () =>
+          HttpResponse.json({
+            deletedIds: [],
+            failed: [{ artifactId: "up-1", error: "Artifact could not be deleted." }],
+          }),
+        ),
+      );
+
+      await expect(knowledgeService.deleteUpload("proj-1", "up-1", "remover-1")).rejects.toThrow(
+        "Artifact could not be deleted.",
+      );
+    });
+  });
+
+  describe("deleteUploads", () => {
+    it("sends every id in one request and returns the per-item outcome", async () => {
+      const fetchSpy = vi.spyOn(apiClient, "fetch").mockResolvedValue({
+        deletedIds: ["up-1"],
+        failed: [{ artifactId: "up-2", error: "Artifact with id up-2 not found." }],
+      });
+
+      const result = await knowledgeService.deleteUploads("proj-1", ["up-1", "up-2"], "r-1");
+
+      expect(fetchSpy).toHaveBeenCalledTimes(1);
+      const part = (fetchSpy.mock.calls[0][1]?.body as FormData).get("request") as Blob;
+      const payload: unknown = JSON.parse(await part.text());
+      expect(payload).toEqual({
+        artifactIds: ["up-1", "up-2"],
+        removerId: "r-1",
+        projectId: "proj-1",
+      });
+      expect(result).toEqual({
+        deletedIds: ["up-1"],
+        failed: [{ artifactId: "up-2", error: "Artifact with id up-2 not found." }],
+      });
+    });
+
+    it("reads an old backend's empty 204 as every id deleted", async () => {
+      server.use(http.delete("/api/v1/uploads", () => new HttpResponse(null, { status: 204 })));
+
+      await expect(
+        knowledgeService.deleteUploads("proj-1", ["up-1", "up-2"], "r-1"),
+      ).resolves.toEqual({ deletedIds: ["up-1", "up-2"], failed: [] });
+    });
+
+    it("never counts an id the answer does not mention as deleted", async () => {
+      server.use(
+        http.delete("/api/v1/uploads", () =>
+          HttpResponse.json({ deletedIds: ["up-1"], failed: [] }),
+        ),
+      );
+
+      const result = await knowledgeService.deleteUploads("proj-1", ["up-1", "up-2"], "r-1");
+
+      expect(result.deletedIds).toEqual(["up-1"]);
+      expect(result.failed.map((item) => item.artifactId)).toEqual(["up-2"]);
+    });
   });
 
   describe("streamArtifactSummary", () => {
@@ -232,25 +292,31 @@ describe("knowledgeService", () => {
     });
   });
 
-  describe("getUnifiedArtifacts", () => {
+  describe("getArtifactPage", () => {
     const projectId = "proj-uuid";
 
-    it("fetches a single page of artifacts", async () => {
+    it("serializes filter criteria and pagination into query params and returns page response", async () => {
       server.use(
         http.get(`/api/v1/projects/${projectId}/artifacts`, ({ request }) => {
           const url = new URL(request.url);
-          expect(url.searchParams.get("page")).toBe("1");
-          expect(url.searchParams.get("size")).toBe("100");
+          expect(url.searchParams.get("page")).toBe("2");
+          expect(url.searchParams.get("size")).toBe("20");
+          expect(url.searchParams.get("search")).toBe("guide");
+          expect(url.searchParams.getAll("types")).toEqual(["FILE", "ISSUE"]);
+          expect(url.searchParams.getAll("sources")).toEqual(["GITHUB"]);
+          expect(url.searchParams.getAll("repositories")).toEqual(["owner/repo"]);
+          expect(url.searchParams.get("format")).toBe("PDF");
+
           return HttpResponse.json({
             items: [
               {
                 id: "art-1",
-                title: "doc1.md",
+                title: "guide.pdf",
                 artifactType: "FILE",
                 sourceSystem: "GITHUB",
                 sourceId: "src-1",
                 sourceUrl: null,
-                mime: "text/markdown",
+                mime: "application/pdf",
                 language: null,
                 ingestedAt: "2026-01-01T00:00:00Z",
                 lastChangedAt: null,
@@ -259,86 +325,269 @@ describe("knowledgeService", () => {
               },
             ],
             page: {
-              totalPages: 1,
+              number: 2,
+              size: 20,
+              totalElements: 25,
+              totalPages: 2,
+              hasNext: false,
+              hasPrevious: true,
             },
           });
         }),
       );
 
-      const artifacts = await knowledgeService.getUnifiedArtifacts(projectId);
-      expect(artifacts).toHaveLength(1);
-      expect(artifacts[0].title).toBe("doc1.md");
+      const page = await knowledgeService.getArtifactPage(projectId, {
+        page: 2,
+        size: 20,
+        search: "guide",
+        types: ["FILE", "ISSUE"],
+        sources: ["GITHUB"],
+        repositories: ["owner/repo"],
+        format: "PDF",
+      });
+
+      expect(page.items).toHaveLength(1);
+      expect(page.items[0].title).toBe("guide.pdf");
+      expect(page.page.totalElements).toBe(25);
     });
+  });
+
+  describe("getArtifactFacets", () => {
+    const projectId = "proj-uuid";
 
-    it("fetches across multiple pages until all pages are retrieved", async () => {
+    it("queries facets endpoint and returns aggregated facet breakdown", async () => {
       server.use(
-        http.get(`/api/v1/projects/${projectId}/artifacts`, ({ request }) => {
+        http.get(`/api/v1/projects/${projectId}/artifacts/facets`, ({ request }) => {
           const url = new URL(request.url);
-          const page = url.searchParams.get("page");
-          if (page === "1") {
-            return HttpResponse.json({
-              items: [
-                {
-                  id: "art-1",
-                  title: "page1.md",
-                  artifactType: "FILE",
-                  sourceSystem: "GITHUB",
-                  sourceId: "src-1",
-                  sourceUrl: null,
-                  mime: "text/markdown",
-                  language: null,
-                  ingestedAt: "2026-01-01T00:00:00Z",
-                  lastChangedAt: null,
-                  contentHash: null,
-                  ingestionRunId: null,
-                },
-              ],
-              page: {
-                totalPages: 2,
-              },
-            });
-          }
+          expect(url.searchParams.get("search")).toBe("guide");
           return HttpResponse.json({
-            items: [
-              {
-                id: "art-2",
-                title: "page2.md",
-                artifactType: "FILE",
-                sourceSystem: "GITHUB",
-                sourceId: "src-2",
-                sourceUrl: null,
-                mime: "text/markdown",
-                language: null,
-                ingestedAt: "2026-01-01T00:00:00Z",
-                lastChangedAt: null,
-                contentHash: null,
-                ingestionRunId: null,
-              },
-            ],
-            page: {
-              totalPages: 2,
-            },
+            types: [{ value: "FILE", count: 10 }],
+            sources: [{ value: "GITHUB", count: 10 }],
+            formats: [{ value: "PDF", count: 3 }],
+            repositories: [{ value: "owner/repo", count: 7 }],
           });
         }),
       );
 
-      const artifacts = await knowledgeService.getUnifiedArtifacts(projectId);
-      expect(artifacts).toHaveLength(2);
-      expect(artifacts[0].title).toBe("page1.md");
-      expect(artifacts[1].title).toBe("page2.md");
+      const facets = await knowledgeService.getArtifactFacets(projectId, {
+        search: "guide",
+      });
+
+      expect(facets.types).toEqual([{ value: "FILE", count: 10 }]);
+      expect(facets.formats).toEqual([{ value: "PDF", count: 3 }]);
+    });
+  });
+
+  describe("list order and filter parity", () => {
+    const projectId = "proj-uuid";
+    const emptyPage = {
+      items: [],
+      page: {
+        number: 0,
+        size: 20,
+        totalElements: 0,
+        totalPages: 0,
+        hasNext: false,
+        hasPrevious: false,
+      },
+    };
+    const emptyFacets = { types: [], sources: [], formats: [], repositories: [] };
+
+    it("sends the sort order with the list request", async () => {
+      let seen: URLSearchParams | null = null;
+      server.use(
+        http.get(`/api/v1/projects/${projectId}/artifacts`, ({ request }) => {
+          seen = new URL(request.url).searchParams;
+          return HttpResponse.json(emptyPage);
+        }),
+      );
+
+      await knowledgeService.getArtifactPage(projectId, { page: 0, size: 20, sort: "TITLE_ASC" });
+
+      expect(seen!.get("sort")).toBe("TITLE_ASC");
     });
 
-    it("propagates ApiError when the request fails with 500", async () => {
+    it("leaves sort out when none is given, so the default request is unchanged", async () => {
+      let seen: URLSearchParams | null = null;
       server.use(
-        http.get(`/api/v1/projects/${projectId}/artifacts`, () =>
-          HttpResponse.json({ message: "Internal server error" }, { status: 500 }),
-        ),
+        http.get(`/api/v1/projects/${projectId}/artifacts`, ({ request }) => {
+          seen = new URL(request.url).searchParams;
+          return HttpResponse.json(emptyPage);
+        }),
       );
 
-      await expect(knowledgeService.getUnifiedArtifacts(projectId)).rejects.toMatchObject({
-        name: "ApiError",
-        status: 500,
+      await knowledgeService.getArtifactPage(projectId, { page: 1, size: 20 });
+
+      expect(seen!.has("sort")).toBe(false);
+    });
+
+    it("never sends page, size or sort to the facets endpoint", async () => {
+      let seen: URLSearchParams | null = null;
+      server.use(
+        http.get(`/api/v1/projects/${projectId}/artifacts/facets`, ({ request }) => {
+          seen = new URL(request.url).searchParams;
+          return HttpResponse.json(emptyFacets);
+        }),
+      );
+
+      await knowledgeService.getArtifactFacets(projectId, {
+        page: 3,
+        size: 50,
+        sort: "CHANGED_DESC",
+        search: "guide",
+        sources: ["GITHUB"],
       });
+
+      expect(seen!.has("page")).toBe(false);
+      expect(seen!.has("size")).toBe(false);
+      expect(seen!.has("sort")).toBe(false);
+      expect(seen!.get("search")).toBe("guide");
+      expect(seen!.getAll("sources")).toEqual(["GITHUB"]);
     });
+
+    it("sends the date range to the list and the facets alike, unlike sort", async () => {
+      let listParams: URLSearchParams | null = null;
+      let facetParams: URLSearchParams | null = null;
+      server.use(
+        http.get(`/api/v1/projects/${projectId}/artifacts`, ({ request }) => {
+          listParams = new URL(request.url).searchParams;
+          return HttpResponse.json(emptyPage);
+        }),
+        http.get(`/api/v1/projects/${projectId}/artifacts/facets`, ({ request }) => {
+          facetParams = new URL(request.url).searchParams;
+          return HttpResponse.json(emptyFacets);
+        }),
+      );
+      const params = {
+        from: "2026-09-01",
+        to: "2026-09-24",
+        sort: "TITLE_ASC" as const,
+      };
+
+      await knowledgeService.getArtifactPage(projectId, params);
+      await knowledgeService.getArtifactFacets(projectId, params);
+
+      for (const seen of [listParams!, facetParams!]) {
+        expect(seen.get("from")).toBe("2026-09-01");
+        expect(seen.get("to")).toBe("2026-09-24");
+      }
+      expect(listParams!.get("sort")).toBe("TITLE_ASC");
+      expect(facetParams!.has("sort")).toBe(false);
+    });
+
+    it("repeats languages on the list and the facets, spelled as given", async () => {
+      const seen: URLSearchParams[] = [];
+      server.use(
+        http.get(`/api/v1/projects/${projectId}/artifacts`, ({ request }) => {
+          seen.push(new URL(request.url).searchParams);
+          return HttpResponse.json(emptyPage);
+        }),
+        http.get(`/api/v1/projects/${projectId}/artifacts/facets`, ({ request }) => {
+          seen.push(new URL(request.url).searchParams);
+          return HttpResponse.json({ ...emptyFacets, languages: [] });
+        }),
+      );
+      const params = { languages: ["Kotlin", "C#"] };
+
+      await knowledgeService.getArtifactPage(projectId, params);
+      const facets = await knowledgeService.getArtifactFacets(projectId, params);
+
+      expect(seen).toHaveLength(2);
+      for (const query of seen) expect(query.getAll("languages")).toEqual(["Kotlin", "C#"]);
+      expect(facets.languages).toEqual([]);
+    });
+  });
+
+  describe("getArtifactById", () => {
+    const projectId = "proj-uuid";
+    const artifactId = "art-uuid";
+
+    it("fetches single artifact by id", async () => {
+      server.use(
+        http.get(`/api/v1/projects/${projectId}/artifacts/${artifactId}`, () => {
+          return HttpResponse.json({
+            id: artifactId,
+            title: "detail.md",
+            artifactType: "FILE",
+            sourceSystem: "GITHUB",
+            sourceId: "src-detail",
+            sourceUrl: null,
+            mime: "text/markdown",
+            language: null,
+            ingestedAt: "2026-01-01T00:00:00Z",
+            lastChangedAt: null,
+            contentHash: null,
+            ingestionRunId: null,
+          });
+        }),
+      );
+
+      const artifact = await knowledgeService.getArtifactById(projectId, artifactId);
+      expect(artifact.id).toBe(artifactId);
+      expect(artifact.title).toBe("detail.md");
+    });
+  });
+});
+
+describe("knowledgeService.getArtifactAiStatus", () => {
+  it("sends every visible id as a repeated ids param in one request", async () => {
+    const seen: string[][] = [];
+    server.use(
+      http.get("/api/v1/projects/:projectId/artifacts/ai-status", ({ request }) => {
+        seen.push(new URL(request.url).searchParams.getAll("ids"));
+        return HttpResponse.json({
+          aiAvailable: true,
+          items: [{ artifactId: "a1", status: "INDEXED", updatedAt: null, chunkCount: 4 }],
+        });
+      }),
+    );
+
+    const result = await knowledgeService.getArtifactAiStatus("p1", ["a1", "a2"]);
+
+    expect(seen).toEqual([["a1", "a2"]]);
+    expect(result).toEqual({
+      aiAvailable: true,
+      items: [{ artifactId: "a1", status: "INDEXED", updatedAt: null, chunkCount: 4 }],
+    });
+  });
+
+  it("answers an empty page locally, without a request", async () => {
+    let calls = 0;
+    server.use(
+      http.get("/api/v1/projects/:projectId/artifacts/ai-status", () => {
+        calls += 1;
+        return HttpResponse.json({ aiAvailable: true, items: [] });
+      }),
+    );
+
+    await expect(knowledgeService.getArtifactAiStatus("p1", [])).resolves.toEqual({
+      aiAvailable: true,
+      items: [],
+    });
+    expect(calls).toBe(0);
+  });
+
+  it("reads a response without aiAvailable as unavailable, so nothing is guessed", async () => {
+    server.use(
+      http.get("/api/v1/projects/:projectId/artifacts/ai-status", () =>
+        HttpResponse.json({
+          items: [{ artifactId: "a1", status: "UNKNOWN", updatedAt: null, chunkCount: null }],
+        }),
+      ),
+    );
+
+    const result = await knowledgeService.getArtifactAiStatus("p1", ["a1"]);
+
+    expect(result.aiAvailable).toBe(false);
+  });
+
+  it("rejects when the request fails", async () => {
+    server.use(
+      http.get("/api/v1/projects/:projectId/artifacts/ai-status", () =>
+        HttpResponse.json({ message: "Too many ids" }, { status: 400 }),
+      ),
+    );
+
+    await expect(knowledgeService.getArtifactAiStatus("p1", ["a1"])).rejects.toThrow();
   });
 });
diff --git a/tests/unit/setup/msw-handlers.ts b/tests/unit/setup/msw-handlers.ts
index c9e1bcad..ff95a7f4 100644
--- a/tests/unit/setup/msw-handlers.ts
+++ b/tests/unit/setup/msw-handlers.ts
@@ -119,6 +119,11 @@ export const handlers = [
   http.get("/api/v1/github/pat", () => HttpResponse.json([])),
   http.get("/api/v1/atlassian/credentials", () => HttpResponse.json([])),
 
+  // AI status for the visible page: the AI answered and knows none of them. Tests about the
+  // chip override this.
+  http.get("/api/v1/projects/:projectId/artifacts/ai-status", () =>
+    HttpResponse.json({ aiAvailable: true, items: [] }),
+  ),
   http.get("/api/v1/projects/:projectId/artifacts", () =>
     HttpResponse.json({
       items: [],
diff --git a/vite.config.ts b/vite.config.ts
index 33c8d879..89743c98 100644
--- a/vite.config.ts
+++ b/vite.config.ts
@@ -2,7 +2,7 @@ import http from "node:http";
 import { fileURLToPath } from "node:url";
 import { keycloakify } from "keycloakify/vite-plugin";
 /// <reference types="vitest" />
-import { defineConfig } from "vitest/config";
+import { defineConfig, configDefaults } from "vitest/config";
 import react from "@vitejs/plugin-react";
 import tailwindcss from "@tailwindcss/vite";
 
@@ -39,6 +39,7 @@ export default defineConfig({
     environment: "jsdom",
     globals: true,
     setupFiles: "./tests/unit/setup/vitest.setup.ts",
+    exclude: [...configDefaults.exclude, "**/.worktrees/**"],
     // An axe scan of a full page takes seconds, and the a11y suite runs many of them in
     // parallel. The default 5s bounds machine load rather than the code under test, so a
     // busy runner fails whichever file happens to be scheduled last.