From a25dfe991ec48f5a2521b2d6dd0e53bbd3d949dd Mon Sep 17 00:00:00 2001
From: tintinthong <justinthong93@gmail.com>
Date: Thu, 5 Mar 2026 15:17:11 +0800
Subject: [PATCH 1/3] get test to run locally for daily report dashboard

---
 .../commands/generate-daily-report.gts        |  6 +-
 .../daily-report-dashboard.gts                | 23 ++++-
 .../catalog/daily-report-dashboard-test.gts   | 97 +++++++++++++++++++
 .../host/tests/integration/catalog/setup.gts  | 76 +++++++++++++++
 4 files changed, 196 insertions(+), 6 deletions(-)
 create mode 100644 packages/host/tests/integration/catalog/daily-report-dashboard-test.gts
 create mode 100644 packages/host/tests/integration/catalog/setup.gts

diff --git a/packages/catalog-realm/commands/generate-daily-report.gts b/packages/catalog-realm/commands/generate-daily-report.gts
index 5d35f6d80db..085d992604f 100644
--- a/packages/catalog-realm/commands/generate-daily-report.gts
+++ b/packages/catalog-realm/commands/generate-daily-report.gts
@@ -96,8 +96,10 @@ export class GenerateDailyReport extends Command<
 
       let prompt =
         'Generate daily report for the selected date from the attached activity log cards using the policy manual and update the attached daily report card';
-      let skillCardId = new URL('../Skill/daily-report-skill', import.meta.url)
-        .href;
+      let skillCardId = new URL(
+        '../daily-report-dashboard/Skill/daily-report-skill',
+        import.meta.url,
+      ).href;
       let useCommand = new UseAiAssistantCommand(this.commandContext);
       await useCommand.execute({
         roomId: 'new',
diff --git a/packages/catalog-realm/daily-report-dashboard/daily-report-dashboard.gts b/packages/catalog-realm/daily-report-dashboard/daily-report-dashboard.gts
index 85e1d7356f8..9fbbacd5946 100644
--- a/packages/catalog-realm/daily-report-dashboard/daily-report-dashboard.gts
+++ b/packages/catalog-realm/daily-report-dashboard/daily-report-dashboard.gts
@@ -13,16 +13,31 @@ import { PolicyManual } from './policy-manual';
 import { GenerateDailyReport } from '../commands/generate-daily-report';
 
 class Isolated extends Component<typeof DailyReportDashboard> {
+  private get policyManualId(): string | undefined {
+    return this.args.model.policyManual?.id;
+  }
+
+  get isGenerateDisabled() {
+    return this._generateReport.isRunning || !this.args.model.policyManual;
+  }
+
   get dailyReportsQuery(): Query {
+    let policyManualId = this.policyManualId;
     return {
       filter: {
         on: {
           module: new URL('./daily-report', import.meta.url).href,
           name: 'DailyReport',
         },
-        eq: {
-          'policyManual.id': this.args.model.policyManual!.id,
-        },
+        every: policyManualId
+          ? [
+              {
+                eq: {
+                  'policyManual.id': policyManualId,
+                },
+              },
+            ]
+          : [],
       },
 
       sort: [
@@ -136,7 +151,7 @@ class Isolated extends Component<typeof DailyReportDashboard> {
                   </div>
                   <Button
                     class='generate-report-button'
-                    @disabled={{this._generateReport.isRunning}}
+                    @disabled={{this.isGenerateDisabled}}
                     {{on 'click' this.generateReport}}
                   >
                     {{#if this._generateReport.isRunning}}
diff --git a/packages/host/tests/integration/catalog/daily-report-dashboard-test.gts b/packages/host/tests/integration/catalog/daily-report-dashboard-test.gts
new file mode 100644
index 00000000000..23ea74dd3d3
--- /dev/null
+++ b/packages/host/tests/integration/catalog/daily-report-dashboard-test.gts
@@ -0,0 +1,97 @@
+import { click, waitFor, waitUntil } from '@ember/test-helpers';
+
+import { module, test } from 'qunit';
+
+import { renderCard } from '../../helpers/render-component';
+
+import { setupCatalogIsolatedCardTest } from './setup';
+
+module('Integration | Catalog | daily-report-dashboard', function (hooks) {
+  setupCatalogIsolatedCardTest(hooks, {
+    beforeEach: async function () {
+      let realm = this.catalogRealm as any;
+      this.catalogTestRealmContents = {
+        'Skill/daily-report-skill.json': {
+          data: {
+            type: 'card',
+            attributes: {
+              cardTitle: 'Daily Report Generation',
+              cardDescription:
+                'Generates daily report output from activity logs',
+              instructions: 'Generate a daily report from activity log cards.',
+              commands: [
+                {
+                  codeRef: {
+                    module: '@cardstack/boxel-host/commands/write-text-file',
+                    name: 'default',
+                  },
+                  requiresApproval: false,
+                },
+              ],
+            },
+            meta: {
+              adoptsFrom: {
+                module: 'https://cardstack.com/base/skill',
+                name: 'Skill',
+              },
+            },
+          },
+        },
+        'PolicyManual/ops.json': {
+          data: {
+            type: 'card',
+            attributes: {
+              manualTitle: 'Ops Policy',
+              activityLogCardType: {
+                module: `${realm.url}daily-report-dashboard/activity-log`,
+                name: 'ActivityLog',
+              },
+            },
+            meta: {
+              adoptsFrom: {
+                module: `${realm.url}daily-report-dashboard/policy-manual`,
+                name: 'PolicyManual',
+              },
+            },
+          },
+        },
+        'DailyReportDashboard/ops.json': {
+          data: {
+            type: 'card',
+            relationships: {
+              policyManual: {
+                links: {
+                  self: `${this.testRealmURL}PolicyManual/ops`,
+                },
+              },
+            },
+            meta: {
+              adoptsFrom: {
+                module: `${realm.url}daily-report-dashboard/daily-report-dashboard`,
+                name: 'DailyReportDashboard',
+              },
+            },
+          },
+        },
+      };
+    },
+  });
+
+  test('daily-report-dashboard', async function (this: any, assert) {
+    let dashboard = await this.store.get(
+      `${this.testRealmURL}DailyReportDashboard/ops`,
+    );
+    assert.ok(dashboard, 'saved dashboard card is loaded from realm');
+    await renderCard(this.loader, dashboard as any, 'isolated');
+    await waitFor('.generate-report-button');
+    assert.dom('.empty-state').exists('dashboard starts with empty reports');
+    await click('.generate-report-button');
+    await waitUntil(() => Boolean(document.querySelector('.reports-grid')), {
+      timeout: 10000,
+    });
+    assert
+      .dom('.empty-state')
+      .doesNotExist('reports list replaces empty state');
+    assert.dom('.reports-grid').exists('generated report is displayed');
+  });
+});
diff --git a/packages/host/tests/integration/catalog/setup.gts b/packages/host/tests/integration/catalog/setup.gts
new file mode 100644
index 00000000000..61f9fde8e5a
--- /dev/null
+++ b/packages/host/tests/integration/catalog/setup.gts
@@ -0,0 +1,76 @@
+import { getService } from '@universal-ember/test-support';
+
+import { CardContextName } from '@cardstack/runtime-common';
+
+import PrerenderedCardSearch from '@cardstack/host/components/prerendered-card-search';
+import { getCardCollection } from '@cardstack/host/resources/card-collection';
+import { getCard } from '@cardstack/host/resources/card-resource';
+
+import {
+  catalogRealm,
+  provideConsumeContext,
+  setupIntegrationTestRealm,
+  setupLocalIndexing,
+  setupRealmCacheTeardown,
+  testRealmURL,
+  withCachedRealmSetup,
+} from '../../helpers';
+import { setupBaseRealm } from '../../helpers/base-realm';
+import { setupMockMatrix } from '../../helpers/mock-matrix';
+import { setupRenderingTest } from '../../helpers/setup';
+
+type SetupOptions = {
+  beforeEach?: (this: any) => Promise<void> | void;
+};
+
+export function setupCatalogIsolatedCardTest(
+  hooks: NestedHooks,
+  options?: SetupOptions,
+) {
+  setupRenderingTest(hooks);
+  setupBaseRealm(hooks);
+  setupLocalIndexing(hooks);
+
+  let activeRealms = [
+    testRealmURL,
+    ...(catalogRealm ? [catalogRealm.url] : []),
+  ];
+  let mockMatrixUtils = setupMockMatrix(hooks, {
+    loggedInAs: '@testuser:localhost',
+    activeRealms,
+    autostart: true,
+  });
+  setupRealmCacheTeardown(hooks, 'catalog-isolated');
+
+  hooks.beforeEach(async function (this: any) {
+    this.loader = getService('loader-service').loader;
+    this.store = getService('store');
+    this.commandContext = getService('command-service').commandContext;
+    this.catalogRealm = catalogRealm as any;
+    this.testRealmURL = testRealmURL;
+    this.catalogTestRealmContents = {};
+
+    provideConsumeContext(CardContextName, {
+      commandContext: this.commandContext,
+      prerenderedCardSearchComponent: PrerenderedCardSearch,
+      getCard: getCard as any,
+      getCards: (this.store as any).getSearchResource.bind(this.store),
+      getCardCollection: getCardCollection as any,
+      store: this.store,
+      mode: 'host',
+      submode: 'host',
+    } as any);
+
+    if (options?.beforeEach) {
+      await options.beforeEach.call(this);
+    }
+
+    await withCachedRealmSetup('catalog-isolated', async () =>
+      setupIntegrationTestRealm({
+        mockMatrixUtils,
+        realmURL: testRealmURL,
+        contents: this.catalogTestRealmContents,
+      }),
+    );
+  });
+}

From 1e0f6fcf467e5fdf554ee40618d9b536a62b5184 Mon Sep 17 00:00:00 2001
From: tintinthong <justinthong93@gmail.com>
Date: Thu, 5 Mar 2026 15:19:37 +0800
Subject: [PATCH 2/3] spike passing test into the catalog runner

---
 packages/host/package.json                    |  1 +
 packages/host/scripts/run-catalog-runner.sh   | 62 ++++++++++++
 .../catalog/catalog-runner-test.gts           | 43 ++++++++
 .../catalog/daily-report-dashboard-test.gts   | 97 ------------------
 .../catalog/generated/test-module.gts         | 99 +++++++++++++++++++
 .../modules/daily-report-dashboard.module.gts | 96 ++++++++++++++++++
 .../host/tests/integration/catalog/setup.gts  | 19 ++--
 7 files changed, 313 insertions(+), 104 deletions(-)
 create mode 100755 packages/host/scripts/run-catalog-runner.sh
 create mode 100644 packages/host/tests/integration/catalog/catalog-runner-test.gts
 delete mode 100644 packages/host/tests/integration/catalog/daily-report-dashboard-test.gts
 create mode 100644 packages/host/tests/integration/catalog/generated/test-module.gts
 create mode 100644 packages/host/tests/integration/catalog/modules/daily-report-dashboard.module.gts

diff --git a/packages/host/package.json b/packages/host/package.json
index c280d2bcc2f..2a0fcf58046 100644
--- a/packages/host/package.json
+++ b/packages/host/package.json
@@ -28,6 +28,7 @@
     "test": "concurrently \"pnpm:lint\" \"pnpm:test:*\" --names \"lint,test:\"",
     "test-with-percy": "percy exec --parallel -- pnpm test:wait-for-servers",
     "test:wait-for-servers": "./scripts/test-wait-for-servers.sh",
+    "test:catalog:runner": "./scripts/run-catalog-runner.sh --test-module ./tests/integration/catalog/modules/daily-report-dashboard.module.gts",
     "ember-test-pre-built": "sleep 15 && ember exam --path ./dist --split $HOST_TEST_PARTITION_COUNT --partition $HOST_TEST_PARTITION --preserve-test-name",
     "wait": "sleep 10000000"
   },
diff --git a/packages/host/scripts/run-catalog-runner.sh b/packages/host/scripts/run-catalog-runner.sh
new file mode 100755
index 00000000000..9fe9be5820f
--- /dev/null
+++ b/packages/host/scripts/run-catalog-runner.sh
@@ -0,0 +1,62 @@
+#!/bin/sh
+
+set -eu
+
+TEST_MODULE=""
+FILTER="Integration | Catalog | runner"
+NO_RUN="false"
+
+while [ "$#" -gt 0 ]; do
+  case "$1" in
+    --test-module)
+      TEST_MODULE="${2:-}"
+      shift 2
+      ;;
+    --filter)
+      FILTER="${2:-}"
+      shift 2
+      ;;
+    --no-run)
+      NO_RUN="true"
+      shift 1
+      ;;
+    *)
+      echo "[catalog-runner] Unknown argument: $1" >&2
+      exit 1
+      ;;
+  esac
+done
+
+if [ -z "$TEST_MODULE" ]; then
+  echo "[catalog-runner] Missing --test-module <path-to-test-module.gts|ts|js>" >&2
+  exit 1
+fi
+
+ROOT_DIR="$(pwd)"
+SOURCE_PATH="$ROOT_DIR/$TEST_MODULE"
+
+if [ ! -f "$SOURCE_PATH" ]; then
+  echo "[catalog-runner] Test module not found: $SOURCE_PATH" >&2
+  exit 1
+fi
+
+GENERATED_DIR="$ROOT_DIR/tests/integration/catalog/generated"
+GENERATED_MODULE_PATH="$GENERATED_DIR/test-module.gts"
+
+mkdir -p "$GENERATED_DIR"
+
+{
+  echo "// Auto-generated by scripts/run-catalog-runner.sh"
+  echo "// Source: $SOURCE_PATH"
+  echo
+  cat "$SOURCE_PATH"
+} > "$GENERATED_MODULE_PATH"
+
+echo "[catalog-runner] Wrote $GENERATED_MODULE_PATH"
+
+if [ "$NO_RUN" = "true" ]; then
+  exit 0
+fi
+
+echo "[catalog-runner] Running ember test --filter \"$FILTER\""
+pnpm exec ember test --filter "$FILTER"
diff --git a/packages/host/tests/integration/catalog/catalog-runner-test.gts b/packages/host/tests/integration/catalog/catalog-runner-test.gts
new file mode 100644
index 00000000000..7a206757566
--- /dev/null
+++ b/packages/host/tests/integration/catalog/catalog-runner-test.gts
@@ -0,0 +1,43 @@
+import { module, test } from 'qunit';
+
+import { renderCard } from '../../helpers/render-component';
+
+import runnerModule from './generated/test-module';
+import { setupCatalogIsolatedCardTest } from './setup';
+
+module('Integration | Catalog | runner', function (hooks) {
+  setupCatalogIsolatedCardTest(hooks, { setupRealm: 'manual' });
+
+  for (let caseDefinition of (runnerModule.cases ?? []) as any[]) {
+    test(caseDefinition.id, async function (this: any, assert) {
+      console.info(`[catalog-runner] START ${caseDefinition.id}`);
+
+      let seed =
+        typeof caseDefinition.seed === 'function'
+          ? await caseDefinition.seed(this)
+          : (caseDefinition.seed ?? {});
+      await this.setupCatalogRealm(
+        seed,
+        `catalog-isolated:${caseDefinition.id}`,
+      );
+
+      let cardURL =
+        typeof caseDefinition.cardURL === 'function'
+          ? await caseDefinition.cardURL(this)
+          : caseDefinition.cardURL;
+      let format = caseDefinition.format ?? 'isolated';
+      let card = await this.store.get(cardURL);
+      await renderCard(this.loader, card as any, format);
+
+      if (typeof caseDefinition.test !== 'function') {
+        throw new Error(
+          `Case "${caseDefinition.id}" is missing an async test(ctx, assert) function`,
+        );
+      }
+
+      await caseDefinition.test(this, assert);
+
+      console.info(`[catalog-runner] PASS ${caseDefinition.id}`);
+    });
+  }
+});
diff --git a/packages/host/tests/integration/catalog/daily-report-dashboard-test.gts b/packages/host/tests/integration/catalog/daily-report-dashboard-test.gts
deleted file mode 100644
index 23ea74dd3d3..00000000000
--- a/packages/host/tests/integration/catalog/daily-report-dashboard-test.gts
+++ /dev/null
@@ -1,97 +0,0 @@
-import { click, waitFor, waitUntil } from '@ember/test-helpers';
-
-import { module, test } from 'qunit';
-
-import { renderCard } from '../../helpers/render-component';
-
-import { setupCatalogIsolatedCardTest } from './setup';
-
-module('Integration | Catalog | daily-report-dashboard', function (hooks) {
-  setupCatalogIsolatedCardTest(hooks, {
-    beforeEach: async function () {
-      let realm = this.catalogRealm as any;
-      this.catalogTestRealmContents = {
-        'Skill/daily-report-skill.json': {
-          data: {
-            type: 'card',
-            attributes: {
-              cardTitle: 'Daily Report Generation',
-              cardDescription:
-                'Generates daily report output from activity logs',
-              instructions: 'Generate a daily report from activity log cards.',
-              commands: [
-                {
-                  codeRef: {
-                    module: '@cardstack/boxel-host/commands/write-text-file',
-                    name: 'default',
-                  },
-                  requiresApproval: false,
-                },
-              ],
-            },
-            meta: {
-              adoptsFrom: {
-                module: 'https://cardstack.com/base/skill',
-                name: 'Skill',
-              },
-            },
-          },
-        },
-        'PolicyManual/ops.json': {
-          data: {
-            type: 'card',
-            attributes: {
-              manualTitle: 'Ops Policy',
-              activityLogCardType: {
-                module: `${realm.url}daily-report-dashboard/activity-log`,
-                name: 'ActivityLog',
-              },
-            },
-            meta: {
-              adoptsFrom: {
-                module: `${realm.url}daily-report-dashboard/policy-manual`,
-                name: 'PolicyManual',
-              },
-            },
-          },
-        },
-        'DailyReportDashboard/ops.json': {
-          data: {
-            type: 'card',
-            relationships: {
-              policyManual: {
-                links: {
-                  self: `${this.testRealmURL}PolicyManual/ops`,
-                },
-              },
-            },
-            meta: {
-              adoptsFrom: {
-                module: `${realm.url}daily-report-dashboard/daily-report-dashboard`,
-                name: 'DailyReportDashboard',
-              },
-            },
-          },
-        },
-      };
-    },
-  });
-
-  test('daily-report-dashboard', async function (this: any, assert) {
-    let dashboard = await this.store.get(
-      `${this.testRealmURL}DailyReportDashboard/ops`,
-    );
-    assert.ok(dashboard, 'saved dashboard card is loaded from realm');
-    await renderCard(this.loader, dashboard as any, 'isolated');
-    await waitFor('.generate-report-button');
-    assert.dom('.empty-state').exists('dashboard starts with empty reports');
-    await click('.generate-report-button');
-    await waitUntil(() => Boolean(document.querySelector('.reports-grid')), {
-      timeout: 10000,
-    });
-    assert
-      .dom('.empty-state')
-      .doesNotExist('reports list replaces empty state');
-    assert.dom('.reports-grid').exists('generated report is displayed');
-  });
-});
diff --git a/packages/host/tests/integration/catalog/generated/test-module.gts b/packages/host/tests/integration/catalog/generated/test-module.gts
new file mode 100644
index 00000000000..0e9a919347b
--- /dev/null
+++ b/packages/host/tests/integration/catalog/generated/test-module.gts
@@ -0,0 +1,99 @@
+// Auto-generated by scripts/run-catalog-runner.sh
+// Source: /Users/tintinthong/github/boxel/packages/host/./tests/integration/catalog/modules/daily-report-dashboard.module.gts
+
+import { click, waitFor, waitUntil } from '@ember/test-helpers';
+
+export default {
+  cases: [
+    {
+      id: 'daily-report-dashboard',
+      format: 'isolated',
+      seed: async (ctx: any) => {
+        let realm = ctx.catalogRealm as any;
+        return {
+          'Skill/daily-report-skill.json': {
+            data: {
+              type: 'card',
+              attributes: {
+                cardTitle: 'Daily Report Generation',
+                cardDescription:
+                  'Generates daily report output from activity logs',
+                instructions:
+                  'Generate a daily report from activity log cards.',
+                commands: [
+                  {
+                    codeRef: {
+                      module: '@cardstack/boxel-host/commands/write-text-file',
+                      name: 'default',
+                    },
+                    requiresApproval: false,
+                  },
+                ],
+              },
+              meta: {
+                adoptsFrom: {
+                  module: 'https://cardstack.com/base/skill',
+                  name: 'Skill',
+                },
+              },
+            },
+          },
+          'PolicyManual/ops.json': {
+            data: {
+              type: 'card',
+              attributes: {
+                manualTitle: 'Ops Policy',
+                activityLogCardType: {
+                  module: `${realm.url}daily-report-dashboard/activity-log`,
+                  name: 'ActivityLog',
+                },
+              },
+              meta: {
+                adoptsFrom: {
+                  module: `${realm.url}daily-report-dashboard/policy-manual`,
+                  name: 'PolicyManual',
+                },
+              },
+            },
+          },
+          'DailyReportDashboard/ops.json': {
+            data: {
+              type: 'card',
+              relationships: {
+                policyManual: {
+                  links: {
+                    self: `${ctx.testRealmURL}PolicyManual/ops`,
+                  },
+                },
+              },
+              meta: {
+                adoptsFrom: {
+                  module: `${realm.url}daily-report-dashboard/daily-report-dashboard`,
+                  name: 'DailyReportDashboard',
+                },
+              },
+            },
+          },
+        };
+      },
+      cardURL: (ctx: any) => `${ctx.testRealmURL}DailyReportDashboard/ops`,
+      test: async (_ctx: any, assert: any) => {
+        await waitFor('.generate-report-button');
+        assert
+          .dom('.empty-state')
+          .exists('dashboard starts with empty reports');
+        await click('.generate-report-button');
+        await waitUntil(
+          () => Boolean(document.querySelector('.reports-grid')),
+          {
+            timeout: 10000,
+          },
+        );
+        assert
+          .dom('.empty-state')
+          .doesNotExist('reports list replaces empty state');
+        assert.dom('.reports-grid').exists('generated report is displayed');
+      },
+    },
+  ],
+} as any;
diff --git a/packages/host/tests/integration/catalog/modules/daily-report-dashboard.module.gts b/packages/host/tests/integration/catalog/modules/daily-report-dashboard.module.gts
new file mode 100644
index 00000000000..1fe30a8ca43
--- /dev/null
+++ b/packages/host/tests/integration/catalog/modules/daily-report-dashboard.module.gts
@@ -0,0 +1,96 @@
+import { click, waitFor, waitUntil } from '@ember/test-helpers';
+
+export default {
+  cases: [
+    {
+      id: 'daily-report-dashboard',
+      format: 'isolated',
+      seed: async (ctx: any) => {
+        let realm = ctx.catalogRealm as any;
+        return {
+          'Skill/daily-report-skill.json': {
+            data: {
+              type: 'card',
+              attributes: {
+                cardTitle: 'Daily Report Generation',
+                cardDescription:
+                  'Generates daily report output from activity logs',
+                instructions:
+                  'Generate a daily report from activity log cards.',
+                commands: [
+                  {
+                    codeRef: {
+                      module: '@cardstack/boxel-host/commands/write-text-file',
+                      name: 'default',
+                    },
+                    requiresApproval: false,
+                  },
+                ],
+              },
+              meta: {
+                adoptsFrom: {
+                  module: 'https://cardstack.com/base/skill',
+                  name: 'Skill',
+                },
+              },
+            },
+          },
+          'PolicyManual/ops.json': {
+            data: {
+              type: 'card',
+              attributes: {
+                manualTitle: 'Ops Policy',
+                activityLogCardType: {
+                  module: `${realm.url}daily-report-dashboard/activity-log`,
+                  name: 'ActivityLog',
+                },
+              },
+              meta: {
+                adoptsFrom: {
+                  module: `${realm.url}daily-report-dashboard/policy-manual`,
+                  name: 'PolicyManual',
+                },
+              },
+            },
+          },
+          'DailyReportDashboard/ops.json': {
+            data: {
+              type: 'card',
+              relationships: {
+                policyManual: {
+                  links: {
+                    self: `${ctx.testRealmURL}PolicyManual/ops`,
+                  },
+                },
+              },
+              meta: {
+                adoptsFrom: {
+                  module: `${realm.url}daily-report-dashboard/daily-report-dashboard`,
+                  name: 'DailyReportDashboard',
+                },
+              },
+            },
+          },
+        };
+      },
+      cardURL: (ctx: any) => `${ctx.testRealmURL}DailyReportDashboard/ops`,
+      test: async (_ctx: any, assert: any) => {
+        await waitFor('.generate-report-button');
+        assert
+          .dom('.empty-state')
+          .exists('dashboard starts with empty reports');
+        await click('.generate-report-button');
+        await waitUntil(
+          () => Boolean(document.querySelector('.reports-grid')),
+          {
+            timeout: 10000,
+          },
+        );
+        assert
+          .dom('.empty-state')
+          .doesNotExist('reports list replaces empty state');
+        assert.dom('.reports-grid').exists('generated report is displayed');
+      },
+    },
+  ],
+} as any;
diff --git a/packages/host/tests/integration/catalog/setup.gts b/packages/host/tests/integration/catalog/setup.gts
index 61f9fde8e5a..814ac6c6ba3 100644
--- a/packages/host/tests/integration/catalog/setup.gts
+++ b/packages/host/tests/integration/catalog/setup.gts
@@ -21,6 +21,7 @@ import { setupRenderingTest } from '../../helpers/setup';
 
 type SetupOptions = {
   beforeEach?: (this: any) => Promise<void> | void;
+  setupRealm?: 'auto' | 'manual';
 };
 
 export function setupCatalogIsolatedCardTest(
@@ -49,6 +50,14 @@ export function setupCatalogIsolatedCardTest(
     this.catalogRealm = catalogRealm as any;
     this.testRealmURL = testRealmURL;
     this.catalogTestRealmContents = {};
+    this.setupCatalogRealm = async (contents: any, cacheKey?: string) =>
+      withCachedRealmSetup(cacheKey ?? 'catalog-isolated', async () =>
+        setupIntegrationTestRealm({
+          mockMatrixUtils,
+          realmURL: testRealmURL,
+          contents,
+        }),
+      );
 
     provideConsumeContext(CardContextName, {
       commandContext: this.commandContext,
@@ -65,12 +74,8 @@ export function setupCatalogIsolatedCardTest(
       await options.beforeEach.call(this);
     }
 
-    await withCachedRealmSetup('catalog-isolated', async () =>
-      setupIntegrationTestRealm({
-        mockMatrixUtils,
-        realmURL: testRealmURL,
-        contents: this.catalogTestRealmContents,
-      }),
-    );
+    if (options?.setupRealm !== 'manual') {
+      await this.setupCatalogRealm(this.catalogTestRealmContents);
+    }
   });
 }

From 7ed41740c69c978a2485e863c412294c72fe0b26 Mon Sep 17 00:00:00 2001
From: tintinthong <justinthong93@gmail.com>
Date: Fri, 6 Mar 2026 09:38:48 +0800
Subject: [PATCH 3/3] add runner docs

---
 .../catalog/catalog-test-runner.md            | 97 +++++++++++++++++++
 1 file changed, 97 insertions(+)
 create mode 100644 packages/host/tests/integration/catalog/catalog-test-runner.md

diff --git a/packages/host/tests/integration/catalog/catalog-test-runner.md b/packages/host/tests/integration/catalog/catalog-test-runner.md
new file mode 100644
index 00000000000..5cb8325652e
--- /dev/null
+++ b/packages/host/tests/integration/catalog/catalog-test-runner.md
@@ -0,0 +1,97 @@
+# catalog-test-runner
+
+This runner lets you execute catalog integration tests by passing a test module file.
+
+## How it works
+
+1. Run `scripts/run-catalog-runner.sh` with `--test-module`.
+2. Script copies your module into:
+   - `tests/integration/catalog/generated/test-module.gts`
+3. QUnit runs `tests/integration/catalog/catalog-runner-test.gts`.
+4. The runner reads `default export` from `generated/test-module.gts` and executes each case.
+
+`setupCatalogIsolatedCardTest(..., { setupRealm: 'manual' })` is used so each case can seed its own realm contents via `this.setupCatalogRealm(seed, cacheKey)`.
+
+## Script
+
+Path:
+- `packages/host/scripts/run-catalog-runner.sh`
+
+Arguments:
+- `--test-module <path>`: required path to `.gts` / `.ts` / `.js` module
+- `--filter <qunit filter>`: optional, defaults to `Integration | Catalog | runner`
+- `--no-run`: optional, only generate `generated/test-module.gts`
+
+## Module API
+
+Your test module must `export default` an object with `cases`:
+
+```ts
+export default {
+  cases: [
+    {
+      id: 'case-name',
+      format: 'isolated', // optional, defaults to 'isolated'
+      seed: async (ctx) => ({
+        'SomeCard/instance.json': {
+          data: {
+            type: 'card',
+            attributes: {},
+            meta: { adoptsFrom: { module: '...', name: '...' } },
+          },
+        },
+      }),
+      cardURL: (ctx) => `${ctx.testRealmURL}SomeCard/instance`,
+      test: async (ctx, assert) => {
+        // DOM assertions here
+      },
+    },
+  ],
+} as any;
+```
+
+### Case fields
+
+- `id`: test name in QUnit output
+- `seed`: object or function returning realm contents to load before rendering
+- `cardURL`: URL or function returning URL of card instance to render
+- `test(ctx, assert)`: assertions/actions after render
+- `format`: render format (`isolated`, `fitted`, etc.)
+
+## Logging
+
+Runner logs per case:
+- `[catalog-runner] START <case-id>`
+- `[catalog-runner] PASS <case-id>`
+
+These appear in browser logs and CI test output.
+
+## Commands
+
+From `packages/host`:
+
+```bash
+./scripts/run-catalog-runner.sh \
+  --test-module ./tests/integration/catalog/modules/daily-report-dashboard.module.gts
+```
+
+or:
+
+```bash
+pnpm test:catalog:runner
+```
+
+Generate only:
+
+```bash
+./scripts/run-catalog-runner.sh \
+  --test-module ./tests/integration/catalog/modules/daily-report-dashboard.module.gts \
+  --no-run
+```
+
+## Browser URL
+
+After host test app is running:
+
+- `http://localhost:4200/tests?filter=Integration%20%7C%20Catalog%20%7C%20runner`
+- `http://localhost:4200/tests?filter=daily-report-dashboard`