diff --git a/packages/host/app/components/operator-mode/submode-layout.gts b/packages/host/app/components/operator-mode/submode-layout.gts
index 59e102b70cc..060818f5c8e 100644
--- a/packages/host/app/components/operator-mode/submode-layout.gts
+++ b/packages/host/app/components/operator-mode/submode-layout.gts
@@ -51,6 +51,7 @@ import type AiAssistantPanelService from '../../services/ai-assistant-panel-serv
 import type MatrixService from '../../services/matrix-service';
 import type OperatorModeStateService from '../../services/operator-mode-state-service';
 import type RecentCardsService from '../../services/recent-cards-service';
+import type SearchSheetStateService from '../../services/search-sheet-state';
 import type StoreService from '../../services/store';
 import type { SearchSheetMode } from '../search-sheet';
 import type { Submode } from '../submode-switcher';
@@ -137,6 +138,8 @@ export default class SubmodeLayout extends Component<Signature> {
   @service declare private store: StoreService;
   @service declare private aiAssistantPanelService: AiAssistantPanelService;
   @service declare private recentCardsService: RecentCardsService;
+  @service('search-sheet-state')
+  declare private searchSheetState: SearchSheetStateService;
 
   private searchElement: HTMLElement | null = null;
   private suppressSearchClose = false;
@@ -346,7 +349,11 @@ export default class SubmodeLayout extends Component<Signature> {
 
   @action private openSearchSheetToPrompt() {
     if (this.searchSheetMode === SearchSheetModes.Closed) {
-      this.searchSheetMode = SearchSheetModes.SearchPrompt;
+      // Reopen straight to the results view when a search is persisted, so the
+      // restored results are shown immediately rather than the compact prompt.
+      this.searchSheetMode = this.searchSheetState.searchKey.trim()
+        ? SearchSheetModes.SearchResults
+        : SearchSheetModes.SearchPrompt;
     }
 
     this.searchElement?.focus();
diff --git a/packages/host/app/components/search-sheet/index.gts b/packages/host/app/components/search-sheet/index.gts
index 6a4342ff841..937501b8537 100644
--- a/packages/host/app/components/search-sheet/index.gts
+++ b/packages/host/app/components/search-sheet/index.gts
@@ -4,7 +4,6 @@ import type Owner from '@ember/owner';
 import { debounce } from '@ember/runloop';
 import { service } from '@ember/service';
 import Component from '@glimmer/component';
-import { tracked } from '@glimmer/tracking';
 
 import onClickOutside from 'ember-click-outside/modifiers/on-click-outside';
 import { modifier } from 'ember-modifier';
@@ -27,6 +26,7 @@ import {
 } from '@cardstack/runtime-common';
 
 import type RealmServerService from '@cardstack/host/services/realm-server';
+import type SearchSheetStateService from '@cardstack/host/services/search-sheet-state';
 import {
   isURLSearchKey,
   resolveSearchKeyAsURL,
@@ -35,6 +35,7 @@ import {
 import SearchPanel from '../search/panel';
 
 import type StoreService from '../../services/store';
+import type { SortOption } from '../search/constants';
 
 export const SearchSheetModes = {
   Closed: 'closed',
@@ -87,11 +88,31 @@ const repositionDropdownsOnTransitionEnd = modifier((element: Element) => {
 const BASE_FILTER: Filter = { type: baseRef };
 
 export default class SearchSheet extends Component<Signature> {
-  @tracked private searchKey = '';
-  @tracked private initialSelectedTypes: ResolvedCodeRef[] | undefined;
-
   @service declare private realmServer: RealmServerService;
   @service declare private store: StoreService;
+  @service('search-sheet-state')
+  declare private searchSheetState: SearchSheetStateService;
+
+  // The sheet's search state is held in the session-scoped service so it
+  // survives the close/reopen that unmounts this component's subtree.
+  private get searchKey() {
+    return this.searchSheetState.searchKey;
+  }
+  private set searchKey(value: string) {
+    this.searchSheetState.searchKey = value;
+  }
+
+  private get initialSelectedTypes(): ResolvedCodeRef[] | undefined {
+    return this.searchSheetState.selectedTypes;
+  }
+
+  private get initialSelectedRealms(): URL[] {
+    return this.searchSheetState.selectedRealms;
+  }
+
+  private get initialActiveSort(): SortOption | undefined {
+    return this.searchSheetState.activeSort;
+  }
 
   constructor(owner: Owner, args: any) {
     super(owner, args);
@@ -141,29 +162,27 @@ export default class SearchSheet extends Component<Signature> {
 
   @action
   private onBlur() {
+    // A plain close/blur keeps the search so reopening restores it; only an
+    // explicit Cancel (or Escape) resets.
     this.args.onBlur();
-    if (this.args.mode === SearchSheetModes.Closed) {
-      this.resetState();
-    }
   }
 
   @action private handleCardSelect(selection: string | { realmURL: string }) {
     if (typeof selection !== 'string') {
       return;
     }
-    this.resetState();
+    // Selecting a result keeps the search, so reopening returns to it.
     this.args.onCardSelect(selection);
   }
 
   @action
   private doExternallyTriggeredSearch(term: string, typeRef?: ResolvedCodeRef) {
     this.searchKey = term;
-    this.initialSelectedTypes = typeRef ? [typeRef] : undefined;
+    this.searchSheetState.selectedTypes = typeRef ? [typeRef] : undefined;
   }
 
   private resetState() {
-    this.searchKey = '';
-    this.initialSelectedTypes = undefined;
+    this.searchSheetState.resetState();
   }
 
   @action private debouncedSetSearchKey(searchKey: string) {
@@ -176,14 +195,23 @@ export default class SearchSheet extends Component<Signature> {
     this.args.onSearch?.(searchKey);
   }
 
-  @action private handleRealmChange(_selectedRealms: URL[]) {
+  @action private handleRealmChange(selectedRealms: URL[]) {
+    this.searchSheetState.selectedRealms = selectedRealms;
     this.args.onFilterChange?.();
   }
 
-  @action private handleTypeChange(_selectedTypes: ResolvedCodeRef[]) {
+  @action private handleTypeChange(selectedTypes: ResolvedCodeRef[]) {
+    this.searchSheetState.selectedTypes = selectedTypes;
     this.args.onFilterChange?.();
   }
 
+  @action private handleSortChange(option: SortOption) {
+    // Unlike realm/type changes, no `onFilterChange` here: the sort control only
+    // exists in the results view, so there's never a prompt→results expansion to
+    // trigger — just record the choice for persistence.
+    this.searchSheetState.activeSort = option;
+  }
+
   @action private onSearchInputKeyDown(e: Event) {
     let kbEvent = e as KeyboardEvent;
     if (kbEvent.key === 'Escape') {
@@ -268,8 +296,12 @@ export default class SearchSheet extends Component<Signature> {
           @searchKey={{this.searchKey}}
           @baseFilter={{BASE_FILTER}}
           @initialSelectedTypes={{this.initialSelectedTypes}}
+          @initialSelectedRealms={{this.initialSelectedRealms}}
+          @initialActiveSort={{this.initialActiveSort}}
+          @persist={{true}}
           @onRealmChange={{this.handleRealmChange}}
           @onTypeChange={{this.handleTypeChange}}
+          @onSortChange={{this.handleSortChange}}
           as |Bar Content|
         >
           <Bar
diff --git a/packages/host/app/components/search/panel-content.gts b/packages/host/app/components/search/panel-content.gts
index 18ac5f0591e..cf67c255f04 100644
--- a/packages/host/app/components/search/panel-content.gts
+++ b/packages/host/app/components/search/panel-content.gts
@@ -3,7 +3,7 @@ import { service } from '@ember/service';
 import Component from '@glimmer/component';
 import { cached, tracked } from '@glimmer/tracking';
 
-import Modifier from 'ember-modifier';
+import Modifier, { modifier } from 'ember-modifier';
 import { consume } from 'ember-provide-consume-context';
 
 import { cn, eq } from '@cardstack/boxel-ui/helpers';
@@ -26,6 +26,8 @@ import type { TypeFilter } from '@cardstack/host/components/type-picker';
 import type NetworkService from '@cardstack/host/services/network';
 import type RealmServerService from '@cardstack/host/services/realm-server';
 import type RecentCards from '@cardstack/host/services/recent-cards-service';
+import type SearchSheetStateService from '@cardstack/host/services/search-sheet-state';
+import type { MainResultsSnapshot } from '@cardstack/host/services/search-sheet-state';
 
 import {
   buildRecentsQuery,
@@ -131,6 +133,11 @@ interface Signature {
     activeSort: SortOption;
     onSortChange: (sort: SortOption) => void;
     initialFocusedSection?: string | null;
+    // When true, view + pagination back onto the session-scoped
+    // search-sheet-state service, and the main results are snapshotted there so
+    // a reopen redisplays them immediately (the operator-mode search sheet opts
+    // in; the card choosers keep their own ephemeral state).
+    persist?: boolean;
     // When true, search-result tiles render the Adorn visual treatment
     // (teal hover type-label tab + teal selection chip).
     adorn?: boolean;
@@ -157,9 +164,32 @@ export default class PanelContent extends Component<Signature> {
   @service declare realmServer: RealmServerService;
   @service('recent-cards-service')
   declare private recentCardsService: RecentCards;
+  @service('search-sheet-state')
+  declare private searchSheetState: SearchSheetStateService;
+
+  @tracked private _localActiveViewId = 'grid';
+  #localPagination = new SectionPagination(this.args.initialFocusedSection);
+
+  // View + pagination live in the persistence service when persisting so they
+  // survive the sheet's close/reopen; otherwise they are component-local.
+  get activeViewId() {
+    return this.args.persist
+      ? this.searchSheetState.activeViewId
+      : this._localActiveViewId;
+  }
+  set activeViewId(id: string) {
+    if (this.args.persist) {
+      this.searchSheetState.activeViewId = id;
+    } else {
+      this._localActiveViewId = id;
+    }
+  }
 
-  @tracked activeViewId = 'grid';
-  pagination = new SectionPagination(this.args.initialFocusedSection);
+  get pagination(): SectionPagination {
+    return this.args.persist
+      ? this.searchSheetState.pagination
+      : this.#localPagination;
+  }
 
   @consume(GetCardContextName) declare private getCard: getCard;
 
@@ -225,6 +255,15 @@ export default class PanelContent extends Component<Signature> {
     });
   }
 
+  // A stable identity for the current main search — the serialized wire query.
+  // Undefined when the search is idle (empty key or a URL paste, both skipped).
+  // The snapshot is keyed by this so a reopen only redisplays results for the
+  // same search, and an idle sheet never captures (or clobbers) a snapshot.
+  private get mainQueryKey(): string | undefined {
+    let query = this.mainSearchQuery;
+    return query ? JSON.stringify(query) : undefined;
+  }
+
   // In the mini card chooser every result row renders as the uniform CardDef
   // fitted tile instead of each card's own fitted template. Bind that
   // rendering through the wire filter's top-level `eq` htmlQuery — fitted
@@ -376,12 +415,104 @@ export default class PanelContent extends Component<Signature> {
     this.args.onSortChange(option);
   }
 
+  // The snapshot to seed the fresh main-search resource with on reopen, so it
+  // adopts the prior rows and skips its fetch — no re-run, no "Searching…"
+  // flash. Only offered while persisting, and only when a captured snapshot
+  // belongs to the current query and actually has rows; the resource re-checks
+  // the query match before adopting it. A changed term/filter/sort has a
+  // different `mainQueryKey`, so the seed no longer matches and the search runs
+  // normally.
+  get mainSearchSeed(): MainResultsSnapshot | undefined {
+    if (!this.args.persist) {
+      return undefined;
+    }
+    let snapshot = this.searchSheetState.mainSnapshot;
+    if (
+      snapshot === undefined ||
+      snapshot.entries.length === 0 ||
+      snapshot.queryKey !== this.mainQueryKey
+    ) {
+      return undefined;
+    }
+    return snapshot;
+  }
+
+  // Persist a freshly-settled main-search snapshot for a later reopen. Skips a
+  // write that matches the stored one (same query, same rows) so a live re-run
+  // that changed nothing doesn't churn the seed identity.
+  persistMainSnapshot = (snapshot: MainResultsSnapshot) => {
+    let current = this.searchSheetState.mainSnapshot;
+    let unchanged =
+      current !== undefined &&
+      current.queryKey === snapshot.queryKey &&
+      current.entries.length === snapshot.entries.length &&
+      current.meta.page?.total === snapshot.meta.page?.total &&
+      current.entries.every((entry, i) => entry.id === snapshot.entries[i].id);
+    if (unchanged) {
+      return;
+    }
+    this.searchSheetState.mainSnapshot = snapshot;
+  };
+
+  // Restore and track the results-list scroll offset across a sheet
+  // close/reopen (only while persisting; the choosers keep their own scroll).
+  //
+  // Capture records the live offset on every scroll event, so the service
+  // always holds the current position. We deliberately don't capture on
+  // teardown: by the time the modifier's destructor runs the element is
+  // detached and reports `scrollTop === 0`, which would clobber the good value.
+  //
+  // Restore is a per-frame retry rather than a single rAF: the seeded rows land
+  // a microtask + render after mount, so on the first frame the list is usually
+  // not yet tall enough to accept the offset (setting it would clamp to 0).
+  // Re-apply each frame until it sticks (or the content settles shorter than
+  // the offset), then stop. The saved offset is read inside the frame, not in
+  // the modifier body, so recording new positions never re-runs this modifier.
+  // Runs AFTER `ScrollToFocusedSection` (placed earlier on the element), so a
+  // restored focused section can't leave the list scrolled to the top.
+  private persistScroll = modifier((element: HTMLElement) => {
+    if (!this.args.persist) {
+      return undefined;
+    }
+    let rafId: number | undefined;
+    let target: number | undefined;
+    let attempts = 0;
+    let restore = () => {
+      if (target === undefined) {
+        target = this.searchSheetState.resultsScrollTop;
+      }
+      if (target <= 0) {
+        return;
+      }
+      element.scrollTop = target;
+      attempts += 1;
+      if (Math.abs(element.scrollTop - target) > 1 && attempts < 30) {
+        // eslint-disable-next-line @cardstack/boxel/no-raf-for-state -- awaiting post-seed layout
+        rafId = requestAnimationFrame(restore);
+      }
+    };
+    // eslint-disable-next-line @cardstack/boxel/no-raf-for-state -- restore needs post-layout scroll height
+    rafId = requestAnimationFrame(restore);
+
+    let onScroll = () => {
+      this.searchSheetState.resultsScrollTop = element.scrollTop;
+    };
+    element.addEventListener('scroll', onScroll, { passive: true });
+    return () => {
+      if (rafId !== undefined) {
+        cancelAnimationFrame(rafId);
+      }
+      element.removeEventListener('scroll', onScroll);
+    };
+  });
+
   <template>
     <div
       {{ScrollToFocusedSection
         focusedSectionSid=this.pagination.focusedSection
         sectionSelector='[data-section-sid]'
       }}
+      {{this.persistScroll}}
       class={{cn
         'search-sheet-content'
         compact=@isCompact
@@ -404,6 +535,8 @@ export default class PanelContent extends Component<Signature> {
         <SearchResults
           @query={{this.mainSearchQuery}}
           @mode='none'
+          @seed={{this.mainSearchSeed}}
+          @onSnapshot={{if @persist this.persistMainSnapshot}}
           as |mainResults|
         >
           <SearchResults
diff --git a/packages/host/app/components/search/panel.gts b/packages/host/app/components/search/panel.gts
index 5acd63506ac..215a922cbd7 100644
--- a/packages/host/app/components/search/panel.gts
+++ b/packages/host/app/components/search/panel.gts
@@ -31,8 +31,16 @@ interface Signature {
     // A cards-only chooser: the type picker offers card types only (file types
     // are hidden so one can't be selected against the card scope).
     cardsOnly?: boolean;
+    // Seed the sort from a restored value (the search sheet passes its
+    // persisted sort); defaults to the first option otherwise.
+    initialActiveSort?: SortOption;
+    // When true, view + pagination + last-results state persist to the
+    // session-scoped search-sheet-state service (the operator-mode search sheet
+    // opts in; the card choosers do not). Forwarded to PanelContent.
+    persist?: boolean;
     onRealmChange?: (selectedRealms: URL[]) => void;
     onTypeChange?: (selectedTypes: ResolvedCodeRef[]) => void;
+    onSortChange?: (option: SortOption) => void;
   };
   Blocks: {
     default: [
@@ -46,6 +54,7 @@ interface Signature {
         | 'activeSort'
         | 'onSortChange'
         | 'initialFocusedSection'
+        | 'persist'
       >,
     ];
   };
@@ -56,7 +65,8 @@ export default class SearchPanel extends Component<Signature> {
 
   @tracked private selectedRealms: URL[] =
     this.args.initialSelectedRealms ?? [];
-  @tracked private activeSort: SortOption = SORT_OPTIONS[0];
+  @tracked private activeSort: SortOption =
+    this.args.initialActiveSort ?? SORT_OPTIONS[0];
 
   private typeSummaries = getTypeSummaries(this, getOwner(this)!, () => ({
     realmURLs: this.selectedRealmURLs,
@@ -128,6 +138,7 @@ export default class SearchPanel extends Component<Signature> {
   @action
   private onSortChange(option: SortOption) {
     this.activeSort = option;
+    this.args.onSortChange?.(option);
   }
 
   @action
@@ -157,6 +168,7 @@ export default class SearchPanel extends Component<Signature> {
         activeSort=this.activeSort
         onSortChange=this.onSortChange
         initialFocusedSection=this.initialFocusedSectionId
+        persist=@persist
       )
     }}
   </template>
diff --git a/packages/host/app/components/search/search-results.gts b/packages/host/app/components/search/search-results.gts
index 6193c50d907..99b87c91f9f 100644
--- a/packages/host/app/components/search/search-results.gts
+++ b/packages/host/app/components/search/search-results.gts
@@ -1,3 +1,4 @@
+import { isDestroyed, isDestroying } from '@ember/destroyable';
 import { service } from '@ember/service';
 import Component from '@glimmer/component';
 
@@ -16,8 +17,27 @@ import {
 
 import type { HydrationMode } from './hydratable-card';
 
+import type { MainResultsSnapshot } from '../../services/search-sheet-state';
 import type StoreService from '../../services/store';
 
+// The card-facing signature plus two host-only, optional extras used by the
+// search sheet to persist and rehydrate its results across a close/reopen.
+// They stay off the public `SearchResultsComponentSignature` (the `@context`
+// contract cards see) and are absent for every other consumer — the card
+// choosers, playground, and card authors — so their behavior is unchanged.
+interface HostSearchResultsSignature {
+  Element: SearchResultsComponentSignature['Element'];
+  Args: SearchResultsComponentSignature['Args'] & {
+    // A prior run's snapshot to adopt on mount instead of fetching, when it
+    // belongs to the current query (forwarded to the search resource).
+    seed?: MainResultsSnapshot;
+    // Invoked with a fresh snapshot whenever the results settle, so the caller
+    // can persist it for a later reopen.
+    onSnapshot?: (snapshot: MainResultsSnapshot) => void;
+  };
+  Blocks: SearchResultsComponentSignature['Blocks'];
+}
+
 // The one search component family. Consumes the heterogeneous `entry`
 // stream from `getSearchEntriesResource` (through the shared render-stable
 // view-model layer) and renders it transparently — prerendered HTML inert (the
@@ -26,7 +46,7 @@ import type StoreService from '../../services/store';
 // `errors`); used without one it renders the default stream of
 // `entry.component`s itself. Additive: it supersedes the `prerendered-card-search`
 // component and the live `SearchContent` tree as call sites migrate.
-export default class SearchResults extends Component<SearchResultsComponentSignature> {
+export default class SearchResults extends Component<HostSearchResultsSignature> {
   @service declare private store: StoreService;
   #log = runtimeLogger('search-results');
 
@@ -47,6 +67,7 @@ export default class SearchResults extends Component<SearchResultsComponentSigna
     () => this.args.query,
     () => this.mode,
     () => this.overlays,
+    () => this.args.seed,
   );
 
   private get results(): SearchResultsYield {
@@ -82,10 +103,55 @@ export default class SearchResults extends Component<SearchResultsComponentSigna
     },
   );
 
+  // Coalesces snapshot captures so a burst of renders schedules a single write.
+  #snapshotCaptureScheduled = false;
+
+  // When the caller opts in via `@onSnapshot`, hand it a snapshot of the raw
+  // rows every time the results settle, so it can persist them for a later
+  // reopen. Deferred into a microtask (like `SearchEntriesResource.modify`):
+  // the callback typically mutates tracked state the render just consumed, so a
+  // synchronous write would trip Glimmer's backtracking assertion. Guards: no
+  // callback (the choosers), still loading (a transient empty re-run must not
+  // be captured), or an idle query (no key to snapshot by). Re-runs when the
+  // loading state or the raw rows change.
+  private captureSnapshot = modifier(
+    (_element: Element, [_isLoading, _rawEntries]: [boolean, unknown]) => {
+      if (!this.args.onSnapshot || this.renderables.isLoading) {
+        return;
+      }
+      if (this.args.query === undefined) {
+        return;
+      }
+      if (this.#snapshotCaptureScheduled) {
+        return;
+      }
+      this.#snapshotCaptureScheduled = true;
+      void Promise.resolve().then(() => {
+        this.#snapshotCaptureScheduled = false;
+        if (isDestroyed(this) || isDestroying(this)) {
+          return;
+        }
+        let query = this.args.query;
+        if (!this.args.onSnapshot || this.renderables.isLoading || !query) {
+          return;
+        }
+        this.args.onSnapshot({
+          queryKey: JSON.stringify(query),
+          entries: [...this.renderables.rawEntries],
+          meta: this.renderables.meta,
+        });
+      });
+    },
+  );
+
   <template>
     <div
       class='search-results'
       {{this.inflateFullItems this.renderables.entries}}
+      {{this.captureSnapshot
+        this.renderables.isLoading
+        this.renderables.rawEntries
+      }}
       data-test-search-results
       ...attributes
     >
diff --git a/packages/host/app/resources/renderable-search-entries.ts b/packages/host/app/resources/renderable-search-entries.ts
index 8fe58c598cb..187fd4b023c 100644
--- a/packages/host/app/resources/renderable-search-entries.ts
+++ b/packages/host/app/resources/renderable-search-entries.ts
@@ -27,6 +27,7 @@ import {
 } from './search-entries';
 
 import type { HydrationMode } from '../components/search/hydratable-card';
+import type { MainResultsSnapshot } from '../services/search-sheet-state';
 
 // The diagnostic/labeling attributes the prerendered HTML carries so consumers
 // (e.g. the operator-mode overlay) can label and icon a card before its
@@ -292,6 +293,13 @@ export class RenderableSearchEntries {
     });
   }
 
+  // The underlying resource's raw `SearchEntry` rows — the shape a snapshot
+  // captures and later seeds a fresh resource with (the view-models above are
+  // derived and can't be fed back in).
+  get rawEntries(): SearchEntry[] {
+    return this.resource.entries;
+  }
+
   get isLoading(): boolean {
     return this.resource.isLoading;
   }
@@ -317,9 +325,10 @@ export function getRenderableSearchEntries(
   getQuery: () => SearchEntryWireQuery | undefined,
   getMode: () => HydrationMode,
   getOverlays: () => boolean = () => true,
+  getSeed: () => MainResultsSnapshot | undefined = () => undefined,
 ): RenderableSearchEntries {
   return new RenderableSearchEntries(
-    getSearchEntriesResource(owner, getQuery),
+    getSearchEntriesResource(owner, getQuery, getSeed),
     getMode,
     getOverlays,
   );
diff --git a/packages/host/app/resources/search-entries.ts b/packages/host/app/resources/search-entries.ts
index c8439ba3c52..45e035a67a3 100644
--- a/packages/host/app/resources/search-entries.ts
+++ b/packages/host/app/resources/search-entries.ts
@@ -1,4 +1,8 @@
-import { isDestroyed, registerDestructor } from '@ember/destroyable';
+import {
+  isDestroyed,
+  isDestroying,
+  registerDestructor,
+} from '@ember/destroyable';
 import { getOwner } from '@ember/owner';
 import { service } from '@ember/service';
 import { buildWaiter } from '@ember/test-waiters';
@@ -12,6 +16,7 @@ import { TrackedArray } from 'tracked-built-ins';
 
 import {
   subscribeToRealm,
+  Deferred,
   htmlQueryRenderingSelection,
   isCardResource,
   isCssResource,
@@ -43,6 +48,7 @@ import { searchErrorEntry } from '../lib/search-error-entry';
 import type LoaderService from '../services/loader-service';
 import type NetworkService from '../services/network';
 import type RealmServerService from '../services/realm-server';
+import type { MainResultsSnapshot } from '../services/search-sheet-state';
 import type StoreService from '../services/store';
 import type {
   RealmEventContent,
@@ -90,6 +96,10 @@ export interface SearchEntry {
 interface Args {
   named: {
     query: SearchEntryWireQuery | undefined;
+    // A snapshot of a prior run's results to adopt on the first modify instead
+    // of fetching, when it belongs to this exact query. Used by the search
+    // sheet to rehydrate on reopen with no re-run; other consumers omit it.
+    seed?: MainResultsSnapshot;
   };
 }
 
@@ -140,6 +150,10 @@ export class SearchEntriesResource extends Resource<Args> {
 
   #previousQuery: SearchEntryWireQuery | undefined;
   #previousRealms: string[] | undefined;
+  // One-shot: a handed-in seed is adopted at most once, on the first modify of
+  // this instance. Once spent, every later query change — including re-typing a
+  // key that was used before — takes the normal fetch path, never the seed.
+  #seedConsumed = false;
   #idleClearScheduled = false;
   #log = runtimeLogger('search-entries-resource');
   // Kept private for tests/internal load bookkeeping.
@@ -200,7 +214,7 @@ export class SearchEntriesResource extends Resource<Args> {
   }
 
   modify(_positional: never[], named: Args['named']) {
-    let { query } = named;
+    let { query, seed } = named;
 
     if (query === undefined) {
       // Clear stale state so live subscriptions don't re-fire the old query.
@@ -318,7 +332,60 @@ export class SearchEntriesResource extends Resource<Args> {
     this.realmsNeedingRefresh.clear();
     this.pendingSelectiveRefresh = undefined;
     this.hasCompletedFullRun = false;
-    this.#trackSearchLoad(this.search.perform());
+
+    // Seed-and-skip: on the first modify of a freshly-mounted resource, if a
+    // snapshot for this exact query was handed in (the search sheet reopening
+    // with an unchanged search), adopt its rows and skip the fetch — no re-run,
+    // no "Searching…" flash. Subscriptions were already (re)established above,
+    // so a live index event still refreshes these rows while the sheet is open.
+    // One-shot via `#seedConsumed`, and gated on the query match, so any later
+    // query change — including re-typing the same key after changing it — falls
+    // through to the fetch below. The result state is applied out of this render
+    // (a microtask, the same escape hatch the fetch path uses): mutating the
+    // tracked `_entries` / `_meta` synchronously here would trip Glimmer's
+    // backtracking assertion. The rows land right after this render, before
+    // paint, so there is no visible empty frame — and, crucially, no fetch.
+    if (
+      !this.#seedConsumed &&
+      seed !== undefined &&
+      seed.queryKey === JSON.stringify(query)
+    ) {
+      this.#seedConsumed = true;
+      let seeded = seed;
+      void Promise.resolve().then(() => {
+        if (isDestroyed(this) || isDestroying(this)) {
+          return;
+        }
+        this._entries.splice(0, this._entries.length, ...seeded.entries);
+        this._meta = seeded.meta;
+        this._errors = undefined;
+        this.hasCompletedFullRun = true;
+      });
+      return;
+    }
+
+    // Start the search out of the render that triggered this modify. A consumer
+    // reads the task's `isRunning` (through `isLoading`) during render, so a
+    // synchronous `perform()` here — which flips `isRunning` — would mutate a
+    // value already consumed in the same computation, tripping Glimmer's
+    // backtracking assertion. This bites specifically when a `<SearchResults>`
+    // mounts with a query already set (e.g. the search sheet reopening with a
+    // restored query, or a chooser rendering recents), where the create + first
+    // `isRunning` read + `perform()` all land in one render. Register the load
+    // synchronously (via a Deferred) so a prerender still waits for the search,
+    // but defer the task start a microtask so its write lands after the render.
+    let loaded = new Deferred<void>();
+    this.#trackSearchLoad(loaded.promise);
+    void Promise.resolve().then(() => {
+      if (isDestroyed(this) || isDestroying(this)) {
+        loaded.fulfill();
+        return;
+      }
+      this.search.perform().then(
+        () => loaded.fulfill(),
+        () => loaded.fulfill(),
+      );
+    });
   }
 
   get isLoading() {
@@ -871,10 +938,12 @@ function memberValidator(member: SearchEntry): string {
 export function getSearchEntriesResource(
   parent: object,
   getQuery: () => SearchEntryWireQuery | undefined,
+  getSeed: () => MainResultsSnapshot | undefined = () => undefined,
 ) {
   return SearchEntriesResource.from(parent, () => ({
     named: {
       query: getQuery(),
+      seed: getSeed(),
     },
   })) as SearchEntriesResource;
 }
diff --git a/packages/host/app/services/search-sheet-state.ts b/packages/host/app/services/search-sheet-state.ts
new file mode 100644
index 00000000000..2f05139f6b8
--- /dev/null
+++ b/packages/host/app/services/search-sheet-state.ts
@@ -0,0 +1,74 @@
+import type Owner from '@ember/owner';
+import Service, { service } from '@ember/service';
+import { tracked } from '@glimmer/tracking';
+
+import type {
+  EntryCollectionDocument,
+  ResolvedCodeRef,
+} from '@cardstack/runtime-common';
+
+import { SectionPagination } from '../utils/search/section-pagination';
+
+import type ResetService from './reset';
+import type { SortOption } from '../components/search/constants';
+import type { SearchEntry } from '../resources/search-entries';
+
+// A snapshot of the last main-search results, retained across a sheet
+// close/reopen so the recreated search resource can be *seeded* with them and
+// skip its reopen fetch entirely — no blank "Searching…" flash, and no re-run
+// for an unchanged query. These are the resource's own raw `SearchEntry` rows
+// (prerendered HTML strings + the wire `item` serialization), so they are
+// self-contained and safe to hold across the sheet teardown, and feed straight
+// back into a fresh resource. `queryKey` is the serialized wire query the
+// snapshot was captured under, so the sheet only reuses it for the same search
+// it belongs to (a changed term/filter/sort re-runs normally).
+export interface MainResultsSnapshot {
+  queryKey: string;
+  entries: SearchEntry[];
+  meta: EntryCollectionDocument['meta'];
+}
+
+// In-memory, session-scoped store for the operator-mode search sheet. Lets the
+// query, filters, view, pagination, and last results survive a sheet
+// close/reopen within a session — the sheet's `@mode`-gated subtree is still
+// destroyed on close, so this service (not the components) holds the state to
+// rehydrate from. Deliberately NOT persisted to localStorage: a page reload
+// clears it. Cleared on logout/realm reset via the `reset` service, following
+// `RecentCardsService`. Scoped to the sheet only — the card choosers never read
+// or write it (they don't opt in via `@persist`).
+export default class SearchSheetStateService extends Service {
+  @service declare private reset: ResetService;
+
+  @tracked searchKey = '';
+  @tracked selectedTypes: ResolvedCodeRef[] | undefined;
+  @tracked selectedRealms: URL[] = [];
+  @tracked activeSort: SortOption | undefined;
+  @tracked activeViewId = 'grid';
+  @tracked pagination = new SectionPagination();
+  @tracked mainSnapshot: MainResultsSnapshot | undefined;
+  // The results-list scroll offset, restored on reopen. Memory-only like the
+  // rest of this state — a page reload starts back at the top.
+  @tracked resultsScrollTop = 0;
+
+  constructor(owner: Owner) {
+    super(owner);
+    this.reset.register(this);
+  }
+
+  resetState() {
+    this.searchKey = '';
+    this.selectedTypes = undefined;
+    this.selectedRealms = [];
+    this.activeSort = undefined;
+    this.activeViewId = 'grid';
+    this.pagination = new SectionPagination();
+    this.mainSnapshot = undefined;
+    this.resultsScrollTop = 0;
+  }
+}
+
+declare module '@ember/service' {
+  interface Registry {
+    'search-sheet-state': SearchSheetStateService;
+  }
+}
diff --git a/packages/host/tests/acceptance/interact-submode-test.gts b/packages/host/tests/acceptance/interact-submode-test.gts
index 826f60ec9ac..167db9a4f9c 100644
--- a/packages/host/tests/acceptance/interact-submode-test.gts
+++ b/packages/host/tests/acceptance/interact-submode-test.gts
@@ -120,9 +120,11 @@ module('Acceptance | interact submode tests', function (hooks) {
       );
 
       await click('[data-test-open-search-field]');
-      assert.dom('[data-test-search-sheet]').hasClass('prompt');
+      // The search persists across close/reopen, so reopening restores the
+      // results view (with the URL search) rather than a blank prompt.
+      assert.dom('[data-test-search-sheet]').hasClass('results');
 
-      await click(`[data-test-search-result="${testRealmURL}person-entry"]`);
+      await click(`[data-test-card="${testRealmURL}person-entry"]`);
 
       assert
         .dom(`[data-test-stack-card="${testRealmURL}person-entry"]`)
@@ -130,6 +132,188 @@ module('Acceptance | interact submode tests', function (hooks) {
     });
   });
 
+  module('search sheet persistence', function () {
+    test('restores the query, view, and results after a close/reopen', async function (assert) {
+      await visitOperatorMode({});
+
+      // Run a search and switch the results to the strip view.
+      await click('[data-test-open-search-field]');
+      await fillIn('[data-test-search-field]', 'Mango');
+      assert.dom('[data-test-search-sheet]').hasClass('results');
+      assert
+        .dom(`[data-test-search-result="${testRealmURL}Pet/mango"]`)
+        .exists('the search found the card');
+
+      await click('[data-test-search-result-header] [aria-label="strip"]');
+      assert
+        .dom('[data-test-search-result-header] [aria-label="strip"]')
+        .hasClass('is-selected', 'strip view is active');
+
+      // Close the sheet by clicking outside it (a plain close keeps the search).
+      await click('[data-test-submode-layout]');
+      assert.dom('[data-test-search-sheet]').hasClass('closed');
+
+      // Reopening restores the results view, the query text, the view toggle, and
+      // the results (adopted from the retained snapshot, with no re-run).
+      await click('[data-test-open-search-field]');
+      assert.dom('[data-test-search-sheet]').hasClass('results');
+      assert.dom('[data-test-search-field]').hasValue('Mango');
+      assert
+        .dom('[data-test-search-result-header] [aria-label="strip"]')
+        .hasClass('is-selected', 'strip view is restored');
+      assert
+        .dom(`[data-test-search-result="${testRealmURL}Pet/mango"]`)
+        .exists('the results are restored');
+    });
+
+    test('reopening an unchanged search does not re-run the query', async function (assert) {
+      await visitOperatorMode({});
+
+      let store = getService('store');
+      let originalSearchEntries = store.searchEntries.bind(store);
+      let mainSearchFetches = 0;
+      store.searchEntries = async (query, realms) => {
+        // Isolate the main search from the recents query (which is not seeded
+        // and does re-run on reopen) by keying on the search term.
+        if (JSON.stringify(query).toLowerCase().includes('mango')) {
+          mainSearchFetches++;
+        }
+        return originalSearchEntries(query, realms);
+      };
+
+      try {
+        await click('[data-test-open-search-field]');
+        await fillIn('[data-test-search-field]', 'Mango');
+        assert
+          .dom(`[data-test-search-result="${testRealmURL}Pet/mango"]`)
+          .exists('the search found the card');
+        let fetchesAfterSearch = mainSearchFetches;
+        assert.ok(fetchesAfterSearch >= 1, 'the initial search fetched');
+
+        // Close and reopen with the query unchanged.
+        await click('[data-test-submode-layout]');
+        assert.dom('[data-test-search-sheet]').hasClass('closed');
+        await click('[data-test-open-search-field]');
+
+        assert
+          .dom(`[data-test-search-result="${testRealmURL}Pet/mango"]`)
+          .exists('the results are shown immediately on reopen');
+        assert.strictEqual(
+          mainSearchFetches,
+          fetchesAfterSearch,
+          'the seeded reopen performs no additional main-search fetch',
+        );
+
+        // Changing the term still runs a fresh search (the seed only matches
+        // the unchanged query).
+        await fillIn('[data-test-search-field]', 'Van Gogh');
+        assert
+          .dom(`[data-test-search-result="${testRealmURL}Pet/vangogh"]`)
+          .exists('a changed query re-runs the search');
+      } finally {
+        store.searchEntries = originalSearchEntries;
+      }
+    });
+
+    test('restores the results scroll position after a close/reopen', async function (assert) {
+      await visitOperatorMode({});
+
+      // A broad term returns enough results for the list to overflow.
+      await click('[data-test-open-search-field]');
+      await fillIn('[data-test-search-field]', 'ma');
+      assert.dom('[data-test-search-sheet]').hasClass('results');
+      await waitFor('[data-test-search-result]');
+
+      let scrollContainer = document.querySelector(
+        '[data-test-search-sheet] .search-sheet-content',
+      ) as HTMLElement;
+      assert.ok(
+        scrollContainer.scrollHeight > scrollContainer.clientHeight,
+        'the results list overflows and can scroll',
+      );
+
+      // Scroll partway down and fire the scroll event so the offset is recorded.
+      scrollContainer.scrollTop = 60;
+      let expected = scrollContainer.scrollTop;
+      assert.ok(expected > 0, 'the list was scrolled away from the top');
+      await triggerEvent(scrollContainer, 'scroll');
+
+      await click('[data-test-submode-layout]');
+      assert.dom('[data-test-search-sheet]').hasClass('closed');
+
+      await click('[data-test-open-search-field]');
+      let restoredContainer = document.querySelector(
+        '[data-test-search-sheet] .search-sheet-content',
+      ) as HTMLElement;
+      // Restore re-applies per frame until the seeded rows are laid out and the
+      // offset sticks; wait for that to settle.
+      for (
+        let i = 0;
+        i < 30 && Math.abs(restoredContainer.scrollTop - expected) > 1;
+        i++
+      ) {
+        // eslint-disable-next-line @cardstack/boxel/no-raf-for-state -- waiting for the per-frame scroll restore
+        await new Promise((resolve) => requestAnimationFrame(resolve));
+      }
+      assert.strictEqual(
+        restoredContainer.scrollTop,
+        expected,
+        'the scroll position is restored on reopen',
+      );
+    });
+
+    test('the Cancel button clears the persisted search', async function (assert) {
+      await visitOperatorMode({});
+
+      await click('[data-test-open-search-field]');
+      await fillIn('[data-test-search-field]', 'Mango');
+      assert.dom('[data-test-search-sheet]').hasClass('results');
+
+      await click('[data-test-search-sheet-cancel-button]');
+      assert.dom('[data-test-search-sheet]').hasClass('closed');
+
+      await click('[data-test-open-search-field]');
+      assert
+        .dom('[data-test-search-sheet]')
+        .hasClass('prompt', 'reopens to a blank prompt, not the prior results');
+      assert.dom('[data-test-search-field]').hasValue('');
+    });
+
+    test('Escape clears the persisted search', async function (assert) {
+      await visitOperatorMode({});
+
+      await click('[data-test-open-search-field]');
+      await fillIn('[data-test-search-field]', 'Mango');
+      assert.dom('[data-test-search-sheet]').hasClass('results');
+
+      await triggerKeyEvent('[data-test-search-field]', 'keydown', 'Escape');
+      assert.dom('[data-test-search-sheet]').hasClass('closed');
+
+      await click('[data-test-open-search-field]');
+      assert.dom('[data-test-search-sheet]').hasClass('prompt');
+      assert.dom('[data-test-search-field]').hasValue('');
+    });
+
+    test('emptying the query then closing reopens to a blank prompt', async function (assert) {
+      await visitOperatorMode({});
+
+      await click('[data-test-open-search-field]');
+      await fillIn('[data-test-search-field]', 'Mango');
+      assert.dom('[data-test-search-sheet]').hasClass('results');
+
+      // Clear the query, then close by clicking outside.
+      await fillIn('[data-test-search-field]', '');
+      await click('[data-test-submode-layout]');
+      assert.dom('[data-test-search-sheet]').hasClass('closed');
+
+      await click('[data-test-open-search-field]');
+      assert
+        .dom('[data-test-search-sheet]')
+        .hasClass('prompt', 'an empty query reopens to the compact prompt');
+      assert.dom('[data-test-search-field]').hasValue('');
+    });
+  });
+
   module('1 stack', function (_hooks) {
     test('restoring the stack from query param', async function (assert) {
       await visitOperatorMode({
diff --git a/packages/host/tests/integration/components/operator-mode-ui-test.gts b/packages/host/tests/integration/components/operator-mode-ui-test.gts
index 6d5c0f275f8..2d1c9cfa15f 100644
--- a/packages/host/tests/integration/components/operator-mode-ui-test.gts
+++ b/packages/host/tests/integration/components/operator-mode-ui-test.gts
@@ -683,7 +683,7 @@ module('Integration | operator-mode | ui', function (hooks) {
       .doesNotExist('select-all checkbox is unchecked after selecting a realm');
   });
 
-  test('clicking outside search sheet resets search input and realm filter', async function (assert) {
+  test('clicking outside search sheet preserves the realm filter', async function (assert) {
     ctx.setCardInOperatorModeState(`${testRealmURL}grid`);
     await renderComponent(
       class TestDriver extends GlimmerComponent {
@@ -722,22 +722,25 @@ module('Integration | operator-mode | ui', function (hooks) {
     await click(`[data-test-operator-mode-stack]`);
     assert.dom(`[data-test-search-sheet="closed"]`).exists();
 
-    // Reopen search sheet
+    // Reopen search sheet — no search term was entered, so it returns to the
+    // compact prompt.
     await click(`[data-test-open-search-field]`);
     assert.dom(`[data-test-search-sheet="search-prompt"]`).exists();
 
-    // Assert search input is cleared
-    assert
-      .dom('[data-test-search-field]')
-      .hasValue('', 'search input is cleared after clicking outside');
-
-    // Assert realm filter is reset — picker trigger should show "All"
+    // The realm filter is preserved across a plain close/reopen (only an
+    // explicit Cancel or Escape clears it). Reopen the picker and confirm the
+    // realm is still checked.
+    let reopenedRealmTrigger =
+      document.querySelector(
+        '[data-test-realm-picker] .ember-power-select-trigger',
+      ) ?? document.querySelector('[data-test-realm-picker]');
+    await click(reopenedRealmTrigger as HTMLElement);
+    await waitFor('.ember-power-select-option', { timeout: 3000 });
     assert
-      .dom('[data-test-realm-picker] [data-test-boxel-picker-selected-item]')
-      .hasText(
-        'All',
-        'realm filter is reset to select-all after clicking outside',
-      );
+      .dom(
+        `[data-test-boxel-picker-option-label="${ctx.realmName}"] .picker-option-row__checkbox--selected`,
+      )
+      .exists('realm selection is preserved after clicking outside');
   });
 
   test('displays card in interact mode when clicking `Open in Interact Mode` menu in preview panel', async function (assert) {
@@ -958,7 +961,7 @@ module('Integration | operator-mode | ui', function (hooks) {
     );
   });
 
-  test('clicking outside search sheet resets type filter selection', async function (assert) {
+  test('clicking outside search sheet preserves the type filter selection', async function (assert) {
     ctx.setCardInOperatorModeState(`${testRealmURL}grid`);
     await renderComponent(
       class TestDriver extends GlimmerComponent {
@@ -997,25 +1000,24 @@ module('Integration | operator-mode | ui', function (hooks) {
     await click(`[data-test-operator-mode-stack]`);
     assert.dom(`[data-test-search-sheet="closed"]`).exists();
 
-    // Reopen search sheet
+    // Reopen — the persisted search term brings the sheet straight back to the
+    // results view with the type filter still applied (only an explicit Cancel
+    // or Escape clears it).
     await click(`[data-test-open-search-field]`);
-    assert.dom(`[data-test-search-sheet="search-prompt"]`).exists();
-
-    // Type filter should be reset — "Any" (select-all) is the only active selection.
-    // The Picker auto-selects the select-all option when @selected is empty, but
-    // select-all items never render a remove button, so its absence confirms no
-    // specific type filter is active.
-    assert
-      .dom('[data-test-type-picker] [data-test-boxel-picker-remove-button]')
-      .doesNotExist(
-        'specific type filter is cleared after closing the search sheet',
-      );
+    assert.dom(`[data-test-search-sheet="search-results"]`).exists();
     assert
-      .dom('[data-test-type-picker] [data-test-boxel-picker-selected-item]')
-      .hasText(
-        'Any',
-        'type picker shows shortLabel "Any" after reset to select-all',
-      );
+      .dom('[data-test-search-field]')
+      .hasValue('Mango', 'the search term is preserved after clicking outside');
+
+    if (typeOptions.length > 0) {
+      // A specific type is still selected — its remove button is present (the
+      // select-all "Any" option never renders one).
+      assert
+        .dom('[data-test-type-picker] [data-test-boxel-picker-remove-button]')
+        .exists(
+          'the type filter selection is preserved after clicking outside',
+        );
+    }
   });
 
   test('type options derived from realm types when no search term, sorted alphabetically', async function (assert) {
diff --git a/packages/host/tests/integration/resources/search-entries-test.gts b/packages/host/tests/integration/resources/search-entries-test.gts
index d8256e6ac69..a496627fd19 100644
--- a/packages/host/tests/integration/resources/search-entries-test.gts
+++ b/packages/host/tests/integration/resources/search-entries-test.gts
@@ -27,9 +27,11 @@ import {
 import {
   getSearchEntriesResource,
   SearchEntriesResource,
+  type SearchEntry,
 } from '@cardstack/host/resources/search-entries';
 
 import type LoaderService from '@cardstack/host/services/loader-service';
+import type { MainResultsSnapshot } from '@cardstack/host/services/search-sheet-state';
 import type StoreService from '@cardstack/host/services/store';
 
 import {
@@ -52,7 +54,12 @@ const testRealm2URL = 'http://test-realm/test2/';
 
 function getResourceForTest(
   parent: object,
-  args: () => { named: { query: SearchEntryWireQuery | undefined } },
+  args: () => {
+    named: {
+      query: SearchEntryWireQuery | undefined;
+      seed?: MainResultsSnapshot;
+    };
+  },
 ) {
   return SearchEntriesResource.from(parent, args) as unknown as Omit<
     SearchEntriesResource,
@@ -62,7 +69,10 @@ function getResourceForTest(
     loaded: Promise<void>;
     modify: (
       positional: never[],
-      named: { query: SearchEntryWireQuery | undefined },
+      named: {
+        query: SearchEntryWireQuery | undefined;
+        seed?: MainResultsSnapshot;
+      },
     ) => void;
   };
 }
@@ -1720,6 +1730,139 @@ module('Integration | search-entries resource', function (hooks) {
     }
   });
 
+  // Seed-and-skip: a snapshot handed in for the current query is adopted on the
+  // first modify instead of fetching, so the search sheet reopening with an
+  // unchanged search shows its prior rows with no re-run. One-shot per instance.
+  module('seed-and-skip', function () {
+    let queryA: SearchEntryWireQuery = {
+      filter: { 'item.on': bookRef },
+      realms: [testRealmURL],
+    };
+    let queryB: SearchEntryWireQuery = {
+      filter: { 'item.on': bookRef, eq: { 'item.status': 'ready' } },
+      realms: [testRealmURL],
+    };
+
+    function seedEntry(id: string): SearchEntry {
+      return { id, realmUrl: testRealmURL, html: [] };
+    }
+
+    function seedFor(
+      query: SearchEntryWireQuery,
+      ids: string[],
+    ): MainResultsSnapshot {
+      return {
+        queryKey: JSON.stringify(query),
+        entries: ids.map(seedEntry),
+        meta: { page: { total: ids.length } },
+      };
+    }
+
+    function countingSearchEntries() {
+      let count = 0;
+      let original = storeService.searchEntries.bind(storeService);
+      storeService.searchEntries = async (query, realms) => {
+        count++;
+        return await original(query, realms);
+      };
+      return {
+        get count() {
+          return count;
+        },
+        restore() {
+          storeService.searchEntries = original;
+        },
+      };
+    }
+
+    test('a seed for the current query adopts its rows and skips the fetch', async function (assert) {
+      let fetches = countingSearchEntries();
+      try {
+        let search = getResourceForTest(storeService, () => ({
+          named: {
+            query: queryA,
+            seed: seedFor(queryA, [`${testRealmURL}books/1`]),
+          },
+        }));
+        // Reading a property runs modify(), which schedules the seed; it lands
+        // on the following microtask (settle), before any paint.
+        void search.entries;
+        await settled();
+        assert.strictEqual(
+          search.entries.length,
+          1,
+          'the seeded row is adopted',
+        );
+        assert.strictEqual(
+          search.entries[0].id,
+          `${testRealmURL}books/1`,
+          'the adopted row is the seeded one',
+        );
+        assert.strictEqual(
+          search.meta.page.total,
+          1,
+          'the seeded meta is used',
+        );
+        assert.strictEqual(fetches.count, 0, 'no fetch is performed');
+      } finally {
+        fetches.restore();
+      }
+    });
+
+    test('a seed for a different query is ignored and the search fetches', async function (assert) {
+      let fetches = countingSearchEntries();
+      try {
+        let search = getResourceForTest(storeService, () => ({
+          named: {
+            query: queryA,
+            // Snapshot belongs to queryB, so its key won't match queryA.
+            seed: seedFor(queryB, [`${testRealmURL}books/1`]),
+          },
+        }));
+        await search.loaded;
+        assert.strictEqual(fetches.count, 1, 'the mismatched seed is ignored');
+        assert.strictEqual(
+          search.entries.length,
+          2,
+          'the real search results are used',
+        );
+      } finally {
+        fetches.restore();
+      }
+    });
+
+    test('the seed is one-shot: a later query change re-fetches, even back to the seeded query', async function (assert) {
+      let fetches = countingSearchEntries();
+      try {
+        let seed = seedFor(queryA, [`${testRealmURL}books/1`]);
+        let search = getResourceForTest(storeService, () => ({
+          named: { query: queryA, seed },
+        }));
+        void search.entries;
+        await settled();
+        assert.strictEqual(search.entries.length, 1, 'seeded on the first run');
+        assert.strictEqual(fetches.count, 0, 'no fetch while seeded');
+
+        // Change to a different query — must fetch.
+        search.modify([], { query: queryB, seed });
+        await settled();
+        assert.strictEqual(fetches.count, 1, 'a changed query fetches');
+
+        // Back to the originally-seeded query — must fetch, not re-adopt the
+        // spent seed.
+        search.modify([], { query: queryA, seed });
+        await settled();
+        assert.strictEqual(
+          fetches.count,
+          2,
+          're-typing the seeded query re-fetches (the seed is spent)',
+        );
+      } finally {
+        fetches.restore();
+      }
+    });
+  });
+
   // modify() runs inside a tracked computation (property access on the
   // resource proxy during render), so these tests exercise the resource the
   // way a real component consumes it — any tracked read-then-write inside
@@ -1728,17 +1871,61 @@ module('Integration | search-entries resource', function (hooks) {
   module('rendered consumption', function () {
     class QueryState {
       @tracked query: SearchEntryWireQuery | undefined;
+      @tracked seed: MainResultsSnapshot | undefined;
     }
 
     class Harness extends GlimmerComponent<{
       Args: { state: QueryState };
     }> {
-      search = getSearchEntriesResource(this, () => this.args.state.query);
+      search = getSearchEntriesResource(
+        this,
+        () => this.args.state.query,
+        () => this.args.state.seed,
+      );
       <template>
         <div data-test-entry-count>{{this.search.entries.length}}</div>
       </template>
     }
 
+    test('a seeded query renders its rows immediately, with no fetch and no backtracking error', async function (assert) {
+      let fetchCount = 0;
+      let originalSearchEntries = storeService.searchEntries.bind(storeService);
+      storeService.searchEntries = async (query, realms) => {
+        fetchCount++;
+        return await originalSearchEntries(query, realms);
+      };
+
+      try {
+        let query: SearchEntryWireQuery = {
+          filter: { 'item.on': bookRef },
+          realms: [testRealmURL],
+        };
+        let state = new QueryState();
+        state.query = query;
+        state.seed = {
+          queryKey: JSON.stringify(query),
+          entries: [
+            { id: `${testRealmURL}books/1`, realmUrl: testRealmURL, html: [] },
+            { id: `${testRealmURL}books/2`, realmUrl: testRealmURL, html: [] },
+          ],
+          meta: { page: { total: 2 } },
+        };
+
+        await render(<template><Harness @state={{state}} /></template>);
+
+        assert
+          .dom('[data-test-entry-count]')
+          .hasText('2', 'the seeded rows render on first paint');
+        assert.strictEqual(
+          fetchCount,
+          0,
+          'a seeded query performs no fetch (and mounting threw no backtracking assertion)',
+        );
+      } finally {
+        storeService.searchEntries = originalSearchEntries;
+      }
+    });
+
     test('a rendered consumer activates from an idle query and clears back to idle', async function (assert) {
       let state = new QueryState();
 
diff --git a/packages/host/tests/unit/services/search-sheet-state-service-test.ts b/packages/host/tests/unit/services/search-sheet-state-service-test.ts
new file mode 100644
index 00000000000..88df008f7ec
--- /dev/null
+++ b/packages/host/tests/unit/services/search-sheet-state-service-test.ts
@@ -0,0 +1,112 @@
+import { getService } from '@universal-ember/test-support';
+import { setupTest } from 'ember-qunit';
+import { module, test } from 'qunit';
+
+import {
+  rri,
+  type ResolvedCodeRef,
+  type Sort,
+} from '@cardstack/runtime-common';
+
+import type { SortOption } from '@cardstack/host/components/search/constants';
+import type ResetService from '@cardstack/host/services/reset';
+import type SearchSheetStateService from '@cardstack/host/services/search-sheet-state';
+
+const CODE_REF: ResolvedCodeRef = {
+  module: rri('http://test-realm/test/pet'),
+  name: 'Pet',
+};
+const SORT: SortOption = {
+  displayName: 'A-Z',
+  sort: [{ by: 'cardTitle', direction: 'asc' }] as Sort,
+};
+
+function populate(service: SearchSheetStateService) {
+  service.searchKey = 'Mango';
+  service.selectedTypes = [CODE_REF];
+  service.selectedRealms = [new URL('http://test-realm/test/')];
+  service.activeSort = SORT;
+  service.activeViewId = 'strip';
+  service.pagination.focus('realm:http://test-realm/test/');
+  service.mainSnapshot = {
+    queryKey: 'key',
+    entries: [],
+    meta: { page: { total: 0 } },
+  };
+  service.resultsScrollTop = 240;
+}
+
+function assertCleared(
+  assert: Assert,
+  service: SearchSheetStateService,
+  label: string,
+) {
+  assert.strictEqual(service.searchKey, '', `${label}: searchKey cleared`);
+  assert.strictEqual(
+    service.selectedTypes,
+    undefined,
+    `${label}: selectedTypes cleared`,
+  );
+  assert.deepEqual(
+    service.selectedRealms,
+    [],
+    `${label}: selectedRealms cleared`,
+  );
+  assert.strictEqual(
+    service.activeSort,
+    undefined,
+    `${label}: activeSort cleared`,
+  );
+  assert.strictEqual(
+    service.activeViewId,
+    'grid',
+    `${label}: activeViewId back to default`,
+  );
+  assert.strictEqual(
+    service.pagination.focusedSection,
+    null,
+    `${label}: pagination reset`,
+  );
+  assert.strictEqual(
+    service.mainSnapshot,
+    undefined,
+    `${label}: mainSnapshot cleared`,
+  );
+  assert.strictEqual(
+    service.resultsScrollTop,
+    0,
+    `${label}: resultsScrollTop back to default`,
+  );
+}
+
+module('Unit | Service | search-sheet-state', function (hooks) {
+  setupTest(hooks);
+
+  let service: SearchSheetStateService;
+
+  hooks.beforeEach(function () {
+    service = getService('search-sheet-state');
+  });
+
+  test('resetState() restores every field to its default', function (assert) {
+    populate(service);
+    service.resetState();
+    assertCleared(assert, service, 'resetState');
+  });
+
+  test('is cleared by the reset service (logout/realm reset)', function (assert) {
+    populate(service);
+    (getService('reset') as ResetService).resetAll();
+    assertCleared(assert, service, 'resetAll');
+  });
+
+  test('resetState() installs a fresh pagination instance', function (assert) {
+    let before = service.pagination;
+    service.resetState();
+    assert.notStrictEqual(
+      service.pagination,
+      before,
+      'a new SectionPagination replaces the old one',
+    );
+  });
+});