diff --git a/packages/catalog-realm/package.json b/packages/catalog-realm/package.json
index 670cf126375..0511e2c080f 100644
--- a/packages/catalog-realm/package.json
+++ b/packages/catalog-realm/package.json
@@ -8,7 +8,10 @@
     "@cardstack/boxel-ui": "workspace:*",
     "@cardstack/local-types": "workspace:*",
     "@cardstack/runtime-common": "workspace:*",
+    "@ember/test-helpers": "catalog:",
     "@types/lodash": "catalog:",
+    "@types/qunit": "catalog:",
+    "@universal-ember/test-support": "catalog:",
     "@types/uuid": "catalog:",
     "chess.js": "catalog:",
     "concurrently": "catalog:",
diff --git a/packages/catalog-realm/tsconfig.json b/packages/catalog-realm/tsconfig.json
index bd925f1b7f3..e18beb2caa5 100644
--- a/packages/catalog-realm/tsconfig.json
+++ b/packages/catalog-realm/tsconfig.json
@@ -27,6 +27,7 @@
     },
     "types": ["@cardstack/local-types"]
   },
+  "include": ["**/*.ts", "**/*.gts", "../local-types/test-support.d.ts"],
   "glint": {
     "environment": ["ember-loose", "ember-template-imports"]
   }
diff --git a/packages/experiments-realm/package.json b/packages/experiments-realm/package.json
index 4be0b2488a7..48903a065b4 100644
--- a/packages/experiments-realm/package.json
+++ b/packages/experiments-realm/package.json
@@ -8,6 +8,9 @@
     "@cardstack/boxel-ui": "workspace:*",
     "@cardstack/local-types": "workspace:*",
     "@cardstack/runtime-common": "workspace:*",
+    "@ember/test-helpers": "catalog:",
+    "@types/qunit": "catalog:",
+    "@universal-ember/test-support": "catalog:",
     "@cardstack/view-transitions": "catalog:",
     "@types/lodash": "catalog:",
     "ember-animated": "catalog:",
diff --git a/packages/experiments-realm/qunit-iframe-plan.md b/packages/experiments-realm/qunit-iframe-plan.md
new file mode 100644
index 00000000000..502ef6b0cb1
--- /dev/null
+++ b/packages/experiments-realm/qunit-iframe-plan.md
@@ -0,0 +1,463 @@
+# QUnit Iframe Runner — Local-First Plan
+
+**Goal:** Write `.gts` test files that live in a realm (e.g. `experiments-realm`).
+The host app loads them via the Loader from the realm URL. Each test file boots its
+own fresh in-browser realm. No webpack involvement, no ember test tree changes.
+
+---
+
+## How it works
+
+```
+Host app (ember serve, port 4200)
+  └─ code mode panel
+       └─ <iframe src="/tests/live-test.html?realmURL=http://localhost:4201/experiments/">
+            │
+            │  The iframe is a SEPARATE browser context:
+            │  - own JS heap, own Ember app instance
+            │  - own loader cache
+            │  - own SQLite WASM instance
+            │  - own CardPrerender (needed for in-browser indexing)
+            │  - no shared state with host app → no prerender contention
+            │
+            ├─ 1. test-helper bootstrap runs (setApplication, QUnit.dump etc.)
+            │
+            ├─ 2. QUnit.config.autostart = false
+            │       ↳ prevents QUnit from starting before realm files are loaded
+            │
+            ├─ 3. shim webpack-bundled test helpers into the Loader
+            │       loader.shimModule('@cardstack/host/tests/helpers', helpers)
+            │       loader.shimModule('@cardstack/host/tests/helpers/mock-matrix', mockMatrix)
+            │       loader.shimModule('@cardstack/host/tests/helpers/setup', setup)
+            │       ↳ the realm-loaded .gts file imports these by module name
+            │         but they live in the webpack bundle, not at a URL.
+            │         shimModule bridges the two module systems.
+            │
+            ├─ 4. loader.import('http://localhost:4201/experiments/sample-command-card')
+            │       ↳ real HTTP GET to realm-server → returns .gts source
+            │       ↳ Loader runs Babel in-browser (transform-modules-amd-plugin)
+            │       ↳ evaluates the AMD module
+            │       ↳ SIDE EFFECT: QUnit.module() / QUnit.test() calls register
+            │         tests into QUnit's internal list
+            │
+            ├─ 5. QUnit.start()
+            │       ↳ QUnit iterates its list and runs each registered test
+            │       ↳ each test calls setupIntegrationTestRealm() which:
+            │            - creates a TestRealmAdapter (in-memory file map)
+            │            - mounts it on virtualNetwork
+            │            - starts a Realm instance in-browser
+            │            - runs SQLite WASM indexer
+            │            - this throwaway realm is UNRELATED to experiments-realm
+            │
+            └─ 6. QUnit renders pass/fail into #qunit DOM node (visible in iframe)
+```
+
+---
+
+## Why a separate HTML page, not a route
+
+The test infrastructure requires:
+- `setApplication(Application.create(config.APP))` called before any test
+- `#ember-testing` DOM node for `render()` to mount into
+- `CardPrerender` component in the DOM (needed by `setupIntegrationTestRealm`)
+
+There is already a precedent in the app for a "context-only" route: `acceptance-test-setup`
+in `packages/host/app/router.ts`. That route has no route file — it just lets
+`application.gts` render so `<CardPrerender />` exists (the comment says exactly this).
+Our test-runner could follow the same pattern as a route, BUT `setApplication` and the
+`#ember-testing` DOM setup are already wired in `tests/index.html` + `test-helper.js`.
+The cleanest approach is a **second test page** alongside `tests/index.html`,
+not a new route inside the running app.
+
+The existing `tests/index.html` loads `assets/tests.js` (the full webpack-bundled
+test suite). The new `live-test.html` loads `assets/live-test.js` instead —
+a minimal entry point that only does the shim + `loader.import` + `QUnit.start`.
+
+---
+
+## Steps and Tasks
+
+Each task is independently committable. Every commit has a **barrier** (what can go
+wrong) and a **verification** (how to confirm the barrier is cleared before moving on).
+
+---
+
+### Step 1 — Card + colocated test file
+
+#### Task 1.1 — Create `experiments-realm/sample-command-card.gts`
+
+Create `packages/experiments-realm/sample-command-card.gts` with the card definition
+only (no test code yet). Verify the card shows up in the experiments realm.
+
+**Barrier:** The realm server may reject a `.gts` file or fail to index it.
+
+**Verification (manual):**
+```sh
+cd packages/realm-server && pnpm start:development
+# open http://localhost:4201/experiments/
+# confirm sample-command-card appears in the realm index JSON
+curl http://localhost:4201/experiments/ -H 'Accept: application/vnd.api+json' | jq '.data[].id'
+```
+
+```ts
+// packages/experiments-realm/sample-command-card.gts
+import { CardDef, field, contains, Component } from 'https://cardstack.com/base/card-api';
+import StringField from 'https://cardstack.com/base/string';
+
+export class SampleCommandCard extends CardDef {
+  static displayName = 'Sample Command Card';
+  @field title = contains(StringField);
+
+  static isolated = class Isolated extends Component<typeof SampleCommandCard> {
+    <template>
+      <h1><@fields.title /></h1>
+      <button type="button">Create Card</button>
+    </template>
+  };
+}
+```
+
+---
+
+#### Task 1.2 — Add the colocated test block to the same file
+
+Append the test module below the card definition. The test imports are all shimmed
+at runtime by `live-test.js` — they are never evaluated in production contexts
+(the file is only ever `loader.import()`'d through `live-test.js`).
+
+**Barrier:** TypeScript / Glint may complain about the mixed card+test imports if
+type-checking is run on `experiments-realm`. `import type` mitigates most of it;
+the `// @ts-ignore` escape hatch covers the rest.
+
+**Verification (manual — no build needed yet):**
+Read the file and confirm no syntax errors using `tsc --noEmit` or the IDE's
+type-checker overlay. The card definition alone in Task 1.1 already passed
+the realm indexer; this step only adds dead code until Step 2 loads it.
+
+```ts
+// ── Tests (static imports, resolved via loader.shimModule in live-test.js) ───
+import { service } from '@ember/service';
+import { click, render } from '@ember/test-helpers';
+import GlimmerComponent from '@glimmer/component';
+import { module, test } from 'qunit';   // shimmed: loader.shimModule('qunit', QUnit)
+
+import { getService } from '@universal-ember/test-support';
+import { baseRealm } from '@cardstack/runtime-common';
+import type StoreService from '@cardstack/host/services/store';
+import {
+  setupIntegrationTestRealm,
+  setupLocalIndexing,
+  setupOnSave,
+  setupCardLogs,
+  testRealmURL,
+  setupRealmCacheTeardown,
+  withCachedRealmSetup,
+  type TestContextWithSave,
+} from '@cardstack/host/tests/helpers';
+import { setupMockMatrix } from '@cardstack/host/tests/helpers/mock-matrix';
+import { setupRenderingTest } from '@cardstack/host/tests/helpers/setup';
+import type { TestRealmAdapter } from '@cardstack/host/tests/helpers/adapter';
+
+// A thin wrapper component that exercises the card's create flow
+class CreateCardButton extends GlimmerComponent {
+  @service declare store: StoreService;
+
+  createCard = async () => {
+    // store.add() creates the instance AND writes it to the throwaway realm
+    await this.store.add(new SampleCommandCard({ title: 'Hello from live-test' }));
+  };
+
+  <template>
+    <button type="button" {{on "click" this.createCard}}>Create Card</button>
+  </template>
+}
+
+module('Experiments | SampleCommandCard', function (hooks) {
+  setupRenderingTest(hooks);
+  setupLocalIndexing(hooks);
+  setupOnSave(hooks);
+  setupRealmCacheTeardown(hooks);
+  setupCardLogs(hooks, async () =>
+    getService('loader-service').loader.import(`${baseRealm.url}card-api`),
+  );
+
+  let mockMatrixUtils = setupMockMatrix(hooks, {
+    loggedInAs: '@testuser:localhost',
+    activeRealms: [testRealmURL],
+    autostart: true,
+  });
+
+  let testRealmAdapter: TestRealmAdapter;
+
+  hooks.beforeEach(async function () {
+    ({ adapter: testRealmAdapter } = await withCachedRealmSetup(async () =>
+      setupIntegrationTestRealm({
+        mockMatrixUtils,
+        contents: {
+          // ↓ the actual class from this file — not a string, not a copy
+          'sample-command-card.gts': { SampleCommandCard },
+          '.realm.json': '{ "name": "Sample Realm" }',
+        },
+      }),
+    ));
+  });
+
+  test<TestContextWithSave>(
+    'clicking Create Card writes a new card to the realm',
+    async function (assert) {
+      assert.expect(3);
+
+      this.onSave((_url, doc) => {
+        assert.strictEqual(
+          (doc as any).data.attributes.title,
+          'Hello from live-test',
+          'saved doc has correct title',
+        );
+      });
+
+      await render(<template><CreateCardButton /></template>);
+      await click('button');
+
+      let store = getService('store');
+      let cardId = store.peekAll('card')[0]?.id;
+      assert.ok(cardId, 'card exists in store');
+
+      let relativePath = `${cardId.substring(testRealmURL.length)}.json`;
+      let file = await testRealmAdapter.openFile(relativePath);
+      assert.ok(file, 'card JSON file exists in the realm adapter');
+    },
+  );
+});
+```
+
+**Commit checkpoint:** `experiments-realm/sample-command-card.gts` exists with card
+definition + inert test block. Realm indexes the card. No new build config yet.
+
+---
+
+### Step 2 — live-test page and entry point
+
+#### Task 2.1 — Add `live-test.html`
+
+Create `packages/host/tests/live-test.html`. Same structure as `tests/index.html`
+but loads `live-test.js` instead of `tests.js`.
+
+**Barrier:** `{{content-for}}` / `{{rootURL}}` tokens must be processed by ember-cli's
+template processor. Confirm by serving the host and visiting the URL — an empty
+QUnit page (no tests yet) should render without JS errors.
+
+**Verification (manual):**
+```sh
+cd packages/host && pnpm start
+open "http://localhost:4200/tests/live-test.html"
+# Expected: blank QUnit page — "0 tests of 0 passed" — no JS console errors
+```
+
+```html
+<!doctype html>
+<html>
+  <head>
+    <meta charset="utf-8" />
+    <title>Realm Test Runner</title>
+    {{content-for "head"}} {{content-for "test-head"}}
+    <link rel="stylesheet" href="{{rootURL}}assets/vendor.css" />
+    <link rel="stylesheet" href="{{rootURL}}assets/@cardstack/host.css" />
+    <link rel="stylesheet" href="{{rootURL}}assets/test-support.css" />
+    {{content-for "head-footer"}} {{content-for "test-head-footer"}}
+  </head>
+  <body>
+    {{content-for "body"}} {{content-for "test-body"}}
+
+    <div id="qunit"></div>
+    <div id="qunit-fixture">
+      <div id="ember-testing-container">
+        <div id="ember-testing"></div>
+      </div>
+    </div>
+
+    <script src="{{rootURL}}assets/vendor.js"></script>
+    <script src="{{rootURL}}assets/test-support.js"></script>
+    <script src="{{rootURL}}assets/@cardstack/host.js"></script>
+    <script src="{{rootURL}}assets/live-test.js"></script>
+
+    {{content-for "body-footer"}} {{content-for "test-body-footer"}}
+  </body>
+</html>
+```
+
+---
+
+#### Task 2.2 — Add `live-test.js` entry point
+
+Create `packages/host/tests/live-test.js`. This is the bootstrap that shims test
+helpers into the Loader, then fires `loader.import()` + `QUnit.start()`.
+
+**Barrier 1:** `getService('loader-service')` requires the Ember app to be booted.
+The service is available immediately after `setApplication` + app boot, which happens
+before any test runs — but `loadRealmTests()` is async and runs _after_ the module
+body. If timing is off, `getService` throws "No application instance". The fix is to
+gate the call inside the async function (after the event loop yields for boot), which
+is what the current structure already does.
+
+**Barrier 2:** `app.import('tests/live-test.js', { type: 'test' })` is a classic
+ember-cli API. With embroider/webpack this may silently no-op or throw. The
+alternative is to add `live-test.js` as a webpack entry in `ember-cli-build.js` via
+`app.options.autoImport` or a manual webpack config extension. **This is the highest-
+risk barrier of the whole plan.** Validate as the first thing in this task.
+
+**Verification for barrier 2 (before writing live-test.js):**
+Add a console.log-only `live-test.js`, wire it into `ember-cli-build.js`, start host,
+visit `live-test.html`. If the log appears in DevTools → `app.import` works. If not,
+switch to webpack entry approach (see fallback below).
+
+**Fallback if `app.import` doesn't work:**
+```js
+// ember-cli-build.js — webpack entry fallback
+const { Webpack } = require('@embroider/webpack');
+return require('@embroider/compat').compatBuild(app, Webpack, {
+  packagerOptions: {
+    webpackConfig: {
+      entry: {
+        'live-test': './tests/live-test.js',
+      },
+    },
+  },
+});
+```
+
+```js
+// packages/host/tests/live-test.js
+import Application from '@cardstack/host/app';
+import config from '@cardstack/host/config/environment';
+import * as QUnit from 'qunit';
+import { setApplication } from '@ember/test-helpers';
+import { setup } from 'qunit-dom';
+import { getService } from '@universal-ember/test-support';
+
+// same setup as test-helper.js
+setApplication(Application.create(config.APP));
+setup(QUnit.assert);
+QUnit.dump.maxDepth = 20;
+
+// ── KEY DIFFERENCE from test-helper.js ──────────────────────────────────────
+// Do NOT call start() yet. Realm test files must be imported first.
+QUnit.config.autostart = false;
+
+// Shim webpack-bundled test helpers into the Loader so realm-loaded
+// .gts files can import them by their module name.
+async function loadRealmTests() {
+  const helpers = await import('@cardstack/host/tests/helpers');
+  const mockMatrix = await import('@cardstack/host/tests/helpers/mock-matrix');
+  const setup = await import('@cardstack/host/tests/helpers/setup');
+
+  let loader = getService('loader-service').loader;
+
+  // Bridge the two module systems
+  loader.shimModule('qunit', QUnit);
+  loader.shimModule('@cardstack/host/tests/helpers', helpers);
+  loader.shimModule('@cardstack/host/tests/helpers/mock-matrix', mockMatrix);
+  loader.shimModule('@cardstack/host/tests/helpers/setup', setup);
+
+  // Read realm URL from query string:
+  //   /tests/live-test.html?realmURL=http://localhost:4201/experiments/
+  const realmURL = new URLSearchParams(window.location.search).get('realmURL')
+    ?? 'http://localhost:4201/experiments/';
+
+  // loader.import fires QUnit.module()/test() as side effects
+  await loader.import(`${realmURL}sample-command-card`);
+
+  // All tests registered — let QUnit run
+  QUnit.start();
+}
+
+loadRealmTests().catch(console.error);
+```
+
+Wire into `ember-cli-build.js`:
+```js
+app.import('tests/live-test.js', { type: 'test' });
+```
+
+**Verification (manual):**
+```sh
+# Terminal 1
+cd packages/realm-server && pnpm start:development
+
+# Terminal 2
+cd packages/host && pnpm start
+
+open "http://localhost:4200/tests/live-test.html?realmURL=http://localhost:4201/experiments/"
+# Expected: QUnit renders "1 test of 1 passed" (or failed with a real assertion error)
+# Either outcome proves the full pipeline works end-to-end.
+```
+
+**Commit checkpoint:** Visiting `live-test.html` with `?realmURL=...` runs the
+`SampleCommandCard` tests. Pass or fail is visible in the QUnit UI.
+
+---
+
+### Step 3 — Terminal runner (`start:services-and-host`)
+
+#### Task 3.1 — Add `start:services-and-host` script
+
+Add a single command that starts the development realm (port 4201, includes
+experiments) and the host ember serve (port 4200) concurrently, then prints the
+live-test URL to open.
+
+The script lives in `packages/realm-server/package.json` and mirrors the shape of
+`start:services-for-host-tests` but without the test-realm overhead — it just needs
+the development realm up and the host serving.
+
+**Barrier:** `start:development` boots pg, matrix, prerender, worker, and all
+development realms. If any of those fail to start, the host never gets the realm
+data it needs. The readiness check on `:4201/experiments/` gates the host start so
+you get a clear error rather than a silent failure.
+
+**What to add to `packages/realm-server/package.json`:**
+```json
+"start:services-and-host": "./scripts/start-services-and-host.sh"
+```
+
+**`packages/realm-server/scripts/start-services-and-host.sh`:**
+```sh
+#!/bin/sh
+set -eu
+
+WAIT_ON_TIMEOUT=${WAIT_ON_TIMEOUT:-120000}
+LOG_LEVELS="${LOG_LEVELS:-*=info}"
+
+NODE_NO_WARNINGS=1 \
+  LOG_LEVELS="$LOG_LEVELS" \
+  start-server-and-test \
+    'run-p -ln start:pg start:prerender-dev start:prerender-manager-dev start:matrix start:smtp start:worker-development start:development' \
+    'http-get://localhost:4201/experiments/_readiness-check?acceptHeader=application%2Fvnd.api%2Bjson' \
+    'cd ../host && pnpm start' \
+    'http://localhost:4200'
+
+echo ""
+echo "Services and host are up."
+echo "Open: http://localhost:4200/tests/live-test.html?realmURL=http://localhost:4201/experiments/"
+```
+
+**Verification (manual):**
+```sh
+cd packages/realm-server && pnpm start:services-and-host
+
+# Once both are ready, open:
+open "http://localhost:4200/tests/live-test.html?realmURL=http://localhost:4201/experiments/"
+# Expected: QUnit renders "1 test of 1 passed"
+```
+
+**Commit checkpoint:** A single `pnpm start:services-and-host` from `packages/realm-server`
+starts everything needed. Opening the printed URL runs the live-test suite in the browser
+and shows pass/fail in the QUnit UI.
+
+---
+
+## Execution order
+
+- [x] Task 1.1 — create `experiments-realm/sample-command-card.gts` (card only)
+- [x] Task 1.2 — append test block to same file; confirm no type errors
+- [] Task 2.1 — add `live-test.html`; confirm blank QUnit page loads at `:4200/tests/live-test.html`
+- [] Task 2.2 — add `live-test.js`; wire into `ember-cli-build.js`; **validate `app.import` barrier first**; confirm tests run at the full URL
+- [ ] Task 3.1 — add `start:services-and-host` script; run it; open live-test URL; confirm "1 test passed"
diff --git a/packages/experiments-realm/sample-command-card.gts b/packages/experiments-realm/sample-command-card.gts
new file mode 100644
index 00000000000..31d42f6a286
--- /dev/null
+++ b/packages/experiments-realm/sample-command-card.gts
@@ -0,0 +1,149 @@
+import { CardDef, field, contains, Component } from 'https://cardstack.com/base/card-api';
+import StringField from 'https://cardstack.com/base/string';
+
+export class SampleCommandCard extends CardDef {
+  static displayName = 'Sample Command Card';
+  @field title = contains(StringField);
+
+  static isolated = class Isolated extends Component<typeof SampleCommandCard> {
+    <template>
+      <h1><@fields.title /></h1>
+      <button type='button'>Create Card</button>
+    </template>
+  };
+}
+
+// ── Tests (imports resolved via loader.shimModule in live-test.js) ────────────
+import { on } from '@ember/modifier';
+import { service } from '@ember/service';
+import { click, render, waitUntil } from '@ember/test-helpers';
+import GlimmerComponent from '@glimmer/component';
+import { module, test } from 'qunit';
+
+import { getService } from '@universal-ember/test-support';
+import { baseRealm, type Realm } from '@cardstack/runtime-common';
+import type StoreService from '@cardstack/host/services/store';
+import {
+  setupIntegrationTestRealm,
+  setupLocalIndexing,
+  setupOnSave,
+  setupCardLogs,
+  testRealmURL,
+  setupRealmCacheTeardown,
+  withCachedRealmSetup,
+  type TestContextWithSave,
+} from '@cardstack/host/tests/helpers';
+import { setupMockMatrix } from '@cardstack/host/tests/helpers/mock-matrix';
+import { setupRenderingTest } from '@cardstack/host/tests/helpers/setup';
+import type { TestRealmAdapter } from '@cardstack/host/tests/helpers/adapter';
+
+class CreateCardButton extends GlimmerComponent {
+  @service declare store: StoreService;
+
+  createCard = async () => {
+    await this.store.add(new SampleCommandCard({ title: 'Hello from live-test' }));
+  };
+
+  <template>
+    <button type='button' {{on 'click' this.createCard}}>Create Card</button>
+  </template>
+}
+
+module('Experiments | SampleCommandCard', function (hooks) {
+  setupRenderingTest(hooks);
+  setupLocalIndexing(hooks);
+  setupOnSave(hooks);
+  setupRealmCacheTeardown(hooks);
+  setupCardLogs(hooks, async () =>
+    (getService('loader-service') as any).loader.import(`${baseRealm.url}card-api`),
+  );
+
+  let mockMatrixUtils = setupMockMatrix(hooks, {
+    loggedInAs: '@testuser:localhost',
+    activeRealms: [testRealmURL],
+    autostart: true,
+  });
+
+  let testRealmAdapter: TestRealmAdapter;
+  let testRealm: Realm;
+
+  hooks.beforeEach(async function () {
+    ({ adapter: testRealmAdapter, realm: testRealm } = await withCachedRealmSetup(async () =>
+      setupIntegrationTestRealm({
+        mockMatrixUtils,
+        contents: {
+          'sample-command-card.gts': { SampleCommandCard },
+          '.realm.json': '{ "name": "Sample Realm" }',
+        },
+      }),
+    ));
+  });
+
+  test('clicking Create Card writes a new card to the realm', async function (
+    this: TestContextWithSave,
+    assert,
+  ) {
+      assert.expect(3);
+
+      let savedUrl: URL | undefined;
+      this.onSave((url, doc) => {
+        savedUrl = url;
+        assert.strictEqual(
+          (doc as any).data.attributes.title,
+          'Hello from live-test',
+          'saved doc has correct title',
+        );
+      });
+
+      await render(<template><CreateCardButton /></template>);
+      await click('button');
+
+      assert.ok(savedUrl, 'card was saved to realm');
+      let relativePath = `${savedUrl!.href.substring(testRealmURL.length)}.json`;
+      let file = await testRealmAdapter.openFile(relativePath);
+      assert.ok(file, 'card JSON file exists in the realm adapter');
+    },
+  );
+
+  test('search finds the newly created card', async function (
+    this: TestContextWithSave,
+    assert,
+  ) {
+    assert.expect(3);
+
+    let savedUrl: URL | undefined;
+    this.onSave((url) => {
+      savedUrl = url;
+    });
+
+    await render(<template><CreateCardButton /></template>);
+    await click('button');
+
+    await waitUntil(() => Boolean(savedUrl), { timeout: 5000 });
+
+    await waitUntil(async () => {
+      let { data: cards } = await testRealm.realmIndexQueryEngine.searchCards({
+        filter: {
+          on: { module: `${testRealmURL}sample-command-card`, name: 'SampleCommandCard' },
+          eq: { title: 'Hello from live-test' },
+        },
+      });
+      return cards.length === 1;
+    }, { timeout: 5000 });
+
+    let { data: cards } = await testRealm.realmIndexQueryEngine.searchCards({
+      filter: {
+        on: { module: `${testRealmURL}sample-command-card`, name: 'SampleCommandCard' },
+        eq: { title: 'Hello from live-test' },
+      },
+    });
+
+    assert.strictEqual(cards.length, 1, 'search returns the created card');
+    assert.strictEqual(
+      (cards[0] as any).attributes?.title,
+      'Hello from live-test',
+      'search result has correct title',
+    );
+    assert.ok(savedUrl, 'card save completed');
+  });
+});
diff --git a/packages/experiments-realm/tsconfig.json b/packages/experiments-realm/tsconfig.json
index f1208dafd2c..8bc7ca601b8 100644
--- a/packages/experiments-realm/tsconfig.json
+++ b/packages/experiments-realm/tsconfig.json
@@ -28,6 +28,7 @@
     },
     "types": ["@cardstack/local-types"]
   },
+  "include": ["**/*.ts", "**/*.gts", "../local-types/test-support.d.ts"],
   "glint": {
     "environment": ["ember-loose", "ember-template-imports"]
   }
diff --git a/packages/host/app/lib/externals.ts b/packages/host/app/lib/externals.ts
index 79074b71e43..a18ace32e6e 100644
--- a/packages/host/app/lib/externals.ts
+++ b/packages/host/app/lib/externals.ts
@@ -5,6 +5,9 @@ import * as emberHelper from '@ember/helper';
 import * as emberModifier from '@ember/modifier';
 import * as emberObject from '@ember/object';
 import * as emberObjectInternals from '@ember/object/internals';
+import * as emberService from '@ember/service';
+import * as emberTestHelpers from '@ember/test-helpers';
+import * as universalEmberTestSupport from '@universal-ember/test-support';
 import * as emberTemplate from '@ember/template';
 import * as emberTemplateFactory from '@ember/template-factory';
 import * as glimmerComponent from '@glimmer/component';
@@ -52,9 +55,25 @@ import * as boxelUiModifiers from '@cardstack/boxel-ui/modifiers';
 import * as runtime from '@cardstack/runtime-common';
 import type { VirtualNetwork } from '@cardstack/runtime-common';
 
+import * as hostTestHelpers from '@cardstack/host/tests/helpers';
+import * as hostTestHelpersAdapter from '@cardstack/host/tests/helpers/adapter';
+import * as hostTestHelpersMockMatrix from '@cardstack/host/tests/helpers/mock-matrix';
+import * as hostTestHelpersSetup from '@cardstack/host/tests/helpers/setup';
+
 import { shimHostCommands } from '../commands';
 
 export function shimExternals(virtualNetwork: VirtualNetwork) {
+  // Always shim qunit. In test environments, use window.QUnit so realm-loaded
+  // test modules register on the same instance the runner will execute. In
+  // non-test environments (code mode, card rendering), use a no-op stub so
+  // realm cards that colocate test imports don't fail to load — the no-op
+  // module() means test callbacks are never invoked outside of test runs.
+  const windowQUnit = (globalThis as any).QUnit;
+  virtualNetwork.shimModule(
+    'qunit',
+    windowQUnit || { module: () => {}, test: () => {}, config: {} },
+  );
+
   virtualNetwork.shimModule('@cardstack/runtime-common', runtime);
   virtualNetwork.shimModule(
     '@cardstack/boxel-ui/components',
@@ -115,6 +134,9 @@ export function shimExternals(virtualNetwork: VirtualNetwork) {
   virtualNetwork.shimModule('@glimmer/tracking', glimmerTracking);
   virtualNetwork.shimModule('@ember/object', emberObject);
   virtualNetwork.shimModule('@ember/object/internals', emberObjectInternals);
+  virtualNetwork.shimModule('@ember/service', emberService);
+  virtualNetwork.shimModule('@ember/test-helpers', emberTestHelpers);
+  virtualNetwork.shimModule('@universal-ember/test-support', universalEmberTestSupport);
   virtualNetwork.shimModule('@ember/helper', emberHelper);
   virtualNetwork.shimModule('@ember/modifier', emberModifier);
   virtualNetwork.shimModule(
@@ -162,5 +184,46 @@ export function shimExternals(virtualNetwork: VirtualNetwork) {
     resolve: () => import('uuid'),
   });
   virtualNetwork.shimModule('awesome-phonenumber', awesomePhoneNumber);
+
+  // Test-only modules so realm cards that colocate tests (importing from
+  // @cardstack/host/tests/helpers etc.) can resolve in environments where the
+  // host test modules are present. When missing, we throw on access so the
+  // error is visible instead of silently hiding it.
+  const missingShim = (moduleId: string) =>
+    new Proxy(
+      {},
+      {
+        get: () => {
+          throw new Error(
+            `Missing shim for ${moduleId}. This module is not available in the current environment.`,
+          );
+        },
+      },
+    );
+  virtualNetwork.shimModule(
+    '@cardstack/host/tests/helpers',
+    hostTestHelpers ?? missingShim('@cardstack/host/tests/helpers'),
+  );
+  virtualNetwork.shimModule(
+    '@cardstack/host/tests/helpers/mock-matrix',
+    hostTestHelpersMockMatrix ??
+      missingShim('@cardstack/host/tests/helpers/mock-matrix'),
+  );
+  virtualNetwork.shimModule(
+    '@cardstack/host/tests/helpers/setup',
+    hostTestHelpersSetup ?? missingShim('@cardstack/host/tests/helpers/setup'),
+  );
+  virtualNetwork.shimModule(
+    '@cardstack/host/tests/helpers/adapter',
+    hostTestHelpersAdapter ??
+      missingShim('@cardstack/host/tests/helpers/adapter'),
+  );
+
+  // Some realm modules use host-only types or helpers. Provide a safe shim so
+  // imports resolve even when the host module isn't present in the build.
+  virtualNetwork.shimModule('@cardstack/host/services/store', {
+    default: class {},
+  });
+
   shimHostCommands(virtualNetwork);
 }
diff --git a/packages/host/ember-cli-build.js b/packages/host/ember-cli-build.js
index 9c727996c18..ba02f0564e0 100644
--- a/packages/host/ember-cli-build.js
+++ b/packages/host/ember-cli-build.js
@@ -13,6 +13,7 @@ const { BoxelUIChecksumPlugin } = require('./lib/build/package-dist-checksums');
 
 module.exports = function (defaults) {
   const app = new EmberApp(defaults, {
+    tests: true,
     trees: {
       app: withSideWatch('app', {
         watching: ['../runtime-common', '../boxel-ui/addon'],
@@ -29,6 +30,7 @@ module.exports = function (defaults) {
       ],
     },
   });
+
   return compatBuild(app, Webpack, {
     staticAddonTrees: true,
     staticAddonTestSupportTrees: true,
diff --git a/packages/host/package.json b/packages/host/package.json
index 5476e470286..576f160bee0 100644
--- a/packages/host/package.json
+++ b/packages/host/package.json
@@ -48,7 +48,7 @@
     "@cardstack/view-transitions": "catalog:",
     "@ember/optional-features": "^2.0.0",
     "@ember/string": "^3.1.1",
-    "@ember/test-helpers": "^3.3.1",
+    "@ember/test-helpers": "catalog:",
     "@ember/test-waiters": "catalog:",
     "@embroider/compat": "^3.5.5",
     "@embroider/core": "^3.4.15",
diff --git a/packages/host/public/live-test.html b/packages/host/public/live-test.html
new file mode 100644
index 00000000000..ca7238992e0
--- /dev/null
+++ b/packages/host/public/live-test.html
@@ -0,0 +1,87 @@
+<!doctype html>
+<html>
+  <head>
+    <meta charset="utf-8" />
+    <title>Realm Test Runner</title>
+    <meta name="description" content="" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+
+    <link rel="stylesheet" href="/assets/vendor.css" />
+    <link rel="stylesheet" href="/assets/@cardstack/host.css" />
+    <link rel="stylesheet" href="/assets/test-support.css" />
+  </head>
+  <body>
+    <div
+      id="live-test-status"
+      style="position: fixed; top: 8px; left: 8px; z-index: 9999; background: #fff; padding: 4px 8px; border: 1px solid #ccc;"
+    >
+      Live-test page loaded.
+    </div>
+    <button
+      id="live-test-start"
+      type="button"
+      style="position: fixed; top: 8px; right: 8px; z-index: 9999; background: #0b5; color: #fff; border: none; padding: 6px 10px; cursor: pointer;"
+    >
+      Start QUnit
+    </button>
+
+    <div id="qunit"></div>
+    <div id="qunit-fixture">
+      <div id="ember-testing-container">
+        <div id="ember-testing"></div>
+      </div>
+    </div>
+
+    <div id="ember-basic-dropdown-wormhole"></div>
+    <div id="ember-testing-loader"></div>
+
+    <script type="module">
+      import * as ContentTag from '/assets/content-tag/standalone.js';
+      globalThis.ContentTagGlobal = ContentTag;
+    </script>
+
+    <script src="/assets/vendor.js"></script>
+    <script src="/assets/test-support.js"></script>
+    <script>
+      // Prevent any auto-start (e.g. test-helper/tests.js) from running before
+      // live-test.js applies its filter. Restored inside live-test.js.
+      console.info('[live-test] HTML loaded');
+      window.__liveTestOriginalQUnitStart = window.QUnit && window.QUnit.start;
+      if (window.QUnit) {
+        window.QUnit.start = function () {
+          window.__liveTestStartBlocked = true;
+        };
+        console.info('[live-test] QUnit detected in HTML');
+      } else {
+        console.warn('[live-test] QUnit missing in HTML');
+      }
+      const statusEl = document.getElementById('live-test-status');
+      if (statusEl) {
+        statusEl.textContent = window.QUnit
+          ? 'Live-test HTML loaded. QUnit present.'
+          : 'Live-test HTML loaded. QUnit missing.';
+      }
+    </script>
+    <script src="/assets/@cardstack/host.js"></script>
+    <script src="/assets/tests.js"></script>
+    <script>
+      setTimeout(() => {
+        if (!window.__liveTestLoaded) {
+          console.error('[live-test] tests.js did not load or live-test runner missing');
+          const statusEl = document.getElementById('live-test-status');
+          if (statusEl) {
+            statusEl.textContent =
+              'Live-test HTML loaded. tests.js missing or live-test runner not loaded.';
+            statusEl.style.background = '#fdd';
+          }
+        } else {
+          const statusEl = document.getElementById('live-test-status');
+          if (statusEl) {
+            statusEl.textContent = 'Live-test runner loaded.';
+            statusEl.style.background = '#dfd';
+          }
+        }
+      }, 0);
+    </script>
+  </body>
+</html>
diff --git a/packages/host/tests/live-test.html b/packages/host/tests/live-test.html
new file mode 100644
index 00000000000..63ed7d92841
--- /dev/null
+++ b/packages/host/tests/live-test.html
@@ -0,0 +1,74 @@
+<!doctype html>
+<html>
+  <head>
+    <meta charset="utf-8" />
+    <title>Realm Test Runner</title>
+    <meta name="description" content="" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+
+    {{content-for "head"}}
+
+    <link rel="stylesheet" href="{{rootURL}}assets/vendor.css" />
+    <link rel="stylesheet" href="{{rootURL}}assets/@cardstack/host.css" />
+    <link rel="stylesheet" href="{{rootURL}}assets/test-support.css" />
+
+    {{content-for "head-footer"}}
+  </head>
+  <body>
+    {{content-for "body"}}
+
+    <div id="qunit"></div>
+    <div
+      id="live-test-status"
+      style="position: fixed; top: 8px; left: 8px; z-index: 9999; background: #fff; padding: 4px 8px; border: 1px solid #ccc;"
+    >
+      Live-test page loaded.
+    </div>
+    <button
+      id="live-test-start"
+      type="button"
+      style="position: fixed; top: 8px; right: 8px; z-index: 9999; background: #0b5; color: #fff; border: none; padding: 6px 10px; cursor: pointer;"
+    >
+      Start QUnit
+    </button>
+    <div id="qunit-fixture">
+      <div id="ember-testing-container">
+        <div id="ember-testing"></div>
+      </div>
+    </div>
+
+    <div id="ember-basic-dropdown-wormhole"></div>
+    <div id="ember-testing-loader"></div>
+
+    <script type="module">
+      import * as ContentTag from '{{rootURL}}assets/content-tag/standalone.js';
+      globalThis.ContentTagGlobal = ContentTag;
+    </script>
+    <script src="{{rootURL}}assets/vendor.js"></script>
+    <script src="{{rootURL}}assets/test-support.js"></script>
+    <script>
+      // Prevent any auto-start (e.g. test-helper/tests.js) from running before
+      // live-test.js applies its filter. Restored inside live-test.js.
+      console.info('[live-test] HTML loaded');
+      window.__liveTestOriginalQUnitStart = window.QUnit && window.QUnit.start;
+      if (window.QUnit) {
+        window.QUnit.start = function () {
+          window.__liveTestStartBlocked = true;
+        };
+        console.info('[live-test] QUnit detected in HTML');
+      } else {
+        console.warn('[live-test] QUnit missing in HTML');
+      }
+      const statusEl = document.getElementById('live-test-status');
+      if (statusEl) {
+        statusEl.textContent = window.QUnit
+          ? 'Live-test HTML loaded. QUnit present.'
+          : 'Live-test HTML loaded. QUnit missing.';
+      }
+    </script>
+    <script src="{{rootURL}}assets/@cardstack/host.js"></script>
+    <script src="{{rootURL}}assets/tests.js"></script>
+
+    {{content-for "body-footer"}}
+  </body>
+</html>
diff --git a/packages/host/tests/live-test.js b/packages/host/tests/live-test.js
new file mode 100644
index 00000000000..28d135b3756
--- /dev/null
+++ b/packages/host/tests/live-test.js
@@ -0,0 +1,297 @@
+import Application from '@cardstack/host/app';
+import config from '@cardstack/host/config/environment';
+import * as QUnit from 'qunit';
+import { setApplication } from '@ember/test-helpers';
+import { setup } from 'qunit-dom';
+import setupOperatorModeParametersMatchAssertion from '@cardstack/host/tests/helpers/operator-mode-parameters-match';
+import { useTestWaiters } from '@cardstack/runtime-common';
+import * as TestWaiters from '@ember/test-waiters';
+import { start } from 'ember-qunit';
+
+function isLiveTestUrl(url) {
+  const parsed = new URL(url);
+  const normalizedPath = parsed.pathname.replace(/\/+$/, '');
+  if (normalizedPath.endsWith('/live-test.html')) {
+    return true;
+  }
+  if (
+    normalizedPath.endsWith('/tests') &&
+    (parsed.searchParams.has('liveTest') ||
+      parsed.searchParams.has('live-test'))
+  ) {
+    return true;
+  }
+  return false;
+}
+
+const isLiveTest = isLiveTestUrl(window.location.href);
+
+if (!isLiveTest) {
+  // If this module is bundled into the main test suite, bail out.
+  // eslint-disable-next-line no-console
+  console.warn('[live-test] Skipping initialization outside live-test.html');
+} else {
+  const globalAny = /** @type {any} */ (globalThis);
+  globalAny.__liveTestLoaded = true;
+  // eslint-disable-next-line no-console
+  console.info('[live-test] Initializing live-test runner');
+
+  let statusEl = document.getElementById('live-test-status');
+  if (!statusEl) {
+    statusEl = document.createElement('div');
+    statusEl.id = 'live-test-status';
+    statusEl.style.position = 'fixed';
+    statusEl.style.top = '8px';
+    statusEl.style.left = '8px';
+    statusEl.style.zIndex = '9999';
+    statusEl.style.background = '#fff';
+    statusEl.style.padding = '4px 8px';
+    statusEl.style.border = '1px solid #ccc';
+    document.body.appendChild(statusEl);
+  }
+  statusEl.textContent = 'Live-test runner loaded.';
+
+  const globalQUnit = globalAny.QUnit;
+  if (globalQUnit && globalQUnit !== QUnit) {
+    // Ensure loader + ember-qunit use the same QUnit instance.
+    globalThis.QUnit = QUnit;
+  } else if (!globalQUnit) {
+    globalThis.QUnit = QUnit;
+  }
+
+  const originalQUnitStart =
+    globalAny.__liveTestOriginalQUnitStart || QUnit.start;
+  if (globalAny.__liveTestOriginalQUnitStart) {
+    QUnit.start = originalQUnitStart;
+  }
+
+  QUnit.dump.maxDepth = 20;
+
+  useTestWaiters(TestWaiters);
+  let loaderRoot = document.getElementById('ember-testing-loader');
+  if (!loaderRoot) {
+    loaderRoot = document.createElement('div');
+    loaderRoot.id = 'ember-testing-loader';
+    document.body.appendChild(loaderRoot);
+  }
+
+  const application = Application.create({
+    ...config.APP,
+    rootElement: '#ember-testing',
+  });
+  setApplication(application);
+  // eslint-disable-next-line no-console
+  console.info('[live-test] Ember application created');
+
+  setup(QUnit.assert);
+  setupOperatorModeParametersMatchAssertion(QUnit.assert);
+
+  // Realm-loaded test modules must register their tests before QUnit starts.
+  QUnit.config.autostart = false;
+  start({ loadTests: false, startTests: false });
+  // eslint-disable-next-line no-console
+  console.info('[live-test] ember-qunit started (loadTests: false)');
+
+  let startButton = document.getElementById('live-test-start');
+  if (!startButton) {
+    startButton = document.createElement('button');
+    startButton.id = 'live-test-start';
+    startButton.type = 'button';
+    startButton.textContent = 'Start QUnit';
+    startButton.style.position = 'fixed';
+    startButton.style.top = '8px';
+    startButton.style.right = '8px';
+    startButton.style.zIndex = '9999';
+    startButton.style.background = '#0b5';
+    startButton.style.color = '#fff';
+    startButton.style.border = 'none';
+    startButton.style.padding = '6px 10px';
+    startButton.style.cursor = 'pointer';
+    document.body.appendChild(startButton);
+  }
+
+  startButton.addEventListener('click', () => {
+    if (!QUnit.config.started) {
+      // eslint-disable-next-line no-console
+      console.info('[live-test] Start button clicked');
+      QUnit.start();
+    }
+  });
+
+  async function loadRealmTests() {
+    const urlParams = new URLSearchParams(window.location.search);
+    const qunitFilter = urlParams.get('filter');
+    const qunitModule = urlParams.get('module');
+    const debugLoad = urlParams.has('debugLoad');
+    const testModuleParam = urlParams.get('testModule');
+
+    // eslint-disable-next-line no-console
+    console.info('[live-test] URL params:', {
+      realmURL: urlParams.get('realmURL'),
+      testModule: testModuleParam,
+      filter: qunitFilter,
+      module: qunitModule,
+      debugLoad,
+    });
+    if (qunitFilter) {
+      QUnit.config.filter = qunitFilter;
+    }
+    if (qunitModule) {
+      QUnit.config.module = qunitModule;
+    }
+
+    const helpers = await import('@cardstack/host/tests/helpers');
+    const mockMatrix = await import(
+      '@cardstack/host/tests/helpers/mock-matrix'
+    );
+    const setupHelpers = await import('@cardstack/host/tests/helpers/setup');
+
+    if (debugLoad) {
+      // eslint-disable-next-line no-console
+      console.group('live-test loadRealmTests');
+      // eslint-disable-next-line no-console
+      console.log('QUnit config:', {
+        filter: QUnit.config.filter,
+        module: QUnit.config.module,
+        autostart: QUnit.config.autostart,
+      });
+      // eslint-disable-next-line no-console
+      console.log('Module count (before import):', QUnit.config.modules.length);
+    }
+
+    const loaderInstance = application.buildInstance({
+      rootElement: '#ember-testing-loader',
+    });
+    await loaderInstance.boot();
+    let loader = loaderInstance.lookup('service:loader-service').loader;
+    // eslint-disable-next-line no-console
+    console.info('[live-test] Loader service ready');
+
+    if (debugLoad) {
+      // eslint-disable-next-line no-console
+      console.log('Loader service:', loader);
+    }
+
+    loader.shimModule('qunit', QUnit);
+    loader.shimModule('@cardstack/host/tests/helpers', helpers);
+    loader.shimModule('@cardstack/host/tests/helpers/mock-matrix', mockMatrix);
+    loader.shimModule('@cardstack/host/tests/helpers/setup', setupHelpers);
+
+    const realmURL =
+      urlParams.get('realmURL') ?? 'http://localhost:4201/experiments/';
+
+    if (debugLoad) {
+      // eslint-disable-next-line no-console
+      console.log('Importing realm module:', `${realmURL}sample-command-card`);
+    }
+
+    const testModules = (testModuleParam ?? 'sample-command-card')
+      .split(',')
+      .map((name) => name.trim())
+      .filter(Boolean)
+      .map((name) => `${realmURL}${name}`);
+
+    const capturedModules = new Set();
+    QUnit.config.testFilter = (testInfo) =>
+      capturedModules.has(testInfo.module);
+    const originalModule = QUnit.module;
+    QUnit.module = function (...args) {
+      const [name] = args;
+      if (typeof name === 'string') {
+        capturedModules.add(name);
+      }
+      // @ts-expect-error QUnit.module has multiple call signatures
+      return originalModule.apply(this, args);
+    };
+
+    try {
+      for (const moduleURL of testModules) {
+        if (debugLoad) {
+          // eslint-disable-next-line no-console
+          console.log('Importing realm module:', moduleURL);
+        }
+        await loader.import(moduleURL);
+      }
+    } finally {
+      QUnit.module = originalModule;
+      await loaderInstance.destroy();
+    }
+
+    if (capturedModules.size > 0) {
+      QUnit.config.testFilter = (testInfo) =>
+        capturedModules.has(testInfo.module);
+    }
+
+    if (debugLoad) {
+      // eslint-disable-next-line no-console
+      console.log(
+        'Import complete. Module count:',
+        QUnit.config.modules.length,
+      );
+      // eslint-disable-next-line no-console
+      console.log(
+        'Module names:',
+        QUnit.config.modules.map((module) => module.name).filter(Boolean),
+      );
+      if (capturedModules.size === 0) {
+        // eslint-disable-next-line no-console
+        console.warn(
+          'No QUnit modules were registered by the realm imports. Check loader errors or shim coverage.',
+        );
+      } else {
+        // eslint-disable-next-line no-console
+        console.log(
+          'Captured realm modules:',
+          Array.from(capturedModules.values()).sort(),
+        );
+      }
+      // eslint-disable-next-line no-console
+      console.groupEnd();
+    }
+    if (urlParams.has('debugModules')) {
+      const moduleFilter = urlParams.get('debugModules');
+      let modules = QUnit.config.modules
+        .map((module) => ({
+          name: module.name,
+          testCount: module.tests?.length ?? 0,
+        }))
+        .filter((module) => module.name);
+
+      if (moduleFilter && moduleFilter !== '1' && moduleFilter !== 'true') {
+        const needle = moduleFilter.toLowerCase();
+        modules = modules.filter((module) =>
+          module.name.toLowerCase().includes(needle),
+        );
+      }
+
+      modules.sort((a, b) => a.name.localeCompare(b.name));
+
+      // TODO: remove debug logging once filter setup is validated
+      // eslint-disable-next-line no-console
+      console.group('QUnit modules');
+      // eslint-disable-next-line no-console
+      console.table(modules);
+      // eslint-disable-next-line no-console
+      console.log(
+        `Total: ${modules.length}. Tip: add debugModules=<substring> to filter.`,
+      );
+      // eslint-disable-next-line no-console
+      console.groupEnd();
+    }
+    if (!QUnit.config.started) {
+      // eslint-disable-next-line no-console
+      console.info('[live-test] Starting QUnit');
+      QUnit.start();
+    }
+  }
+
+  loadRealmTests().catch((error) => {
+    // eslint-disable-next-line no-console
+    console.error('Failed to load realm tests', error);
+    if (!QUnit.config.started) {
+      // eslint-disable-next-line no-console
+      console.info('[live-test] Starting QUnit after error');
+      QUnit.start();
+    }
+  });
+}
diff --git a/packages/host/tests/test-helper.js b/packages/host/tests/test-helper.js
index b2cc907f39c..a27e72214b4 100644
--- a/packages/host/tests/test-helper.js
+++ b/packages/host/tests/test-helper.js
@@ -7,21 +7,42 @@ import setupOperatorModeParametersMatchAssertion from '@cardstack/host/tests/hel
 import start from 'ember-exam/test-support/start';
 import { useTestWaiters } from '@cardstack/runtime-common';
 import * as TestWaiters from '@ember/test-waiters';
+import './live-test';
 
-QUnit.dump.maxDepth = 20;
+function isLiveTestUrl(url) {
+  const parsed = new URL(url);
+  const normalizedPath = parsed.pathname.replace(/\/+$/, '');
+  if (normalizedPath.endsWith('/live-test.html')) {
+    return true;
+  }
+  if (
+    normalizedPath.endsWith('/tests') &&
+    (parsed.searchParams.has('liveTest') ||
+      parsed.searchParams.has('live-test'))
+  ) {
+    return true;
+  }
+  return false;
+}
 
-useTestWaiters(TestWaiters);
-setApplication(Application.create(config.APP));
+const isLiveTest = isLiveTestUrl(window.location.href);
 
-setup(QUnit.assert);
-setupOperatorModeParametersMatchAssertion(QUnit.assert);
+if (!isLiveTest) {
+  QUnit.dump.maxDepth = 20;
 
-const urlParams = new URLSearchParams(window.location.search);
-const isParallelExamRun =
-  urlParams.has('browser') || urlParams.has('partition');
+  useTestWaiters(TestWaiters);
+  setApplication(Application.create(config.APP));
 
-if (isParallelExamRun) {
-  QUnit.config.failOnZeroTests = false;
-}
+  setup(QUnit.assert);
+  setupOperatorModeParametersMatchAssertion(QUnit.assert);
+
+  const urlParams = new URLSearchParams(window.location.search);
+  const isParallelExamRun =
+    urlParams.has('browser') || urlParams.has('partition');
 
-start();
+  if (isParallelExamRun) {
+    QUnit.config.failOnZeroTests = false;
+  }
+
+  start();
+}
diff --git a/packages/local-types/test-support.d.ts b/packages/local-types/test-support.d.ts
new file mode 100644
index 00000000000..816ce4768e3
--- /dev/null
+++ b/packages/local-types/test-support.d.ts
@@ -0,0 +1,66 @@
+// Opt-in type declarations for colocated realm test files.
+// Add this path to your realm package's tsconfig "include" array:
+//   "../local-types/test-support.d.ts"
+//
+// Also add to your realm package's devDependencies:
+//   "@ember/test-helpers": "catalog:"
+//   "@types/qunit": "catalog:"
+//   "@universal-ember/test-support": "catalog:"
+//
+// The declarations below cover @cardstack/host internal modules which have no
+// separate npm package. All other test imports resolve via node_modules.
+
+// ── @cardstack/host services ─────────────────────────────────────────────────
+declare module '@cardstack/host/services/store' {
+  export default class StoreService {
+    add(instance: unknown): Promise<unknown>;
+    peek(id: string): unknown;
+  }
+}
+
+// ── @cardstack/host test helpers ─────────────────────────────────────────────
+declare module '@cardstack/host/tests/helpers/adapter' {
+  export interface TestRealmAdapter {
+    openFile(path: string): Promise<{ content: string | Uint8Array } | undefined>;
+  }
+}
+
+declare module '@cardstack/host/tests/helpers' {
+  import type { TestRealmAdapter } from '@cardstack/host/tests/helpers/adapter';
+
+  export interface SetupRealmResult {
+    adapter: TestRealmAdapter;
+  }
+
+  export function setupIntegrationTestRealm(opts: {
+    mockMatrixUtils: unknown;
+    contents: Record<string, unknown>;
+  }): Promise<SetupRealmResult>;
+
+  export function setupLocalIndexing(hooks: unknown): void;
+  export function setupOnSave(hooks: unknown): void;
+  export function setupCardLogs(hooks: unknown, fn: () => Promise<unknown>): void;
+  export function setupRealmCacheTeardown(hooks: unknown): void;
+  export function withCachedRealmSetup<T>(fn: () => Promise<T>): Promise<T>;
+
+  export const testRealmURL: string;
+
+  export interface TestContextWithSave {
+    onSave(cb: (url: URL, doc: unknown) => void): void;
+  }
+}
+
+declare module '@cardstack/host/tests/helpers/mock-matrix' {
+  export function setupMockMatrix(
+    hooks: unknown,
+    opts: {
+      loggedInAs: string;
+      activeRealms: string[];
+      autostart: boolean;
+    },
+  ): unknown;
+}
+
+declare module '@cardstack/host/tests/helpers/setup' {
+  export function setupRenderingTest(hooks: unknown): void;
+}
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 4b031e5cb62..633c7cfd74b 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -75,6 +75,9 @@ catalogs:
     '@ember/string':
       specifier: ^4.0.1
       version: 4.0.1
+    '@ember/test-helpers':
+      specifier: ^3.3.1
+      version: 3.3.1
     '@ember/test-waiters':
       specifier: ^4.1.1
       version: 4.1.1
@@ -734,7 +737,7 @@ importers:
         version: 1.5.2(@glimmer/component@2.0.0)(@glint/template@1.3.0)(ember-cli-htmlbars@6.3.0)(ember-modifier@4.1.0(ember-source@5.12.0(patch_hash=2586bd032e74105d65b7953ccaae1cd1d1175047a58ba89ec0057f1f8b7b7fe1)(@glimmer/component@2.0.0)(@glint/template@1.3.0)(rsvp@4.8.5)(webpack@5.104.1)))
       '@glint/environment-ember-template-imports':
         specifier: 1.3.0
-        version: 1.3.0(@glint/environment-ember-loose@1.5.2(@glimmer/component@2.0.0)(@glint/template@1.3.0)(ember-cli-htmlbars@6.3.0)(ember-modifier@4.1.0(ember-source@5.12.0(patch_hash=2586bd032e74105d65b7953ccaae1cd1d1175047a58ba89ec0057f1f8b7b7fe1)(@glimmer/component@2.0.0)(@glint/template@1.3.0)(rsvp@4.8.5)(webpack@5.104.1))))(@glint/template@1.3.0)
+        version: 1.3.0(@glint/environment-ember-loose@1.5.2(@glimmer/component@2.0.0)(@glint/template@1.3.0)(ember-cli-htmlbars@6.3.0)(ember-modifier@4.1.0(ember-source@5.12.0(patch_hash=2586bd032e74105d65b7953ccaae1cd1d1175047a58ba89ec0057f1f8b7b7fe1)(@glimmer/component@2.0.0)(@glint/template@1.3.0)(rsvp@4.8.5))))(@glint/template@1.3.0)
       '@playwright/test':
         specifier: 'catalog:'
         version: 1.57.0
@@ -1391,7 +1394,7 @@ importers:
         version: 1.3.0(typescript@5.9.3)
       '@glint/environment-ember-template-imports':
         specifier: 1.3.0
-        version: 1.3.0(@glint/environment-ember-loose@1.5.2(@glimmer/component@2.0.0)(@glint/template@1.3.0)(ember-cli-htmlbars@6.3.0)(ember-modifier@4.1.0(ember-source@5.12.0(patch_hash=2586bd032e74105d65b7953ccaae1cd1d1175047a58ba89ec0057f1f8b7b7fe1)(@glimmer/component@2.0.0)(@glint/template@1.3.0)(rsvp@4.8.5)(webpack@5.104.1))))(@glint/template@1.3.0)
+        version: 1.3.0(@glint/environment-ember-loose@1.5.2(@glimmer/component@2.0.0)(@glint/template@1.3.0)(ember-cli-htmlbars@6.3.0)(ember-modifier@4.1.0(ember-source@5.12.0(patch_hash=2586bd032e74105d65b7953ccaae1cd1d1175047a58ba89ec0057f1f8b7b7fe1)(@glimmer/component@2.0.0)(@glint/template@1.3.0)(rsvp@4.8.5))))(@glint/template@1.3.0)
       '@glint/template':
         specifier: 1.3.0
         version: 1.3.0
@@ -1584,12 +1587,21 @@ importers:
       '@cardstack/runtime-common':
         specifier: workspace:*
         version: link:../runtime-common
+      '@ember/test-helpers':
+        specifier: 'catalog:'
+        version: 3.3.1(@babel/core@7.28.6)(@glint/template@1.3.0)(ember-source@5.12.0(patch_hash=2586bd032e74105d65b7953ccaae1cd1d1175047a58ba89ec0057f1f8b7b7fe1)(@glimmer/component@2.0.0)(@glint/template@1.3.0)(rsvp@4.8.5)(webpack@5.104.1))(webpack@5.104.1)
       '@types/lodash':
         specifier: 'catalog:'
         version: 4.17.23
+      '@types/qunit':
+        specifier: 'catalog:'
+        version: 2.19.13
       '@types/uuid':
         specifier: 'catalog:'
         version: 9.0.8
+      '@universal-ember/test-support':
+        specifier: 'catalog:'
+        version: 0.5.1(@babel/core@7.28.6)(@glint/template@1.3.0)(ember-source@5.12.0(patch_hash=2586bd032e74105d65b7953ccaae1cd1d1175047a58ba89ec0057f1f8b7b7fe1)(@glimmer/component@2.0.0)(@glint/template@1.3.0)(rsvp@4.8.5)(webpack@5.104.1))(qunit@2.25.0)
       chess.js:
         specifier: 'catalog:'
         version: 1.0.0-beta.8
@@ -1702,9 +1714,18 @@ importers:
       '@cardstack/view-transitions':
         specifier: 'catalog:'
         version: 0.2.0(@babel/core@7.28.6)(ember-modifier@4.1.0(ember-source@5.12.0(patch_hash=2586bd032e74105d65b7953ccaae1cd1d1175047a58ba89ec0057f1f8b7b7fe1)(@glimmer/component@2.0.0)(@glint/template@1.3.0)(rsvp@4.8.5)(webpack@5.104.1)))
+      '@ember/test-helpers':
+        specifier: 'catalog:'
+        version: 3.3.1(@babel/core@7.28.6)(@glint/template@1.3.0)(ember-source@5.12.0(patch_hash=2586bd032e74105d65b7953ccaae1cd1d1175047a58ba89ec0057f1f8b7b7fe1)(@glimmer/component@2.0.0)(@glint/template@1.3.0)(rsvp@4.8.5)(webpack@5.104.1))(webpack@5.104.1)
       '@types/lodash':
         specifier: 'catalog:'
         version: 4.17.23
+      '@types/qunit':
+        specifier: 'catalog:'
+        version: 2.19.13
+      '@universal-ember/test-support':
+        specifier: 'catalog:'
+        version: 0.5.1(@babel/core@7.28.6)(@glint/template@1.3.0)(ember-source@5.12.0(patch_hash=2586bd032e74105d65b7953ccaae1cd1d1175047a58ba89ec0057f1f8b7b7fe1)(@glimmer/component@2.0.0)(@glint/template@1.3.0)(rsvp@4.8.5)(webpack@5.104.1))(qunit@2.25.0)
       chess.js:
         specifier: 'catalog:'
         version: 1.0.0-beta.8
@@ -1713,7 +1734,7 @@ importers:
         version: 8.2.2
       ember-animated:
         specifier: 'catalog:'
-        version: 2.2.0(@babel/core@7.28.6)(@ember/test-helpers@5.4.1(@babel/core@7.28.6)(@glint/template@1.3.0))(@glint/template@1.3.0)
+        version: 2.2.0(@babel/core@7.28.6)(@ember/test-helpers@3.3.1(@babel/core@7.28.6)(@glint/template@1.3.0)(ember-source@5.12.0(patch_hash=2586bd032e74105d65b7953ccaae1cd1d1175047a58ba89ec0057f1f8b7b7fe1)(@glimmer/component@2.0.0)(@glint/template@1.3.0)(rsvp@4.8.5)(webpack@5.104.1))(webpack@5.104.1))(@glint/template@1.3.0)
       ember-concurrency:
         specifier: 'catalog:'
         version: 4.0.6(@babel/core@7.28.6)(@glint/template@1.3.0)
@@ -1785,7 +1806,7 @@ importers:
         specifier: ^3.1.1
         version: 3.1.1
       '@ember/test-helpers':
-        specifier: ^3.3.1
+        specifier: 'catalog:'
         version: 3.3.1(@babel/core@7.28.6)(@glint/template@1.3.0)(ember-source@5.12.0(patch_hash=2586bd032e74105d65b7953ccaae1cd1d1175047a58ba89ec0057f1f8b7b7fe1)(@glimmer/component@2.0.0)(@glint/template@1.3.0)(rsvp@4.8.5)(webpack@5.104.1))(webpack@5.104.1)
       '@ember/test-waiters':
         specifier: 'catalog:'
@@ -1819,7 +1840,7 @@ importers:
         version: 1.5.2(@glimmer/component@2.0.0)(@glint/template@1.3.0)(ember-cli-htmlbars@6.3.0)(ember-modifier@4.1.0(ember-source@5.12.0(patch_hash=2586bd032e74105d65b7953ccaae1cd1d1175047a58ba89ec0057f1f8b7b7fe1)(@glimmer/component@2.0.0)(@glint/template@1.3.0)(rsvp@4.8.5)(webpack@5.104.1)))
       '@glint/environment-ember-template-imports':
         specifier: 1.3.0
-        version: 1.3.0(@glint/environment-ember-loose@1.5.2(@glimmer/component@2.0.0)(@glint/template@1.3.0)(ember-cli-htmlbars@6.3.0)(ember-modifier@4.1.0(ember-source@5.12.0(patch_hash=2586bd032e74105d65b7953ccaae1cd1d1175047a58ba89ec0057f1f8b7b7fe1)(@glimmer/component@2.0.0)(@glint/template@1.3.0)(rsvp@4.8.5)(webpack@5.104.1))))(@glint/template@1.3.0)
+        version: 1.3.0(@glint/environment-ember-loose@1.5.2(@glimmer/component@2.0.0)(@glint/template@1.3.0)(ember-cli-htmlbars@6.3.0)(ember-modifier@4.1.0(ember-source@5.12.0(patch_hash=2586bd032e74105d65b7953ccaae1cd1d1175047a58ba89ec0057f1f8b7b7fe1)(@glimmer/component@2.0.0)(@glint/template@1.3.0)(rsvp@4.8.5))))(@glint/template@1.3.0)
       '@glint/template':
         specifier: 1.3.0
         version: 1.3.0
@@ -2800,7 +2821,7 @@ importers:
         version: 1.5.2(@glimmer/component@2.0.0)(@glint/template@1.3.0)(ember-cli-htmlbars@6.3.0)(ember-modifier@4.1.0(ember-source@5.12.0(patch_hash=2586bd032e74105d65b7953ccaae1cd1d1175047a58ba89ec0057f1f8b7b7fe1)(@glimmer/component@2.0.0)(@glint/template@1.3.0)(rsvp@4.8.5)(webpack@5.104.1)))
       '@glint/environment-ember-template-imports':
         specifier: 1.3.0
-        version: 1.3.0(@glint/environment-ember-loose@1.5.2(@glimmer/component@2.0.0)(@glint/template@1.3.0)(ember-cli-htmlbars@6.3.0)(ember-modifier@4.1.0(ember-source@5.12.0(patch_hash=2586bd032e74105d65b7953ccaae1cd1d1175047a58ba89ec0057f1f8b7b7fe1)(@glimmer/component@2.0.0)(@glint/template@1.3.0)(rsvp@4.8.5)(webpack@5.104.1))))(@glint/template@1.3.0)
+        version: 1.3.0(@glint/environment-ember-loose@1.5.2(@glimmer/component@2.0.0)(@glint/template@1.3.0)(ember-cli-htmlbars@6.3.0)(ember-modifier@4.1.0(ember-source@5.12.0(patch_hash=2586bd032e74105d65b7953ccaae1cd1d1175047a58ba89ec0057f1f8b7b7fe1)(@glimmer/component@2.0.0)(@glint/template@1.3.0)(rsvp@4.8.5))))(@glint/template@1.3.0)
       '@types/dompurify':
         specifier: 'catalog:'
         version: 3.2.0
@@ -2884,7 +2905,7 @@ importers:
         version: 1.5.2(@glimmer/component@2.0.0)(@glint/template@1.3.0)(ember-cli-htmlbars@6.3.0)(ember-modifier@4.1.0(ember-source@5.12.0(patch_hash=2586bd032e74105d65b7953ccaae1cd1d1175047a58ba89ec0057f1f8b7b7fe1)(@glimmer/component@2.0.0)(@glint/template@1.3.0)(rsvp@4.8.5)(webpack@5.104.1)))
       '@glint/environment-ember-template-imports':
         specifier: ^1.3.0
-        version: 1.3.0(@glint/environment-ember-loose@1.5.2(@glimmer/component@2.0.0)(@glint/template@1.3.0)(ember-cli-htmlbars@6.3.0)(ember-modifier@4.1.0(ember-source@5.12.0(patch_hash=2586bd032e74105d65b7953ccaae1cd1d1175047a58ba89ec0057f1f8b7b7fe1)(@glimmer/component@2.0.0)(@glint/template@1.3.0)(rsvp@4.8.5)(webpack@5.104.1))))(@glint/template@1.3.0)
+        version: 1.3.0(@glint/environment-ember-loose@1.5.2(@glimmer/component@2.0.0)(@glint/template@1.3.0)(ember-cli-htmlbars@6.3.0)(ember-modifier@4.1.0(ember-source@5.12.0(patch_hash=2586bd032e74105d65b7953ccaae1cd1d1175047a58ba89ec0057f1f8b7b7fe1)(@glimmer/component@2.0.0)(@glint/template@1.3.0)(rsvp@4.8.5))))(@glint/template@1.3.0)
       '@glint/template':
         specifier: ^1.3.0
         version: 1.3.0
@@ -9575,7 +9596,7 @@ packages:
 
   glob@7.2.3:
     resolution: {integrity: sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q==}
-    deprecated: Glob versions prior to v9 are no longer supported
+    deprecated: Old versions of glob are not supported, and contain widely publicized security vulnerabilities, which have been fixed in the current version. Please update. Support for old versions may be purchased (at exorbitant rates) by contacting i@izs.me
 
   glob@8.1.0:
     resolution: {integrity: sha512-r8hpEjiQEYlF2QU0df3dS+nxxSIreXQS1qRhMJM0Q5NDdR386C7jb7Hwwod8Fgiuex+k0GFjgft18yvxm5XoCQ==}
@@ -15886,7 +15907,7 @@ snapshots:
       ember-cli-htmlbars: 6.3.0
       ember-modifier: 4.1.0(ember-source@5.12.0(patch_hash=2586bd032e74105d65b7953ccaae1cd1d1175047a58ba89ec0057f1f8b7b7fe1)(@glimmer/component@2.0.0)(@glint/template@1.3.0)(rsvp@4.8.5)(webpack@5.104.1))
 
-  '@glint/environment-ember-template-imports@1.3.0(@glint/environment-ember-loose@1.5.2(@glimmer/component@2.0.0)(@glint/template@1.3.0)(ember-cli-htmlbars@6.3.0)(ember-modifier@4.1.0(ember-source@5.12.0(patch_hash=2586bd032e74105d65b7953ccaae1cd1d1175047a58ba89ec0057f1f8b7b7fe1)(@glimmer/component@2.0.0)(@glint/template@1.3.0)(rsvp@4.8.5)(webpack@5.104.1))))(@glint/template@1.3.0)':
+  '@glint/environment-ember-template-imports@1.3.0(@glint/environment-ember-loose@1.5.2(@glimmer/component@2.0.0)(@glint/template@1.3.0)(ember-cli-htmlbars@6.3.0)(ember-modifier@4.1.0(ember-source@5.12.0(patch_hash=2586bd032e74105d65b7953ccaae1cd1d1175047a58ba89ec0057f1f8b7b7fe1)(@glimmer/component@2.0.0)(@glint/template@1.3.0)(rsvp@4.8.5))))(@glint/template@1.3.0)':
     dependencies:
       '@glint/environment-ember-loose': 1.5.2(@glimmer/component@2.0.0)(@glint/template@1.3.0)(ember-cli-htmlbars@6.3.0)(ember-modifier@4.1.0(ember-source@5.12.0(patch_hash=2586bd032e74105d65b7953ccaae1cd1d1175047a58ba89ec0057f1f8b7b7fe1)(@glimmer/component@2.0.0)(@glint/template@1.3.0)(rsvp@4.8.5)(webpack@5.104.1)))
       '@glint/template': 1.3.0
diff --git a/pnpm-workspace.yaml b/pnpm-workspace.yaml
index 87e15f278de..dc10b4855c0 100644
--- a/pnpm-workspace.yaml
+++ b/pnpm-workspace.yaml
@@ -27,6 +27,7 @@ catalog:
   "@cardstack/requirejs-monaco-ember-polyfill": ^0.0.1
   "@cardstack/view-transitions": ^0.2.0
   "@ember/string": ^4.0.1
+  "@ember/test-helpers": ^3.3.1
   "@ember/test-waiters": ^4.1.1
   "@eslint/eslintrc": ^2.1.4
   "@eslint/js": ^8.57.1