diff --git a/__tests__/components/ui/search/global-search.test.tsx b/__tests__/components/ui/search/global-search.test.tsx
new file mode 100644
index 00000000..82720819
--- /dev/null
+++ b/__tests__/components/ui/search/global-search.test.tsx
@@ -0,0 +1,169 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { render, screen, fireEvent } from "@testing-library/react";
+import userEvent from "@testing-library/user-event";
+import { useRouter } from "next/navigation";
+import { GlobalSearch } from "@/components/ui/search/global-search";
+import { useSearch, type SearchState } from "@/lib/api/search";
+import { TestProviders } from "@/test-utils/providers";
+import { Some, None } from "@/types/option";
+import { ItemStatus } from "@/types/general";
+import { SearchHitType, type SearchHit } from "@/types/search";
+
+vi.mock("@/lib/api/search", async (importOriginal) => {
+  const actual = await importOriginal<typeof import("@/lib/api/search")>();
+  return { ...actual, useSearch: vi.fn() };
+});
+
+const goalHit: SearchHit = {
+  type: SearchHitType.Goal,
+  id: "goal-1",
+  score: 0.6,
+  title: "Weekly planning habit",
+  snippet: Some("Build a <mark>weekly</mark> ritual"),
+  created_at: "2026-08-14T09:12:00Z",
+  updated_at: "2026-09-02T16:40:00Z",
+  organization_id: "org-1",
+  coaching_relationship_id: Some("rel-1"),
+  status: ItemStatus.InProgress,
+  created_in_session_id: Some("sess-1"),
+};
+
+const actionHit: SearchHit = {
+  type: SearchHitType.Action,
+  id: "action-1",
+  score: 0.3,
+  title: "Draft the weekly plan template",
+  snippet: None,
+  created_at: "2026-09-01T10:00:00Z",
+  updated_at: "2026-09-10T11:30:00Z",
+  organization_id: "org-1",
+  coaching_relationship_id: Some("rel-1"),
+  coaching_session_id: Some("sess-2"),
+  goal_id: Some("goal-1"),
+  status: ItemStatus.NotStarted,
+  due_by: None,
+  session_date: Some("2026-09-01T09:00:00"),
+  session_title: Some("Weekly sync"),
+};
+
+const loaded = (hits: SearchHit[], nextCursor = None as ReturnType<typeof Some<string>> | typeof None): SearchState => ({
+  kind: "loaded",
+  query: "weekly",
+  hits,
+  nextCursor,
+  isLoadingMore: false,
+});
+
+function mockSearch(state: SearchState, loadMore = vi.fn()) {
+  vi.mocked(useSearch).mockReturnValue({ state, loadMore });
+  return loadMore;
+}
+
+async function typeQuery(text: string) {
+  const input = screen.getByRole("combobox", { name: "Search" });
+  await userEvent.type(input, text);
+  return input;
+}
+
+describe("GlobalSearch", () => {
+  const push = vi.fn();
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    vi.mocked(useRouter).mockReturnValue({
+      push,
+      replace: vi.fn(),
+      back: vi.fn(),
+      forward: vi.fn(),
+      refresh: vi.fn(),
+      prefetch: vi.fn(),
+    });
+  });
+
+  it("shows nothing below the field until the query is searchable", async () => {
+    mockSearch({ kind: "idle" });
+    render(<GlobalSearch />, { wrapper: TestProviders });
+    await typeQuery("w");
+    expect(screen.queryByRole("status", { name: "Searching" })).not.toBeInTheDocument();
+  });
+
+  it("shows skeleton rows while a search is in flight", async () => {
+    mockSearch({ kind: "loading", query: "weekly" });
+    render(<GlobalSearch />, { wrapper: TestProviders });
+    await typeQuery("weekly");
+    expect(screen.getByRole("status", { name: "Searching" })).toBeInTheDocument();
+  });
+
+  it("renders hits with highlighted snippet text as marks, not HTML", async () => {
+    mockSearch(loaded([goalHit, actionHit]));
+    render(<GlobalSearch />, { wrapper: TestProviders });
+    await typeQuery("weekly");
+
+    expect(screen.getByText("Weekly planning habit")).toBeInTheDocument();
+    const mark = screen.getByText("weekly", { selector: "mark" });
+    expect(mark.tagName).toBe("MARK");
+    expect(screen.queryByText("<mark>")).not.toBeInTheDocument();
+    expect(screen.getByText("Not Started · Weekly sync")).toBeInTheDocument();
+  });
+
+  it("navigates to the hit's page on select and clears the field", async () => {
+    mockSearch(loaded([actionHit]));
+    render(<GlobalSearch />, { wrapper: TestProviders });
+    const input = await typeQuery("weekly");
+
+    await userEvent.click(screen.getByText("Draft the weekly plan template"));
+
+    expect(push).toHaveBeenCalledWith("/coaching-sessions/sess-2?panel=actions&highlight=action-1");
+    expect(input).toHaveValue("");
+  });
+
+  it("keeps the dropdown open while the pointer is pressed on a result", async () => {
+    mockSearch(loaded([actionHit]));
+    render(<GlobalSearch />, { wrapper: TestProviders });
+    const input = await typeQuery("weekly");
+    const row = screen.getByText("Draft the weekly plan template");
+
+    const mouseDown = fireEvent.mouseDown(row);
+    expect(mouseDown).toBe(false);
+    expect(input).toHaveFocus();
+    // Simulate the browser moving focus away without preventDefault.
+    fireEvent.blur(input, { relatedTarget: null });
+    expect(screen.queryByText("Draft the weekly plan template")).not.toBeInTheDocument();
+  });
+
+  it("shows an empty state naming the query", async () => {
+    mockSearch(loaded([]));
+    render(<GlobalSearch />, { wrapper: TestProviders });
+    await typeQuery("weekly");
+    expect(screen.getByText("No results for “weekly”")).toBeInTheDocument();
+  });
+
+  it("shows a friendly message for a rate-limited search", async () => {
+    mockSearch({ kind: "error", query: "weekly", error: { kind: "rate_limited" } });
+    render(<GlobalSearch />, { wrapper: TestProviders });
+    await typeQuery("weekly");
+    expect(screen.getByRole("alert")).toHaveTextContent("Too many searches at once");
+  });
+
+  it("offers to load more when a cursor is pending", async () => {
+    const loadMore = mockSearch(loaded([goalHit], Some("CUR")));
+    render(<GlobalSearch />, { wrapper: TestProviders });
+    await typeQuery("weekly");
+
+    await userEvent.click(screen.getByText("Show more results"));
+    expect(loadMore).toHaveBeenCalledTimes(1);
+  });
+
+  it("focuses the field on Cmd+K and clears on Escape", async () => {
+    mockSearch(loaded([goalHit]));
+    render(<GlobalSearch />, { wrapper: TestProviders });
+    const input = screen.getByRole("combobox", { name: "Search" });
+
+    fireEvent.keyDown(document.body, { key: "k", metaKey: true });
+    expect(input).toHaveFocus();
+
+    await userEvent.type(input, "weekly");
+    await userEvent.keyboard("{Escape}");
+    expect(input).toHaveValue("");
+  });
+});
diff --git a/__tests__/lib/api/search.test.tsx b/__tests__/lib/api/search.test.tsx
new file mode 100644
index 00000000..aabf59b6
--- /dev/null
+++ b/__tests__/lib/api/search.test.tsx
@@ -0,0 +1,229 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { act, renderHook } from "@testing-library/react";
+import { AxiosError, type AxiosRequestConfig } from "axios";
+import { EntityApi } from "@/lib/api/entity-api";
+import { EntityApiError } from "@/types/entity-api-error";
+import {
+  SearchApi,
+  buildSearchQuery,
+  toSearchError,
+  useSearch,
+} from "@/lib/api/search";
+import { SearchErrorCode, SearchableType } from "@/types/search";
+
+vi.mock("@/lib/api/entity-api", async (importOriginal) => {
+  const actual = await importOriginal<typeof import("@/lib/api/entity-api")>();
+  return { ...actual, EntityApi: { getFn: vi.fn() } };
+});
+
+vi.mock("@/site.config", () => ({
+  siteConfig: { env: { backendServiceURL: "http://localhost:3000" } },
+}));
+
+const goalHit = (id: string) => ({
+  type: "goal",
+  id,
+  score: 0.5,
+  title: `Goal ${id}`,
+  snippet: null,
+  created_at: "2026-01-01T00:00:00Z",
+  updated_at: "2026-01-01T00:00:00Z",
+  organization_id: "org-1",
+  coaching_relationship_id: "rel-1",
+  status: "InProgress",
+  created_in_session_id: null,
+});
+
+const httpError = (status: number, data?: unknown): EntityApiError =>
+  new EntityApiError(
+    "get",
+    "http://localhost:3000/search",
+    new AxiosError("failed", "ERR_BAD_REQUEST", undefined, undefined, {
+      status,
+      statusText: "",
+      headers: {},
+      config: {} as never,
+      data,
+    })
+  );
+
+describe("buildSearchQuery", () => {
+  it("serializes only defined params and joins types with commas", () => {
+    const qs = buildSearchQuery({
+      q: "plan",
+      types: [SearchableType.Goals, SearchableType.Actions],
+      limit: 10,
+      organization_id: undefined,
+    });
+    expect(qs.get("q")).toBe("plan");
+    expect(qs.get("types")).toBe("goals,actions");
+    expect(qs.get("limit")).toBe("10");
+    expect(qs.has("organization_id")).toBe(false);
+  });
+
+  it("truncates the query at the backend's limit", () => {
+    const qs = buildSearchQuery({ q: "x".repeat(300) });
+    expect(qs.get("q")).toHaveLength(256);
+  });
+});
+
+describe("toSearchError", () => {
+  it("maps structured 400 bodies to validation errors", () => {
+    expect(
+      toSearchError(httpError(400, { error: "malformed_cursor", message: "bad cursor" }))
+    ).toEqual({ kind: "validation", code: SearchErrorCode.MalformedCursor, message: "bad cursor" });
+  });
+
+  it("maps 429 and 503", () => {
+    expect(toSearchError(httpError(429))).toEqual({ kind: "rate_limited" });
+    expect(toSearchError(httpError(503))).toEqual({ kind: "unavailable" });
+  });
+
+  it("maps network failures", () => {
+    const error = new EntityApiError(
+      "get",
+      "http://localhost:3000/search",
+      new AxiosError("Network Error", "ERR_NETWORK")
+    );
+    expect(toSearchError(error)).toEqual({ kind: "network" });
+  });
+
+  it("falls back to unknown for anything else", () => {
+    expect(toSearchError(new Error("boom"))).toEqual({ kind: "unknown", message: "boom" });
+    expect(toSearchError(httpError(400, { error: "not_a_code" })).kind).toBe("unknown");
+  });
+});
+
+describe("SearchApi.search", () => {
+  beforeEach(() => vi.clearAllMocks());
+
+  it("calls the search endpoint with the encoded query and passes the abort signal", async () => {
+    vi.mocked(EntityApi.getFn).mockResolvedValue({ query: "weekly plan", limit: 25, hits: [], next_cursor: null });
+    const controller = new AbortController();
+
+    const result = await SearchApi.search({ q: "weekly plan" }, controller.signal);
+
+    expect(result.isOk()).toBe(true);
+    const [url, config] = vi.mocked(EntityApi.getFn).mock.calls[0] as [string, AxiosRequestConfig];
+    expect(url).toBe("http://localhost:3000/search?q=weekly+plan");
+    expect(config.signal).toBe(controller.signal);
+  });
+});
+
+describe("useSearch", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    vi.useFakeTimers();
+  });
+  afterEach(() => vi.useRealTimers());
+
+  it("stays idle without a request for queries under two characters", () => {
+    const { result } = renderHook(() => useSearch("a", {}, 0));
+    act(() => vi.advanceTimersByTime(10));
+    expect(result.current.state).toEqual({ kind: "idle" });
+    expect(EntityApi.getFn).not.toHaveBeenCalled();
+  });
+
+  it("debounces: only the last query within the window is sent", async () => {
+    vi.mocked(EntityApi.getFn).mockResolvedValue({ query: "plan", limit: 25, hits: [goalHit("g1")], next_cursor: null });
+    const { result, rerender } = renderHook(({ q }) => useSearch(q, {}, 250), {
+      initialProps: { q: "pl" },
+    });
+    expect(result.current.state).toEqual({ kind: "loading", query: "pl" });
+
+    rerender({ q: "pla" });
+    act(() => vi.advanceTimersByTime(100));
+    rerender({ q: "plan" });
+    act(() => vi.advanceTimersByTime(250));
+
+    expect(EntityApi.getFn).toHaveBeenCalledTimes(1);
+    expect(vi.mocked(EntityApi.getFn).mock.calls[0][0]).toContain("q=plan");
+
+    await act(async () => {
+      await vi.runAllTimersAsync();
+    });
+    expect(result.current.state.kind).toBe("loaded");
+    if (result.current.state.kind === "loaded") {
+      expect(result.current.state.hits.map((h) => h.id)).toEqual(["g1"]);
+    }
+  });
+
+  it("aborts the in-flight request when the query changes", async () => {
+    vi.mocked(EntityApi.getFn).mockImplementation(
+      (_url: string, config?: AxiosRequestConfig) =>
+        new Promise((_resolve, reject) => {
+          config?.signal?.addEventListener("abort", () => reject(new Error("aborted")));
+        })
+    );
+    const { rerender } = renderHook(({ q }) => useSearch(q, {}, 0), {
+      initialProps: { q: "first" },
+    });
+    act(() => vi.advanceTimersByTime(1));
+    const firstSignal = (vi.mocked(EntityApi.getFn).mock.calls[0][1] as AxiosRequestConfig).signal;
+
+    rerender({ q: "second" });
+    act(() => vi.advanceTimersByTime(1));
+
+    expect(firstSignal?.aborted).toBe(true);
+    expect(EntityApi.getFn).toHaveBeenCalledTimes(2);
+  });
+
+  it("surfaces typed errors", async () => {
+    vi.mocked(EntityApi.getFn).mockRejectedValue(httpError(429));
+    const { result } = renderHook(() => useSearch("plan", {}, 0));
+
+    await act(async () => {
+      await vi.runAllTimersAsync();
+    });
+
+    expect(result.current.state).toEqual({
+      kind: "error",
+      query: "plan",
+      error: { kind: "rate_limited" },
+    });
+  });
+
+  it("loadMore appends the next page using the cursor", async () => {
+    vi.mocked(EntityApi.getFn)
+      .mockResolvedValueOnce({ query: "plan", limit: 1, hits: [goalHit("g1")], next_cursor: "CUR" })
+      .mockResolvedValueOnce({ query: "plan", limit: 1, hits: [goalHit("g2")], next_cursor: null });
+    const { result } = renderHook(() => useSearch("plan", {}, 0));
+
+    await act(async () => {
+      await vi.runAllTimersAsync();
+    });
+    expect(result.current.state.kind).toBe("loaded");
+
+    act(() => result.current.loadMore());
+    expect(result.current.state).toMatchObject({ kind: "loaded", isLoadingMore: true });
+    expect(vi.mocked(EntityApi.getFn).mock.calls[1][0]).toContain("cursor=CUR");
+
+    await act(async () => {
+      await vi.runAllTimersAsync();
+    });
+    expect(result.current.state).toMatchObject({ kind: "loaded", isLoadingMore: false });
+    if (result.current.state.kind === "loaded") {
+      expect(result.current.state.hits.map((h) => h.id)).toEqual(["g1", "g2"]);
+      expect(result.current.state.nextCursor.none).toBe(true);
+    }
+  });
+
+  it("a filter change resets to page one", async () => {
+    vi.mocked(EntityApi.getFn).mockResolvedValue({ query: "plan", limit: 25, hits: [], next_cursor: null });
+    const { result, rerender } = renderHook(
+      ({ types }) => useSearch("plan", { types }, 0),
+      { initialProps: { types: [SearchableType.Goals] } }
+    );
+    await act(async () => {
+      await vi.runAllTimersAsync();
+    });
+    expect(result.current.state.kind).toBe("loaded");
+
+    rerender({ types: [SearchableType.Actions] });
+    expect(result.current.state).toEqual({ kind: "loading", query: "plan" });
+    await act(async () => {
+      await vi.runAllTimersAsync();
+    });
+    expect(vi.mocked(EntityApi.getFn).mock.calls[1][0]).toContain("types=actions");
+  });
+});
diff --git a/__tests__/lib/utils/search-hit-href.test.ts b/__tests__/lib/utils/search-hit-href.test.ts
new file mode 100644
index 00000000..26209cad
--- /dev/null
+++ b/__tests__/lib/utils/search-hit-href.test.ts
@@ -0,0 +1,81 @@
+import { describe, it, expect } from "vitest";
+import { searchHitHref } from "@/lib/utils/search-hit-href";
+import { Some, None } from "@/types/option";
+import { ItemStatus } from "@/types/general";
+import { TopicStatus } from "@/types/coaching-session-topic";
+import { SearchHitType, type SearchHit } from "@/types/search";
+
+const base = {
+  id: "hit-1",
+  score: 1,
+  title: "t",
+  snippet: None,
+  created_at: "2026-01-01T00:00:00Z",
+  updated_at: "2026-01-01T00:00:00Z",
+  organization_id: "org-1",
+  coaching_relationship_id: Some("rel-1"),
+};
+
+describe("searchHitHref", () => {
+  it("links sessions to their page", () => {
+    const hit: SearchHit = {
+      ...base,
+      type: SearchHitType.CoachingSession,
+      date: "2026-01-01T00:00:00",
+    };
+    expect(searchHitHref(hit)).toEqual(Some("/coaching-sessions/hit-1"));
+  });
+
+  it("links goals to the goals panel of their creating session, else the dashboard", () => {
+    const inSession: SearchHit = {
+      ...base,
+      type: SearchHitType.Goal,
+      status: ItemStatus.InProgress,
+      created_in_session_id: Some("sess-1"),
+    };
+    expect(searchHitHref(inSession)).toEqual(Some("/coaching-sessions/sess-1?panel=goals"));
+    expect(searchHitHref({ ...inSession, created_in_session_id: None })).toEqual(
+      Some("/dashboard")
+    );
+  });
+
+  it("links actions to the actions panel with a highlight", () => {
+    const hit: SearchHit = {
+      ...base,
+      type: SearchHitType.Action,
+      coaching_session_id: Some("sess-1"),
+      goal_id: None,
+      status: ItemStatus.NotStarted,
+      due_by: None,
+      session_date: None,
+      session_title: None,
+    };
+    expect(searchHitHref(hit)).toEqual(
+      Some("/coaching-sessions/sess-1?panel=actions&highlight=hit-1")
+    );
+    expect(searchHitHref({ ...hit, coaching_session_id: None })).toEqual(Some("/actions"));
+  });
+
+  it("returns None for agreements and topics without a session", () => {
+    const agreement: SearchHit = {
+      ...base,
+      type: SearchHitType.Agreement,
+      coaching_session_id: None,
+      session_date: None,
+      session_title: None,
+    };
+    expect(searchHitHref(agreement).none).toBe(true);
+    expect(searchHitHref({ ...agreement, coaching_session_id: Some("s") })).toEqual(
+      Some("/coaching-sessions/s?panel=agreements")
+    );
+
+    const topic: SearchHit = {
+      ...base,
+      type: SearchHitType.Topic,
+      coaching_session_id: Some("s"),
+      status: TopicStatus.Open,
+      priority: None,
+    };
+    expect(searchHitHref(topic)).toEqual(Some("/coaching-sessions/s"));
+  });
+});
diff --git a/__tests__/types/search.test.ts b/__tests__/types/search.test.ts
new file mode 100644
index 00000000..f153988d
--- /dev/null
+++ b/__tests__/types/search.test.ts
@@ -0,0 +1,162 @@
+import { describe, it, expect } from "vitest";
+import {
+  SearchHitType,
+  isSearchableQuery,
+  parseSearchHit,
+  parseSearchResponse,
+  splitSnippet,
+} from "@/types/search";
+import { ItemStatus } from "@/types/general";
+import { TopicPriority, TopicStatus } from "@/types/coaching-session-topic";
+
+const base = {
+  id: "hit-1",
+  score: 0.5,
+  title: "Weekly planning habit",
+  snippet: "Build a <mark>weekly</mark> ritual",
+  created_at: "2026-08-14T09:12:00Z",
+  updated_at: "2026-09-02T16:40:00Z",
+  organization_id: "org-1",
+  coaching_relationship_id: "rel-1",
+};
+
+describe("parseSearchHit", () => {
+  it("parses a coaching session hit", () => {
+    const hit = parseSearchHit({
+      ...base,
+      type: "coaching_session",
+      date: "2026-09-01T09:00:00",
+    });
+    expect(hit.some && hit.val.type === SearchHitType.CoachingSession).toBe(true);
+    if (hit.some && hit.val.type === SearchHitType.CoachingSession) {
+      expect(hit.val.date).toBe("2026-09-01T09:00:00");
+      expect(hit.val.snippet).toEqual({ some: true, none: false, val: base.snippet });
+    }
+  });
+
+  it("wraps nullable goal fields in Option", () => {
+    const hit = parseSearchHit({
+      ...base,
+      type: "goal",
+      status: "InProgress",
+      created_in_session_id: null,
+      snippet: null,
+    });
+    expect(hit.some).toBe(true);
+    if (hit.some && hit.val.type === SearchHitType.Goal) {
+      expect(hit.val.status).toBe(ItemStatus.InProgress);
+      expect(hit.val.created_in_session_id.none).toBe(true);
+      expect(hit.val.snippet.none).toBe(true);
+    }
+  });
+
+  it("parses action extras", () => {
+    const hit = parseSearchHit({
+      ...base,
+      type: "action",
+      coaching_session_id: "sess-1",
+      goal_id: "goal-1",
+      status: "NotStarted",
+      due_by: null,
+      session_date: "2026-09-01T09:00:00",
+      session_title: "Weekly sync",
+    });
+    if (!hit.some || hit.val.type !== SearchHitType.Action) throw new Error("expected action");
+    expect(hit.val.coaching_session_id).toEqual({ some: true, none: false, val: "sess-1" });
+    expect(hit.val.session_title).toEqual({ some: true, none: false, val: "Weekly sync" });
+    expect(hit.val.goal_id).toEqual({ some: true, none: false, val: "goal-1" });
+    expect(hit.val.due_by.none).toBe(true);
+  });
+
+  it("parses topic status and priority", () => {
+    const hit = parseSearchHit({
+      ...base,
+      type: "topic",
+      coaching_session_id: "sess-1",
+      status: "Discussed",
+      priority: "High",
+    });
+    if (!hit.some || hit.val.type !== SearchHitType.Topic) throw new Error("expected topic");
+    expect(hit.val.status).toBe(TopicStatus.Discussed);
+    expect(hit.val.priority).toEqual({ some: true, none: false, val: TopicPriority.High });
+  });
+
+  it("returns None for hit types this client does not know", () => {
+    expect(parseSearchHit({ ...base, type: "note" }).none).toBe(true);
+    expect(parseSearchHit({ ...base, type: "transcript" }).none).toBe(true);
+  });
+
+  it("throws on a hit missing required fields", () => {
+    expect(() => parseSearchHit({ type: "goal", id: "x" })).toThrow();
+    expect(() => parseSearchHit("nope")).toThrow();
+  });
+});
+
+describe("parseSearchResponse", () => {
+  it("drops unknown types and keeps the cursor", () => {
+    const response = parseSearchResponse({
+      query: "weekly",
+      limit: 25,
+      hits: [
+        { ...base, type: "goal", status: "InProgress", created_in_session_id: null },
+        { ...base, id: "u-1", type: "user" },
+        { ...base, id: "ag-1", type: "agreement", coaching_session_id: "sess-1" },
+      ],
+      next_cursor: "AT2c",
+    });
+    expect(response.hits.map((h) => h.type)).toEqual([
+      SearchHitType.Goal,
+      SearchHitType.Agreement,
+    ]);
+    expect(response.next_cursor).toEqual({ some: true, none: false, val: "AT2c" });
+  });
+
+  it("maps a null cursor to None", () => {
+    const response = parseSearchResponse({ query: "x", limit: 25, hits: [], next_cursor: null });
+    expect(response.next_cursor.none).toBe(true);
+  });
+
+  it("throws when hits is not an array", () => {
+    expect(() => parseSearchResponse({ query: "x" })).toThrow();
+  });
+});
+
+describe("splitSnippet", () => {
+  it("splits marks into highlighted segments", () => {
+    expect(splitSnippet("Build a <mark>weekly</mark> <mark>plan</mark> ritual")).toEqual([
+      { text: "Build a ", highlighted: false },
+      { text: "weekly", highlighted: true },
+      { text: " ", highlighted: false },
+      { text: "plan", highlighted: true },
+      { text: " ritual", highlighted: false },
+    ]);
+  });
+
+  it("returns one plain segment when there are no marks", () => {
+    expect(splitSnippet("plain text")).toEqual([{ text: "plain text", highlighted: false }]);
+  });
+
+  it("unescapes HTML entities in both plain and highlighted segments", () => {
+    expect(splitSnippet("<mark>Plan</mark> Q3 &amp; Q4")).toEqual([
+      { text: "Plan", highlighted: true },
+      { text: " Q3 & Q4", highlighted: false },
+    ]);
+    expect(splitSnippet("if a &lt; b then <mark>retry</mark>")).toEqual([
+      { text: "if a < b then ", highlighted: false },
+      { text: "retry", highlighted: true },
+    ]);
+    expect(splitSnippet("<mark>a &gt; b</mark>")).toEqual([{ text: "a > b", highlighted: true }]);
+  });
+
+  it("unescapes &amp; last so a doubly escaped entity stays literal", () => {
+    expect(splitSnippet("&amp;lt;")).toEqual([{ text: "&lt;", highlighted: false }]);
+  });
+});
+
+describe("isSearchableQuery", () => {
+  it("requires two characters after trimming", () => {
+    expect(isSearchableQuery(" a ")).toBe(false);
+    expect(isSearchableQuery("ab")).toBe(true);
+    expect(isSearchableQuery("  ab  ")).toBe(true);
+  });
+});
diff --git a/src/components/ui/command.tsx b/src/components/ui/command.tsx
index 165ec9cb..484a9cce 100644
--- a/src/components/ui/command.tsx
+++ b/src/components/ui/command.tsx
@@ -117,7 +117,7 @@ const CommandItem = React.forwardRef<
   <CommandPrimitive.Item
     ref={ref}
     className={cn(
-      "relative flex cursor-default select-none items-center rounded-sm px-2 py-1.5 text-sm outline-none aria-selected:bg-accent aria-selected:text-accent-foreground data-[disabled]:pointer-events-none data-[disabled]:opacity-50",
+      "relative flex cursor-default select-none items-center rounded-sm px-2 py-1.5 text-sm outline-none aria-selected:bg-accent aria-selected:text-accent-foreground data-[disabled=true]:pointer-events-none data-[disabled=true]:opacity-50",
       className
     )}
     {...props}
diff --git a/src/components/ui/search/global-search.tsx b/src/components/ui/search/global-search.tsx
new file mode 100644
index 00000000..663fab1d
--- /dev/null
+++ b/src/components/ui/search/global-search.tsx
@@ -0,0 +1,365 @@
+"use client";
+
+import { useCallback, useEffect, useRef, useState, type FocusEvent } from "react";
+import { useRouter } from "next/navigation";
+import { Command as CommandPrimitive } from "cmdk";
+import {
+  Calendar,
+  CheckSquare,
+  Handshake,
+  MessageSquare,
+  Search,
+  Target,
+  X,
+} from "lucide-react";
+import { DateTime } from "ts-luxon";
+
+import { cn } from "@/components/lib/utils";
+import { Button } from "@/components/ui/button";
+import { CommandItem, CommandList } from "@/components/ui/command";
+import { Skeleton } from "@/components/ui/skeleton";
+import { Spinner } from "@/components/ui/spinner";
+import { SearchSnippet } from "@/components/ui/search/search-snippet";
+import { useSearch, type SearchState } from "@/lib/api/search";
+import { useCoachingRelationshipStateStore } from "@/lib/providers/coaching-relationship-state-store-provider";
+import { searchHitHref } from "@/lib/utils/search-hit-href";
+import { actionStatusToString } from "@/types/general";
+import { type Option, Some, None } from "@/types/option";
+import {
+  SearchHitType,
+  isSearchableQuery,
+  type SearchError,
+  type SearchHit,
+} from "@/types/search";
+
+const TYPE_LABELS: Record<SearchHitType, string> = {
+  [SearchHitType.CoachingSession]: "Session",
+  [SearchHitType.Goal]: "Goal",
+  [SearchHitType.Action]: "Action",
+  [SearchHitType.Agreement]: "Agreement",
+  [SearchHitType.Topic]: "Topic",
+};
+
+function HitIcon({ type, className }: { type: SearchHitType; className?: string }) {
+  switch (type) {
+    case SearchHitType.CoachingSession:
+      return <Calendar className={className} aria-hidden />;
+    case SearchHitType.Goal:
+      return <Target className={className} aria-hidden />;
+    case SearchHitType.Action:
+      return <CheckSquare className={className} aria-hidden />;
+    case SearchHitType.Agreement:
+      return <Handshake className={className} aria-hidden />;
+    case SearchHitType.Topic:
+      return <MessageSquare className={className} aria-hidden />;
+    default: {
+      const _exhaustive: never = type;
+      throw new Error(`Unhandled search hit type: ${_exhaustive}`);
+    }
+  }
+}
+
+// Session dates arrive as naive ISO strings; read them as UTC so the calendar day is stable.
+const formatDate = (iso: string): string =>
+  DateTime.fromISO(iso, { zone: "utc" }).toFormat("MMM d, yyyy");
+
+/** The secondary line under a hit's title, or None when there is nothing worth showing. */
+function hitMeta(hit: SearchHit): Option<string> {
+  const parts: string[] = [];
+  switch (hit.type) {
+    case SearchHitType.CoachingSession:
+      parts.push(formatDate(hit.date));
+      break;
+    case SearchHitType.Goal:
+      parts.push(actionStatusToString(hit.status));
+      break;
+    case SearchHitType.Action:
+      parts.push(actionStatusToString(hit.status));
+      if (hit.session_title.some) parts.push(hit.session_title.val);
+      break;
+    case SearchHitType.Agreement:
+      if (hit.session_title.some) parts.push(hit.session_title.val);
+      if (hit.session_date.some) parts.push(formatDate(hit.session_date.val));
+      break;
+    case SearchHitType.Topic:
+      parts.push(hit.status);
+      if (hit.priority.some) parts.push(`${hit.priority.val} priority`);
+      break;
+    default: {
+      const _exhaustive: never = hit;
+      throw new Error(`Unhandled search hit type: ${_exhaustive}`);
+    }
+  }
+  return parts.length > 0 ? Some(parts.join(" · ")) : None;
+}
+
+function errorMessage(error: SearchError): string {
+  switch (error.kind) {
+    case "validation":
+      return error.message;
+    case "rate_limited":
+      return "Too many searches at once. Pause a moment and try again.";
+    case "unavailable":
+      return "Search is temporarily unavailable.";
+    case "network":
+      return "Can't reach the server. Check your connection.";
+    case "unknown":
+      return "Something went wrong while searching.";
+    default: {
+      const _exhaustive: never = error;
+      throw new Error(`Unhandled search error: ${_exhaustive}`);
+    }
+  }
+}
+
+const isTypingTarget = (target: EventTarget | null): boolean =>
+  (target instanceof HTMLElement && target.isContentEditable) ||
+  target instanceof HTMLInputElement ||
+  target instanceof HTMLTextAreaElement ||
+  target instanceof HTMLSelectElement;
+
+interface GlobalSearchProps {
+  className?: string;
+}
+
+/**
+ * Header search field: debounced keyword search across sessions, goals,
+ * actions, agreements and topics, with results in a dropdown beneath the
+ * field. Cmd/Ctrl+K or "/" focuses it from anywhere outside a text input.
+ */
+export function GlobalSearch({ className }: GlobalSearchProps) {
+  const router = useRouter();
+  const setCurrentCoachingRelationshipId = useCoachingRelationshipStateStore(
+    (state) => state.setCurrentCoachingRelationshipId
+  );
+  const [query, setQuery] = useState("");
+  const [open, setOpen] = useState(false);
+  const inputRef = useRef<HTMLInputElement>(null);
+  const rootRef = useRef<HTMLDivElement>(null);
+  const { state, loadMore } = useSearch(query);
+
+  useEffect(() => {
+    const onKeyDown = (event: KeyboardEvent) => {
+      const isShortcut =
+        (event.key === "k" && (event.metaKey || event.ctrlKey)) || event.key === "/";
+      if (!isShortcut || isTypingTarget(event.target)) return;
+      event.preventDefault();
+      inputRef.current?.focus();
+    };
+    document.addEventListener("keydown", onKeyDown);
+    return () => document.removeEventListener("keydown", onKeyDown);
+  }, []);
+
+  const reset = useCallback(() => {
+    setQuery("");
+    setOpen(false);
+    inputRef.current?.blur();
+  }, []);
+
+  const handleBlur = useCallback((event: FocusEvent<HTMLDivElement>) => {
+    if (!rootRef.current?.contains(event.relatedTarget)) setOpen(false);
+  }, []);
+
+  const handleSelect = useCallback(
+    (hit: SearchHit) => {
+      const href = searchHitHref(hit);
+      if (href.none) return;
+      // The dashboard fallback for a goal only shows it under its own relationship.
+      if (hit.type === SearchHitType.Goal && hit.coaching_relationship_id.some) {
+        setCurrentCoachingRelationshipId(hit.coaching_relationship_id.val);
+      }
+      reset();
+      router.push(href.val);
+    },
+    [reset, router, setCurrentCoachingRelationshipId]
+  );
+
+  const showResults = open && isSearchableQuery(query);
+
+  return (
+    <div
+      ref={rootRef}
+      className={cn("relative w-full", className)}
+      onBlur={handleBlur}
+    >
+      <CommandPrimitive
+        shouldFilter={false}
+        loop
+        label="Search"
+        className="w-full"
+        onKeyDown={(event) => {
+          if (event.key === "Escape") {
+            event.preventDefault();
+            if (query) reset();
+            else inputRef.current?.blur();
+          }
+        }}
+      >
+        <div className="relative flex items-center">
+          <Search
+            className="pointer-events-none absolute left-2.5 h-4 w-4 text-muted-foreground/60"
+            aria-hidden
+          />
+          <CommandPrimitive.Input
+            ref={inputRef}
+            value={query}
+            onValueChange={(value) => {
+              setQuery(value);
+              setOpen(true);
+            }}
+            onFocus={() => setOpen(true)}
+            placeholder="Search sessions, notes, actions…"
+            className={cn(
+              "h-8 w-full rounded-md border border-input bg-background pl-8 text-sm",
+              "placeholder:text-muted-foreground focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2",
+              query ? "pr-8" : "pr-14"
+            )}
+          />
+          {query ? (
+            <Button
+              type="button"
+              variant="ghost"
+              size="icon"
+              aria-label="Clear search"
+              onClick={reset}
+              className="absolute right-0.5 h-7 w-7 rounded-full text-muted-foreground/60 hover:text-foreground"
+            >
+              <X className="h-3.5 w-3.5" />
+            </Button>
+          ) : (
+            <kbd className="pointer-events-none absolute right-1.5 hidden h-5 select-none items-center gap-1 rounded border bg-muted px-1.5 font-mono text-[10px] font-medium text-muted-foreground sm:flex">
+              ⌘K
+            </kbd>
+          )}
+        </div>
+
+        {showResults && (
+          <div
+            className="absolute left-0 right-0 top-full z-50 mt-2 overflow-hidden rounded-lg border bg-popover text-popover-foreground shadow-md"
+            // Keep focus in the input: otherwise mousedown blurs it and the
+            // dropdown unmounts before the click reaches the item.
+            onMouseDown={(event) => event.preventDefault()}
+          >
+            <SearchResults state={state} onSelect={handleSelect} onLoadMore={loadMore} />
+          </div>
+        )}
+      </CommandPrimitive>
+    </div>
+  );
+}
+
+interface SearchResultsProps {
+  state: SearchState;
+  onSelect: (hit: SearchHit) => void;
+  onLoadMore: () => void;
+}
+
+function SearchResults({ state, onSelect, onLoadMore }: SearchResultsProps) {
+  switch (state.kind) {
+    case "idle":
+      return null;
+    case "loading":
+      return <SearchResultsSkeleton />;
+    case "error":
+      return (
+        <p role="alert" className="px-3 py-4 text-sm text-destructive">
+          {errorMessage(state.error)}
+        </p>
+      );
+    case "loaded":
+      if (state.hits.length === 0) {
+        return (
+          <p className="px-3 py-6 text-center text-sm text-muted-foreground">
+            No results for “{state.query.trim()}”
+          </p>
+        );
+      }
+      return (
+        <CommandList className="max-h-[min(24rem,60vh)]">
+          <CommandPrimitive.Group className="p-1">
+            {state.hits.map((hit) => (
+              <SearchResultRow key={`${hit.type}:${hit.id}`} hit={hit} onSelect={onSelect} />
+            ))}
+          </CommandPrimitive.Group>
+          {state.nextCursor.some && (
+            <CommandItem
+              value="__load_more__"
+              onSelect={onLoadMore}
+              disabled={state.isLoadingMore}
+              className="mx-1 mb-1 justify-center text-xs text-muted-foreground"
+            >
+              {state.isLoadingMore ? (
+                <>
+                  <Spinner className="mr-2 h-3.5 w-3.5" />
+                  Loading more…
+                </>
+              ) : (
+                "Show more results"
+              )}
+            </CommandItem>
+          )}
+        </CommandList>
+      );
+    default: {
+      const _exhaustive: never = state;
+      throw new Error(`Unhandled search state: ${_exhaustive}`);
+    }
+  }
+}
+
+const SKELETON_ROW_COUNT = 3;
+
+/** Placeholder rows shaped like results so the dropdown height holds steady when hits land. */
+function SearchResultsSkeleton() {
+  return (
+    <div role="status" aria-label="Searching" className="p-1">
+      {Array.from({ length: SKELETON_ROW_COUNT }, (_, index) => (
+        <div key={index} className="flex items-start gap-3 px-2 py-2">
+          <Skeleton className="mt-0.5 h-4 w-4 rounded-sm" />
+          <div className="flex-1 space-y-1.5">
+            <Skeleton className="h-3.5 w-2/3" />
+            <Skeleton className="h-3 w-full" />
+            <Skeleton className="h-3 w-1/3" />
+          </div>
+        </div>
+      ))}
+    </div>
+  );
+}
+
+interface SearchResultRowProps {
+  hit: SearchHit;
+  onSelect: (hit: SearchHit) => void;
+}
+
+function SearchResultRow({ hit, onSelect }: SearchResultRowProps) {
+  const href = searchHitHref(hit);
+  const meta = hitMeta(hit);
+  return (
+    <CommandItem
+      value={`${hit.type}:${hit.id}`}
+      onSelect={() => onSelect(hit)}
+      disabled={href.none}
+      className="cursor-pointer items-start gap-3 px-2 py-2"
+    >
+      <HitIcon type={hit.type} className="mt-0.5 h-4 w-4 shrink-0 text-muted-foreground/60" />
+      <div className="min-w-0 flex-1">
+        <div className="flex items-baseline gap-2">
+          <span className="truncate text-[13px] font-medium text-foreground">{hit.title}</span>
+          <span className="shrink-0 text-xs text-muted-foreground">{TYPE_LABELS[hit.type]}</span>
+        </div>
+        {hit.snippet.some && (
+          <SearchSnippet
+            snippet={hit.snippet.val}
+            className="mt-0.5 line-clamp-2 text-xs text-muted-foreground"
+          />
+        )}
+        {meta.some && (
+          <div className="mt-0.5 truncate text-xs text-muted-foreground tabular-nums">
+            {meta.val}
+          </div>
+        )}
+      </div>
+    </CommandItem>
+  );
+}
diff --git a/src/components/ui/search/search-snippet.tsx b/src/components/ui/search/search-snippet.tsx
new file mode 100644
index 00000000..792b5b76
--- /dev/null
+++ b/src/components/ui/search/search-snippet.tsx
@@ -0,0 +1,26 @@
+import { splitSnippet } from "@/types/search";
+
+interface SearchSnippetProps {
+  snippet: string;
+  className?: string;
+}
+
+/** Renders a backend snippet's `<mark>` markers as text nodes, never as HTML. */
+export function SearchSnippet({ snippet, className }: SearchSnippetProps) {
+  return (
+    <span className={className}>
+      {splitSnippet(snippet).map((segment, index) =>
+        segment.highlighted ? (
+          <mark
+            key={index}
+            className="rounded-[3px] px-0.5 font-medium bg-yellow-200 text-black dark:bg-yellow-500/40 dark:text-foreground"
+          >
+            {segment.text}
+          </mark>
+        ) : (
+          <span key={index}>{segment.text}</span>
+        )
+      )}
+    </span>
+  );
+}
diff --git a/src/components/ui/site-header.tsx b/src/components/ui/site-header.tsx
index 3468ec3a..15ce2cdd 100644
--- a/src/components/ui/site-header.tsx
+++ b/src/components/ui/site-header.tsx
@@ -5,6 +5,7 @@ import { MainNav } from "@/components/ui/main-nav";
 import { ModeToggle } from "@/components/ui/mode-toggle";
 import { JoinSessionPopover } from "@/components/ui/join-session-popover";
 import { UserNav } from "@/components/ui/user-nav";
+import { GlobalSearch } from "@/components/ui/search/global-search";
 import { useCoachingRelationshipStateStore } from "@/lib/providers/coaching-relationship-state-store-provider";
 import { useShowSessionSwitcher } from "@/lib/hooks/use-show-session-switcher";
 
@@ -18,10 +19,11 @@ export function SiteHeader() {
     <header className="sticky top-0 z-50 w-full border-b border-border/40 bg-background/95 backdrop-blur supports-[backdrop-filter]:bg-background/60">
       <div className="flex h-14 pl-4 w-full max-w-screen-2xl items-center">
         <MainNav />
-        <div className="flex flex-1 items-center justify-end space-x-2">
+        <div className="flex flex-1 items-center justify-end gap-2 pr-4">
           {/* <div className="w-full flex-1 md:w-auto md:flex-none">
             <CommandMenu />
           </div> */}
+          <GlobalSearch className="max-w-md" />
           <nav className="flex items-center gap-1">
             {showSessionSwitcher && (
               <>
diff --git a/src/lib/api/search.ts b/src/lib/api/search.ts
new file mode 100644
index 00000000..36814079
--- /dev/null
+++ b/src/lib/api/search.ts
@@ -0,0 +1,233 @@
+"use client";
+
+// Search API — GET /search, keyword mode. Cursor pagination means results
+// accumulate across pages, so this module owns its own state machine
+// rather than going through SWR's single-key cache.
+
+import { useCallback, useEffect, useRef, useState } from "react";
+import axios from "axios";
+import { ResultAsync } from "neverthrow";
+import { siteConfig } from "@/site.config";
+import { EntityApi, EntityApiError } from "./entity-api";
+import {
+  SearchErrorCode,
+  isSearchableQuery,
+  parseSearchResponse,
+  SEARCH_MAX_QUERY_LENGTH,
+  type SearchError,
+  type SearchHit,
+  type SearchParams,
+  type SearchResponse,
+} from "@/types/search";
+import { type Option, Some, None } from "@/types/option";
+
+const SEARCH_BASEURL: string = `${siteConfig.env.backendServiceURL}/search`;
+
+/** Matches the backend's sizing guidance for its per-IP rate limit. */
+export const SEARCH_DEBOUNCE_MS = 250;
+
+/** Serializes params to the wire format; drops undefined fields. */
+export function buildSearchQuery(params: SearchParams): URLSearchParams {
+  const qs = new URLSearchParams();
+  qs.set("q", params.q.slice(0, SEARCH_MAX_QUERY_LENGTH));
+  if (params.types !== undefined && params.types.length > 0) {
+    qs.set("types", params.types.join(","));
+  }
+  const scalar: Array<[string, string | number | undefined]> = [
+    ["organization_id", params.organization_id],
+    ["coaching_relationship_id", params.coaching_relationship_id],
+    ["user_id", params.user_id],
+    ["coaching_session_id", params.coaching_session_id],
+    ["goal_id", params.goal_id],
+    ["goal_filter", params.goal_filter],
+    ["status", params.status],
+    ["topic_status", params.topic_status],
+    ["created_from", params.created_from],
+    ["created_to", params.created_to],
+    ["updated_from", params.updated_from],
+    ["updated_to", params.updated_to],
+    ["tz", params.tz],
+    ["limit", params.limit],
+    ["cursor", params.cursor],
+    ["mode", params.mode],
+  ];
+  for (const [key, value] of scalar) {
+    if (value !== undefined) qs.set(key, String(value));
+  }
+  return qs;
+}
+
+const ERROR_CODES = Object.values(SearchErrorCode);
+
+/** Maps a thrown fetch error onto the typed SearchError union. */
+export function toSearchError(error: unknown): SearchError {
+  if (!(error instanceof EntityApiError)) {
+    return {
+      kind: "unknown",
+      message: error instanceof Error ? error.message : String(error),
+    };
+  }
+  if (error.isNetworkError()) return { kind: "network" };
+  if (error.status === 429) return { kind: "rate_limited" };
+  if (error.status === 503) return { kind: "unavailable" };
+  if (error.status === 400) {
+    const body = error.data as { error?: unknown; message?: unknown } | undefined;
+    const code = body?.error;
+    if (ERROR_CODES.includes(code as SearchErrorCode)) {
+      return {
+        kind: "validation",
+        code: code as SearchErrorCode,
+        message: typeof body?.message === "string" ? body.message : error.message,
+      };
+    }
+  }
+  return { kind: "unknown", message: error.message };
+}
+
+/** True when the failure is an aborted request rather than a real error. */
+export function isCancelled(error: unknown): boolean {
+  if (axios.isCancel(error)) return true;
+  return error instanceof EntityApiError && axios.isCancel(error.originalError);
+}
+
+export const SearchApi = {
+  /**
+   * Runs one search page. Pass `signal` to cancel superseded requests; a
+   * cancelled call rejects with an error `isCancelled` recognises.
+   */
+  search: (
+    params: SearchParams,
+    signal?: AbortSignal
+  ): ResultAsync<SearchResponse, SearchError> =>
+    ResultAsync.fromPromise(
+      EntityApi.getFn<unknown>(
+        `${SEARCH_BASEURL}?${buildSearchQuery(params).toString()}`,
+        { signal }
+      ).then(parseSearchResponse),
+      toSearchError
+    ),
+};
+
+/** Filters applied to every page of a search; excludes `q`, `cursor`, `limit`. */
+export type SearchFilters = Omit<SearchParams, "q" | "cursor">;
+
+export type SearchState =
+  | { kind: "idle" }
+  | { kind: "loading"; query: string }
+  | {
+      kind: "loaded";
+      query: string;
+      hits: SearchHit[];
+      nextCursor: Option<string>;
+      isLoadingMore: boolean;
+    }
+  | { kind: "error"; query: string; error: SearchError };
+
+export interface UseSearchResult {
+  state: SearchState;
+  /** Fetches the next page and appends it; no-op unless a `next_cursor` is pending. */
+  loadMore: () => void;
+}
+
+/**
+ * Debounced, cancellable keyword search. Any change to `query` or `filters`
+ * resets to page one; `loadMore` appends the next keyset page. Queries the
+ * backend would reject as too short resolve to `idle` without a request.
+ */
+export function useSearch(
+  query: string,
+  filters: SearchFilters = {},
+  debounceMs: number = SEARCH_DEBOUNCE_MS
+): UseSearchResult {
+  // Loading and idle are derived, so a keystroke never needs an effect to flip state.
+  const [result, setResult] = useState<Option<SettledSearch>>(None);
+  const controllerRef = useRef<AbortController | null>(null);
+  // Serialized so an identical object literal on every render isn't a change.
+  const filtersKey = JSON.stringify(filters);
+  // Requests fire from timers and callbacks, which read the latest filters here.
+  const filtersRef = useRef(filters);
+  useEffect(() => {
+    filtersRef.current = filters;
+  });
+
+  const runPage = useCallback(
+    (q: string, key: string, cursor: Option<string>) => {
+      controllerRef.current?.abort();
+      const controller = new AbortController();
+      controllerRef.current = controller;
+
+      const params: SearchParams = {
+        ...filtersRef.current,
+        q,
+        ...(cursor.some ? { cursor: cursor.val } : {}),
+      };
+
+      SearchApi.search(params, controller.signal).match(
+        (response) => {
+          if (controller.signal.aborted) return;
+          setResult((prev) => {
+            const previousHits =
+              cursor.some && prev.some && prev.val.state.kind === "loaded"
+                ? prev.val.state.hits
+                : [];
+            return Some({
+              query: q,
+              filtersKey: key,
+              state: {
+                kind: "loaded",
+                query: q,
+                hits: [...previousHits, ...response.hits],
+                nextCursor: response.next_cursor,
+                isLoadingMore: false,
+              },
+            });
+          });
+        },
+        (error) => {
+          if (controller.signal.aborted) return;
+          setResult(Some({ query: q, filtersKey: key, state: { kind: "error", query: q, error } }));
+        }
+      );
+    },
+    []
+  );
+
+  useEffect(() => {
+    if (!isSearchableQuery(query)) {
+      controllerRef.current?.abort();
+      return;
+    }
+    // Sent untrimmed: a trailing space is the backend's opt-out of prefix matching.
+    const timer = setTimeout(() => runPage(query, filtersKey, None), debounceMs);
+    return () => clearTimeout(timer);
+  }, [query, filtersKey, debounceMs, runPage]);
+
+  useEffect(() => () => controllerRef.current?.abort(), []);
+
+  const isCurrent =
+    result.some && result.val.query === query && result.val.filtersKey === filtersKey;
+
+  const state: SearchState = !isSearchableQuery(query)
+    ? { kind: "idle" }
+    : isCurrent
+      ? result.val.state
+      : { kind: "loading", query };
+
+  const loadMore = useCallback(() => {
+    if (!isCurrent) return;
+    const current = result.val.state;
+    if (current.kind !== "loaded" || current.isLoadingMore || current.nextCursor.none) {
+      return;
+    }
+    setResult(Some({ ...result.val, state: { ...current, isLoadingMore: true } }));
+    runPage(current.query, filtersKey, Some(current.nextCursor.val));
+  }, [isCurrent, result, filtersKey, runPage]);
+
+  return { state, loadMore };
+}
+
+interface SettledSearch {
+  query: string;
+  filtersKey: string;
+  state: Extract<SearchState, { kind: "loaded" | "error" }>;
+}
diff --git a/src/lib/utils/search-hit-href.ts b/src/lib/utils/search-hit-href.ts
new file mode 100644
index 00000000..c4f63164
--- /dev/null
+++ b/src/lib/utils/search-hit-href.ts
@@ -0,0 +1,43 @@
+import { PanelSection } from "@/components/ui/coaching-sessions/coaching-session-panel-selector";
+import { type Option, Some, None } from "@/types/option";
+import { SearchHitType, type SearchHit } from "@/types/search";
+
+const sessionHref = (sessionId: string, panel?: PanelSection): string =>
+  panel === undefined
+    ? `/coaching-sessions/${sessionId}`
+    : `/coaching-sessions/${sessionId}?panel=${panel}`;
+
+/**
+ * Resolves the page a search hit should open. `None` when the hit has no
+ * reachable location in this app, so the caller can render it inert.
+ */
+export function searchHitHref(hit: SearchHit): Option<string> {
+  switch (hit.type) {
+    case SearchHitType.CoachingSession:
+      return Some(sessionHref(hit.id));
+    case SearchHitType.Goal:
+      // Goals have no page of their own; the dashboard's goals card is the
+      // fallback when the goal was created outside a session.
+      return hit.created_in_session_id.some
+        ? Some(sessionHref(hit.created_in_session_id.val, PanelSection.Goals))
+        : Some("/dashboard");
+    case SearchHitType.Action:
+      return hit.coaching_session_id.some
+        ? Some(
+            `${sessionHref(hit.coaching_session_id.val, PanelSection.Actions)}&highlight=${hit.id}`
+          )
+        : Some("/actions");
+    case SearchHitType.Agreement:
+      return hit.coaching_session_id.some
+        ? Some(sessionHref(hit.coaching_session_id.val, PanelSection.Agreements))
+        : None;
+    case SearchHitType.Topic:
+      return hit.coaching_session_id.some
+        ? Some(sessionHref(hit.coaching_session_id.val))
+        : None;
+    default: {
+      const _exhaustive: never = hit;
+      throw new Error(`Unhandled search hit type: ${_exhaustive}`);
+    }
+  }
+}
diff --git a/src/types/search.ts b/src/types/search.ts
new file mode 100644
index 00000000..d0abe671
--- /dev/null
+++ b/src/types/search.ts
@@ -0,0 +1,296 @@
+// ─── Search Types (GET /search) ──────────────────────────────────────
+// Mirrors the backend's keyword search contract: one endpoint, one merged
+// hit list across entity types, keyset pagination via an opaque cursor.
+
+import { Id, ItemStatus } from "@/types/general";
+import { type Option, Some, None } from "@/types/option";
+import { TopicPriority, TopicStatus } from "@/types/coaching-session-topic";
+
+/** Hit variants the frontend knows how to render and link to. */
+export enum SearchHitType {
+  CoachingSession = "coaching_session",
+  Goal = "goal",
+  Action = "action",
+  Agreement = "agreement",
+  Topic = "topic",
+}
+
+/** Values accepted by the `types` query parameter. */
+export enum SearchableType {
+  CoachingSessions = "coaching_sessions",
+  Goals = "goals",
+  Actions = "actions",
+  Agreements = "agreements",
+  Topics = "topics",
+}
+
+export enum SearchMode {
+  Keyword = "keyword",
+  Semantic = "semantic",
+  Hybrid = "hybrid",
+}
+
+/** Stable machine-readable discriminators on 400 responses. */
+export enum SearchErrorCode {
+  QueryTooShort = "query_too_short",
+  UnknownType = "unknown_type",
+  ContradictoryParams = "contradictory_params",
+  MalformedCursor = "malformed_cursor",
+  ModeUnavailable = "mode_unavailable",
+  KeywordWeightOutOfRange = "keyword_weight_out_of_range",
+  InvalidTimezone = "invalid_timezone",
+}
+
+/** Backend enforces this after trimming; mirrored client-side to skip the round trip. */
+export const SEARCH_MIN_QUERY_LENGTH = 2;
+/** Backend silently truncates longer queries. */
+export const SEARCH_MAX_QUERY_LENGTH = 256;
+
+interface SearchHitBase {
+  id: Id;
+  score: number;
+  title: string;
+  snippet: Option<string>;
+  created_at: string;
+  updated_at: string;
+  organization_id: Id;
+  coaching_relationship_id: Option<Id>;
+}
+
+export interface CoachingSessionHit extends SearchHitBase {
+  type: SearchHitType.CoachingSession;
+  date: string;
+}
+
+export interface GoalHit extends SearchHitBase {
+  type: SearchHitType.Goal;
+  status: ItemStatus;
+  created_in_session_id: Option<Id>;
+}
+
+export interface ActionHit extends SearchHitBase {
+  type: SearchHitType.Action;
+  coaching_session_id: Option<Id>;
+  goal_id: Option<Id>;
+  status: ItemStatus;
+  due_by: Option<string>;
+  session_date: Option<string>;
+  session_title: Option<string>;
+}
+
+export interface AgreementHit extends SearchHitBase {
+  type: SearchHitType.Agreement;
+  coaching_session_id: Option<Id>;
+  session_date: Option<string>;
+  session_title: Option<string>;
+}
+
+export interface TopicHit extends SearchHitBase {
+  type: SearchHitType.Topic;
+  coaching_session_id: Option<Id>;
+  status: TopicStatus;
+  priority: Option<TopicPriority>;
+}
+
+export type SearchHit =
+  | CoachingSessionHit
+  | GoalHit
+  | ActionHit
+  | AgreementHit
+  | TopicHit;
+
+/** The wire response also echoes `query` and `limit`; nothing here reads them, so they are not modeled. */
+export interface SearchResponse {
+  hits: SearchHit[];
+  next_cursor: Option<string>;
+}
+
+/** Client-side filters. Everything is optional except `q`. */
+export interface SearchParams {
+  q: string;
+  types?: SearchableType[];
+  organization_id?: Id;
+  coaching_relationship_id?: Id;
+  user_id?: Id;
+  coaching_session_id?: Id;
+  goal_id?: Id;
+  goal_filter?: "all" | "linked" | "unlinked";
+  status?: ItemStatus;
+  topic_status?: TopicStatus;
+  created_from?: string;
+  created_to?: string;
+  updated_from?: string;
+  updated_to?: string;
+  tz?: string;
+  limit?: number;
+  cursor?: string;
+  mode?: SearchMode;
+}
+
+/** Typed failure at the search API boundary. */
+export type SearchError =
+  | { kind: "validation"; code: SearchErrorCode; message: string }
+  | { kind: "rate_limited" }
+  | { kind: "unavailable" }
+  | { kind: "network" }
+  | { kind: "unknown"; message: string };
+
+// ─── Parsing ─────────────────────────────────────────────────────────
+
+type Raw = Record<string, unknown>;
+
+function isRecord(value: unknown): value is Raw {
+  return typeof value === "object" && value !== null;
+}
+
+function optionalString(value: unknown): Option<string> {
+  return typeof value === "string" ? Some(value) : None;
+}
+
+function requireString(obj: Raw, field: string): string {
+  const value = obj[field];
+  if (typeof value !== "string") {
+    throw new Error(`Invalid search hit: expected string \`${field}\``);
+  }
+  return value;
+}
+
+function parseEnum<E extends string>(
+  values: readonly E[],
+  value: unknown,
+  fallback: E
+): E {
+  return values.includes(value as E) ? (value as E) : fallback;
+}
+
+function parseBase(obj: Raw): SearchHitBase {
+  const score = obj.score;
+  if (typeof score !== "number") {
+    throw new Error("Invalid search hit: expected number `score`");
+  }
+  return {
+    id: requireString(obj, "id"),
+    score,
+    title: requireString(obj, "title"),
+    snippet: optionalString(obj.snippet),
+    created_at: requireString(obj, "created_at"),
+    updated_at: requireString(obj, "updated_at"),
+    organization_id: requireString(obj, "organization_id"),
+    coaching_relationship_id: optionalString(obj.coaching_relationship_id),
+  };
+}
+
+const ITEM_STATUSES = Object.values(ItemStatus);
+const TOPIC_STATUSES = Object.values(TopicStatus);
+const TOPIC_PRIORITIES = Object.values(TopicPriority);
+
+/**
+ * Parses one raw hit. Returns `None` for hit types this client doesn't know,
+ * which the backend adds additively over time and asks us to ignore.
+ */
+export function parseSearchHit(value: unknown): Option<SearchHit> {
+  if (!isRecord(value) || typeof value.type !== "string") {
+    throw new Error("Invalid search hit: expected object with string `type`");
+  }
+
+  switch (value.type) {
+    case SearchHitType.CoachingSession:
+      return Some({
+        ...parseBase(value),
+        type: SearchHitType.CoachingSession,
+        date: requireString(value, "date"),
+      });
+    case SearchHitType.Goal:
+      return Some({
+        ...parseBase(value),
+        type: SearchHitType.Goal,
+        status: parseEnum(ITEM_STATUSES, value.status, ItemStatus.NotStarted),
+        created_in_session_id: optionalString(value.created_in_session_id),
+      });
+    case SearchHitType.Action:
+      return Some({
+        ...parseBase(value),
+        type: SearchHitType.Action,
+        coaching_session_id: optionalString(value.coaching_session_id),
+        goal_id: optionalString(value.goal_id),
+        status: parseEnum(ITEM_STATUSES, value.status, ItemStatus.NotStarted),
+        due_by: optionalString(value.due_by),
+        session_date: optionalString(value.session_date),
+        session_title: optionalString(value.session_title),
+      });
+    case SearchHitType.Agreement:
+      return Some({
+        ...parseBase(value),
+        type: SearchHitType.Agreement,
+        coaching_session_id: optionalString(value.coaching_session_id),
+        session_date: optionalString(value.session_date),
+        session_title: optionalString(value.session_title),
+      });
+    case SearchHitType.Topic:
+      return Some({
+        ...parseBase(value),
+        type: SearchHitType.Topic,
+        coaching_session_id: optionalString(value.coaching_session_id),
+        status: parseEnum(TOPIC_STATUSES, value.status, TopicStatus.Open),
+        priority: TOPIC_PRIORITIES.includes(value.priority as TopicPriority)
+          ? Some(value.priority as TopicPriority)
+          : None,
+      });
+    default:
+      return None;
+  }
+}
+
+/** Validates and normalizes the `data` payload of a 200 search response. */
+export function parseSearchResponse(value: unknown): SearchResponse {
+  if (!isRecord(value) || !Array.isArray(value.hits)) {
+    throw new Error("Invalid SearchResponse data");
+  }
+
+  const hits: SearchHit[] = [];
+  for (const raw of value.hits) {
+    const hit = parseSearchHit(raw);
+    if (hit.some) hits.push(hit.val);
+  }
+
+  return { hits, next_cursor: optionalString(value.next_cursor) };
+}
+
+// ─── Snippets ────────────────────────────────────────────────────────
+
+export interface SnippetSegment {
+  text: string;
+  highlighted: boolean;
+}
+
+const MARK_PATTERN = /<mark>([\s\S]*?)<\/mark>/g;
+
+// `&amp;` last, so an escaped entity like `&amp;lt;` doesn't become `<`.
+const unescapeSnippetText = (text: string): string =>
+  text.replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&amp;/g, "&");
+
+/**
+ * Splits a backend snippet on its `<mark>` markers into plain and highlighted
+ * text segments so it can be rendered as text nodes, never as HTML. The
+ * backend HTML-escapes stored text before adding markers, so each segment is
+ * unescaped here.
+ */
+export function splitSnippet(snippet: string): SnippetSegment[] {
+  const segments: SnippetSegment[] = [];
+  const push = (text: string, highlighted: boolean) =>
+    segments.push({ text: unescapeSnippetText(text), highlighted });
+  let cursor = 0;
+  for (const match of snippet.matchAll(MARK_PATTERN)) {
+    const start = match.index;
+    if (start > cursor) push(snippet.slice(cursor, start), false);
+    if (match[1].length > 0) push(match[1], true);
+    cursor = start + match[0].length;
+  }
+  if (cursor < snippet.length) push(snippet.slice(cursor), false);
+  return segments;
+}
+
+/** True once a query is worth sending: backend rejects anything shorter after trimming. */
+export function isSearchableQuery(q: string): boolean {
+  return q.trim().length >= SEARCH_MIN_QUERY_LENGTH;
+}