@cardstack/boxel-cli 0.13.0-unstable.4 → 0.13.0-unstable.6

package/bundled-test-harness/assets/fallback-banner-live-delete-test-CuFiH1D8.js

@@ -0,0 +1,207 @@
+import { s as __toESM } from "./chunk-Rp0pCe6z.js";
+import { Br as testRealmURL } from "./runtime-common-BTaLJEw-.js";
+import { t as config } from "./environment-DIUJgBKt.js";
+import { wt as setComponentTemplate } from "./cache-DtDz7X5V-Wn8jRDfL.js";
+import { H as templateFactory } from "./index-DaCZcoCY-CgzbilMy.js";
+import "./component-BJO47HTh.js";
+import { t as Component } from "./dist-CkA1rgqO.js";
+import "./template-factory-ds9s0u8l.js";
+import { t as OperatorModeContainer } from "./container-CBZZ8uFw.js";
+import { T as settled, o as waitFor } from "./dist-BOAdzfkP.js";
+import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
+import { F as setupLocalIndexing, I as setupOnSave, L as setupRealmCacheTeardown, M as setupCardLogs, P as setupIntegrationTestRealm, Z as withCachedRealmSetup, lt as setupRenderingTest, ot as setupOperatorModeStateCleanup, t as setupMockMatrix } from "./mock-matrix-FjsXmU7-.js";
+import { r as getService } from "./dist-CPfIHBla.js";
+import { n as renderComponent } from "./render-component-B15Z0e2v.js";
+//#region tests/integration/components/ai-assistant-panel/fallback-banner-live-delete-test.gts
+var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
+var USER_CHOICE_ID = `${testRealmURL}SystemCard/user-choice`;
+var ENV_DEFAULT_ID = `${testRealmURL}SystemCard/env-default`;
+var SYSTEM_CARD_CONTENT = { data: {
+	type: "card",
+	attributes: {},
+	meta: { adoptsFrom: {
+		module: "@cardstack/base/system-card",
+		name: "SystemCard"
+	} }
+} };
+function envDefaultGuard(hooks) {
+	let original;
+	hooks.beforeEach(function() {
+		original = config.defaultSystemCardId;
+	});
+	hooks.afterEach(function() {
+		config.defaultSystemCardId = original;
+	});
+}
+function commonSetup(hooks) {
+	let loader;
+	setupRenderingTest(hooks);
+	setupOperatorModeStateCleanup(hooks);
+	envDefaultGuard(hooks);
+	hooks.beforeEach(function() {
+		loader = getService("loader-service").loader;
+	});
+	setupLocalIndexing(hooks);
+	setupOnSave(hooks);
+	setupCardLogs(hooks, async () => await loader.import("@cardstack/base/card-api"));
+	setupRealmCacheTeardown(hooks);
+}
+async function seedRealm(mockMatrixUtils, opts) {
+	let contents = {
+		".realm.json": `{ "name": "Fallback Banner Live Delete Test Realm" }`,
+		...opts.withUserChoice && { "SystemCard/user-choice.json": SYSTEM_CARD_CONTENT },
+		...opts.withEnvDefault && { "SystemCard/env-default.json": SYSTEM_CARD_CONTENT }
+	};
+	let realm;
+	await withCachedRealmSetup(async () => {
+		let setup = await setupIntegrationTestRealm({
+			mockMatrixUtils,
+			contents
+		});
+		realm = setup.realm;
+		return setup;
+	});
+	return realm;
+}
+async function openAiAssistantPanel() {
+	getService("operator-mode-state-service").restore({ stacks: [[]] });
+	await renderComponent(class TestDriver extends Component {
+		noop = () => {};
+		static {
+			setComponentTemplate(templateFactory({
+				"id": "gMgXxlZ7",
+				"block": "[[[8,[32,0],null,[[\"@onClose\"],[[30,0,[\"noop\"]]]],null]],[],[]]",
+				"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/components/ai-assistant-panel/fallback-banner-live-delete-test.gts",
+				"scope": () => [OperatorModeContainer],
+				"isStrictMode": true
+			}), this);
+		}
+	});
+	getService("ai-assistant-panel-service").openPanel();
+	await settled();
+	await waitFor("[data-test-close-ai-assistant]");
+}
+(0, import_qunit.module)("Integration | ai-assistant-panel | fallback-banner | live delete | in-tab UI delete of user-chosen card, no env default", function(hooks) {
+	commonSetup(hooks);
+	let mockMatrixUtils = setupMockMatrix(hooks, {
+		loggedInAs: "@testuser:localhost",
+		activeRealms: [testRealmURL],
+		autostart: false,
+		systemCardAccountData: { id: USER_CHOICE_ID }
+	});
+	hooks.beforeEach(async function() {
+		config.defaultSystemCardId = void 0;
+		await seedRealm(mockMatrixUtils, {
+			withUserChoice: true,
+			withEnvDefault: false
+		});
+		let matrixService = getService("matrix-service");
+		await matrixService.ready;
+		await matrixService.start();
+	});
+	(0, import_qunit.test)("deleting the active SystemCard in-tab surfaces the fallback banner and clears the user preference", async function(assert) {
+		await openAiAssistantPanel();
+		let matrixService = getService("matrix-service");
+		assert.strictEqual(matrixService.systemCard?.id, USER_CHOICE_ID, "precondition: the user-chosen SystemCard is active");
+		assert.dom("[data-test-fallback-banner]").doesNotExist("precondition: banner is not shown while the card loads");
+		await getService("store").delete(USER_CHOICE_ID);
+		await settled();
+		assert.dom("[data-test-fallback-banner]").exists("banner appears after the active SystemCard is deleted in-tab");
+		assert.true(matrixService.isUsingFallbackSystemCard, "chain reported as broken once the active card is gone");
+		assert.strictEqual(matrixService.systemCard, void 0, "the deleted card is no longer the active SystemCard");
+		assert.deepEqual(mockMatrixUtils.getSystemCardAccountData(), { id: void 0 }, "matrix account-data preference is cleared so the dangling id is not rebroadcast");
+	});
+});
+(0, import_qunit.module)("Integration | ai-assistant-panel | fallback-banner | live delete | cross-machine delete of user-chosen card, no env default", function(hooks) {
+	commonSetup(hooks);
+	let mockMatrixUtils = setupMockMatrix(hooks, {
+		loggedInAs: "@testuser:localhost",
+		activeRealms: [testRealmURL],
+		autostart: false,
+		systemCardAccountData: { id: USER_CHOICE_ID }
+	});
+	let realm;
+	hooks.beforeEach(async function() {
+		config.defaultSystemCardId = void 0;
+		realm = await seedRealm(mockMatrixUtils, {
+			withUserChoice: true,
+			withEnvDefault: false
+		});
+		let matrixService = getService("matrix-service");
+		await matrixService.ready;
+		await matrixService.start();
+	});
+	(0, import_qunit.test)("a delete originating elsewhere (realm invalidation) surfaces the banner and clears the user preference", async function(assert) {
+		await openAiAssistantPanel();
+		let matrixService = getService("matrix-service");
+		assert.strictEqual(matrixService.systemCard?.id, USER_CHOICE_ID, "precondition: the user-chosen SystemCard is active");
+		await realm.delete("SystemCard/user-choice.json");
+		await settled();
+		assert.dom("[data-test-fallback-banner]").exists("banner appears after the cross-machine deletion propagates");
+		assert.true(matrixService.isUsingFallbackSystemCard, "chain reported as broken once the realm invalidation arrives");
+		assert.strictEqual(matrixService.systemCard, void 0, "the deleted card is no longer the active SystemCard");
+		assert.deepEqual(mockMatrixUtils.getSystemCardAccountData(), { id: void 0 }, "matrix account-data preference is cleared on cross-machine deletion too");
+	});
+});
+(0, import_qunit.module)("Integration | ai-assistant-panel | fallback-banner | live delete | env default deleted with no user choice", function(hooks) {
+	commonSetup(hooks);
+	let mockMatrixUtils = setupMockMatrix(hooks, {
+		loggedInAs: "@testuser:localhost",
+		activeRealms: [testRealmURL],
+		autostart: false
+	});
+	let realm;
+	hooks.beforeEach(async function() {
+		config.defaultSystemCardId = ENV_DEFAULT_ID;
+		realm = await seedRealm(mockMatrixUtils, {
+			withUserChoice: false,
+			withEnvDefault: true
+		});
+		let matrixService = getService("matrix-service");
+		await matrixService.ready;
+		await matrixService.start();
+	});
+	(0, import_qunit.test)("deleting the env-default SystemCard surfaces the banner without touching account data", async function(assert) {
+		await openAiAssistantPanel();
+		let matrixService = getService("matrix-service");
+		assert.strictEqual(matrixService.systemCard?.id, ENV_DEFAULT_ID, "precondition: env default is the active SystemCard");
+		assert.strictEqual(mockMatrixUtils.getSystemCardAccountData(), void 0, "precondition: no user preference is recorded");
+		await realm.delete("SystemCard/env-default.json");
+		await settled();
+		assert.dom("[data-test-fallback-banner]").exists("banner appears after the env-default card is deleted");
+		assert.true(matrixService.isUsingFallbackSystemCard, "chain reported as broken once env default is gone");
+		assert.strictEqual(matrixService.systemCard, void 0, "no SystemCard is active after the env default is deleted");
+		assert.strictEqual(mockMatrixUtils.getSystemCardAccountData(), void 0, "no account-data write occurs when the deleted card was the env default, not a user pick");
+	});
+});
+(0, import_qunit.module)("Integration | ai-assistant-panel | fallback-banner | live delete | user-chosen card deleted, env default takes over silently", function(hooks) {
+	commonSetup(hooks);
+	let mockMatrixUtils = setupMockMatrix(hooks, {
+		loggedInAs: "@testuser:localhost",
+		activeRealms: [testRealmURL],
+		autostart: false,
+		systemCardAccountData: { id: USER_CHOICE_ID }
+	});
+	hooks.beforeEach(async function() {
+		config.defaultSystemCardId = ENV_DEFAULT_ID;
+		await seedRealm(mockMatrixUtils, {
+			withUserChoice: true,
+			withEnvDefault: true
+		});
+		let matrixService = getService("matrix-service");
+		await matrixService.ready;
+		await matrixService.start();
+	});
+	(0, import_qunit.test)("env default silently takes over and the user preference is cleared, no banner", async function(assert) {
+		await openAiAssistantPanel();
+		let matrixService = getService("matrix-service");
+		assert.strictEqual(matrixService.systemCard?.id, USER_CHOICE_ID, "precondition: the user-chosen SystemCard is active");
+		await getService("store").delete(USER_CHOICE_ID);
+		await settled();
+		assert.dom("[data-test-fallback-banner]").doesNotExist("no banner — env default takes over silently");
+		assert.false(matrixService.isUsingFallbackSystemCard, "chain is healthy once env default takes over");
+		assert.strictEqual(matrixService.systemCard?.id, ENV_DEFAULT_ID, "env default is the active SystemCard after deletion");
+		assert.deepEqual(mockMatrixUtils.getSystemCardAccountData(), { id: void 0 }, "matrix account-data preference is cleared even when env default rescues us");
+	});
+});
+//#endregion

package/bundled-test-harness/assets/fallback-banner-test-CqSRN7D8.js

@@ -0,0 +1,225 @@
+import { s as __toESM } from "./chunk-Rp0pCe6z.js";
+import { Br as testRealmURL } from "./runtime-common-BTaLJEw-.js";
+import { t as config } from "./environment-DIUJgBKt.js";
+import { wt as setComponentTemplate } from "./cache-DtDz7X5V-Wn8jRDfL.js";
+import { H as templateFactory } from "./index-DaCZcoCY-CgzbilMy.js";
+import "./component-BJO47HTh.js";
+import { t as Component } from "./dist-CkA1rgqO.js";
+import "./template-factory-ds9s0u8l.js";
+import { t as OperatorModeContainer } from "./container-CBZZ8uFw.js";
+import { T as settled, d as click, o as waitFor } from "./dist-BOAdzfkP.js";
+import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
+import { Et as percySnapshot, F as setupLocalIndexing, I as setupOnSave, L as setupRealmCacheTeardown, M as setupCardLogs, P as setupIntegrationTestRealm, Z as withCachedRealmSetup, lt as setupRenderingTest, ot as setupOperatorModeStateCleanup, t as setupMockMatrix } from "./mock-matrix-FjsXmU7-.js";
+import { r as getService } from "./dist-CPfIHBla.js";
+import { n as renderComponent } from "./render-component-B15Z0e2v.js";
+//#region tests/integration/components/ai-assistant-panel/fallback-banner-test.gts
+var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
+var BAD_SYSTEM_CARD_ID = `${testRealmURL}SystemCard/does-not-exist`;
+var GOOD_SYSTEM_CARD_ID = `${testRealmURL}SystemCard/default`;
+var SYSTEM_CARD_CONTENT = { data: {
+	type: "card",
+	attributes: {},
+	meta: { adoptsFrom: {
+		module: "@cardstack/base/system-card",
+		name: "SystemCard"
+	} }
+} };
+function envDefaultGuard(hooks) {
+	let original;
+	hooks.beforeEach(function() {
+		original = config.defaultSystemCardId;
+	});
+	hooks.afterEach(function() {
+		config.defaultSystemCardId = original;
+	});
+}
+function commonSetup(hooks) {
+	let loader;
+	setupRenderingTest(hooks);
+	setupOperatorModeStateCleanup(hooks);
+	envDefaultGuard(hooks);
+	hooks.beforeEach(function() {
+		loader = getService("loader-service").loader;
+	});
+	setupLocalIndexing(hooks);
+	setupOnSave(hooks);
+	setupCardLogs(hooks, async () => await loader.import("@cardstack/base/card-api"));
+	setupRealmCacheTeardown(hooks);
+}
+async function seedRealm(mockMatrixUtils) {
+	await withCachedRealmSetup(async () => setupIntegrationTestRealm({
+		mockMatrixUtils,
+		contents: {
+			".realm.json": `{ "name": "Fallback Banner Test Realm" }`,
+			"SystemCard/default.json": SYSTEM_CARD_CONTENT
+		}
+	}));
+}
+async function openAiAssistantPanel() {
+	getService("operator-mode-state-service").restore({ stacks: [[]] });
+	await renderComponent(class TestDriver extends Component {
+		noop = () => {};
+		static {
+			setComponentTemplate(templateFactory({
+				"id": "CaAY0LGq",
+				"block": "[[[8,[32,0],null,[[\"@onClose\"],[[30,0,[\"noop\"]]]],null]],[],[]]",
+				"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/components/ai-assistant-panel/fallback-banner-test.gts",
+				"scope": () => [OperatorModeContainer],
+				"isStrictMode": true
+			}), this);
+		}
+	});
+	getService("ai-assistant-panel-service").openPanel();
+	await settled();
+	await waitFor("[data-test-close-ai-assistant]");
+}
+(0, import_qunit.module)("Integration | ai-assistant-panel | fallback-banner | broken chain (user pick fails + no env default)", function(hooks) {
+	commonSetup(hooks);
+	let mockMatrixUtils = setupMockMatrix(hooks, {
+		loggedInAs: "@testuser:localhost",
+		activeRealms: [testRealmURL],
+		autostart: false,
+		systemCardAccountData: { id: BAD_SYSTEM_CARD_ID }
+	});
+	hooks.beforeEach(async function() {
+		config.defaultSystemCardId = void 0;
+		await seedRealm(mockMatrixUtils);
+		let matrixService = getService("matrix-service");
+		await matrixService.ready;
+		await matrixService.start();
+	});
+	(0, import_qunit.test)("isUsingFallbackSystemCard is true", function(assert) {
+		let matrixService = getService("matrix-service");
+		assert.true(matrixService.isUsingFallbackSystemCard, "chain reported as broken");
+	});
+	(0, import_qunit.test)("banner renders in the panel", async function(assert) {
+		await openAiAssistantPanel();
+		await percySnapshot(assert);
+		assert.dom("[data-test-fallback-banner]").exists("banner is rendered when the SystemCard chain is broken");
+	});
+	(0, import_qunit.test)("clicking the dismiss button hides the banner", async function(assert) {
+		await openAiAssistantPanel();
+		assert.dom("[data-test-fallback-banner]").exists();
+		await click("[data-test-fallback-banner-dismiss]");
+		assert.dom("[data-test-fallback-banner]").doesNotExist("banner is removed after dismiss");
+	});
+});
+(0, import_qunit.module)("Integration | ai-assistant-panel | fallback-banner | broken chain (env default fails)", function(hooks) {
+	commonSetup(hooks);
+	let mockMatrixUtils = setupMockMatrix(hooks, {
+		loggedInAs: "@testuser:localhost",
+		activeRealms: [testRealmURL],
+		autostart: false
+	});
+	hooks.beforeEach(async function() {
+		config.defaultSystemCardId = BAD_SYSTEM_CARD_ID;
+		await seedRealm(mockMatrixUtils);
+		let matrixService = getService("matrix-service");
+		await matrixService.ready;
+		await matrixService.start();
+	});
+	(0, import_qunit.test)("isUsingFallbackSystemCard is true even with no user choice", function(assert) {
+		let matrixService = getService("matrix-service");
+		assert.true(matrixService.isUsingFallbackSystemCard, "env default failure surfaces as broken chain");
+	});
+});
+(0, import_qunit.module)("Integration | ai-assistant-panel | fallback-banner | silent env-default recovery", function(hooks) {
+	commonSetup(hooks);
+	let mockMatrixUtils = setupMockMatrix(hooks, {
+		loggedInAs: "@testuser:localhost",
+		activeRealms: [testRealmURL],
+		autostart: false,
+		systemCardAccountData: { id: BAD_SYSTEM_CARD_ID }
+	});
+	hooks.beforeEach(async function() {
+		config.defaultSystemCardId = GOOD_SYSTEM_CARD_ID;
+		await seedRealm(mockMatrixUtils);
+		let matrixService = getService("matrix-service");
+		await matrixService.ready;
+		await matrixService.start();
+	});
+	(0, import_qunit.test)("isUsingFallbackSystemCard stays false when env default loads successfully", function(assert) {
+		let matrixService = getService("matrix-service");
+		assert.false(matrixService.isUsingFallbackSystemCard, "user-pick failure recovered silently via env default");
+		assert.strictEqual(matrixService.systemCard?.id, GOOD_SYSTEM_CARD_ID, "env default is the active system card");
+	});
+	(0, import_qunit.test)("banner does not render", async function(assert) {
+		await openAiAssistantPanel();
+		assert.dom("[data-test-fallback-banner]").doesNotExist();
+	});
+});
+(0, import_qunit.module)("Integration | ai-assistant-panel | fallback-banner | MVP steady state (no SystemCard configured)", function(hooks) {
+	commonSetup(hooks);
+	let mockMatrixUtils = setupMockMatrix(hooks, {
+		loggedInAs: "@testuser:localhost",
+		activeRealms: [testRealmURL],
+		autostart: false
+	});
+	hooks.beforeEach(async function() {
+		config.defaultSystemCardId = void 0;
+		await seedRealm(mockMatrixUtils);
+		let matrixService = getService("matrix-service");
+		await matrixService.ready;
+		await matrixService.start();
+	});
+	(0, import_qunit.test)("isUsingFallbackSystemCard is false in MVP steady state", function(assert) {
+		let matrixService = getService("matrix-service");
+		assert.false(matrixService.isUsingFallbackSystemCard, "no user choice + no env default = no chain to break");
+	});
+	(0, import_qunit.test)("banner does not render", async function(assert) {
+		await openAiAssistantPanel();
+		assert.dom("[data-test-fallback-banner]").doesNotExist();
+	});
+});
+(0, import_qunit.module)("Integration | ai-assistant-panel | fallback-banner | healthy SystemCard", function(hooks) {
+	commonSetup(hooks);
+	let mockMatrixUtils = setupMockMatrix(hooks, {
+		loggedInAs: "@testuser:localhost",
+		activeRealms: [testRealmURL],
+		autostart: false,
+		systemCardAccountData: { id: GOOD_SYSTEM_CARD_ID }
+	});
+	hooks.beforeEach(async function() {
+		config.defaultSystemCardId = GOOD_SYSTEM_CARD_ID;
+		await seedRealm(mockMatrixUtils);
+		let matrixService = getService("matrix-service");
+		await matrixService.ready;
+		await matrixService.start();
+	});
+	(0, import_qunit.test)("isUsingFallbackSystemCard is false", function(assert) {
+		let matrixService = getService("matrix-service");
+		assert.false(matrixService.isUsingFallbackSystemCard);
+		assert.strictEqual(matrixService.systemCard?.id, GOOD_SYSTEM_CARD_ID);
+	});
+	(0, import_qunit.test)("banner does not render", async function(assert) {
+		await openAiAssistantPanel();
+		assert.dom("[data-test-fallback-banner]").doesNotExist();
+	});
+});
+(0, import_qunit.module)("Integration | ai-assistant-panel | fallback-banner | live recovery when the user switches to a working SystemCard", function(hooks) {
+	commonSetup(hooks);
+	let mockMatrixUtils = setupMockMatrix(hooks, {
+		loggedInAs: "@testuser:localhost",
+		activeRealms: [testRealmURL],
+		autostart: false,
+		systemCardAccountData: { id: BAD_SYSTEM_CARD_ID }
+	});
+	hooks.beforeEach(async function() {
+		config.defaultSystemCardId = void 0;
+		await seedRealm(mockMatrixUtils);
+		let matrixService = getService("matrix-service");
+		await matrixService.ready;
+		await matrixService.start();
+	});
+	(0, import_qunit.test)("banner disappears once the user picks a healthy SystemCard", async function(assert) {
+		await openAiAssistantPanel();
+		assert.dom("[data-test-fallback-banner]").exists("banner is visible while the chain is broken");
+		let matrixService = getService("matrix-service");
+		await matrixService.setUserSystemCard(GOOD_SYSTEM_CARD_ID);
+		await settled();
+		assert.dom("[data-test-fallback-banner]").doesNotExist("banner disappears reactively once the new SystemCard loads");
+		assert.false(matrixService.isUsingFallbackSystemCard, "chain is no longer marked as broken");
+		assert.strictEqual(matrixService.systemCard?.id, GOOD_SYSTEM_CARD_ID, "the new user-chosen SystemCard is active");
+	});
+});
+//#endregion

package/bundled-test-harness/assets/fallback-banner-test-DQkrFE4-.js

@@ -0,0 +1,53 @@
+import { s as __toESM } from "./chunk-Rp0pCe6z.js";
+import { wt as setComponentTemplate } from "./cache-DtDz7X5V-Wn8jRDfL.js";
+import { H as templateFactory } from "./index-DaCZcoCY-CgzbilMy.js";
+import "./component-BJO47HTh.js";
+import "./template-factory-ds9s0u8l.js";
+import { t as templateOnly } from "./template-only-6nVzLWF-.js";
+import { d as click, h as render } from "./dist-BOAdzfkP.js";
+import { n as FallbackBanner, t as FALLBACK_BANNER_MESSAGE } from "./fallback-banner--S1OU8ox.js";
+import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
+import { lt as setupRenderingTest } from "./mock-matrix-FjsXmU7-.js";
+//#region tests/integration/components/ai-assistant/fallback-banner-test.gts
+var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
+(0, import_qunit.module)("Integration | Component | ai-assistant/fallback-banner", function(hooks) {
+	setupRenderingTest(hooks);
+	(0, import_qunit.test)("renders the warning copy", async function(assert) {
+		await render(setComponentTemplate(templateFactory({
+			"id": "decfFqXt",
+			"block": "[[[8,[32,0],null,null,null]],[],[]]",
+			"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/components/ai-assistant/fallback-banner-test.gts",
+			"scope": () => [FallbackBanner],
+			"isStrictMode": true
+		}), templateOnly()));
+		assert.dom("[data-test-fallback-banner]").exists();
+		assert.dom("[data-test-fallback-banner]").hasText(FALLBACK_BANNER_MESSAGE);
+	});
+	(0, import_qunit.test)("does not render a dismiss button when @onDismiss is omitted", async function(assert) {
+		await render(setComponentTemplate(templateFactory({
+			"id": "decfFqXt",
+			"block": "[[[8,[32,0],null,null,null]],[],[]]",
+			"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/components/ai-assistant/fallback-banner-test.gts",
+			"scope": () => [FallbackBanner],
+			"isStrictMode": true
+		}), templateOnly()));
+		assert.dom("[data-test-fallback-banner-dismiss]").doesNotExist();
+	});
+	(0, import_qunit.test)("clicking the dismiss button invokes @onDismiss", async function(assert) {
+		let calls = 0;
+		let handleDismiss = () => {
+			calls += 1;
+		};
+		await render(setComponentTemplate(templateFactory({
+			"id": "Ljau0Mze",
+			"block": "[[[8,[32,0],null,[[\"@onDismiss\"],[[32,1]]],null]],[],[]]",
+			"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/components/ai-assistant/fallback-banner-test.gts",
+			"scope": () => [FallbackBanner, handleDismiss],
+			"isStrictMode": true
+		}), templateOnly()));
+		assert.dom("[data-test-fallback-banner-dismiss]").exists();
+		await click("[data-test-fallback-banner-dismiss]");
+		assert.strictEqual(calls, 1, "@onDismiss fired once");
+	});
+});
+//#endregion

package/bundled-test-harness/assets/fallback-models-test-BWekNxC0.js

@@ -0,0 +1,161 @@
+import { s as __toESM } from "./chunk-Rp0pCe6z.js";
+import { Br as testRealmURL, Fn as APP_BOXEL_ACTIVE_LLM, pr as DEFAULT_FALLBACK_MODELS } from "./runtime-common-BTaLJEw-.js";
+import { wt as setComponentTemplate } from "./cache-DtDz7X5V-Wn8jRDfL.js";
+import { H as templateFactory } from "./index-DaCZcoCY-CgzbilMy.js";
+import "./component-BJO47HTh.js";
+import { t as Component } from "./dist-CkA1rgqO.js";
+import "./template-factory-ds9s0u8l.js";
+import { t as OperatorModeContainer } from "./container-CBZZ8uFw.js";
+import { M as waitUntil, d as click, o as waitFor } from "./dist-BOAdzfkP.js";
+import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
+import { F as setupLocalIndexing, I as setupOnSave, L as setupRealmCacheTeardown, M as setupCardLogs, P as setupIntegrationTestRealm, Z as withCachedRealmSetup, lt as setupRenderingTest, ot as setupOperatorModeStateCleanup, t as setupMockMatrix } from "./mock-matrix-FjsXmU7-.js";
+import { r as getService } from "./dist-CPfIHBla.js";
+import { n as renderComponent } from "./render-component-B15Z0e2v.js";
+//#region tests/integration/components/ai-assistant-panel/fallback-models-test.gts
+var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
+var CURATED_MODEL_ID = "anthropic/claude-sonnet-4.6";
+var CURATED_ROW = DEFAULT_FALLBACK_MODELS.find((m) => m.modelId === CURATED_MODEL_ID);
+var NON_CURATED_MODEL_ID = "some-non-curated/model";
+(0, import_qunit.module)("Integration | ai-assistant-panel | fallback-models", function(hooks) {
+	const realmName = "Fallback Models Test Realm";
+	let loader;
+	let operatorModeStateService;
+	setupRenderingTest(hooks);
+	setupOperatorModeStateCleanup(hooks);
+	hooks.beforeEach(function() {
+		loader = getService("loader-service").loader;
+	});
+	setupLocalIndexing(hooks);
+	setupOnSave(hooks);
+	setupCardLogs(hooks, async () => await loader.import("@cardstack/base/card-api"));
+	let mockMatrixUtils = setupMockMatrix(hooks, {
+		loggedInAs: "@testuser:localhost",
+		activeRealms: [testRealmURL],
+		autostart: true,
+		now: (() => {
+			let clock = new Date(2026, 4, 25).getTime();
+			return () => clock += 10;
+		})()
+	});
+	let { createAndJoinRoom, getRoomState, simulateRemoteMessage } = mockMatrixUtils;
+	setupRealmCacheTeardown(hooks);
+	hooks.beforeEach(async function() {
+		operatorModeStateService = this.owner.lookup("service:operator-mode-state-service");
+		await withCachedRealmSetup(async () => setupIntegrationTestRealm({
+			mockMatrixUtils,
+			contents: { ".realm.json": `{ "name": "${realmName}" }` }
+		}));
+	});
+	function getMatrixService() {
+		return getService("matrix-service");
+	}
+	function freshRoom() {
+		return createAndJoinRoom({
+			sender: "@testuser:localhost",
+			name: `fallback-test-room-${Math.random().toString(36).slice(2, 8)}`
+		});
+	}
+	async function setCardInOperatorModeState() {
+		operatorModeStateService.restore({ stacks: [[]] });
+	}
+	async function openAiAssistant() {
+		await waitFor("[data-test-open-ai-assistant]");
+		await click("[data-test-open-ai-assistant]");
+		await waitFor("[data-test-room-settled]");
+		let roomId = document.querySelector("[data-test-room]")?.getAttribute("data-test-room");
+		if (!roomId) throw new Error("Expected a room ID");
+		return roomId;
+	}
+	async function renderAiAssistantPanel() {
+		await setCardInOperatorModeState();
+		await renderComponent(class TestDriver extends Component {
+			noop = () => {};
+			static {
+				setComponentTemplate(templateFactory({
+					"id": "maq87qHZ",
+					"block": "[[[8,[32,0],null,[[\"@onClose\"],[[30,0,[\"noop\"]]]],null]],[],[]]",
+					"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/components/ai-assistant-panel/fallback-models-test.gts",
+					"scope": () => [OperatorModeContainer],
+					"isStrictMode": true
+				}), this);
+			}
+		});
+		return openAiAssistant();
+	}
+	(0, import_qunit.test)("resolveActiveLLMConfig fills caps from DEFAULT_FALLBACK_MODELS for a curated model when no systemCard", async function(assert) {
+		let roomId = freshRoom();
+		let matrixService = getMatrixService();
+		assert.strictEqual(matrixService.systemCard, void 0, "precondition: no systemCard");
+		let caps = matrixService.resolveActiveLLMConfig(roomId, CURATED_MODEL_ID);
+		assert.strictEqual(caps.toolsSupported, CURATED_ROW.toolsSupported, "toolsSupported from curated row");
+		assert.deepEqual(caps.inputModalities, CURATED_ROW.inputModalities, "inputModalities from curated row");
+		assert.strictEqual(caps.reasoningEffort, void 0, "reasoningEffort never auto-filled from the curated fallback");
+	});
+	(0, import_qunit.test)("resolveActiveLLMConfig falls to conservative floor for a non-curated model with no prior event", async function(assert) {
+		let roomId = freshRoom();
+		let caps = getMatrixService().resolveActiveLLMConfig(roomId, NON_CURATED_MODEL_ID);
+		assert.false(caps.toolsSupported, "conservative floor disables tools for an unknown model");
+		assert.deepEqual(caps.inputModalities, ["text"], "conservative floor limits modalities to text");
+		assert.strictEqual(caps.reasoningEffort, void 0, "reasoningEffort stays undefined at the floor");
+	});
+	(0, import_qunit.test)("resolveActiveLLMConfig: caller override beats DEFAULT_FALLBACK_MODELS", async function(assert) {
+		let roomId = freshRoom();
+		let caps = getMatrixService().resolveActiveLLMConfig(roomId, CURATED_MODEL_ID, { toolsSupported: false });
+		assert.false(caps.toolsSupported, "explicit caller override wins over the curated row");
+		assert.deepEqual(caps.inputModalities, CURATED_ROW.inputModalities, "fields not overridden still come from the curated row");
+	});
+	(0, import_qunit.test)("resolveActiveLLMConfig rehydrates caps from a prior valid event for the same model", async function(assert) {
+		let roomId = await renderAiAssistantPanel();
+		let matrixService = getMatrixService();
+		await matrixService.sendActiveLLMEvent(roomId, "uncurated/model-x", {
+			toolsSupported: true,
+			inputModalities: ["text", "audio"]
+		});
+		await waitUntil(() => matrixService.getRoomData(roomId)?.events?.some((e) => e.type === "app.boxel.active-llm" && e.content?.model === "uncurated/model-x"));
+		let caps = matrixService.resolveActiveLLMConfig(roomId, "uncurated/model-x");
+		assert.true(caps.toolsSupported, "toolsSupported rehydrated from prior event");
+		assert.deepEqual(caps.inputModalities, ["text", "audio"], "inputModalities rehydrated from prior event");
+	});
+	(0, import_qunit.test)("resolveActiveLLMConfig skips a prior broken event and falls to the conservative floor", async function(assert) {
+		let roomId = await renderAiAssistantPanel();
+		let matrixService = getMatrixService();
+		simulateRemoteMessage(roomId, "@testuser:localhost", { model: "uncurated/broken-model" }, {
+			type: APP_BOXEL_ACTIVE_LLM,
+			state_key: ""
+		});
+		await waitUntil(() => matrixService.getRoomData(roomId)?.events?.some((e) => e.type === "app.boxel.active-llm" && e.content?.model === "uncurated/broken-model"));
+		let caps = matrixService.resolveActiveLLMConfig(roomId, "uncurated/broken-model");
+		assert.false(caps.toolsSupported, "broken prior event ignored; tools disabled at the floor");
+		assert.deepEqual(caps.inputModalities, ["text"], "broken prior event ignored; modalities at the floor");
+	});
+	(0, import_qunit.test)("sendActiveLLMEvent ships resolved caps on the wire for a curated model", async function(assert) {
+		let roomId = freshRoom();
+		await getMatrixService().sendActiveLLMEvent(roomId, CURATED_MODEL_ID);
+		let state = getRoomState(roomId, APP_BOXEL_ACTIVE_LLM, "");
+		assert.deepEqual(state, {
+			model: CURATED_MODEL_ID,
+			toolsSupported: CURATED_ROW.toolsSupported,
+			reasoningEffort: void 0,
+			inputModalities: CURATED_ROW.inputModalities
+		}, "state event reflects the resolved caps; reasoningEffort stays undefined");
+	});
+	(0, import_qunit.test)("sendActiveLLMEvent preserves an explicit caller override on the wire", async function(assert) {
+		let roomId = freshRoom();
+		await getMatrixService().sendActiveLLMEvent(roomId, CURATED_MODEL_ID, { toolsSupported: false });
+		let state = getRoomState(roomId, APP_BOXEL_ACTIVE_LLM, "");
+		assert.false(state?.toolsSupported, "caller override survives the internal resolver");
+		assert.deepEqual(state?.inputModalities, CURATED_ROW.inputModalities, "fields not overridden still come from the curated row");
+	});
+	(0, import_qunit.test)("picker shows the curated fallback models when no systemCard is configured", async function(assert) {
+		let matrixService = getMatrixService();
+		assert.strictEqual(matrixService.systemCard, void 0, "precondition: no systemCard");
+		await renderAiAssistantPanel();
+		await click("[data-test-llm-select-selected]");
+		await waitFor(".menu-content");
+		for (let row of DEFAULT_FALLBACK_MODELS) {
+			await waitUntil(() => document.querySelector(".menu-content")?.textContent?.includes(row.displayName));
+			assert.dom(".menu-content").containsText(row.displayName, `picker shows ${row.displayName} from the curated fallback list`);
+		}
+	});
+});
+//#endregion