diff --git a/web/tests/integration/search-browser.html b/web/tests/integration/search-browser.html
new file mode 100644
index 0000000..c9b458f
--- /dev/null
+++ b/web/tests/integration/search-browser.html
@@ -0,0 +1,25 @@
+<!doctype html>
+<html>
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width,initial-scale=1" />
+  </head>
+  <body>
+    <p
+      style="
+        position: fixed;
+        left: 4px;
+        bottom: 4px;
+        z-index: 40;
+        max-width: 190px;
+        pointer-events: none;
+        font: 10px sans-serif;
+      "
+    >
+      Synthetic account session · real App and encrypted WASM/IndexedDB · no
+      account backend or human profile
+    </p>
+    <div id="root"></div>
+    <script type="module" src="./search-browser.tsx"></script>
+  </body>
+</html>
diff --git a/web/tests/integration/search-browser.mjs b/web/tests/integration/search-browser.mjs
new file mode 100644
index 0000000..1b3966b
--- /dev/null
+++ b/web/tests/integration/search-browser.mjs
@@ -0,0 +1,888 @@
+import { chromium, expect } from "@playwright/test";
+import { mkdir, writeFile } from "node:fs/promises";
+const output = process.env.NOTES_UI_OUTPUT ?? "test-results/search-browser";
+await mkdir(output, { recursive: true });
+const browser = await chromium.launch({ channel: "chrome", headless: true });
+const context = await browser.newContext({
+  viewport: { width: 1160, height: 850 },
+});
+const page = await context.newPage();
+let diagnosticPage = page;
+const errors = [];
+page.on("pageerror", (e) => errors.push(e.message));
+async function runQuery(raw) {
+  const input = page.getByRole("textbox", {
+    name: "Search notes, clips and cards",
+    exact: true,
+  });
+  await input.fill(raw);
+  await input.press("Enter");
+}
+try {
+  await page.goto(
+    `${process.env.NOTES_PREVIEW_URL ?? "http://127.0.0.1:5179"}/tests/integration/search-browser.html`,
+  );
+  await expect(
+    page.getByRole("heading", { name: "All notes", exact: true }),
+  ).toBeVisible();
+  await page.evaluate(() => {
+    window.__searchMotion = [];
+    let prior = null;
+    let closingAt = 0;
+    new MutationObserver(() => {
+      const element = document.querySelector(".workspace-search");
+      if (!element) {
+        if (prior && closingAt)
+          window.__searchMotion.push({
+            phase: "removed",
+            elapsed: performance.now() - closingAt,
+          });
+        prior = null;
+        closingAt = 0;
+        return;
+      }
+      const phase = element.getAttribute("data-phase");
+      if (prior === phase) return;
+      prior = phase;
+      const css = getComputedStyle(element);
+      window.__searchMotion.push({
+        phase,
+        duration: css.animationDuration,
+        name: css.animationName,
+        transform: css.transform,
+        inert: element.inert,
+        hidden: element.getAttribute("aria-hidden"),
+        frames: element.getAnimations().flatMap((animation) =>
+          animation.effect.getKeyframes().map((frame) => ({
+            opacity: frame.opacity,
+            transform: frame.transform,
+          })),
+        ),
+      });
+      if (phase === "closing") closingAt = performance.now();
+    }).observe(document.getElementById("main"), {
+      subtree: true,
+      childList: true,
+      attributes: true,
+      attributeFilter: ["data-phase"],
+    });
+  });
+  await page
+    .getByRole("button", { name: "Search notes, clips and cards", exact: true })
+    .click();
+  await runQuery("lisbon");
+  await expect(
+    page.getByText("69 results for “lisbon”", { exact: true }),
+  ).toBeVisible();
+  const searchCss = await page.evaluate(() => {
+    const row = document.querySelector(".search-result"),
+      content = document.querySelector(".search-content"),
+      heading = document.querySelector(".search-heading h1"),
+      group = document.querySelector(".search-group"),
+      label = group.querySelector("h2"),
+      count = label.querySelector("span"),
+      list = group.querySelector("ul");
+    const r = getComputedStyle(row),
+      c = getComputedStyle(content),
+      h = getComputedStyle(heading),
+      g = getComputedStyle(group),
+      b = getComputedStyle(label),
+      n = getComputedStyle(count),
+      u = getComputedStyle(list);
+    const rows = [...list.querySelectorAll(".search-result")];
+    const inactive = getComputedStyle(
+        document.querySelector('.search-tabs button[aria-pressed="false"]'),
+      ),
+      active = getComputedStyle(
+        document.querySelector('.search-tabs button[aria-pressed="true"]'),
+      ),
+      sub = getComputedStyle(document.querySelector(".search-heading p")),
+      ghost = getComputedStyle(
+        document.querySelector(".search-heading > button"),
+      );
+    const token = (name) => {
+      const probe = document.createElement("span");
+      probe.hidden = true;
+      probe.style.color = `var(${name})`;
+      document.body.append(probe);
+      const value = getComputedStyle(probe).color;
+      probe.remove();
+      return value;
+    };
+    const pill = (style) => ({
+      height: style.height,
+      minHeight: style.minHeight,
+      padding: style.padding,
+      radius: style.borderRadius,
+      border: style.borderTopWidth,
+      gap: style.gap,
+      size: style.fontSize,
+      background: style.backgroundColor,
+      color: style.color,
+    });
+    return {
+      row: {
+        border: r.borderTopWidth,
+        gap: r.gap,
+        padding: r.padding,
+        radius: r.borderRadius,
+        margin: r.marginBottom,
+      },
+      content: { padding: c.padding, gap: c.gap },
+      heading: { size: h.fontSize, spacing: h.letterSpacing },
+      sub: { size: sub.fontSize, color: sub.color },
+      ghost: {
+        height: ghost.height,
+        minHeight: ghost.minHeight,
+        padding: ghost.padding,
+        radius: ghost.borderRadius,
+        gap: ghost.gap,
+        size: ghost.fontSize,
+        background: ghost.backgroundColor,
+        color: ghost.color,
+      },
+      pills: { inactive: pill(inactive), active: pill(active) },
+      tokens: {
+        raise: token("--raise"),
+        t2: token("--t2"),
+        t3: token("--t3"),
+        btn: token("--btn"),
+        btnt: token("--btnt"),
+      },
+      section: {
+        size: b.fontSize,
+        weight: b.fontWeight,
+        padding: b.padding,
+        margin: b.margin,
+        alignment: b.justifyContent,
+        countSize: n.fontSize,
+        countColor: n.color,
+        countExpected: getComputedStyle(document.documentElement)
+          .getPropertyValue("--t3")
+          .trim(),
+        gap: g.gap,
+        listGap: u.gap,
+        headingToRow:
+          rows[0].getBoundingClientRect().top -
+          label.getBoundingClientRect().bottom,
+        rowToRow:
+          rows[1].getBoundingClientRect().top -
+          rows[0].getBoundingClientRect().bottom,
+      },
+    };
+  });
+  expect(searchCss.row).toEqual({
+    border: "0px",
+    gap: "3px",
+    padding: "10px 12px",
+    radius: "10px",
+    margin: "0px",
+  });
+  expect(searchCss.content).toEqual({ padding: "6px 28px 24px", gap: "8px" });
+  expect(searchCss.heading).toEqual({ size: "22px", spacing: "-0.33px" });
+  expect(searchCss.section).toMatchObject({
+    size: "13px",
+    weight: "500",
+    padding: "12px 0px 6px",
+    margin: "0px",
+    alignment: "space-between",
+    countSize: "12px",
+    gap: "8px",
+    listGap: "8px",
+    headingToRow: 8,
+    rowToRow: 8,
+  });
+  expect(searchCss.section.countColor).toBe(searchCss.tokens.t3);
+  expect(searchCss.sub).toEqual({ size: "13px", color: searchCss.tokens.t3 });
+  expect(searchCss.ghost).toEqual({
+    height: "30px",
+    minHeight: "30px",
+    padding: "0px 12px",
+    radius: "9px",
+    gap: "6px",
+    size: "12.5px",
+    background: searchCss.tokens.raise,
+    color: searchCss.tokens.t2,
+  });
+  expect(searchCss.pills.inactive).toEqual({
+    height: "28px",
+    minHeight: "28px",
+    padding: "0px 11px",
+    radius: "999px",
+    border: "0px",
+    gap: "6px",
+    size: "12px",
+    background: searchCss.tokens.raise,
+    color: searchCss.tokens.t2,
+  });
+  expect(searchCss.pills.active).toMatchObject({
+    border: "0px",
+    background: searchCss.tokens.btn,
+    color: searchCss.tokens.btnt,
+  });
+  await writeFile(
+    output + "/computed-css.json",
+    JSON.stringify(searchCss, null, 2),
+  );
+  const noteGroup = page.getByRole("region", {
+    name: "Notes results",
+    exact: true,
+  });
+  await expect(noteGroup.getByRole("listitem")).toHaveCount(50);
+  await page
+    .getByRole("button", { name: "Next Notes results", exact: true })
+    .click();
+  await expect(
+    page.getByText("Notes 51–62 of 62", { exact: true }),
+  ).toBeVisible();
+  await expect(noteGroup.getByRole("listitem")).toHaveCount(12);
+  await page
+    .getByRole("button", { name: "Previous Notes results", exact: true })
+    .click();
+  await expect(noteGroup.getByRole("listitem")).toHaveCount(50);
+  await page
+    .getByRole("button", { name: "Next Notes results", exact: true })
+    .click();
+  await expect(
+    page.getByText("Notes 51–62 of 62", { exact: true }),
+  ).toBeVisible();
+  await noteGroup.getByRole("button").nth(5).scrollIntoViewIfNeeded();
+  const retainedScroll = await page
+    .locator(".unified-search")
+    .evaluate((element) => element.scrollTop);
+  await noteGroup.getByRole("button").nth(5).click();
+  await expect(
+    page.getByRole("textbox", { name: "Note title", exact: true }),
+  ).toBeVisible();
+  await page
+    .getByRole("button", { name: "Back to search", exact: true })
+    .click();
+  await expect(
+    page.getByText("69 results for “lisbon”", { exact: true }),
+  ).toBeVisible();
+  await expect
+    .poll(async () =>
+      Math.abs(
+        (await page
+          .locator(".unified-search")
+          .evaluate((element) => element.scrollTop)) - retainedScroll,
+      ),
+    )
+    .toBeLessThan(2);
+  await expect(
+    page.getByText("Notes 51–62 of 62", { exact: true }),
+  ).toBeVisible();
+  await expect(noteGroup.getByRole("listitem")).toHaveCount(12);
+  await page
+    .getByRole("button", { name: "Previous Notes results", exact: true })
+    .click();
+  await expect(noteGroup.getByRole("listitem")).toHaveCount(50);
+  const before = await page.evaluate(() => window.__searchFixture.metadata());
+  await page
+    .getByRole("region", { name: "Clips results", exact: true })
+    .getByRole("button")
+    .filter({ hasText: "Archived" })
+    .click();
+  await expect(
+    page.getByRole("button", { name: "← Back to clips", exact: true }),
+  ).toBeVisible();
+  const after = await page.evaluate(() => window.__searchFixture.metadata());
+  expect(after.clips).toEqual(before.clips);
+  await page
+    .getByRole("button", { name: "Back to search", exact: true })
+    .click();
+  await page
+    .getByRole("region", { name: "Cards results", exact: true })
+    .getByRole("button")
+    .first()
+    .click();
+  const card = page.getByRole("dialog", { name: "Card", exact: true });
+  await expect(card).toBeVisible();
+  await expect(
+    card.getByText("Loading card content…", { exact: true }),
+  ).toHaveCount(0);
+  await expect(
+    card.getByRole("button", { name: "Show answer", exact: true }),
+  ).toBeEnabled();
+  await card.getByRole("button", { name: "Show answer", exact: true }).click();
+  await expect(
+    card.getByRole("heading", { name: "Answer", exact: true }),
+  ).toBeVisible();
+  await card
+    .getByRole("button", { name: "Back to search", exact: true })
+    .click();
+  await expect(card).toHaveCount(0);
+  expect(
+    (await page.evaluate(() => window.__searchFixture.metadata())).eventCount,
+  ).toBe(before.eventCount);
+
+  await runQuery("strasse");
+  await expect(
+    page.getByText("2 results for “strasse”", { exact: true }),
+  ).toBeVisible();
+  await runQuery("\u{10428}");
+  await expect(
+    page.getByText("1 result for “\u{10428}”", { exact: true }),
+  ).toBeVisible();
+  await runQuery("<script>");
+  await expect(
+    page.getByText("1 result for “<script>”", { exact: true }),
+  ).toBeVisible();
+  await expect(page.locator(".unified-search script")).toHaveCount(0);
+  await expect(
+    page.locator(".search-match").filter({ hasText: "<script>" }),
+  ).toHaveCount(1);
+  for (const raw of [
+    "private-journal-sentinel",
+    "private-source-sentinel",
+    "trash-only-sentinel",
+  ]) {
+    await runQuery(raw);
+    await expect(
+      page.getByRole("heading", {
+        name: `No results for “${raw}”`,
+        exact: true,
+      }),
+    ).toBeVisible();
+    await expect(
+      page.getByRole("button", { name: "All 0", exact: true }),
+    ).toBeVisible();
+  }
+  await runQuery("lisbon");
+  await expect(
+    page.getByText("69 results for “lisbon”", { exact: true }),
+  ).toBeVisible();
+  const privacyExitCount = await page.evaluate(
+    () =>
+      window.__searchMotion.filter((event) => event.phase === "closing").length,
+  );
+  const packing = before.notes.find((n) => n.title === "Lisbon packing");
+  await page.evaluate(
+    ({ id }) => window.__searchFixture.renameNote(id, "Lisbon packing renamed"),
+    { id: packing.id },
+  );
+  // This fixture writes from a separate real actor: unknown authority clears the private query.
+  await expect(
+    page.getByRole("textbox", {
+      name: "Search notes, clips and cards",
+      exact: true,
+    }),
+  ).toHaveCount(0);
+  expect(
+    await page.evaluate(
+      () =>
+        window.__searchMotion.filter((event) => event.phase === "closing")
+          .length,
+    ),
+  ).toBe(privacyExitCount);
+  await page
+    .getByRole("button", { name: "Search notes, clips and cards", exact: true })
+    .click();
+  await expect(
+    page.getByRole("textbox", {
+      name: "Search notes, clips and cards",
+      exact: true,
+    }),
+  ).toHaveValue("");
+  await runQuery("lisbon");
+  await expect(
+    page.getByText("69 results for “lisbon”", { exact: true }),
+  ).toBeVisible();
+  // The actual UI writes through the same admitted App owner: retain raw query, require explicit rerun.
+  await page
+    .getByRole("region", { name: "Notes results", exact: true })
+    .getByRole("button")
+    .first()
+    .click();
+  const admittedTitle = page.getByRole("textbox", {
+    name: "Note title",
+    exact: true,
+  });
+  await admittedTitle.fill((await admittedTitle.inputValue()) + " via UI");
+  await expect(
+    page.getByText("Saved in this browser", { exact: true }),
+  ).toBeVisible();
+  await page
+    .getByRole("button", { name: "Back to search", exact: true })
+    .click();
+  await expect(
+    page.getByRole("heading", { name: "Your library changed", exact: true }),
+  ).toBeVisible();
+  await expect(
+    page.getByText("69 results for “lisbon”", { exact: true }),
+  ).toHaveCount(0);
+  await page.getByRole("button", { name: "Search again", exact: true }).click();
+  await expect(
+    page.getByText("69 results for “lisbon”", { exact: true }),
+  ).toBeVisible();
+  await page
+    .getByRole("button", { name: "Next Notes results", exact: true })
+    .click();
+  await expect(
+    page.getByText("Notes 51–62 of 62", { exact: true }),
+  ).toBeFocused();
+  await page
+    .getByRole("button", { name: "Previous Notes results", exact: true })
+    .click();
+  await expect(
+    page.getByText("Notes 1–50 of 62", { exact: true }),
+  ).toBeFocused();
+  const view = page.getByRole("region", { name: "Search", exact: true });
+  async function stable() {
+    await page
+      .locator(".workspace-search[data-phase=open]")
+      .evaluate(async (element) => {
+        await document.fonts.ready;
+        await Promise.all(
+          element
+            .getAnimations({ subtree: true })
+            .filter((a) => a.effect?.getTiming().iterations !== Infinity)
+            .map((a) => a.finished.catch(() => {})),
+        );
+      });
+    await expect(page.locator(".workspace-search[data-phase=open]")).toHaveCSS(
+      "opacity",
+      "1",
+    );
+    await expect(view).toHaveCSS("opacity", "1");
+  }
+  for (const theme of ["light", "dark", "dim"]) {
+    await page.evaluate(
+      (theme) => (document.documentElement.dataset.theme = theme),
+      theme,
+    );
+    await view.evaluate((element) => {
+      element.scrollTop = 0;
+    });
+    await stable();
+    await page.screenshot({ path: output + `/search-${theme}.png` });
+  }
+  await page.setViewportSize({ width: 390, height: 844 });
+  await page.emulateMedia({ reducedMotion: "reduce" });
+  await view.evaluate((element) => {
+    element.scrollTop = 0;
+  });
+  await stable();
+  await page.screenshot({
+    path: output + "/search-narrow-header-dim-reduced.png",
+  });
+  await expect
+    .poll(() =>
+      page.evaluate(() => document.documentElement.scrollWidth <= innerWidth),
+    )
+    .toBe(true);
+  await page
+    .getByRole("button", { name: "Next Notes results", exact: true })
+    .scrollIntoViewIfNeeded();
+  await page.screenshot({ path: output + "/search-narrow-dim-reduced.png" });
+  await page
+    .getByRole("button", { name: "Next Notes results", exact: true })
+    .click();
+  await expect(
+    page.getByText("Notes 51–62 of 62", { exact: true }),
+  ).toBeFocused();
+  await page.getByRole("button", { name: "Cards 5", exact: true }).click();
+  await page
+    .getByRole("region", { name: "Cards results", exact: true })
+    .getByRole("button")
+    .first()
+    .click();
+  await expect(card).toBeVisible();
+  await expect(
+    card.getByRole("button", { name: "Show answer", exact: true }),
+  ).toBeEnabled();
+  await card.evaluate(async (element) => {
+    await document.fonts.ready;
+    await Promise.all(
+      element
+        .getAnimations({ subtree: true })
+        .map((a) => a.finished.catch(() => {})),
+    );
+  });
+  await page.screenshot({
+    path: output + "/card-preview-narrow-dim-reduced.png",
+  });
+  await card
+    .getByRole("button", { name: "Back to search", exact: true })
+    .click();
+  await expect(
+    page.getByRole("button", { name: "Cards 5", exact: true }),
+  ).toHaveAttribute("aria-pressed", "true");
+  await page.getByRole("button", { name: "All 69", exact: true }).click();
+  await page.setViewportSize({ width: 1160, height: 850 });
+  await page.emulateMedia({ reducedMotion: "no-preference" });
+  await page.getByRole("button", { name: "Clear search", exact: true }).click();
+  await page.getByRole("button", { name: "Study", exact: true }).click();
+  await page.getByRole("button", { name: /^Study \d+ cards?$/ }).click();
+  await page.getByRole("button", { name: "Show answer", exact: true }).click();
+  await expect(page.getByRole("button", { name: /^Good/ })).toBeVisible();
+  await page
+    .getByRole("button", { name: "Search notes, clips and cards", exact: true })
+    .click();
+  await runQuery("lisbon");
+  await expect(
+    page.getByText("69 results for “lisbon”", { exact: true }),
+  ).toBeVisible();
+  await page
+    .getByRole("region", { name: "Cards results", exact: true })
+    .getByRole("button")
+    .filter({ has: page.locator("b").filter({ hasText: "Train arrival" }) })
+    .click();
+  await expect(card).toBeVisible();
+  await card
+    .getByRole("button", { name: "Back to search", exact: true })
+    .click();
+  await page.getByRole("button", { name: "Clear search", exact: true }).click();
+  await expect(page.getByRole("button", { name: /^Good/ })).toBeVisible();
+  await page.getByRole("button", { name: "End session", exact: true }).click();
+  await page.getByRole("button", { name: "Journal", exact: true }).click();
+  await expect(
+    page.getByRole("heading", { name: "Journal is locked", exact: true }),
+  ).toBeVisible();
+  await page
+    .getByRole("button", { name: "Search notes, clips and cards", exact: true })
+    .click();
+  await runQuery("private-journal-sentinel");
+  await expect(
+    page.getByRole("heading", {
+      name: "No results for “private-journal-sentinel”",
+      exact: true,
+    }),
+  ).toBeVisible();
+  await page.getByRole("button", { name: "Clear search", exact: true }).click();
+  await expect(
+    page.getByRole("heading", { name: "Journal is locked", exact: true }),
+  ).toBeVisible();
+  await page.getByRole("button", { name: "All notes", exact: false }).click();
+  await page
+    .getByRole("button", { name: "Search notes, clips and cards", exact: true })
+    .click();
+  await runQuery("lisbon");
+  await expect(
+    page.getByText("69 results for “lisbon”", { exact: true }),
+  ).toBeVisible();
+  await page
+    .getByRole("region", { name: "Notes results", exact: true })
+    .getByRole("button")
+    .first()
+    .click();
+  const title = page.getByRole("textbox", { name: "Note title", exact: true });
+  await title.fill("Unsaved search guard");
+  await title.press("Control+k");
+  await expect(
+    page.getByRole("textbox", {
+      name: "Search notes, clips and cards",
+      exact: true,
+    }),
+  ).toHaveCount(0);
+  await expect(
+    page.getByText("Saved in this browser", { exact: true }),
+  ).toBeVisible();
+  await expect(
+    page.getByRole("textbox", {
+      name: "Search notes, clips and cards",
+      exact: true,
+    }),
+  ).toHaveCount(0);
+  await title.press("Control+k");
+  await expect(
+    page.getByRole("textbox", {
+      name: "Search notes, clips and cards",
+      exact: true,
+    }),
+  ).toBeVisible();
+  // Actual PM actor, selection and Undo survive origin A -> Search -> B -> Back/Clear.
+  await page.getByRole("button", { name: "Clear search", exact: true }).click();
+  await page.getByRole("button", { name: "All notes", exact: false }).click();
+  await page.getByRole("button", { name: /^Other ordinary note/ }).click();
+  const originEditor = page.getByRole("textbox", {
+    name: "Note content",
+    exact: true,
+  });
+  await originEditor.fill("Origin actor Undo marker");
+  await expect(
+    page.getByText("Saved in this browser", { exact: true }),
+  ).toBeVisible();
+  await originEditor.press("Control+Home");
+  await originEditor.press("Shift+End");
+  await expect
+    .poll(() =>
+      originEditor.evaluate(
+        (element) =>
+          element.editor.state.selection.to -
+          element.editor.state.selection.from,
+      ),
+    )
+    .toBe("Origin actor Undo marker".length);
+  const originalSelection = await originEditor.evaluate((element) => {
+    window.__originNoteEditor = element;
+    const view = element.editor.view;
+    return { from: view.state.selection.from, to: view.state.selection.to };
+  });
+  expect(originalSelection.to - originalSelection.from).toBe(
+    "Origin actor Undo marker".length,
+  );
+  await originEditor.press("Control+k");
+  await runQuery("lisbon page 01");
+  await expect(
+    page.getByText("1 result for “lisbon page 01”", { exact: true }),
+  ).toBeVisible();
+  await page
+    .getByRole("region", { name: "Notes results", exact: true })
+    .getByRole("button")
+    .click();
+  await expect(
+    page.getByRole("textbox", { name: "Note title", exact: true }),
+  ).toHaveValue("Lisbon page 01");
+  expect(await page.evaluate(() => window.__originNoteEditor.isConnected)).toBe(
+    true,
+  );
+  expect(await page.locator(".note-actor").count()).toBe(2);
+  expect(
+    await page.evaluate(() => {
+      const view = window.__originNoteEditor.editor.view;
+      return { from: view.state.selection.from, to: view.state.selection.to };
+    }),
+  ).toEqual(originalSelection);
+  await page
+    .getByRole("button", { name: "Back to search", exact: true })
+    .click();
+  await expect(
+    page.getByText("1 result for “lisbon page 01”", { exact: true }),
+  ).toBeVisible();
+  await page.getByRole("button", { name: "Clear search", exact: true }).click();
+  await expect(
+    page.getByRole("textbox", { name: "Note title", exact: true }),
+  ).toHaveValue("Other ordinary note");
+  expect(
+    await originEditor.evaluate(
+      (element) => element === window.__originNoteEditor,
+    ),
+  ).toBe(true);
+  expect(
+    await originEditor.evaluate((element) => {
+      const view = element.editor.view;
+      return { from: view.state.selection.from, to: view.state.selection.to };
+    }),
+  ).toEqual(originalSelection);
+  await originEditor.press("Control+z");
+  await expect(originEditor).toHaveText("Independent writing.");
+  await expect(
+    page.getByText("Saved in this browser", { exact: true }),
+  ).toBeVisible();
+  await page
+    .getByRole("button", { name: "Search notes, clips and cards", exact: true })
+    .click();
+  await page.evaluate(() => window.__searchFixture.seedLarge());
+  await runQuery("bounded");
+  await expect(
+    page.getByRole("heading", { name: "Search is paused", exact: true }),
+  ).toBeVisible();
+  await page
+    .getByRole("button", { name: "Cancel search", exact: true })
+    .click();
+  await expect(
+    page.getByRole("heading", {
+      name: "Search your notes, clips and cards.",
+      exact: true,
+    }),
+  ).toBeVisible();
+  await runQuery("bounded");
+  let rounds = 0;
+  while (true) {
+    await expect
+      .poll(
+        async () =>
+          (await page
+            .getByRole("heading", { name: "Search is paused", exact: true })
+            .count()) ||
+          (await page
+            .getByText("3 results for “bounded”", { exact: true })
+            .count()),
+      )
+      .toBeGreaterThan(0);
+    if (
+      await page.getByText("3 results for “bounded”", { exact: true }).count()
+    )
+      break;
+    if (++rounds > 10) throw Error("Too many explicit search rounds");
+    await page.getByRole("button", { name: "Continue", exact: true }).click();
+  }
+  await expect(
+    page.getByText("3 results for “bounded”", { exact: true }),
+  ).toBeVisible();
+  expect(
+    (await page.evaluate(() => window.__searchFixture.metadata())).eventCount,
+  ).toBe(before.eventCount);
+  expect(page.url()).not.toContain("bounded");
+  await page.evaluate(() => window.__searchFixture.erase());
+  await expect(
+    page.getByRole("textbox", {
+      name: "Search notes, clips and cards",
+      exact: true,
+    }),
+  ).toHaveCount(0);
+  await page
+    .getByRole("button", { name: "Search notes, clips and cards", exact: true })
+    .click();
+  await expect(
+    page.getByRole("textbox", {
+      name: "Search notes, clips and cards",
+      exact: true,
+    }),
+  ).toHaveValue("");
+  // Last, separate disposable profile: genuine unnotified wrapping-proof replacement.
+  const proofContext = await browser.newContext({
+      viewport: { width: 1160, height: 850 },
+    }),
+    proofPage = await proofContext.newPage();
+  diagnosticPage = proofPage;
+  proofPage.on("pageerror", (error) => errors.push(error.message));
+  await proofPage.goto(
+    `${process.env.NOTES_PREVIEW_URL ?? "http://127.0.0.1:5179"}/tests/integration/search-browser.html`,
+  );
+  await expect(
+    proofPage.getByRole("heading", { name: "All notes", exact: true }),
+  ).toBeVisible();
+  await expect
+    .poll(() =>
+      proofPage.evaluate(async () => {
+        const { checkClose } = await import("/src/desktop/closeGuard.ts");
+        return checkClose();
+      }),
+    )
+    .toBe("allowed");
+  await proofPage
+    .getByRole("button", { name: "Search notes, clips and cards", exact: true })
+    .click();
+  const proofQuery = proofPage.getByRole("textbox", {
+    name: "Search notes, clips and cards",
+    exact: true,
+  });
+  await proofQuery.fill("lisbon");
+  await proofQuery.press("Enter");
+  await expect(
+    proofPage.getByText("69 results for “lisbon”", { exact: true }),
+  ).toBeVisible();
+  await proofPage
+    .getByRole("region", { name: "Notes results", exact: true })
+    .getByRole("button")
+    .first()
+    .click();
+  await expect(proofPage.locator(".workspace-search")).toHaveCount(0);
+  await proofPage.evaluate(() => {
+    window.__staleSearchFlash = false;
+    new MutationObserver(() => {
+      const surface = document.querySelector(
+        '.workspace-search:not([aria-hidden="true"])',
+      );
+      if (
+        surface
+          ?.querySelector(".search-heading p")
+          ?.textContent?.includes("69 results")
+      )
+        window.__staleSearchFlash = true;
+    }).observe(document.getElementById("main"), {
+      subtree: true,
+      childList: true,
+      characterData: true,
+    });
+  });
+  await proofPage.evaluate(() =>
+    window.__searchFixture.invalidateWrappingProof(),
+  );
+  await proofPage
+    .getByRole("button", { name: "Back to search", exact: true })
+    .click();
+  await expect(proofPage.locator(".workspace-search")).toHaveCount(0);
+  expect(await proofPage.evaluate(() => window.__staleSearchFlash)).toBe(false);
+  await expect(proofPage.locator(".note-actor")).toHaveCount(0);
+  await proofContext.close();
+  diagnosticPage = page;
+  const motion = await page.evaluate(() => window.__searchMotion);
+  expect(
+    motion.some(
+      (event) =>
+        event.phase === "open" &&
+        event.duration === "0.24s" &&
+        event.frames.some((frame) => frame.transform === "translateY(6px)"),
+    ),
+  ).toBe(true);
+  expect(
+    motion.some(
+      (event) =>
+        event.phase === "closing" &&
+        event.duration === "0.17s" &&
+        event.inert &&
+        event.hidden === "true",
+    ),
+  ).toBe(true);
+  expect(
+    motion.some(
+      (event) =>
+        event.phase === "open" &&
+        event.duration === "0.15s" &&
+        event.name === "search-route-fade-in" &&
+        event.transform === "none",
+    ),
+  ).toBe(true);
+  expect(
+    motion.some(
+      (event) =>
+        event.phase === "closing" &&
+        event.duration === "0.15s" &&
+        event.name === "search-route-fade-out" &&
+        event.inert,
+    ),
+  ).toBe(true);
+  expect(
+    motion.some((event) => event.phase === "removed" && event.elapsed >= 120),
+  ).toBe(true);
+  expect(errors).toEqual([]);
+  await writeFile(output + "/motion.json", JSON.stringify(motion, null, 2));
+  await writeFile(
+    output + "/result.json",
+    JSON.stringify(
+      {
+        checks: [
+          "69 exact counts including actual5cards",
+          "50 PreviousNext pages",
+          "guarded Note result and scroll-preserving return",
+          "archived Clip internal reader no mutation",
+          "actual card bounded preview and answer no review event",
+          "Unicode full-fold/astral + escapedHTMLmatches",
+          "Journal/sourcequote/Trash exclusion",
+          "knownchanged explicitrerun",
+          "paging focus +3themes/narrow/reduced +boundedcardpreview",
+          "held revealedStudy +protectedJournalreturn",
+          "actualdirtyCtrlK explicitretry",
+          "genuine largecorpus pause/Continue/cancel",
+          "erase clearsprivatequery/routes",
+          "computed240/170 page motion and150 reduced opacity; privacy skips exit",
+          "StrictMode actual PM actor/selection/Undo preserved origin A to B and Clear",
+          "fresh reentry rejects genuine unnotified wrapping-proof tamper with no ready flash",
+        ],
+        pageErrors: errors,
+      },
+      null,
+      2,
+    ),
+  );
+  console.log("Search browser basic passed");
+} catch (e) {
+  await diagnosticPage.screenshot({
+    path: output + "/failure.png",
+    fullPage: true,
+  });
+  await writeFile(
+    output + "/failure.txt",
+    String(e) +
+      "\nURL " +
+      diagnosticPage.url() +
+      "\n" +
+      (await diagnosticPage.locator("body").innerText()),
+  );
+  throw e;
+} finally {
+  await browser.close();
+}
diff --git a/web/tests/integration/search-browser.tsx b/web/tests/integration/search-browser.tsx
new file mode 100644
index 0000000..6591d08
--- /dev/null
+++ b/web/tests/integration/search-browser.tsx
@@ -0,0 +1,358 @@
+// Disposable browser-context fixture only. Never imported by production entry.
+import { StrictMode } from "react";
+import { createRoot } from "react-dom/client";
+import { App } from "../../src/App";
+import { applyInitialPreferences } from "../../src/ui/primitives";
+import { openNotesStore } from "../../src/data";
+import { establish, lock } from "../../src/account/session";
+import { loadEngine, DeviceKeys } from "../../src/data/engine";
+import {
+  newWrappingKey,
+  wrappingSecret,
+  readRecord,
+  mutateRecord,
+  type DeviceRecord,
+} from "../../src/data/database";
+import {
+  openCollectionsStore,
+  replaceJournal,
+} from "../../src/collections/store";
+import { createDeck, saveEntry } from "../../src/study/model";
+import { createNoteLinkService } from "../../src/links/store";
+import {
+  createJournalEnvelope,
+  emptyJournal,
+  journalToday,
+  writeJournalEntry,
+} from "../../src/collections/journal";
+import type { NoteDocument } from "../../src/domain/contracts";
+import "../../src/styles/app.css";
+import "@fontsource/geist/400.css";
+import "@fontsource/geist/500.css";
+
+const identity = {
+  accountId: "a1111111-1111-4111-8111-111111111111",
+  deviceId: "a2222222-2222-4222-8222-222222222222",
+  email: "isolated-search-fixture@example.test",
+  deviceState: "trusted" as const,
+};
+const doc = (text: string): NoteDocument => ({
+  type: "doc",
+  content: [{ type: "paragraph", content: [{ type: "text", text }] }],
+});
+applyInitialPreferences();
+async function start() {
+  await loadEngine();
+  const fresh = !(await readRecord<DeviceRecord>("devices", identity.email));
+  if (fresh) {
+    const wrapKey = await newWrappingKey(),
+      secret = await wrappingSecret(wrapKey),
+      keys = DeviceKeys.create();
+    try {
+      await mutateRecord<DeviceRecord>("devices", identity.email, () => ({
+        ...identity,
+        wrapKey,
+        sealedKeys: keys.export(secret),
+        generation: 0,
+        verifiedTrust: true,
+      }));
+    } finally {
+      secret.fill(0);
+      keys.free();
+    }
+  }
+  establish(identity);
+  const notes = await openNotesStore(identity),
+    collections = await openCollectionsStore(identity);
+  if (fresh) {
+    const note = await notes.create({
+      title: "Lisbon packing",
+      tags: ["travel"],
+      document: doc(
+        "Café, Straße and <script>literal text</script>. Budget €20.",
+      ),
+    });
+    for (let i = 1; i <= 61; i++)
+      await notes.create({
+        title: `Lisbon page ${String(i).padStart(2, "0")}`,
+        tags: ["pagination"],
+        document: doc(`Travel item ${i}.`),
+      });
+    await notes.create({
+      title: "Other ordinary note",
+      tags: [],
+      document: doc("Independent writing."),
+    });
+    const target = await notes.create({
+      title: "Connected label",
+      tags: [],
+      document: doc("Target writing."),
+    });
+    const emptyTarget = await notes.create({
+      title: "",
+      tags: [],
+      document: doc("Empty title target writing."),
+    });
+    const links = createNoteLinkService(notes);
+    await links.verifyGraph();
+    const targetReference = await links.reference(target.id),
+      emptyReference = await links.reference(emptyTarget.id);
+    await notes.create({
+      title: "Reference source",
+      tags: [],
+      document: {
+        type: "doc",
+        content: [
+          {
+            type: "paragraph",
+            content: [
+              { type: "text", text: "Current " },
+              {
+                type: "noteLink",
+                attrs: { version: 1, target: targetReference.target },
+              },
+              { type: "text", text: " label and " },
+              { type: "text", text: "Stra", marks: [{ type: "bold" }] },
+              { type: "text", text: "ße \u{10400}" },
+            ],
+          },
+        ],
+      },
+    });
+    await notes.create({
+      title: "Boundary source",
+      tags: [],
+      document: {
+        type: "doc",
+        content: [
+          {
+            type: "paragraph",
+            content: [
+              { type: "text", text: "prefixZX" },
+              {
+                type: "noteLink",
+                attrs: { version: 1, target: emptyReference.target },
+              },
+              { type: "text", text: "QVsuffix" },
+            ],
+          },
+        ],
+      },
+    });
+    const trash = await notes.create({
+      title: "Lisbon trash-only-sentinel",
+      tags: [],
+      document: doc("trash-only-sentinel"),
+    });
+    await notes.trash(trash.id, trash.revision);
+    const at = new Date("2026-01-01T12:00:00.000Z"),
+      current = await collections.read();
+    await collections.update(current, (state) => {
+      let study = createDeck(state.study, "Lisbon travel", at);
+      const base = {
+        deckId: study.decks[0]!.id,
+        revision: 1,
+        tags: ["trip"],
+        source: {
+          noteId: note.id,
+          noteRevision: note.revision,
+          quote: "private-source-sentinel",
+        },
+      };
+      study = saveEntry(
+        study,
+        {
+          ...base,
+          id: crypto.randomUUID(),
+          type: "basic",
+          front: "Where is Lisbon?",
+          back: "Portugal",
+        },
+        at,
+      );
+      study = saveEntry(
+        study,
+        {
+          ...base,
+          id: crypto.randomUUID(),
+          type: "reversed",
+          front: "Lisbon departure",
+          back: "Train arrival",
+        },
+        at,
+      );
+      study = saveEntry(
+        study,
+        {
+          ...base,
+          id: crypto.randomUUID(),
+          type: "cloze",
+          text: "Lisbon is in {{city}} and costs {{cost}}.",
+          blanks: [
+            { id: "city", answer: "Portugal" },
+            { id: "cost", answer: "€20" },
+          ],
+        },
+        at,
+      );
+      return {
+        ...state,
+        study,
+        clips: {
+          ...state.clips,
+          items: [
+            {
+              id: crypto.randomUUID(),
+              revision: 1,
+              title: "Lisbon saved archive",
+              originalUrl: "https://example.test/lisbon-archive",
+              canonicalUrl: "https://example.test/lisbon-archive",
+              text: "Archived saved text with Café.",
+              createdAt: at.toISOString(),
+              updatedAt: at.toISOString(),
+              readAt: null,
+              readLater: true,
+              archivedAt: at.toISOString(),
+            },
+            {
+              id: crypto.randomUUID(),
+              revision: 1,
+              title: "Lisbon link only",
+              originalUrl: "https://example.test/lisbon-link",
+              canonicalUrl: "https://example.test/lisbon-link",
+              text: null,
+              createdAt: at.toISOString(),
+              updatedAt: at.toISOString(),
+              readAt: null,
+              readLater: false,
+              archivedAt: null,
+            },
+          ],
+        },
+      };
+    });
+    const latest = await collections.read();
+    const journal = writeJournalEntry(
+      emptyJournal(),
+      journalToday(),
+      doc("Lisbon private-journal-sentinel"),
+      null,
+      new Date(),
+    );
+    // Synthetic-only passphrase exists solely in this disposable test entry.
+    const sealed = await createJournalEnvelope(
+      "Synthetic Journal fixture phrase 2026",
+      journal,
+      { accountId: identity.accountId, epoch: latest.epoch },
+      () => {},
+    );
+    await replaceJournal(collections, latest, sealed.envelope);
+  }
+  Object.assign(window, {
+    __searchFixture: {
+      metadata: async () => {
+        const state = await collections.read();
+        return {
+          accountId: identity.accountId,
+          collectionsEpoch: state.epoch,
+          notes: (await notes.list()).map(
+            ({ id, title, revision, trashedAt }) => ({
+              id,
+              title,
+              revision,
+              trashedAt,
+            }),
+          ),
+          clips: state.clips.items.map(
+            ({ id, title, revision, archivedAt, readAt, readLater }) => ({
+              id,
+              title,
+              revision,
+              archivedAt,
+              readAt,
+              readLater,
+            }),
+          ),
+          cards: state.study.cards.map(({ id, entryId, key, revision }) => ({
+            id,
+            entryId,
+            key,
+            revision,
+          })),
+          entries: state.study.entries.map(
+            ({ id, type, deckId, revision }) => ({
+              id,
+              type,
+              deckId,
+              revision,
+            }),
+          ),
+          eventCount: state.study.events.length,
+        };
+      },
+      renameNote: async (id: string, title: string) => {
+        const note = await notes.get(id);
+        if (!note) throw new Error("Fixture note unavailable");
+        await notes.update(id, { title }, note.revision);
+      },
+      invalidateWrappingProof: async () => {
+        // Unnotified authority failure in this disposable profile only. Keep
+        // the sealed bytes unchanged; expose neither the old nor new key.
+        const replacement = await newWrappingKey();
+        await mutateRecord<DeviceRecord>(
+          "devices",
+          identity.email,
+          (current) => {
+            if (!current) throw new Error("Fixture device record unavailable");
+            return { ...current, wrapKey: replacement };
+          },
+        );
+      },
+      seedLarge: async (count = 3) => {
+        if (!Number.isInteger(count) || count < 1 || count > 3)
+          throw new Error("Choose one to three real large fixture notes.");
+        for (let i = 0; i < count; i++) {
+          const title =
+            i === 0 ? "Large bounded corpus" : `Large bounded corpus ${i + 1}`;
+          if ((await notes.list()).some((note) => note.title === title))
+            continue;
+          await notes.create({
+            title,
+            tags: [],
+            document: {
+              type: "doc",
+              content: [
+                {
+                  type: "paragraph",
+                  content: [{ type: "text", text: "a ".repeat(475000) }],
+                },
+                {
+                  type: "paragraph",
+                  content: [
+                    {
+                      type: "text",
+                      text: "b ".repeat(475000) + " bounded-hit",
+                    },
+                  ],
+                },
+              ],
+            },
+          });
+        }
+      },
+      erase: () => notes.erase(),
+      lock: () => lock(false),
+    },
+  });
+  performance.mark("search-fixture-app-render");
+  createRoot(document.getElementById("root")!).render(
+    <StrictMode>
+      <App />
+    </StrictMode>,
+  );
+}
+void start().catch((error) => {
+  document.getElementById("root")!.dataset.fixtureFailed = "true";
+  document.getElementById("root")!.textContent =
+    error instanceof Error ? error.message : "Search fixture failed";
+});
diff --git a/web/tests/integration/search-fixture-smoke.mjs b/web/tests/integration/search-fixture-smoke.mjs
new file mode 100644
index 0000000..bc5608d
--- /dev/null
+++ b/web/tests/integration/search-fixture-smoke.mjs
@@ -0,0 +1,74 @@
+import { chromium, expect } from "@playwright/test";
+import { mkdir, writeFile } from "node:fs/promises";
+const output = process.env.NOTES_UI_OUTPUT ?? "test-results/search-fixture";
+await mkdir(output, { recursive: true });
+const browser = await chromium.launch({ channel: "chrome", headless: true });
+const context = await browser.newContext({
+  viewport: { width: 1160, height: 850 },
+});
+const page = await context.newPage(),
+  errors = [];
+page.on("pageerror", (error) => errors.push(error.message));
+try {
+  await page.goto(
+    `${process.env.NOTES_PREVIEW_URL ?? "http://127.0.0.1:5179"}/tests/integration/search-browser.html`,
+  );
+  await page.waitForFunction(
+    () =>
+      !!window.__searchFixture ||
+      document.getElementById("root")?.dataset.fixtureFailed === "true",
+    undefined,
+    { timeout: 20000 },
+  );
+  if (await page.locator("#root").getAttribute("data-fixture-failed"))
+    throw new Error(await page.locator("#root").innerText());
+  await expect(
+    page.getByRole("heading", { name: "All notes", exact: true }),
+  ).toBeVisible();
+  const metadata = await page.evaluate(() => window.__searchFixture.metadata());
+  expect(
+    metadata.notes.filter(
+      (note) => !note.trashedAt && note.title.toLowerCase().includes("lisbon"),
+    ),
+  ).toHaveLength(62);
+  expect(metadata.clips).toHaveLength(2);
+  expect(metadata.cards).toHaveLength(5);
+  expect(metadata.notes.filter((note) => !!note.trashedAt)).toHaveLength(1);
+  expect(metadata.eventCount).toBe(0);
+  await page.reload();
+  await page.waitForFunction(() => !!window.__searchFixture);
+  await expect(
+    page.getByRole("heading", { name: "All notes", exact: true }),
+  ).toBeVisible();
+  const after = await page.evaluate(() => window.__searchFixture.metadata());
+  expect(after.cards).toEqual(metadata.cards);
+  expect(after.clips).toEqual(metadata.clips);
+  expect(after.notes).toEqual(metadata.notes);
+  expect(errors).toEqual([]);
+  await writeFile(
+    `${output}/result.json`,
+    JSON.stringify(
+      {
+        qualified:
+          "Test-only actual App + encrypted WASM/IDB synthetic session; not account authentication or Search UI acceptance",
+        notesMatchingLisbon: 62,
+        clips: 2,
+        actualCards: 5,
+        trashed: 1,
+        eventCount: 0,
+        reloadRetainsActualIdentities: true,
+        pageErrors: errors,
+      },
+      null,
+      2,
+    ),
+  );
+  console.log("Search mixed-corpus fixture and reload passed");
+} catch (error) {
+  await page.screenshot({ path: `${output}/failure.png` });
+  await writeFile(`${output}/failure.txt`, String(error));
+  throw error;
+} finally {
+  await context.close();
+  await browser.close();
+}
diff --git a/web/tests/integration/search-profile.mjs b/web/tests/integration/search-profile.mjs
new file mode 100644
index 0000000..377ad48
--- /dev/null
+++ b/web/tests/integration/search-profile.mjs
@@ -0,0 +1,194 @@
+import { chromium, expect } from "@playwright/test";
+import { mkdir, writeFile } from "node:fs/promises";
+const output = process.env.NOTES_UI_OUTPUT ?? "test-results/search-profile";
+await mkdir(output, { recursive: true });
+const browser = await chromium.launch({ channel: "chrome", headless: true });
+const context = await browser.newContext({
+  viewport: { width: 1160, height: 850 },
+  reducedMotion: "no-preference",
+});
+await context.addInitScript(() => {
+  window.__searchProbe = { shifts: [], longTasks: [] };
+  for (const type of ["layout-shift", "longtask"]) {
+    if (!PerformanceObserver.supportedEntryTypes.includes(type)) continue;
+    new PerformanceObserver((list) => {
+      for (const entry of list.getEntries()) {
+        if (type === "layout-shift")
+          window.__searchProbe.shifts.push({
+            time: entry.startTime,
+            value: entry.value,
+            hadRecentInput: entry.hadRecentInput,
+          });
+        else
+          window.__searchProbe.longTasks.push({
+            time: entry.startTime,
+            duration: entry.duration,
+          });
+      }
+    }).observe({ type, buffered: true });
+  }
+});
+const page = await context.newPage(),
+  errors = [],
+  samples = [];
+const profiler =
+  process.env.NOTES_PROFILE_CPU === "1"
+    ? await context.newCDPSession(page)
+    : null;
+page.on("pageerror", (error) => errors.push(error.message));
+try {
+  await page.goto(
+    `${process.env.NOTES_PREVIEW_URL ?? "http://127.0.0.1:5179"}/tests/integration/search-browser.html`,
+  );
+  await page.waitForFunction(
+    () =>
+      !!window.__searchFixture ||
+      document.getElementById("root")?.dataset.fixtureFailed === "true",
+  );
+  if (await page.locator("#root").getAttribute("data-fixture-failed"))
+    throw new Error(await page.locator("#root").innerText());
+  await expect(
+    page.getByRole("heading", { name: "All notes", exact: true }),
+  ).toBeVisible();
+  await expect
+    .poll(() =>
+      page.evaluate(async () => {
+        const { checkClose } = await import("/src/desktop/closeGuard.ts");
+        return checkClose();
+      }),
+    )
+    .toBe("allowed");
+  await page
+    .getByRole("button", { name: "Search notes, clips and cards", exact: true })
+    .click();
+  const input = page.getByRole("textbox", {
+    name: "Search notes, clips and cards",
+    exact: true,
+  });
+  await expect(input).toBeVisible();
+  if (profiler) {
+    await profiler.send("Profiler.enable");
+    await profiler.send("Profiler.start");
+  }
+  for (const [query, count] of [
+    ["lisbon", 69],
+    ["strasse", 2],
+    ["private-journal-sentinel", 0],
+    ["<script>", 1],
+    ["lisbon", 69],
+  ]) {
+    await input.fill(query);
+    const started = await page.evaluate(() => performance.now());
+    await input.press("Enter");
+    await expect(page.locator(".search-heading p")).toContainText(
+      `${count} ${count === 1 ? "result" : "results"}`,
+    );
+    if (count)
+      await expect(page.locator(".search-heading p")).toContainText(
+        `“${query}”`,
+      );
+    else
+      await expect(
+        page.getByRole("heading", {
+          name: `No results for “${query}”`,
+          exact: true,
+        }),
+      ).toBeVisible();
+    const ready = await page.evaluate(() => performance.now());
+    await page.locator(".unified-search").evaluate(async (element) => {
+      await Promise.all(
+        element
+          .getAnimations({ subtree: true })
+          .filter(
+            (animation) =>
+              animation.effect?.getTiming().iterations !== Infinity,
+          )
+          .map((animation) => animation.finished.catch(() => {})),
+      );
+      await new Promise((resolve) =>
+        requestAnimationFrame(() => requestAnimationFrame(resolve)),
+      );
+    });
+    samples.push(
+      await page.evaluate(
+        ({ query, count, started, ready }) => ({
+          query,
+          count,
+          readyMs: +(ready - started).toFixed(2),
+          settledMs: +(performance.now() - started).toFixed(2),
+          unexpectedCLS: window.__searchProbe.shifts
+            .filter((entry) => entry.time >= started && !entry.hadRecentInput)
+            .reduce((sum, entry) => sum + entry.value, 0),
+          allInteractionShift: window.__searchProbe.shifts
+            .filter((entry) => entry.time >= started)
+            .reduce((sum, entry) => sum + entry.value, 0),
+          longTasks: window.__searchProbe.longTasks.filter(
+            (entry) => entry.time >= started,
+          ),
+          renderedResultRows: document.querySelectorAll(
+            ".unified-search .search-result",
+          ).length,
+        }),
+        { query, count, started, ready },
+      ),
+    );
+    expect(await page.locator(".unified-search script").count()).toBe(0);
+  }
+  await expect(
+    page
+      .getByRole("region", { name: "Notes results", exact: true })
+      .locator(".search-result"),
+  ).toHaveCount(50);
+  await page
+    .getByRole("button", { name: "Next Notes results", exact: true })
+    .click();
+  await expect(
+    page
+      .getByRole("region", { name: "Notes results", exact: true })
+      .locator(".search-result"),
+  ).toHaveCount(12);
+  await expect(page.locator(".search-heading p")).toContainText("69 results");
+  const focusAfterPaging = await page.evaluate(() => ({
+    tag: document.activeElement?.tagName,
+    label: document.activeElement?.getAttribute("aria-label"),
+  }));
+  if (profiler) {
+    const { profile } = await profiler.send("Profiler.stop");
+    await writeFile(`${output}/cpu-profile.json`, JSON.stringify(profile));
+  }
+  expect(errors).toEqual([]);
+  await writeFile(
+    `${output}/result.json`,
+    JSON.stringify(
+      {
+        qualified:
+          "Developer-server Chrome headless interaction samples on genuine encrypted synthetic mixed corpus; no production baseline/LCP/native/60fps acceptance claim",
+        browser: browser.version(),
+        samples,
+        boundedCurrentNotesPage: "50 then12; total69 retained",
+        focusAfterPaging,
+        escapedHtmlLookingContent: true,
+        pageErrors: errors,
+      },
+      null,
+      2,
+    ),
+  );
+  console.log(
+    "Search developer interaction profile passed: " +
+      JSON.stringify(
+        samples.map(({ query, readyMs, unexpectedCLS }) => ({
+          query,
+          readyMs,
+          unexpectedCLS,
+        })),
+      ),
+  );
+} catch (error) {
+  await page.screenshot({ path: `${output}/failure.png` });
+  await writeFile(`${output}/failure.txt`, String(error));
+  throw error;
+} finally {
+  await context.close();
+  await browser.close();
+}
diff --git a/web/tests/integration/setup-browser.mjs b/web/tests/integration/setup-browser.mjs
new file mode 100644
index 0000000..4de128c
--- /dev/null
+++ b/web/tests/integration/setup-browser.mjs
@@ -0,0 +1,278 @@
+import { chromium, expect } from "@playwright/test";
+import { mkdir, writeFile } from "node:fs/promises";
+const output = process.env.NOTES_UI_OUTPUT ?? "test-results/setup-browser";
+await mkdir(output, { recursive: true });
+const browser = await chromium.launch({ channel: "chrome", headless: true });
+const context = await browser.newContext({
+  viewport: { width: 1160, height: 850 },
+});
+await context.route(
+  "**/tests/integration/note-link-entry-browser.html**",
+  async (route) => {
+    const response = await route.fetch();
+    await route.fulfill({
+      response,
+      body: (await response.text()).replace(
+        "font:12px sans-serif",
+        "position:fixed;left:4px;bottom:4px;z-index:40;max-width:190px;pointer-events:none;font:10px sans-serif",
+      ),
+    });
+  },
+);
+const page = await context.newPage(),
+  errors = [];
+page.on("pageerror", (error) => errors.push(error.message));
+async function settled(locator) {
+  await locator.evaluate(async (element) => {
+    await document.fonts.ready;
+    await Promise.all(
+      element
+        .getAnimations({ subtree: true })
+        .filter((a) => a.effect?.getTiming().iterations !== Infinity)
+        .map((a) => a.finished.catch(() => {})),
+    );
+  });
+  await expect(locator).toHaveCSS("opacity", "1");
+}
+async function openManual() {
+  await page.getByRole("button", { name: "Settings", exact: true }).click();
+  await page
+    .getByRole("dialog", { name: "Settings", exact: true })
+    .getByRole("button", { name: "Set up Notes", exact: true })
+    .click();
+  await expect(
+    page.getByRole("dialog", { name: "Set up Orbyn Notes" }),
+  ).toBeVisible();
+}
+async function choose(files) {
+  const wait = page.waitForEvent("filechooser");
+  await page
+    .getByRole("dialog", { name: "Set up Orbyn Notes" })
+    .getByRole("button", { name: "Import notes", exact: true })
+    .click();
+  await (await wait).setFiles(files);
+}
+try {
+  await page.goto(
+    `${process.env.NOTES_PREVIEW_URL ?? "http://127.0.0.1:5179"}/tests/integration/note-link-entry-browser.html`,
+  );
+  let setup = page.getByRole("dialog", { name: "Set up Orbyn Notes" });
+  await expect(setup).toBeVisible();
+  await expect(setup).toContainText("Step 2 of 3");
+  if ((await page.evaluate(() => localStorage.getItem("notes.setup"))) !== null)
+    throw Error("Setup persisted before explicit completion");
+  for (const theme of ["light", "dark", "dim"]) {
+    await page.evaluate((value) => {
+      document.documentElement.dataset.theme = value;
+    }, theme);
+    await settled(setup);
+    await page.screenshot({ path: `${output}/first-run-${theme}.png` });
+  }
+  await page.setViewportSize({ width: 390, height: 844 });
+  await page.emulateMedia({ reducedMotion: "reduce" });
+  await setup
+    .getByRole("button", { name: "Import notes", exact: true })
+    .scrollIntoViewIfNeeded();
+  await expect(
+    setup.getByRole("button", { name: "Import notes", exact: true }),
+  ).toBeInViewport();
+  await setup
+    .getByRole("button", { name: "Close setup", exact: true })
+    .scrollIntoViewIfNeeded();
+  await expect(
+    setup.getByRole("button", { name: "Close setup", exact: true }),
+  ).toBeInViewport();
+  if (
+    await page.evaluate(() => document.documentElement.scrollWidth > innerWidth)
+  )
+    throw Error("Setup horizontal overflow");
+  await settled(setup);
+  await page.screenshot({ path: output + "/first-run-narrow-dim-reduced.png" });
+  await page.setViewportSize({ width: 1160, height: 850 });
+  await page.emulateMedia({ reducedMotion: "no-preference" });
+  await choose([]);
+  await expect(
+    setup.getByRole("button", { name: "Import notes", exact: true }),
+  ).toBeEnabled();
+  await choose({
+    name: "not-markdown.txt",
+    mimeType: "text/plain",
+    buffer: Buffer.from("Original stays unchanged."),
+  });
+  await expect(setup.getByRole("alert")).toContainText("Choose Markdown files");
+  await setup.getByRole("button", { name: "Skip", exact: true }).click();
+  await expect(setup).toContainText("Step 3 of 3");
+  await setup.getByRole("button", { name: "Skip", exact: true }).click();
+  await expect(setup).toHaveCount(0);
+  await expect(
+    page.getByRole("heading", { name: "No notes yet", exact: true }),
+  ).toBeVisible();
+  await expect(
+    page.getByText(
+      "Write your first note, or bring in what you already have.",
+      { exact: true },
+    ),
+  ).toBeVisible();
+  await expect(
+    page.getByText("Notes are encrypted on this device.", { exact: true }),
+  ).toBeVisible();
+  await page.screenshot({ path: output + "/empty-library-dim.png" });
+  const hint = await page.evaluate(() => localStorage.getItem("notes.setup"));
+  if (hint !== '{"version":1,"dismissed":true}')
+    throw Error("Setup preference shape/content mismatch");
+  await openManual();
+  setup = page.getByRole("dialog", { name: "Set up Orbyn Notes" });
+  await choose([
+    {
+      name: "one.md",
+      mimeType: "text/markdown",
+      buffer: Buffer.from("# Imported one\n\nReal encrypted local writing."),
+    },
+    {
+      name: "two.md",
+      mimeType: "text/markdown",
+      buffer: Buffer.from("# Imported two\n\nSecond real local note."),
+    },
+  ]);
+  const review = page.getByRole("dialog", { name: "Import Markdown" });
+  await expect(review).toContainText("2 files ready");
+  await review
+    .getByRole("button", { name: "Import remaining", exact: true })
+    .click();
+  await expect(review).toHaveCount(0);
+  await expect(setup).toContainText("2 notes imported.");
+  await expect(setup).toContainText("Step 3 of 3");
+  await setup.getByRole("button", { name: "Skip", exact: true }).click();
+  await expect(setup).toHaveCount(0);
+  let data = await page.evaluate(() => window.__noteEntryFixture.metadata());
+  if (data.notes.length !== 2) throw Error("Actual imported count mismatch");
+  await page.reload();
+  await expect(
+    page.getByRole("button", { name: /Imported one/ }).first(),
+  ).toBeVisible();
+  await expect(setup).toHaveCount(0);
+  data = await page.evaluate(() => window.__noteEntryFixture.metadata());
+  if (data.notes.length !== 2) throw Error("Encrypted import reload mismatch");
+  await page.getByRole("button", { name: "Study", exact: true }).click();
+  await page
+    .getByRole("button", { name: "New deck", exact: true })
+    .first()
+    .click();
+  let dialog = page.getByRole("dialog", { name: "New deck", exact: true });
+  await dialog.getByLabel("Name").fill("Actual retained setup study");
+  await dialog
+    .getByRole("button", { name: "Create deck", exact: true })
+    .click();
+  await page
+    .getByRole("button", { name: "Add card", exact: true })
+    .first()
+    .click();
+  dialog = page.getByRole("dialog", { name: "Add card", exact: true });
+  await dialog
+    .getByLabel("Front", { exact: true })
+    .fill("Actual setup question");
+  await dialog
+    .getByLabel("Back", { exact: true })
+    .fill("Actual retained answer");
+  await dialog.getByRole("button", { name: "Add card", exact: true }).click();
+  await page.getByRole("button", { name: /^Study 1 card$/ }).click();
+  await page.getByRole("button", { name: "Show answer", exact: true }).click();
+  await openManual();
+  await page
+    .getByRole("dialog", { name: "Set up Orbyn Notes" })
+    .getByRole("button", { name: "Close setup", exact: true })
+    .click();
+  await expect(
+    page.getByRole("article", { name: "Card answer", exact: true }),
+  ).toContainText("Actual retained answer");
+  await page.getByRole("button", { name: "End session", exact: true }).click();
+  await page.getByRole("button", { name: "Journal", exact: true }).click();
+  await expect(
+    page.getByRole("heading", {
+      name: "Set a Journal passphrase",
+      exact: true,
+    }),
+  ).toBeVisible();
+  const secret = "synthetic-setup-journal-only-passphrase";
+  await page.getByLabel("Passphrase", { exact: true }).fill(secret);
+  await page.getByLabel("Confirm passphrase", { exact: true }).fill(secret);
+  await page.getByRole("button", { name: "Lock Journal", exact: true }).click();
+  await expect(
+    page
+      .getByRole("textbox", { name: "Journal entry", exact: true })
+      .or(
+        page.getByRole("heading", { name: "Journal is locked", exact: true }),
+      ),
+  ).toBeVisible();
+  if (
+    await page
+      .getByRole("heading", { name: "Journal is locked", exact: true })
+      .count()
+  ) {
+    await page.getByLabel("Passphrase", { exact: true }).fill(secret);
+    await page
+      .getByRole("button", { name: "Unlock Journal", exact: true })
+      .click();
+  }
+  await page
+    .getByRole("textbox", { name: "Journal entry", exact: true })
+    .fill("Synthetic protected marker for setup lifecycle.");
+  await expect(page.getByText("Saved", { exact: true })).toBeVisible();
+  await openManual();
+  await expect(
+    page.getByText("Synthetic protected marker for setup lifecycle.", {
+      exact: true,
+    }),
+  ).toHaveCount(0);
+  await page
+    .getByRole("dialog", { name: "Set up Orbyn Notes" })
+    .getByRole("button", { name: "Close setup", exact: true })
+    .click();
+  await expect(
+    page.getByRole("heading", { name: "Journal is locked", exact: true }),
+  ).toBeVisible();
+  await expect(
+    page.getByText("Synthetic protected marker for setup lifecycle.", {
+      exact: true,
+    }),
+  ).toHaveCount(0);
+  await page.screenshot({ path: output + "/journal-return-protected.png" });
+  if (errors.length) throw Error(errors.join("\n"));
+  await writeFile(
+    output + "/result.json",
+    JSON.stringify(
+      {
+        qualified:
+          "Actual App/production UI and real WASM/IndexedDB under disposable synthetic session; no account backend/native OS/file-dialog/physical IME claim. Fixture provenance label fixed before paint.",
+        checks: [
+          "optional first-run actual empty writable profile",
+          "all3themes+narrow/reduced actionreachability",
+          "actual file input cancel and invalidextension",
+          "skip exactempty principalcopy",
+          "exactcontent-free persisted profile hint",
+          "explicitSettingsreopen despitehint",
+          "real2file Markdown encryptedimport+reload",
+          "revealedStudy actor preserved",
+          "cleanJournalhost disposed and protectedgate onreturn",
+        ],
+        pageErrors: errors,
+      },
+      null,
+      2,
+    ),
+  );
+  console.log("Setup browser passed");
+} catch (error) {
+  await page.screenshot({ path: output + "/failure.png" });
+  await writeFile(
+    output + "/failure.txt",
+    String(error) +
+      "\nURL " +
+      page.url() +
+      "\n" +
+      (await page.locator("body").innerText()),
+  );
+  throw error;
+} finally {
+  await browser.close();
+}
diff --git a/web/tests/ui/search-routing.test.tsx b/web/tests/ui/search-routing.test.tsx
new file mode 100644
index 0000000..d9e556d
--- /dev/null
+++ b/web/tests/ui/search-routing.test.tsx
@@ -0,0 +1,627 @@
+import {
+  act,
+  fireEvent,
+  render,
+  screen,
+  waitFor,
+  within,
+} from "@testing-library/react";
+import { afterEach, beforeEach, expect, it, vi } from "vitest";
+import type { Note, NotesStore } from "../../src/domain/contracts";
+import type {
+  NotesLibrary,
+  NotesLibraryStore,
+  LibrarySnapshot,
+} from "../../src/library/contracts";
+import type { NoteLinkService, NoteTarget } from "../../src/links/contracts";
+import type { NoteLinkNavigator } from "../../src/links/navigation";
+import type { SearchState, LocalSearchService } from "../../src/search/results";
+import type { SearchInvalidation } from "../../src/search/contracts";
+import { Workspace } from "../../src/ui/Workspace";
+import { registerCloseGuard } from "../../src/desktop/closeGuard";
+import type { NoteExportIntent } from "../../src/links/contracts";
+import { buildDownload } from "../../src/ui/download";
+const model = vi.hoisted(() => ({
+  service: null as NoteLinkService | null,
+  noteMounts: new Map<string, number>(),
+  noteUnmounts: new Map<string, number>(),
+  searchState: { status: "idle", raw: "" } as SearchState,
+  searchService: null as LocalSearchService | null,
+  searchInvalidate: null as ((reason: SearchInvalidation) => void) | null,
+  searchListeners: new Set<() => void>(),
+  linkBoot: true,
+  sourceBoot: true,
+  invalidate: null as ((reason: "epoch" | "closed") => void) | null,
+}));
+vi.mock("../../src/ui/noteLinkOwner", () => ({
+  useNoteLinkOwner: (
+    _owner: unknown,
+    onInvalidate: (reason: "epoch" | "closed") => void,
+  ) => {
+    model.invalidate = onInvalidate;
+    return {
+      service: model.service,
+      error: "",
+      bootSettled: model.linkBoot,
+      retry: vi.fn(),
+    };
+  },
+}));
+vi.mock("../../src/ui/studySourceOwners", () => ({
+  useStudySourceOwners: () => ({
+    service: null,
+    collections: null,
+    error: "",
+    bootSettled: model.sourceBoot,
+    retry: vi.fn(),
+  }),
+}));
+vi.mock("../../src/ui/localSearchOwner", async () => {
+  const React = await import("react");
+  return {
+    useLocalSearchOwner: (
+      _owner: unknown,
+      _collections: unknown,
+      invalidate: (reason: SearchInvalidation) => void,
+    ) => {
+      model.searchInvalidate = invalidate;
+      const state = React.useSyncExternalStore(
+        (listener) => {
+          model.searchListeners.add(listener);
+          return () => {
+            model.searchListeners.delete(listener);
+          };
+        },
+        () => model.searchState,
+      );
+      return {
+        service: model.searchService,
+        state,
+        error: false,
+        retry: vi.fn(),
+      };
+    },
+  };
+});
+vi.mock("../../src/ui/download", () => ({
+  buildDownload: vi.fn(() => ({
+    blob: new Blob(["legacy"]),
+    name: "legacy.md",
+  })),
+}));
+vi.mock("../../src/ui/NoteEditor", async () => {
+  const React = await import("react");
+  return {
+    NoteEditor: (
+      props: Parameters<typeof import("../../src/ui/NoteEditor").NoteEditor>[0],
+    ) => {
+      const [value, setValue] = React.useState(0);
+      React.useEffect(() => {
+        model.noteMounts.set(
+          props.note.id,
+          (model.noteMounts.get(props.note.id) ?? 0) + 1,
+        );
+        return () => {
+          model.noteUnmounts.set(
+            props.note.id,
+            (model.noteUnmounts.get(props.note.id) ?? 0) + 1,
+          );
+        };
+      }, []);
+      return (
+        <section>
+          <h2>Editor {props.note.title}</h2>
+          <div role="textbox" aria-label="Note content" tabIndex={0} />
+          <output>
+            Actor state {props.note.id} {value}
+          </output>
+          <button onClick={() => setValue(value + 1)}>
+            Advance actor state
+          </button>
+          <button onClick={() => props.onExport(props.note)}>
+            Export this note
+          </button>
+        </section>
+      );
+    },
+  };
+});
+const epoch = "22222222-2222-4222-8222-222222222222",
+  account = "11111111-1111-4111-8111-111111111111";
+const note = (id: string): Note => ({
+  id,
+  title: id,
+  revision: 1,
+  tags: [],
+  createdAt: "2026-11-11T00:00:00Z",
+  updatedAt: "2026-11-11T00:00:00Z",
+  trashedAt: null,
+  document: { type: "doc", content: [{ type: "paragraph" }] },
+});
+const a = note("A"),
+  b = note("B"),
+  snapshot: LibrarySnapshot = {
+    token: { epoch, revision: 1 },
+    notes: [a, b],
+    metadata: [],
+    tags: [],
+    preferences: { sort: "edited" },
+  };
+const target = (noteId: string): NoteTarget => ({
+  kind: "note",
+  accountId: account,
+  libraryEpoch: epoch,
+  noteId,
+});
+function held<T>() {
+  let resolve!: (value: T) => void;
+  const promise = new Promise<T>((yes) => {
+    resolve = yes;
+  });
+  return { promise, resolve };
+}
+function fixture() {
+  const library: NotesLibrary = {
+    read: vi.fn(async () => ({ mode: "ready" as const, snapshot })),
+    updateWithSourceSteps: vi.fn(),
+    replaceDocument: vi.fn(),
+    setPinned: vi.fn(),
+    setSort: vi.fn(),
+    createTag: vi.fn(),
+    renameTag: vi.fn(),
+    recolorTag: vi.fn(),
+    mergeTag: vi.fn(),
+    deleteTag: vi.fn(),
+    history: vi.fn(),
+    version: vi.fn(),
+    restoreVersion: vi.fn(),
+    changeTrash: vi.fn(),
+    undoTrash: vi.fn(),
+    emptyTrash: vi.fn(),
+    eraseLegacy: vi.fn(),
+  };
+  const base: NotesStore = {
+    list: vi.fn(async () => [a, b]),
+    get: vi.fn(async (id) => (id === "A" ? a : b)),
+    create: vi.fn(),
+    update: vi.fn(),
+    trash: vi.fn(),
+    restore: vi.fn(),
+    erase: vi.fn(),
+    subscribe: () => () => {},
+    persistence: () => ({ status: "ready" }),
+    close: vi.fn(),
+  };
+  const owner: NotesLibraryStore = { ...base, library };
+  const service: NoteLinkService = {
+    admission: vi.fn(async () => ({
+      mode: "current" as const,
+      token: snapshot.token,
+      graph: "ready" as const,
+    })),
+    currentToken: vi.fn(),
+    search: vi.fn(),
+    reference: vi.fn(),
+    resolve: vi.fn(async (ref) => ({
+      status: "available" as const,
+      target: ref,
+      token: snapshot.token,
+      noteRevision: 1,
+      title: ref.noteId,
+    })),
+    outgoing: vi.fn(),
+    backlinks: vi.fn(),
+    linkedNoteIds: vi.fn(async () => ({
+      status: "ready" as const,
+      token: snapshot.token,
+      items: [],
+    })),
+    verifyGraph: vi.fn(),
+    cancelVerification: vi.fn(),
+    prepareRepair: vi.fn(),
+    commitRepair: vi.fn(),
+    prepareExport: vi.fn(),
+    exportFiles: vi.fn(),
+    assertFreshExport: vi.fn(),
+    subscribe: () => () => {},
+    onInvalidate: () => () => {},
+    close: vi.fn(),
+  };
+  model.service = service;
+  let navigator: NoteLinkNavigator | null = null;
+  const register = vi.fn((value: NoteLinkNavigator | null) => {
+    navigator = value;
+  });
+  const props = {
+    store: base,
+    library,
+    sourceOwner: owner,
+    session: {
+      accountId: account,
+      deviceId: "33333333-3333-4333-8333-333333333333",
+      email: "explicit-routing-boundary@example.test",
+      deviceState: "trusted" as const,
+    },
+    onSignOut: vi.fn(async () => {}),
+    onNoteLinkNavigatorReady: register,
+    onNoteLinkScopeRevoked: vi.fn(),
+  };
+  const view = render(<Workspace {...props} />);
+  return { base, service, register, view, props, nav: () => navigator };
+}
+function publish(state: SearchState) {
+  model.searchState = state;
+  model.searchListeners.forEach((fn) => fn());
+}
+function readySearch(): SearchState {
+  return {
+    status: "ready",
+    raw: "needle",
+    handle: Object.freeze({}) as Extract<
+      SearchState,
+      { status: "ready" }
+    >["handle"],
+    versions: {
+      accountId: account,
+      library: snapshot.token,
+      collections: { epoch, revision: 1 },
+    },
+    counts: { all: 1, notes: 1, clips: 0, cards: 0 },
+    groups: [
+      {
+        kind: "note",
+        offset: 0,
+        previous: null,
+        next: null,
+        items: [
+          {
+            locator: target("A"),
+            entityRevision: 1,
+            primary: { text: "A", matches: [], before: false, after: false },
+            secondary: [],
+          },
+        ],
+      },
+    ],
+    page: null,
+  };
+}
+beforeEach(() => {
+  model.noteMounts.clear();
+  model.noteUnmounts.clear();
+  model.searchState = { status: "idle", raw: "" };
+  model.searchListeners.clear();
+  model.searchInvalidate = null;
+  model.searchService = {
+    getSnapshot: () => model.searchState,
+    subscribe: () => () => {},
+    onInvalidate: () => () => {},
+    query: vi.fn(async () => {
+      publish(readySearch());
+    }),
+    continue: vi.fn(),
+    page: vi.fn(),
+    cancelPage: vi.fn(),
+    cancel: vi.fn(() => publish({ status: "idle", raw: "" })),
+    close: vi.fn(),
+  };
+  vi.stubGlobal("matchMedia", () => ({
+    matches: true,
+    addEventListener: vi.fn(),
+    removeEventListener: vi.fn(),
+  }));
+  model.linkBoot = true;
+  model.sourceBoot = true;
+  model.service = null;
+  vi.mocked(buildDownload).mockClear();
+  HTMLDialogElement.prototype.showModal = function () {
+    this.setAttribute("open", "");
+  };
+  HTMLDialogElement.prototype.close = function () {
+    this.removeAttribute("open");
+  };
+  URL.createObjectURL = vi.fn(() => "blob:synthetic");
+  URL.revokeObjectURL = vi.fn();
+});
+
+it("blocks keyboard Search admission while dirty and requires a new explicit command after the guard clears", async () => {
+  const f = fixture();
+  await screen.findByRole("heading", { name: "All notes" });
+  const stop = registerCloseGuard(() => false);
+  fireEvent.keyDown(window, { key: "k", ctrlKey: true });
+  expect(
+    screen.queryByRole("textbox", { name: "Search notes, clips and cards" }),
+  ).not.toBeInTheDocument();
+  stop();
+  await act(async () => {});
+  expect(
+    screen.queryByRole("textbox", { name: "Search notes, clips and cards" }),
+  ).not.toBeInTheDocument();
+  fireEvent.keyDown(window, { key: "k", ctrlKey: true });
+  expect(
+    await screen.findByRole("textbox", {
+      name: "Search notes, clips and cards",
+    }),
+  ).toBeVisible();
+  expect(model.searchService!.query).not.toHaveBeenCalled();
+  expect(f.base.update).not.toHaveBeenCalled();
+});
+async function search() {
+  fireEvent.click(
+    screen.getByRole("button", { name: "Search notes, clips and cards" }),
+  );
+  const input = await screen.findByRole("textbox", {
+    name: "Search notes, clips and cards",
+  });
+  fireEvent.change(input, { target: { value: "needle" } });
+  fireEvent.submit(input.closest("form")!);
+  await screen.findByText("1 result for “needle”");
+  return input;
+}
+it("keeps exact clean Notes origin through result and Back/Clear without persisting the query", async () => {
+  const f = fixture();
+  await screen.findByRole("heading", { name: "All notes" });
+  fireEvent.click(screen.getByRole("button", { name: /^B / }));
+  await screen.findByRole("heading", { name: "Editor B" });
+  const hash = location.hash;
+  await search();
+  fireEvent.click(
+    within(screen.getByRole("region", { name: "Notes results" })).getByRole(
+      "button",
+    ),
+  );
+  await screen.findByRole("heading", { name: "Editor A" });
+  fireEvent.click(screen.getByRole("button", { name: "Back to search" }));
+  await screen.findByText("1 result for “needle”");
+  fireEvent.click(screen.getByRole("button", { name: "Clear search" }));
+  await screen.findByRole("heading", { name: "Editor B" });
+  expect(location.hash).toBe(hash);
+  expect(f.base.update).not.toHaveBeenCalled();
+});
+it("fences a held result resolution when scope is revoked before its late completion", async () => {
+  const f = fixture();
+  await screen.findByRole("heading", { name: "All notes" });
+  await search();
+  const pending = held<Awaited<ReturnType<NoteLinkService["resolve"]>>>();
+  vi.mocked(f.service.resolve).mockReturnValueOnce(pending.promise);
+  fireEvent.click(
+    within(screen.getByRole("region", { name: "Notes results" })).getByRole(
+      "button",
+    ),
+  );
+  act(() => {
+    model.searchInvalidate!("epoch");
+    publish({ status: "idle", raw: "" });
+  });
+  await act(async () => {
+    pending.resolve({
+      status: "available",
+      target: target("A"),
+      noteRevision: 1,
+      title: "A",
+      token: snapshot.token,
+    });
+  });
+  expect(
+    screen.queryByRole("heading", { name: "Editor A" }),
+  ).not.toBeInTheDocument();
+  expect(
+    screen.queryByRole("textbox", { name: "Search notes, clips and cards" }),
+  ).not.toBeInTheDocument();
+  expect(screen.queryByText(/needle/)).not.toBeInTheDocument();
+});
+it("keeps changed query text but requires explicit Search again before new counts", async () => {
+  fixture();
+  await screen.findByRole("heading", { name: "All notes" });
+  await search();
+  expect(model.searchService!.query).toHaveBeenCalledTimes(1);
+  act(() => {
+    model.searchInvalidate!("changed");
+    publish({ status: "changed", raw: "needle" });
+  });
+  expect(
+    screen.getByRole("textbox", { name: "Search notes, clips and cards" }),
+  ).toHaveValue("needle");
+  expect(screen.queryByText("1 result for “needle”")).not.toBeInTheDocument();
+  expect(model.searchService!.query).toHaveBeenCalledTimes(1);
+  fireEvent.click(screen.getByRole("button", { name: "Search again" }));
+  await screen.findByText("1 result for “needle”");
+  expect(model.searchService!.query).toHaveBeenCalledTimes(2);
+});
+it("clears a held raw query and route on privacy invalidation even before the first service query", async () => {
+  fixture();
+  await screen.findByRole("heading", { name: "All notes" });
+  fireEvent.click(
+    screen.getByRole("button", { name: "Search notes, clips and cards" }),
+  );
+  const input = await screen.findByRole("textbox", {
+    name: "Search notes, clips and cards",
+  });
+  fireEvent.change(input, { target: { value: "private pending raw" } });
+  act(() => model.searchInvalidate!("unverified"));
+  expect(
+    screen.queryByRole("textbox", { name: "Search notes, clips and cards" }),
+  ).not.toBeInTheDocument();
+  fireEvent.click(
+    screen.getByRole("button", { name: "Search notes, clips and cards" }),
+  );
+  expect(
+    await screen.findByRole("textbox", {
+      name: "Search notes, clips and cards",
+    }),
+  ).toHaveValue("");
+  expect(model.searchService!.query).not.toHaveBeenCalled();
+});
+
+it("removes a retained ready certificate before exposing Search while a genuine freshness action is held", async () => {
+  fixture();
+  await screen.findByRole("heading", { name: "All notes" });
+  await search();
+  fireEvent.click(
+    within(screen.getByRole("region", { name: "Notes results" })).getByRole(
+      "button",
+    ),
+  );
+  await screen.findByRole("heading", { name: "Editor A" });
+  const proof = held<void>();
+  vi.mocked(model.searchService!.query).mockImplementationOnce(async () => {
+    publish({ status: "pending", raw: "needle", progress: null });
+    await proof.promise;
+    publish(readySearch());
+  });
+  fireEvent.click(screen.getByRole("button", { name: "Back to search" }));
+  expect(
+    screen.getByText("Searching local notes, clips and cards…"),
+  ).toBeVisible();
+  expect(screen.queryByText("1 result for “needle”")).not.toBeInTheDocument();
+  expect(
+    screen.queryByRole("region", { name: "Notes results" }),
+  ).not.toBeInTheDocument();
+  expect(model.searchService!.query).toHaveBeenCalledTimes(2);
+  await act(async () => proof.resolve(undefined));
+  await screen.findByText("1 result for “needle”");
+});
+it("retains changed state on Back instead of silently granting a new matching round", async () => {
+  fixture();
+  await screen.findByRole("heading", { name: "All notes" });
+  await search();
+  fireEvent.click(
+    within(screen.getByRole("region", { name: "Notes results" })).getByRole(
+      "button",
+    ),
+  );
+  await screen.findByRole("heading", { name: "Editor A" });
+  act(() => {
+    model.searchInvalidate!("changed");
+    publish({ status: "changed", raw: "needle" });
+  });
+  fireEvent.click(screen.getByRole("button", { name: "Back to search" }));
+  expect(
+    screen.getByRole("heading", { name: "Your library changed" }),
+  ).toBeVisible();
+  expect(model.searchService!.query).toHaveBeenCalledTimes(1);
+});
+it("clears query and every held editor when a held reentry proof fails authority, suppressing its late error", async () => {
+  fixture();
+  await screen.findByRole("heading", { name: "All notes" });
+  fireEvent.click(screen.getByRole("button", { name: /^B / }));
+  await screen.findByRole("heading", { name: "Editor B" });
+  await search();
+  fireEvent.click(
+    within(screen.getByRole("region", { name: "Notes results" })).getByRole(
+      "button",
+    ),
+  );
+  await screen.findByRole("heading", { name: "Editor A" });
+  const proof = held<void>();
+  vi.mocked(model.searchService!.query).mockImplementationOnce(async () => {
+    publish({ status: "pending", raw: "needle", progress: null });
+    await proof.promise;
+    throw Error("Unverified source");
+  });
+  fireEvent.click(screen.getByRole("button", { name: "Back to search" }));
+  expect(screen.queryByText("1 result for “needle”")).not.toBeInTheDocument();
+  await act(async () => {
+    model.searchInvalidate!("unverified");
+    publish({ status: "idle", raw: "" });
+    proof.resolve(undefined);
+  });
+  expect(
+    screen.queryByRole("textbox", { name: "Search notes, clips and cards" }),
+  ).not.toBeInTheDocument();
+  expect(
+    screen.queryByText("Search couldn’t finish this action. Try again."),
+  ).not.toBeInTheDocument();
+  expect(model.noteUnmounts.get("A")).toBe(1);
+  expect(model.noteUnmounts.get("B")).toBe(1);
+});
+it("keeps max2 actors at stable keyed positions through origin B to result A and Clear, preserving local state", async () => {
+  const f = fixture();
+  await screen.findByRole("heading", { name: "All notes" });
+  fireEvent.click(screen.getByRole("button", { name: /^B / }));
+  const origin = (
+    await screen.findByRole("heading", { name: "Editor B" })
+  ).closest("section")!;
+  fireEvent.click(
+    within(origin).getByRole("button", { name: "Advance actor state" }),
+  );
+  await search();
+  fireEvent.click(
+    within(screen.getByRole("region", { name: "Notes results" })).getByRole(
+      "button",
+    ),
+  );
+  await screen.findByRole("heading", { name: "Editor A" });
+  expect(origin.isConnected).toBe(true);
+  expect(model.noteMounts.get("B")).toBe(1);
+  expect(f.view.container.querySelectorAll(".note-actor")).toHaveLength(2);
+  fireEvent.click(screen.getByRole("button", { name: "Back to search" }));
+  await screen.findByText("1 result for “needle”");
+  fireEvent.click(screen.getByRole("button", { name: "Clear search" }));
+  expect(
+    (await screen.findByRole("heading", { name: "Editor B" })).closest(
+      "section",
+    ),
+  ).toBe(origin);
+  expect(within(origin).getByRole("status")).toHaveTextContent(
+    "Actor state B 1",
+  );
+  expect(model.noteMounts.get("B")).toBe(1);
+  expect(model.noteUnmounts.get("B")).toBeUndefined();
+  expect(f.view.container.querySelectorAll(".note-actor")).toHaveLength(1);
+});
+
+it("freshens a hidden ready certificate on sidebar reentry before exposing any old counts", async () => {
+  fixture();
+  await screen.findByRole("heading", { name: "All notes" });
+  await search();
+  fireEvent.click(screen.getByRole("button", { name: /^All notes/ }));
+  const proof = held<void>();
+  vi.mocked(model.searchService!.query).mockImplementationOnce(async () => {
+    publish({ status: "pending", raw: "needle", progress: null });
+    await proof.promise;
+    publish(readySearch());
+  });
+  fireEvent.click(
+    screen.getByRole("button", { name: "Search notes, clips and cards" }),
+  );
+  expect(
+    screen.getByText("Searching local notes, clips and cards…"),
+  ).toBeVisible();
+  expect(screen.queryByText("1 result for “needle”")).not.toBeInTheDocument();
+  expect(model.searchService!.query).toHaveBeenLastCalledWith(
+    "needle",
+    undefined,
+    { note: 0 },
+  );
+  await act(async () => proof.resolve(undefined));
+  await screen.findByText("1 result for “needle”");
+});
+
+it("passes only numeric current page intent into a fresh query, never retained cursors", async () => {
+  fixture();
+  await screen.findByRole("heading", { name: "All notes" });
+  await search();
+  const state = readySearch();
+  if (state.status !== "ready") throw Error("Expected ready fixture");
+  act(() =>
+    publish({
+      ...state,
+      counts: { all: 120, notes: 120, clips: 0, cards: 0 },
+      groups: state.groups.map((group) => ({ ...group, offset: 50 })),
+    }),
+  );
+  fireEvent.click(
+    within(screen.getByRole("region", { name: "Notes results" })).getByRole(
+      "button",
+      { name: "A" },
+    ),
+  );
+  await screen.findByRole("heading", { name: "Editor A" });
+  fireEvent.click(screen.getByRole("button", { name: "Back to search" }));
+  expect(model.searchService!.query).toHaveBeenLastCalledWith(
+    "needle",
+    undefined,
+    { note: 50 },
+  );
+});
diff --git a/web/tests/ui/setup.test.tsx b/web/tests/ui/setup.test.tsx
new file mode 100644
index 0000000..2880747
--- /dev/null
+++ b/web/tests/ui/setup.test.tsx
@@ -0,0 +1,478 @@
+import {
+  act,
+  fireEvent,
+  render,
+  screen,
+  waitFor,
+  within,
+} from "@testing-library/react";
+import { beforeEach, afterEach, expect, it, vi } from "vitest";
+import type { Note, NotesStore } from "../../src/domain/contracts";
+import type {
+  NotesLibrary,
+  NotesLibraryStore,
+  LibrarySnapshot,
+} from "../../src/library/contracts";
+import type {
+  NoteLinkService,
+  OwnerAdmission,
+} from "../../src/links/contracts";
+import { createSetupPreference } from "../../src/setup/preference";
+import { registerCloseGuard, checkClose } from "../../src/desktop/closeGuard";
+import { Workspace } from "../../src/ui/Workspace";
+import { FirstRunSetup } from "../../src/ui/FirstRunSetup";
+const model = vi.hoisted(() => ({
+  boot: true,
+  service: null as NoteLinkService | null,
+  mounts: 0,
+  unmounts: 0,
+}));
+vi.mock("../../src/ui/noteLinkOwner", () => ({
+  useNoteLinkOwner: () => ({
+    service: model.service,
+    bootSettled: model.boot,
+    error: "",
+    retry: vi.fn(),
+  }),
+}));
+vi.mock("../../src/ui/studySourceOwners", () => ({
+  useStudySourceOwners: () => ({
+    service: null,
+    collections: null,
+    bootSettled: model.boot,
+    error: "",
+    retry: vi.fn(),
+  }),
+}));
+vi.mock("../../src/ui/CollectionsHost", async () => {
+  const React = await import("react");
+  return {
+    CollectionsHost: ({ view }: { view: string }) => {
+      const [value, setValue] = React.useState(0);
+      React.useEffect(() => {
+        model.mounts++;
+        return () => {
+          model.unmounts++;
+        };
+      }, []);
+      return (
+        <section aria-label={`${view} actor`}>
+          <output>{value}</output>
+          <button onClick={() => setValue(value + 1)}>Advance actor</button>
+        </section>
+      );
+    },
+  };
+});
+type NoteInput = Parameters<NotesStore["create"]>[0];
+const epoch = "22222222-2222-4222-8222-222222222222",
+  accountId = "11111111-1111-4111-8111-111111111111";
+function fixture({
+  populated = false,
+  incoming = false,
+  readOnly = false,
+  dismissed = false,
+} = {}) {
+  const notes: Note[] = populated
+    ? [
+        {
+          id: "existing",
+          revision: 1,
+          title: "Existing note",
+          document: { type: "doc", content: [{ type: "paragraph" }] },
+          tags: [],
+          createdAt: "2026-11-11T00:00:00Z",
+          updatedAt: "2026-11-11T00:00:00Z",
+          trashedAt: null,
+        },
+      ]
+    : [];
+  const snapshot = (): LibrarySnapshot => ({
+      token: { epoch, revision: notes.length },
+      notes: [...notes],
+      tags: [],
+      metadata: [],
+      preferences: { sort: "edited" },
+    }),
+    listeners = new Set<() => void>(),
+    linkListeners = new Set<() => void>();
+  let admission: OwnerAdmission = readOnly
+    ? {
+        mode: "index-recovery",
+        token: snapshot().token,
+        reason: "index-invalid",
+      }
+    : { mode: "current", token: snapshot().token, graph: "pending" };
+  const library: NotesLibrary = {
+    read: vi.fn(async () => ({ mode: "ready" as const, snapshot: snapshot() })),
+    updateWithSourceSteps: vi.fn(),
+    replaceDocument: vi.fn(),
+    setPinned: vi.fn(),
+    setSort: vi.fn(),
+    createTag: vi.fn(),
+    renameTag: vi.fn(),
+    recolorTag: vi.fn(),
+    mergeTag: vi.fn(),
+    deleteTag: vi.fn(),
+    history: vi.fn(),
+    version: vi.fn(),
+    restoreVersion: vi.fn(),
+    changeTrash: vi.fn(),
+    undoTrash: vi.fn(),
+    emptyTrash: vi.fn(),
+    eraseLegacy: vi.fn(),
+  };
+  const append = (input: NoteInput): Note => {
+    const note: Note = {
+      ...input,
+      id: `import-${notes.length}`,
+      revision: 1,
+      createdAt: "2026-11-11T00:00:00Z",
+      updatedAt: "2026-11-11T00:00:00Z",
+      trashedAt: null,
+    };
+    notes.push(note);
+    listeners.forEach((fn) => fn());
+    return note;
+  };
+  const store: NotesStore = {
+    list: vi.fn(async () => [...notes]),
+    get: vi.fn(async (id) => notes.find((note) => note.id === id) ?? null),
+    create: vi.fn(async (input) => append(input)),
+    update: vi.fn(),
+    trash: vi.fn(),
+    restore: vi.fn(),
+    erase: vi.fn(),
+    subscribe: (listener) => {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    persistence: () => ({ status: "ready" }),
+    close: vi.fn(),
+  };
+  const owner: NotesLibraryStore = { ...store, library };
+  const service: NoteLinkService = {
+    admission: vi.fn(async () => admission),
+    currentToken: vi.fn(),
+    search: vi.fn(),
+    reference: vi.fn(),
+    resolve: vi.fn(),
+    outgoing: vi.fn(),
+    backlinks: vi.fn(),
+    linkedNoteIds: vi.fn(async () => ({
+      status: "ready" as const,
+      token: snapshot().token,
+      items: [],
+    })),
+    verifyGraph: vi.fn(),
+    cancelVerification: vi.fn(),
+    prepareRepair: vi.fn(),
+    commitRepair: vi.fn(),
+    prepareExport: vi.fn(),
+    exportFiles: vi.fn(),
+    assertFreshExport: vi.fn(),
+    subscribe: (listener) => {
+      linkListeners.add(listener);
+      return () => {
+        linkListeners.delete(listener);
+      };
+    },
+    onInvalidate: () => () => {},
+    close: vi.fn(),
+  };
+  model.service = service;
+  const preference = createSetupPreference(() => null);
+  if (dismissed) preference.dismiss();
+  const props = {
+    store,
+    library,
+    sourceOwner: owner,
+    session: {
+      accountId,
+      deviceId: "33333333-3333-4333-8333-333333333333",
+      email: "setup-boundary@example.test",
+      deviceState: "trusted" as const,
+    },
+    onSignOut: vi.fn(async () => {}),
+    incomingNoteIntentActive: incoming,
+    setupPreference: preference,
+  };
+  const view = render(<Workspace {...props} />);
+  return {
+    view,
+    props,
+    store,
+    notes,
+    append,
+    preference,
+    notify: () => listeners.forEach((fn) => fn()),
+    writable: () => {
+      admission = {
+        mode: "current",
+        token: snapshot().token,
+        graph: "pending",
+      };
+      linkListeners.forEach((fn) => fn());
+    },
+  };
+}
+beforeEach(() => {
+  model.boot = true;
+  model.service = null;
+  model.mounts = 0;
+  model.unmounts = 0;
+  vi.stubGlobal("matchMedia", () => ({
+    matches: true,
+    addEventListener: vi.fn(),
+    removeEventListener: vi.fn(),
+  }));
+  HTMLDialogElement.prototype.showModal = function () {
+    this.setAttribute("open", "");
+  };
+  HTMLDialogElement.prototype.close = function () {
+    this.removeAttribute("open");
+  };
+  window.scrollBy = vi.fn();
+});
+afterEach(() => vi.unstubAllGlobals());
+function file(name: string, text: string) {
+  const value = new File([text], name, { type: "text/markdown" });
+  Object.defineProperty(value, "text", { value: vi.fn(async () => text) });
+  return value;
+}
+async function setup() {
+  return screen.findByRole("dialog", { name: "Set up Orbyn Notes" });
+}
+async function skipAll() {
+  let dialog = await setup();
+  fireEvent.click(within(dialog).getByRole("button", { name: "Skip" }));
+  fireEvent.click(within(dialog).getByRole("button", { name: "Skip" }));
+  await waitFor(() =>
+    expect(
+      screen.queryByRole("dialog", { name: "Set up Orbyn Notes" }),
+    ).not.toBeInTheDocument(),
+  );
+}
+it("opens optional setup once for a genuinely scoped empty writable library and reaches exact empty-library actions after skip", async () => {
+  const f = fixture();
+  const dialog = await setup();
+  expect(dialog).toHaveTextContent("Every step is optional.");
+  expect(dialog).toHaveTextContent("Apple Notes import isn’t available");
+  expect(
+    within(dialog).queryByRole("button", { name: /Apple|Sync|Plus/ }),
+  ).not.toBeInTheDocument();
+  await skipAll();
+  expect(f.preference.isDismissed()).toBe(true);
+  expect(screen.getByRole("heading", { name: "No notes yet" })).toBeVisible();
+  expect(
+    screen.getByText(
+      "Write your first note, or bring in what you already have.",
+    ),
+  ).toBeVisible();
+  expect(screen.getByText("Notes are encrypted on this device.")).toBeVisible();
+  expect(screen.getByRole("button", { name: "Import notes" })).toBeVisible();
+  expect(
+    screen.getByText(
+      "Setup closed. This browser couldn’t save the preference.",
+    ),
+  ).toBeVisible();
+});
+it("consumes the automatic attempt when an incoming intent refuses it, without takeover when the intent finishes", async () => {
+  const f = fixture({ incoming: true });
+  await screen.findByRole("heading", { name: "No notes yet" });
+  await act(async () => {});
+  expect(
+    screen.queryByRole("dialog", { name: "Set up Orbyn Notes" }),
+  ).not.toBeInTheDocument();
+  f.view.rerender(<Workspace {...f.props} incomingNoteIntentActive={false} />);
+  act(f.notify);
+  await act(async () => {});
+  expect(
+    screen.queryByRole("dialog", { name: "Set up Orbyn Notes" }),
+  ).not.toBeInTheDocument();
+});
+it("does not open after read-only recovery or after a dirty guard later clears", async () => {
+  const f = fixture({ readOnly: true });
+  await screen.findByText(
+    "Note links need repair. Your notes are still available.",
+  );
+  await act(async () => {});
+  act(f.writable);
+  await act(async () => {});
+  expect(
+    screen.queryByRole("dialog", { name: "Set up Orbyn Notes" }),
+  ).not.toBeInTheDocument();
+  f.view.unmount();
+  const stop = registerCloseGuard(() => false);
+  const other = fixture();
+  try {
+    await screen.findByRole("heading", { name: "No notes yet" });
+    await act(async () => {});
+  } finally {
+    stop();
+  }
+  act(other.notify);
+  await act(async () => {});
+  expect(
+    screen.queryByRole("dialog", { name: "Set up Orbyn Notes" }),
+  ).not.toBeInTheDocument();
+});
+it("keeps a clean Study actor mounted through explicit Settings setup, even when the profile hint was already dismissed", async () => {
+  const f = fixture({ populated: true, dismissed: true });
+  await screen.findByRole("heading", { name: "All notes" });
+  fireEvent.click(screen.getByRole("button", { name: "Study" }));
+  const actor = await screen.findByRole("region", { name: "study actor" });
+  fireEvent.click(within(actor).getByRole("button", { name: "Advance actor" }));
+  fireEvent.click(screen.getByRole("button", { name: "Settings" }));
+  fireEvent.click(
+    within(screen.getByRole("dialog", { name: "Settings" })).getByRole(
+      "button",
+      { name: "Set up Notes" },
+    ),
+  );
+  const dialog = await setup();
+  fireEvent.click(within(dialog).getByRole("button", { name: "Close setup" }));
+  await waitFor(() =>
+    expect(
+      screen.queryByRole("dialog", { name: "Set up Orbyn Notes" }),
+    ).not.toBeInTheDocument(),
+  );
+  expect(
+    within(screen.getByRole("region", { name: "study actor" })).getByRole(
+      "status",
+    ),
+  ).toHaveTextContent("1");
+  expect(model.mounts).toBe(1);
+  expect(model.unmounts).toBe(0);
+  expect(f.preference.isDismissed()).toBe(true);
+});
+it("cancels the actual file-selection operation without completing setup or leaving a held close guard", async () => {
+  const f = fixture();
+  fireEvent.click(
+    within(await setup()).getByRole("button", { name: "Import notes" }),
+  );
+  expect(checkClose()).toBe("draft");
+  act(() => {
+    f.view.container
+      .querySelector("input[type=file]")!
+      .dispatchEvent(new Event("cancel"));
+  });
+  await waitFor(() => expect(checkClose()).toBe("allowed"));
+  expect(
+    within(await setup()).getByRole("button", { name: "Import notes" }),
+  ).toBeEnabled();
+  expect(f.store.create).not.toHaveBeenCalled();
+  expect(f.preference.isDismissed()).toBe(false);
+});
+it("preserves partial imports and retries only remaining Markdown while reporting real completion", async () => {
+  const f = fixture();
+  fireEvent.click(
+    within(await setup()).getByRole("button", { name: "Import notes" }),
+  );
+  fireEvent.change(f.view.container.querySelector("input[type=file]")!, {
+    target: { files: [file("one.md", "# One"), file("two.md", "# Two")] },
+  });
+  const review = await screen.findByRole("dialog", { name: "Import Markdown" });
+  vi.mocked(f.store.create)
+    .mockImplementationOnce(async (input) => f.append(input))
+    .mockRejectedValueOnce(Error("Storage is full."));
+  fireEvent.click(
+    within(review).getByRole("button", { name: "Import remaining" }),
+  );
+  await within(review).findByText(/Imported 1 of 2 notes/);
+  expect(f.notes).toHaveLength(1);
+  expect(checkClose()).toBe("draft");
+  fireEvent.click(
+    within(review).getByRole("button", { name: "Import remaining" }),
+  );
+  await waitFor(() =>
+    expect(
+      screen.queryByRole("dialog", { name: "Import Markdown" }),
+    ).not.toBeInTheDocument(),
+  );
+  expect(f.notes).toHaveLength(2);
+  expect(f.store.create).toHaveBeenCalledTimes(3);
+  expect(within(await setup()).getByText("2 notes imported.")).toBeVisible();
+  expect(within(await setup()).getByText("Step 3 of 3")).toBeVisible();
+  expect(f.preference.isDismissed()).toBe(false);
+});
+it("uses truthful native storage copy without a working sync or Apple Notes action", () => {
+  render(
+    <FirstRunSetup
+      email="synthetic@example.test"
+      environment="desktop"
+      importState="idle"
+      onChooseMarkdown={vi.fn()}
+      onComplete={vi.fn()}
+      onClose={vi.fn()}
+    />,
+  );
+  const dialog = screen.getByRole("dialog", { name: "Set up Orbyn Notes" });
+  expect(dialog).toHaveTextContent("in this app on this device");
+  expect(dialog).not.toHaveTextContent("browser profile");
+  expect(dialog).not.toHaveTextContent("Plus");
+  expect(
+    within(dialog).queryByRole("button", { name: /Sync|Apple/ }),
+  ).not.toBeInTheDocument();
+});
+it("closes clean setup for an incoming intent without completing the profile hint or reopening afterward", async () => {
+  const f = fixture();
+  await setup();
+  f.view.rerender(<Workspace {...f.props} incomingNoteIntentActive />);
+  await waitFor(() =>
+    expect(
+      screen.queryByRole("dialog", { name: "Set up Orbyn Notes" }),
+    ).not.toBeInTheDocument(),
+  );
+  expect(f.preference.isDismissed()).toBe(false);
+  f.view.rerender(<Workspace {...f.props} incomingNoteIntentActive={false} />);
+  act(f.notify);
+  await act(async () => {});
+  expect(
+    screen.queryByRole("dialog", { name: "Set up Orbyn Notes" }),
+  ).not.toBeInTheDocument();
+});
+it("disposes the Journal actor while setup is visible and creates a new protected owner on return", async () => {
+  fixture({ populated: true, dismissed: true });
+  await screen.findByRole("heading", { name: "All notes" });
+  fireEvent.click(screen.getByRole("button", { name: "Journal" }));
+  const actor = await screen.findByRole("region", { name: "journal actor" });
+  fireEvent.click(within(actor).getByRole("button", { name: "Advance actor" }));
+  fireEvent.click(screen.getByRole("button", { name: "Settings" }));
+  fireEvent.click(
+    within(screen.getByRole("dialog", { name: "Settings" })).getByRole(
+      "button",
+      { name: "Set up Notes" },
+    ),
+  );
+  const dialog = await setup();
+  expect(
+    screen.queryByRole("region", { name: "journal actor" }),
+  ).not.toBeInTheDocument();
+  expect(model.unmounts).toBe(1);
+  fireEvent.click(within(dialog).getByRole("button", { name: "Close setup" }));
+  const returned = await screen.findByRole("region", { name: "journal actor" });
+  expect(within(returned).getByRole("status")).toHaveTextContent("0");
+  expect(model.mounts).toBe(2);
+});
+it("keeps invalid Markdown selection on the import step with no writes, completion or held guard", async () => {
+  const f = fixture();
+  fireEvent.click(
+    within(await setup()).getByRole("button", { name: "Import notes" }),
+  );
+  fireEvent.change(f.view.container.querySelector("input[type=file]")!, {
+    target: { files: [file("wrong.txt", "not Markdown")] },
+  });
+  const dialog = await setup();
+  await within(dialog).findByRole("alert");
+  expect(dialog).toHaveTextContent("Choose Markdown files up to 2 MB each.");
+  expect(dialog).toHaveTextContent("Step 2 of 3");
+  expect(f.store.create).not.toHaveBeenCalled();
+  expect(f.preference.isDismissed()).toBe(false);
+  expect(checkClose()).toBe("allowed");
+  expect(
+    within(dialog).getByRole("button", { name: "Import notes" }),
+  ).toBeEnabled();
+});