@cardstack/boxel-cli 0.3.2-unstable.59 → 0.3.2-unstable.60

package/bundled-test-harness/assets/ai-assistant-test-CZATBlJS.js

@@ -0,0 +1,2137 @@
+import { s as __toESM } from "./chunk-CGdGNDIi.js";
+import { r as initializeDeferredDecorator, t as decorateFieldV2 } from "./runtime-CYyqkz5q-z3Y1hsJm.js";
+import { Dn as APP_BOXEL_LLM_MODE, Jr as wrapper_default, Mi as skillCardRef, Mn as APP_BOXEL_REASONING_CONTENT_KEY, On as APP_BOXEL_MESSAGE_MSGTYPE, Zn as testRealmURL, ca as Deferred, pn as APP_BOXEL_ACTIVE_LLM, ua as rri, vi as baseRealm } from "./runtime-common-C7uLt5dN.js";
+import { $n as setComponentTemplate } from "./service-DJ87xpDt.js";
+import { V as templateFactory } from "./index-DaCZcoCY-D2gI_aMw.js";
+import { i as envSkillId, o as skillsRealmURL, t as catalogRealmURL } from "./utils-C7xS5xXC.js";
+import "./template-D3TMIrc1.js";
+import "./template-factory-DMEv2kVd.js";
+import { m as GridContainer } from "./components-DkyK1awC.js";
+import { t as AiAssistantMessageDrafts, v as src_default } from "./local-storage-keys-wtjuKtZY.js";
+import { I as waitUntil, N as visit, d as click, l as triggerEvent, o as waitFor, s as fillIn } from "./dist-D1U_uSwt.js";
+import { t as require_qunit } from "./qunit-Cqwmt9Vl.js";
+import { r as getService } from "./dist-CY3T64Hs.js";
+import { D as setupAcceptanceTestRealm, F as setupUserSubscription, M as setupOnSave, P as setupRealmServerEndpoints, a as SYSTEM_CARD_FIXTURE_CONTENTS, at as setupAuthEndpoints, b as getMonacoContent, h as delay, i as getRoomIdForRealmAndUser, j as setupLocalIndexing, nt as setupApplicationTest, o as addSkillToAiAssistant, s as assertMessages, t as setupMockMatrix, tt as visitOperatorMode, w as realmConfigCardJSON } from "./mock-matrix-BhFWlMMr.js";
+import { G as contains, I as StringField, L as SystemCard, Q as field, a as CardDef, d as Component, lt as linksTo, mt as setupBaseRealm, o as CardInfoField, s as CardsGrid, ut as linksToMany, w as ModelConfiguration } from "./base-realm-DpSTsZxD.js";
+//#region tests/acceptance/ai-assistant-test.gts
+var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
+async function selectCardFromCatalog(cardId) {
+	await click("[data-test-attach-button]");
+	await click("[data-test-attach-card-btn]");
+	await fillIn("[data-test-search-field]", cardId);
+	await click(`[data-test-card-catalog-item="${cardId}"]`);
+	await click("[data-test-card-catalog-go-button]");
+}
+async function waitForSessionPreparationToFinish(timeout = 3e4) {
+	const aiAssistantPanelService = getService("ai-assistant-panel-service");
+	await waitUntil(() => !aiAssistantPanelService.isPreparingSession, { timeout });
+}
+var countryDefinition = `import { field, contains, CardDef } from 'https://cardstack.com/base/card-api';
+  import StringField from 'https://cardstack.com/base/string';
+  export class Country extends CardDef {
+    static displayName = 'Country';
+    @field name = contains(StringField);
+  }`;
+var matrixRoomId;
+var mockedFileContent = "Hello, world!";
+var TEST_MODEL_NAMES = {
+	"openai/gpt-5": "OpenAI: GPT-5",
+	"openai/gpt-5-extended": "OpenAI: GPT-5 Extended Thinking",
+	"openai/gpt-4o-mini": "OpenAI: GPT-4o-mini",
+	"anthropic/claude-sonnet-4.6": "Anthropic: Claude Sonnet 4.6",
+	"anthropic/claude-sonnet-4.5": "Anthropic: Claude Sonnet 4.5",
+	"anthropic/claude-3.7-sonnet": "Anthropic: Claude 3.7 Sonnet",
+	"deepseek/deepseek-chat-v3-0324": "DeepSeek: DeepSeek V3 0324",
+	"google/gemini-2.5-flash": "Google: Gemini 2.5 Flash"
+};
+var TEST_MODEL_CONFIG_IDS = {
+	"openai/gpt-5": `${testRealmURL}ModelConfiguration/gpt-5`,
+	"openai/gpt-5-extended": `${testRealmURL}ModelConfiguration/gpt-5-extended`,
+	"openai/gpt-4o-mini": `${testRealmURL}ModelConfiguration/gpt-4o-mini`,
+	"anthropic/claude-sonnet-4.6": `${testRealmURL}ModelConfiguration/claude-sonnet-4.6`,
+	"anthropic/claude-sonnet-4.5": `${testRealmURL}ModelConfiguration/claude-sonnet-4.5`,
+	"anthropic/claude-3.7-sonnet": `${testRealmURL}ModelConfiguration/claude-sonnet-3.7`,
+	"deepseek/deepseek-chat-v3-0324": `${testRealmURL}ModelConfiguration/deepseek-chat-v3-0324`,
+	"google/gemini-2.5-flash": `${testRealmURL}ModelConfiguration/gemini-2.5-flash`
+};
+function configIdFor(modelId) {
+	return TEST_MODEL_CONFIG_IDS[modelId] ?? modelId;
+}
+function modelNameFor(llmId) {
+	return TEST_MODEL_NAMES[llmId] ?? llmId;
+}
+(0, import_qunit.module)("Acceptance | AI Assistant tests", function(hooks) {
+	setupApplicationTest(hooks);
+	setupLocalIndexing(hooks);
+	setupOnSave(hooks);
+	let mockMatrixUtils = setupMockMatrix(hooks, {
+		loggedInAs: "@testuser:localhost",
+		activeRealms: [baseRealm.url, testRealmURL],
+		directRooms: [
+			getRoomIdForRealmAndUser(testRealmURL, "@testuser:localhost"),
+			getRoomIdForRealmAndUser(baseRealm.url, "@testuser:localhost"),
+			"test-auth-realm-server-session-room"
+		]
+	});
+	let { createAndJoinRoom, getRoomIds, getRoomState, simulateRemoteMessage } = mockMatrixUtils;
+	setupRealmServerEndpoints(hooks, [{
+		route: "_request-forward",
+		getResponse: async (req) => {
+			const body = await req.json();
+			if (body.url.includes("openrouter.ai/api/v1/chat/completions")) {
+				const requestBody = JSON.parse(body.requestBody);
+				if (requestBody.messages && requestBody.messages.some((msg) => msg.content && msg.content.includes("Please provide a concise summary"))) {
+					const conversationText = requestBody.messages.filter((msg) => msg.role === "user" && !msg.content.includes("Please provide a concise summary")).map((msg) => msg.content).join(" ");
+					let summary = "This conversation focused on general discussion.";
+					if (conversationText.includes("project")) summary = "This conversation focused on project help, specifically creating a new card for a person with name and age fields. The user requested assistance with card creation and field definition.";
+					else if (conversationText.includes("card") && conversationText.includes("file")) summary = "This conversation involved discussing a person card (Hassan) and a pet definition file. The user shared both a Person card and a pet.gts file, then asked for help understanding the structure.";
+					else if (conversationText.includes("error")) throw new Error("OpenRouter API error");
+					return new Response(JSON.stringify({ choices: [{ message: { content: summary } }] }), {
+						status: 200,
+						headers: { "Content-Type": "application/json" }
+					});
+				}
+			}
+			return new Response(JSON.stringify({
+				success: true,
+				data: {
+					id: 123,
+					name: "test"
+				}
+			}), {
+				status: 200,
+				headers: { "Content-Type": "application/json" }
+			});
+		}
+	}]);
+	setupBaseRealm(hooks);
+	hooks.beforeEach(async function() {
+		matrixRoomId = createAndJoinRoom({
+			sender: "@testuser:localhost",
+			name: "room-test"
+		});
+		setupUserSubscription();
+		setupAuthEndpoints();
+		class Pet extends CardDef {
+			static displayName = "Pet";
+			static {
+				decorateFieldV2(this.prototype, "name", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#name = (initializeDeferredDecorator(this, "name"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "favoriteTreat", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#favoriteTreat = (initializeDeferredDecorator(this, "favoriteTreat"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "cardTitle", [field], function() {
+					return contains(StringField, { computeVia: function() {
+						return this.name;
+					} });
+				});
+			}
+			#cardTitle = (initializeDeferredDecorator(this, "cardTitle"), void 0);
+			static embedded = class Embedded extends Component {
+				static {
+					setComponentTemplate(templateFactory({
+						"id": "42cIT+kJ",
+						"block": "[[[10,\"h3\"],[15,\"data-test-pet\",[30,1,[\"name\"]]],[12],[1,\"\\n  \"],[8,[30,2,[\"name\"]],null,null,null],[1,\"\\n\"],[13]],[\"@model\",\"@fields\"],[]]",
+						"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/acceptance/ai-assistant-test.gts",
+						"isStrictMode": true
+					}), this);
+				}
+			};
+			static isolated = class Isolated extends Component {
+				static {
+					setComponentTemplate(templateFactory({
+						"id": "Z8KhIcUS",
+						"block": "[[[8,[32,0],[[24,0,\"container\"]],null,[[\"default\"],[[[[1,\"\\n  \"],[10,\"h2\"],[12],[8,[30,1,[\"cardTitle\"]],null,null,null],[13],[1,\"\\n  \"],[10,0],[12],[1,\"\\n    \"],[10,0],[12],[1,\"Favorite Treat: \"],[8,[30,1,[\"favoriteTreat\"]],null,null,null],[13],[1,\"\\n    \"],[10,0],[14,\"data-test-editable-meta\",\"\"],[12],[1,\"\\n\"],[41,[30,2],[[[1,\"        \"],[8,[30,1,[\"cardTitle\"]],null,null,null],[1,\"\\n        is editable.\\n\"]],[]],[[[1,\"        \"],[8,[30,1,[\"cardTitle\"]],null,null,null],[1,\"\\n        is NOT editable.\\n\"]],[]]],[1,\"    \"],[13],[1,\"\\n  \"],[13],[1,\"\\n\"]],[]]]]]],[\"@fields\",\"@canEdit\"],[\"if\"]]",
+						"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/acceptance/ai-assistant-test.gts",
+						"scope": () => [GridContainer],
+						"isStrictMode": true
+					}), this);
+				}
+			};
+		}
+		class Person extends CardDef {
+			static displayName = "Person";
+			static {
+				decorateFieldV2(this.prototype, "firstName", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#firstName = (initializeDeferredDecorator(this, "firstName"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "lastName", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#lastName = (initializeDeferredDecorator(this, "lastName"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "pet", [field], function() {
+					return linksTo(Pet);
+				});
+			}
+			#pet = (initializeDeferredDecorator(this, "pet"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "friends", [field], function() {
+					return linksToMany(Pet);
+				});
+			}
+			#friends = (initializeDeferredDecorator(this, "friends"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "firstLetterOfTheName", [field], function() {
+					return contains(StringField, { computeVia: function() {
+						if (!this.firstName) return;
+						return this.firstName[0];
+					} });
+				});
+			}
+			#firstLetterOfTheName = (initializeDeferredDecorator(this, "firstLetterOfTheName"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "cardTitle", [field], function() {
+					return contains(StringField, { computeVia: function() {
+						return [this.firstName, this.lastName].filter(Boolean).join(" ");
+					} });
+				});
+			}
+			#cardTitle = (initializeDeferredDecorator(this, "cardTitle"), void 0);
+			static isolated = class Isolated extends Component {
+				static {
+					setComponentTemplate(templateFactory({
+						"id": "cygZodII",
+						"block": "[[[10,\"h2\"],[15,\"data-test-person\",[30,1,[\"firstName\"]]],[12],[1,\"\\n  \"],[8,[30,2,[\"firstName\"]],null,null,null],[1,\"\\n\"],[13],[1,\"\\n\"],[10,2],[15,\"data-test-first-letter-of-the-name\",[30,1,[\"firstLetterOfTheName\"]]],[12],[1,\"\\n  \"],[8,[30,2,[\"firstLetterOfTheName\"]],null,null,null],[1,\"\\n\"],[13],[1,\"\\nPet:\\n\"],[8,[30,2,[\"pet\"]],null,null,null],[1,\"\\nFriends:\\n\"],[8,[30,2,[\"friends\"]],null,null,null]],[\"@model\",\"@fields\"],[]]",
+						"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/acceptance/ai-assistant-test.gts",
+						"isStrictMode": true
+					}), this);
+				}
+			};
+		}
+		let mangoPet = new Pet({ name: "Mango" });
+		let openAiGpt5Model = new ModelConfiguration({
+			cardInfo: new CardInfoField({ name: modelNameFor("openai/gpt-5") }),
+			modelId: "openai/gpt-5",
+			toolsSupported: true,
+			reasoningEffort: "minimal"
+		});
+		let openAiGpt5ExtendedModel = new ModelConfiguration({
+			cardInfo: new CardInfoField({ name: modelNameFor("openai/gpt-5-extended") }),
+			modelId: "openai/gpt-5",
+			toolsSupported: true,
+			reasoningEffort: "high"
+		});
+		let openAiGpt4oMiniModel = new ModelConfiguration({
+			cardInfo: new CardInfoField({ name: modelNameFor("openai/gpt-4o-mini") }),
+			modelId: "openai/gpt-4o-mini",
+			toolsSupported: true
+		});
+		let anthropicClaudeSonnet46Model = new ModelConfiguration({
+			cardInfo: new CardInfoField({ name: modelNameFor("anthropic/claude-sonnet-4.6") }),
+			modelId: "anthropic/claude-sonnet-4.6",
+			toolsSupported: true
+		});
+		let anthropicClaudeSonnet45Model = new ModelConfiguration({
+			cardInfo: new CardInfoField({ name: modelNameFor("anthropic/claude-sonnet-4.5") }),
+			modelId: "anthropic/claude-sonnet-4.5",
+			toolsSupported: true
+		});
+		let anthropicClaudeSonnet37Model = new ModelConfiguration({
+			cardInfo: new CardInfoField({ name: modelNameFor("anthropic/claude-3.7-sonnet") }),
+			modelId: "anthropic/claude-3.7-sonnet",
+			toolsSupported: true
+		});
+		let defaultSystemCard = new SystemCard({
+			defaultModelConfiguration: anthropicClaudeSonnet46Model,
+			modelConfigurations: [
+				openAiGpt5Model,
+				openAiGpt5ExtendedModel,
+				openAiGpt4oMiniModel,
+				anthropicClaudeSonnet46Model,
+				anthropicClaudeSonnet45Model,
+				anthropicClaudeSonnet37Model
+			]
+		});
+		let deepseekModel = new ModelConfiguration({
+			cardInfo: new CardInfoField({ name: modelNameFor("deepseek/deepseek-chat-v3-0324") }),
+			modelId: "deepseek/deepseek-chat-v3-0324",
+			toolsSupported: true
+		});
+		let geminiFlashModel = new ModelConfiguration({
+			cardInfo: new CardInfoField({ name: modelNameFor("google/gemini-2.5-flash") }),
+			modelId: "google/gemini-2.5-flash",
+			toolsSupported: true
+		});
+		let alternateSystemCard = new SystemCard({
+			defaultModelConfiguration: deepseekModel,
+			modelConfigurations: [
+				deepseekModel,
+				geminiFlashModel,
+				openAiGpt5Model
+			]
+		});
+		await setupAcceptanceTestRealm({
+			mockMatrixUtils,
+			contents: {
+				...SYSTEM_CARD_FIXTURE_CONTENTS,
+				"person.gts": { Person },
+				"pet.gts": { Pet },
+				"broken-card.gts": `
+          import { CardDef, field, contains } from 'https://cardstack.com/base/card-api';
+          import StringField from 'https://cardstack.com/base/string';
+          import { BrokenField } from './does-not-exist';
+          export class BrokenCard extends CardDef {
+            static displayName = 'Broken Card';
+            @field name = contains(StringField);
+            @field broken = contains(BrokenField);
+          }
+        `,
+				"BrokenCard/errored.json": { data: {
+					attributes: { name: "Errored Instance" },
+					meta: { adoptsFrom: {
+						module: "../broken-card",
+						name: "BrokenCard"
+					} }
+				} },
+				"country.gts": countryDefinition,
+				"Country/indonesia.json": { data: {
+					attributes: { name: "Indonesia" },
+					meta: { adoptsFrom: {
+						module: `${testRealmURL}country`,
+						name: "Country"
+					} }
+				} },
+				"Pet/ringo.json": new Pet({ name: "Ringo" }),
+				"Person/hassan.json": new Person({
+					firstName: "Hassan",
+					lastName: "Abdel-Rahman",
+					pet: mangoPet,
+					friends: [mangoPet]
+				}),
+				"Pet/mango.json": mangoPet,
+				"Pet/vangogh.json": new Pet({ name: "Van Gogh" }),
+				"Person/fadhlan.json": new Person({
+					firstName: "Fadhlan",
+					pet: mangoPet,
+					friends: [mangoPet]
+				}),
+				"plant.gts": `
+          import { CardDef, field, contains, StringField } from 'https://cardstack.com/base/card-api';
+          export class Plant extends CardDef {
+            static displayName = "Plant";
+            @field commonName = contains(StringField);
+          }
+        `,
+				"Plant/highbush-blueberry.json": { data: {
+					attributes: { commonName: "Highbush Blueberry" },
+					meta: { adoptsFrom: {
+						module: `../plant`,
+						name: "Plant"
+					} }
+				} },
+				"Spec/plant-spec.json": { data: {
+					type: "card",
+					attributes: {
+						ref: {
+							name: "Plant",
+							module: `${testRealmURL}plant`
+						},
+						specType: "card",
+						cardTitle: "Plant spec"
+					},
+					meta: { adoptsFrom: {
+						module: "https://cardstack.com/base/spec",
+						name: "Spec"
+					} }
+				} },
+				"Skill/example.json": { data: {
+					attributes: {
+						cardTitle: "Example Skill",
+						cardDescription: "This skill card is for testing purposes",
+						instructions: "This is an example skill card",
+						commands: []
+					},
+					meta: { adoptsFrom: skillCardRef }
+				} },
+				"Skill/example2.json": { data: {
+					attributes: {
+						cardTitle: "Example 2 Skill",
+						cardDescription: "This skill card is also for testing purposes",
+						instructions: "This is a second example skill card",
+						commands: []
+					},
+					meta: { adoptsFrom: skillCardRef }
+				} },
+				"ModelConfiguration/gpt-4o-mini.json": openAiGpt4oMiniModel,
+				"ModelConfiguration/gpt-5.json": openAiGpt5Model,
+				"ModelConfiguration/gpt-5-extended.json": openAiGpt5ExtendedModel,
+				"ModelConfiguration/claude-sonnet-4.6.json": anthropicClaudeSonnet46Model,
+				"ModelConfiguration/claude-sonnet-4.5.json": anthropicClaudeSonnet45Model,
+				"ModelConfiguration/claude-sonnet-3.7.json": anthropicClaudeSonnet37Model,
+				"SystemCard/default.json": defaultSystemCard,
+				"ModelConfiguration/deepseek-chat-v3-0324.json": deepseekModel,
+				"ModelConfiguration/gemini-2.5-flash.json": geminiFlashModel,
+				"SystemCard/productivity.json": alternateSystemCard,
+				"index.json": new CardsGrid(),
+				"realm.json": realmConfigCardJSON({
+					name: "Test Workspace B",
+					backgroundURL: "https://i.postimg.cc/VNvHH93M/pawel-czerwinski-Ly-ZLa-A5jti-Y-unsplash.jpg",
+					iconURL: "https://i.postimg.cc/L8yXRvws/icon.png"
+				})
+			}
+		});
+		getService("matrix-service").fetchMatrixHostedFile = async (_url) => {
+			return new Response(mockedFileContent);
+		};
+	});
+	(0, import_qunit.test)("attaches a card in a conversation multiple times", async function(assert) {
+		await visitOperatorMode({ stacks: [[{
+			id: `${testRealmURL}index`,
+			format: "isolated"
+		}]] });
+		await click("[data-test-open-ai-assistant]");
+		await waitFor(`[data-room-settled]`);
+		const testCard = `${testRealmURL}Person/hassan`;
+		for (let i = 1; i <= 3; i++) {
+			await fillIn("[data-test-message-field]", `Message - ${i}`);
+			await selectCardFromCatalog(testCard);
+			await click("[data-test-send-message-btn]");
+		}
+		assertMessages(assert, [
+			{
+				from: "testuser",
+				message: "Message - 1",
+				cards: [{
+					id: testCard,
+					cardTitle: "Hassan"
+				}]
+			},
+			{
+				from: "testuser",
+				message: "Message - 2",
+				cards: [{
+					id: testCard,
+					cardTitle: "Hassan"
+				}]
+			},
+			{
+				from: "testuser",
+				message: "Message - 3",
+				cards: [{
+					id: testCard,
+					cardTitle: "Hassan"
+				}]
+			}
+		]);
+		await click("[data-test-boxel-filter-list-button=\"All Cards\"]");
+		await click(`[data-test-stack-card="${testRealmURL}index"] [data-test-cards-grid-item="${testCard}"] .field-component-card`);
+		await waitFor(`[data-test-stack-card="${testCard}"]`);
+		await click(`[data-test-stack-card="${testCard}"] [data-test-edit-button]`);
+		await fillIn("[data-test-field=\"firstName\"] [data-test-boxel-input]", "Updated Name");
+		await click(`[data-test-stack-card="${testCard}"] [data-test-edit-button]`);
+		await fillIn("[data-test-message-field]", `Message with updated card`);
+		await click("[data-test-send-message-btn]");
+		assertMessages(assert, [
+			{
+				from: "testuser",
+				message: "Message - 1",
+				cards: [{
+					id: testCard,
+					cardTitle: "Updated Name Abdel-Rahman"
+				}]
+			},
+			{
+				from: "testuser",
+				message: "Message - 2",
+				cards: [{
+					id: testCard,
+					cardTitle: "Updated Name Abdel-Rahman"
+				}]
+			},
+			{
+				from: "testuser",
+				message: "Message - 3",
+				cards: [{
+					id: testCard,
+					cardTitle: "Updated Name Abdel-Rahman"
+				}]
+			},
+			{
+				from: "testuser",
+				message: "Message with updated card",
+				cards: [{
+					id: testCard,
+					cardTitle: "Updated Name Abdel-Rahman"
+				}]
+			}
+		]);
+	});
+	(0, import_qunit.test)("attached cards include computed fields", async function(assert) {
+		await visitOperatorMode({ stacks: [[{
+			id: `${testRealmURL}index`,
+			format: "isolated"
+		}]] });
+		await click("[data-test-open-ai-assistant]");
+		await waitFor(`[data-room-settled]`);
+		const testCard = `${testRealmURL}Person/hassan`;
+		await fillIn("[data-test-message-field]", `Message - 1`);
+		await selectCardFromCatalog(testCard);
+		await click("[data-test-send-message-btn]");
+		assertMessages(assert, [{
+			from: "testuser",
+			message: "Message - 1",
+			cards: [{
+				id: testCard,
+				cardTitle: "Hassan"
+			}]
+		}]);
+		let roomEvents = mockMatrixUtils.getRoomEvents(matrixRoomId);
+		let lastMessageEvent = roomEvents[roomEvents.length - 1];
+		assert.ok(lastMessageEvent, "A message event was found");
+		let messageDataString = lastMessageEvent.content?.data;
+		assert.ok(messageDataString, "Message has data string");
+		let messageData = JSON.parse(messageDataString);
+		assert.ok(messageData, "Message data is parsable");
+		let attachedCards = messageData.attachedCards;
+		assert.ok(attachedCards, "Message has attachedCards");
+		assert.strictEqual(attachedCards.length, 1, "One card is attached");
+		let attachedCard = attachedCards[0];
+		assert.ok(attachedCard, "Attached card is present");
+		const mxcUrl = attachedCard.url;
+		assert.ok(mxcUrl, "Attached card has a URL (mxc)");
+		assert.ok(mxcUrl.startsWith("http://mock-server/_matrix/media/"), `Card URL "${mxcUrl}" should start with http://mock-server/_matrix/media/`);
+		let cardContent = await getService("matrix-service").downloadCardFileDef(attachedCard);
+		assert.strictEqual(cardContent.data.attributes.cardTitle, "Hassan Abdel-Rahman", "Computed card title is present in downloaded content");
+	});
+	(0, import_qunit.test)("displays active LLM in chat input", async function(assert) {
+		await visitOperatorMode({ stacks: [[{
+			id: `${testRealmURL}index`,
+			format: "isolated"
+		}]] });
+		await click("[data-test-open-ai-assistant]");
+		await waitFor(`[data-room-settled]`);
+		let defaultModelName = modelNameFor("anthropic/claude-sonnet-4.6");
+		assert.dom("[data-test-llm-select-selected]").hasText(defaultModelName);
+		await click("[data-test-llm-select-selected]");
+		assert.dom("[data-test-llm-select-item]").exists({ count: 6 });
+		let llmIdToChangeTo = "anthropic/claude-3.7-sonnet";
+		let llmConfigId = configIdFor(llmIdToChangeTo);
+		let llmNameToChangeTo = modelNameFor("anthropic/claude-3.7-sonnet");
+		assert.dom(`[data-test-llm-select-item="${llmConfigId}"]`).hasText(llmNameToChangeTo);
+		await click(`[data-test-llm-select-item="${llmConfigId}"] button`);
+		await click("[data-test-llm-select-selected]");
+		assert.dom("[data-test-llm-select-selected]").hasText(llmNameToChangeTo);
+		let roomState = getRoomState(matrixRoomId, APP_BOXEL_ACTIVE_LLM, "");
+		assert.strictEqual(roomState.model, llmIdToChangeTo);
+	});
+	(0, import_qunit.test)("active LLM event includes metadata when switching models", async function(assert) {
+		await visitOperatorMode({ stacks: [[{
+			id: `${testRealmURL}index`,
+			format: "isolated"
+		}]] });
+		await click("[data-test-open-ai-assistant]");
+		await waitFor("[data-room-settled]");
+		await click("[data-test-llm-select-selected]");
+		await click(`[data-test-llm-select-item="${configIdFor("openai/gpt-4o-mini")}"] button`);
+		await click("[data-test-llm-select-selected]");
+		await waitUntil(() => {
+			return getRoomState(matrixRoomId, APP_BOXEL_ACTIVE_LLM, "").model === "openai/gpt-4o-mini";
+		});
+		let firstState = getRoomState(matrixRoomId, APP_BOXEL_ACTIVE_LLM, "");
+		assert.strictEqual(firstState.model, "openai/gpt-4o-mini", "Switching to GPT-4o mini updates active LLM");
+		assert.true(firstState.toolsSupported, "Active LLM event records tool support for GPT-4o mini");
+		assert.strictEqual(firstState.reasoningEffort, null, "Reasoning effort is omitted when not configured");
+		await click("[data-test-llm-select-selected]");
+		await click(`[data-test-llm-select-item="${configIdFor("openai/gpt-5")}"] button`);
+		await click("[data-test-llm-select-selected]");
+		await waitUntil(() => {
+			return getRoomState(matrixRoomId, APP_BOXEL_ACTIVE_LLM, "").model === "openai/gpt-5";
+		});
+		let secondState = getRoomState(matrixRoomId, APP_BOXEL_ACTIVE_LLM, "");
+		assert.strictEqual(secondState.model, "openai/gpt-5", "Switching back to GPT-5 updates active LLM");
+		assert.true(secondState.toolsSupported, "Active LLM event records tool support for GPT-5");
+		assert.strictEqual(secondState.reasoningEffort, "minimal", "Active LLM event records configured reasoning effort for GPT-5");
+	});
+	(0, import_qunit.test)("duplicate model IDs render as distinct menu items with correct state", async function(assert) {
+		await visitOperatorMode({ stacks: [[{
+			id: `${testRealmURL}index`,
+			format: "isolated"
+		}]] });
+		await click("[data-test-open-ai-assistant]");
+		await waitFor(`[data-room-settled]`);
+		await click("[data-test-llm-select-selected]");
+		let gpt5ConfigId = configIdFor("openai/gpt-5");
+		let gpt5ExtendedConfigId = configIdFor("openai/gpt-5-extended");
+		assert.dom(`[data-test-llm-select-item="${gpt5ConfigId}"]`).exists("GPT-5 (minimal) config appears in the menu");
+		assert.dom(`[data-test-llm-select-item="${gpt5ExtendedConfigId}"]`).exists("GPT-5 Extended Thinking config appears in the menu");
+		assert.dom(`[data-test-llm-select-item="${gpt5ConfigId}"]`).hasText(modelNameFor("openai/gpt-5"));
+		assert.dom(`[data-test-llm-select-item="${gpt5ExtendedConfigId}"]`).hasText(modelNameFor("openai/gpt-5-extended"));
+		await click(`[data-test-llm-select-item="${gpt5ExtendedConfigId}"] button`);
+		await click("[data-test-llm-select-selected]");
+		await waitUntil(() => {
+			let state = getRoomState(matrixRoomId, APP_BOXEL_ACTIVE_LLM, "");
+			return state.model === "openai/gpt-5" && state.reasoningEffort === "high";
+		});
+		let extendedState = getRoomState(matrixRoomId, APP_BOXEL_ACTIVE_LLM, "");
+		assert.strictEqual(extendedState.model, "openai/gpt-5", "Extended thinking variant sends the same modelId");
+		assert.strictEqual(extendedState.reasoningEffort, "high", "Extended thinking variant sends its own reasoningEffort");
+		await click("[data-test-llm-select-selected]");
+		await click(`[data-test-llm-select-item="${gpt5ConfigId}"] button`);
+		await click("[data-test-llm-select-selected]");
+		await waitUntil(() => {
+			let state = getRoomState(matrixRoomId, APP_BOXEL_ACTIVE_LLM, "");
+			return state.model === "openai/gpt-5" && state.reasoningEffort === "minimal";
+		});
+		let minimalState = getRoomState(matrixRoomId, APP_BOXEL_ACTIVE_LLM, "");
+		assert.strictEqual(minimalState.model, "openai/gpt-5", "Minimal variant sends the same modelId");
+		assert.strictEqual(minimalState.reasoningEffort, "minimal", "Minimal variant sends its own reasoningEffort");
+	});
+	(0, import_qunit.test)("defaults to the system card default regardless of submode", async function(assert) {
+		await visitOperatorMode({ stacks: [[{
+			id: `${testRealmURL}index`,
+			format: "isolated"
+		}]] });
+		await click("[data-test-open-ai-assistant]");
+		await waitFor(`[data-room-settled]`);
+		let matrixService = getService("matrix-service");
+		let defaultSystemModelId = matrixService.systemCard?.defaultModelConfiguration?.modelId ?? matrixService.systemCard?.modelConfigurations?.[0]?.modelId;
+		assert.ok(defaultSystemModelId, "system card provides a default model");
+		let expectedName = modelNameFor(defaultSystemModelId);
+		assert.dom("[data-test-llm-select-selected]").hasText(expectedName);
+		await click("[data-test-submode-switcher-button]");
+		await click("[data-test-boxel-menu-item-text=\"Code\"]");
+		assert.dom("[data-test-llm-select-selected]").hasText(expectedName);
+		await click("[data-test-close-ai-assistant]");
+	});
+	(0, import_qunit.test)("selecting a new system card via menu updates available models", async function(assert) {
+		await visitOperatorMode({ stacks: [[{
+			id: `${testRealmURL}SystemCard/productivity`,
+			format: "isolated"
+		}]] });
+		await click("[data-test-open-ai-assistant]");
+		await waitFor(`[data-room-settled]`);
+		await click("[data-test-llm-select-selected]");
+		assert.dom(`[data-test-llm-select-item="${configIdFor("deepseek/deepseek-chat-v3-0324")}"]`).doesNotExist();
+		await click("[data-test-llm-select-selected]");
+		await click("[data-test-close-ai-assistant]");
+		await click("[data-test-more-options-button]");
+		await click("[data-test-boxel-menu-item-text=\"Set as My System Card\"]");
+		let matrixService = getService("matrix-service");
+		await waitUntil(() => matrixService.systemCard?.modelConfigurations?.[0]?.modelId === "deepseek/deepseek-chat-v3-0324");
+		await click("[data-test-open-ai-assistant]");
+		await waitFor(`[data-room-settled]`);
+		assert.dom("[data-test-llm-select-selected]").hasText(modelNameFor("deepseek/deepseek-chat-v3-0324"));
+		await click("[data-test-llm-select-selected]");
+		assert.dom(`[data-test-llm-select-item="${configIdFor("deepseek/deepseek-chat-v3-0324")}"]`).exists();
+		assert.dom(`[data-test-llm-select-item="${configIdFor("deepseek/deepseek-chat-v3-0324")}"]`).hasText(modelNameFor("deepseek/deepseek-chat-v3-0324"));
+		assert.dom(`[data-test-llm-select-item="${configIdFor("google/gemini-2.5-flash")}"]`).exists();
+		await click("[data-test-pill-menu-button]");
+		await click("[data-test-close-ai-assistant]");
+	});
+	(0, import_qunit.test)("LLM select footer shows \"Go to current system card\" action", async function(assert) {
+		await visitOperatorMode({ stacks: [[{
+			id: `${testRealmURL}index`,
+			format: "isolated"
+		}]] });
+		await click("[data-test-open-ai-assistant]");
+		await waitFor("[data-room-settled]");
+		await click("[data-test-llm-select-selected]");
+		assert.dom("[data-test-go-to-system-card]").exists("Go to system card action is visible");
+		assert.dom("[data-test-go-to-system-card]").hasText("Go to current system card");
+		await click("[data-test-pill-menu-button]");
+		await click("[data-test-close-ai-assistant]");
+	});
+	(0, import_qunit.test)("LLM select footer shows \"Restore default\" when non-default system card is active", async function(assert) {
+		await visitOperatorMode({ stacks: [[{
+			id: `${testRealmURL}SystemCard/productivity`,
+			format: "isolated"
+		}]] });
+		await click("[data-test-more-options-button]");
+		await click("[data-test-boxel-menu-item-text=\"Set as My System Card\"]");
+		let matrixService = getService("matrix-service");
+		await waitUntil(() => matrixService.systemCard?.modelConfigurations?.[0]?.modelId === "deepseek/deepseek-chat-v3-0324");
+		await click("[data-test-open-ai-assistant]");
+		await waitFor("[data-room-settled]");
+		await click("[data-test-llm-select-selected]");
+		assert.dom("[data-test-restore-default-system-card]").exists("Restore default action is visible for non-default system card");
+		await click("[data-test-pill-menu-button]");
+		await click("[data-test-close-ai-assistant]");
+	});
+	(0, import_qunit.test)("LLM select footer hides \"Restore default\" when default system card is active", async function(assert) {
+		await visitOperatorMode({ stacks: [[{
+			id: `${testRealmURL}index`,
+			format: "isolated"
+		}]] });
+		await click("[data-test-open-ai-assistant]");
+		await waitFor("[data-room-settled]");
+		await click("[data-test-llm-select-selected]");
+		assert.dom("[data-test-restore-default-system-card]").doesNotExist("Restore default action is hidden when default system card is active");
+		await click("[data-test-pill-menu-button]");
+		await click("[data-test-close-ai-assistant]");
+	});
+	(0, import_qunit.test)("auto-attached file is not displayed in interact mode", async function(assert) {
+		await visitOperatorMode({
+			submode: "interact",
+			codePath: `${testRealmURL}index.json`,
+			stacks: [[{
+				id: `${testRealmURL}index`,
+				format: "isolated"
+			}]]
+		});
+		await click("[data-test-boxel-filter-list-button=\"All Cards\"]");
+		await click("[data-test-cards-grid-item=\"http://test-realm/test/Person/fadhlan\"] .field-component-card");
+		await click("[data-test-open-ai-assistant]");
+		await waitFor(`[data-room-settled]`);
+		assert.dom("[data-test-autoattached-file]").doesNotExist();
+		assert.dom("[data-test-autoattached-card]").exists();
+		await click("[data-test-submode-switcher-button]");
+		await click("[data-test-boxel-menu-item-text=\"Code\"]");
+		assert.dom("[data-test-autoattached-file]").exists();
+		assert.dom("[data-test-autoattached-card]").exists();
+		await click("[data-test-submode-switcher-button]");
+		await click("[data-test-boxel-menu-item-text=\"Interact\"]");
+		assert.dom("[data-test-autoattached-file]").doesNotExist();
+		assert.dom("[data-test-autoattached-card]").exists();
+	});
+	(0, import_qunit.test)("cards are auto-attached in code mode", async function(assert) {
+		await visitOperatorMode({
+			submode: "interact",
+			codePath: `${testRealmURL}index.json`,
+			stacks: [[{
+				id: `${testRealmURL}index`,
+				format: "isolated"
+			}]]
+		});
+		await click("[data-test-boxel-filter-list-button=\"All Cards\"]");
+		await click("[data-test-cards-grid-item=\"http://test-realm/test/Person/fadhlan\"] .field-component-card");
+		await click("[data-test-open-ai-assistant]");
+		await waitFor(`[data-room-settled]`);
+		await waitUntil(() => document.querySelector("[data-test-autoattached-card]") || document.querySelector("[data-test-autoattached-file]"));
+		assert.dom("[data-test-autoattached-file]").doesNotExist();
+		assert.dom("[data-test-autoattached-card]").exists();
+		await click("[data-test-submode-switcher-button]");
+		await click("[data-test-boxel-menu-item-text=\"Code\"]");
+		assert.dom("[data-test-autoattached-file]").exists();
+		assert.dom("[data-test-autoattached-card]").exists();
+		await click(`[data-test-autoattached-card] [data-test-remove-card-btn]`);
+		assert.dom("[data-test-autoattached-card]").doesNotExist();
+	});
+	(0, import_qunit.test)("errored card instance is not auto-attached in code mode", async function(assert) {
+		await visitOperatorMode({
+			submode: "code",
+			codePath: `${testRealmURL}BrokenCard/errored.json`,
+			stacks: [[]]
+		});
+		await click("[data-test-open-ai-assistant]");
+		await waitFor(`[data-room-settled]`);
+		assert.dom("[data-test-autoattached-file]").exists("errored card JSON file should still be auto-attached as a file");
+		assert.dom("[data-test-autoattached-card]").doesNotExist("errored card instance should not be auto-attached as a card");
+	});
+	(0, import_qunit.test)("can send a newly created auto-attached card", async function(assert) {
+		await visitOperatorMode({
+			submode: "interact",
+			codePath: `${testRealmURL}index.json`,
+			stacks: [[{
+				id: `${testRealmURL}index`,
+				format: "isolated"
+			}]]
+		});
+		let id;
+		this.onSave((url) => {
+			id = url.href;
+		});
+		await click("[data-test-open-ai-assistant]");
+		assert.dom("[data-test-attached-card]").doesNotExist();
+		await click("[data-test-boxel-filter-list-button=\"All Cards\"]");
+		await click("[data-test-create-new-card-button]");
+		await click(`[data-test-card-catalog-item="https://cardstack.com/base/types/card"]`);
+		await click(`[data-test-card-catalog-go-button]`);
+		await waitUntil(() => id);
+		id = id;
+		await fillIn("[data-test-field=\"cardInfo-name\"] input", "new card");
+		assert.dom(`[data-test-attached-card]`).containsText("new card");
+		await fillIn("[data-test-message-field]", `Message with updated card`);
+		await click("[data-test-send-message-btn]");
+		assertMessages(assert, [{
+			from: "testuser",
+			message: "Message with updated card",
+			cards: [{
+				id,
+				cardTitle: "new card"
+			}]
+		}]);
+	});
+	(0, import_qunit.test)("can open attached card dropdown menu", async function(assert) {
+		await visitOperatorMode({
+			submode: "interact",
+			codePath: `${testRealmURL}index.json`,
+			stacks: [[{
+				id: `${testRealmURL}index`,
+				format: "isolated"
+			}]]
+		});
+		await click("[data-test-boxel-filter-list-button=\"All Cards\"]");
+		await click("[data-test-cards-grid-item=\"http://test-realm/test/Person/fadhlan\"] .field-component-card");
+		await click("[data-test-open-ai-assistant]");
+		await waitFor(`[data-room-settled]`);
+		await waitUntil(() => document.querySelector("[data-test-autoattached-card]") || document.querySelector("[data-test-autoattached-file]"));
+		await fillIn("[data-test-message-field]", `Message with updated card`);
+		await click("[data-test-send-message-btn]");
+		mockedFileContent = "test card content";
+		await click("[data-test-workspace-chooser-toggle]");
+		await click("[data-test-attached-file-dropdown-button=\"Fadhlan\"]");
+		assert.dom("[data-test-boxel-menu-item-text=\"Open in Code Mode\"]").exists();
+		assert.dom("[data-test-boxel-menu-item-text=\"Copy Submitted Content\"]").exists();
+		assert.dom("[data-test-boxel-menu-item-text=\"Restore Submitted Content\"]").exists();
+		await waitFor("[data-test-copy-file-content=\"test card content\"]");
+		await click("[data-test-boxel-menu-item-text=\"Open in Code Mode\"]");
+		await waitUntil(() => getMonacoContent().startsWith("{\"data\":{\"type\":\"card\",\"id\":\"http://test-realm/test/Person/fadhlan\""), { timeout: 5e3 });
+	});
+	(0, import_qunit.test)("can open attach file modal", async function(assert) {
+		await visitOperatorMode({
+			submode: "code",
+			stacks: [[{
+				id: `${testRealmURL}index`,
+				format: "isolated"
+			}]]
+		});
+		await click("[data-test-open-ai-assistant]");
+		await waitFor(`[data-room-settled]`);
+		await getService("monaco-service").getMonacoContext();
+		await click("[data-test-attach-button]");
+		await click("[data-test-attach-file-btn]");
+		assert.dom("[data-test-choose-file-modal]").exists();
+		assert.dom("[data-test-file=\"pet.gts\"]").exists();
+		await click("[data-test-realm-dropdown-trigger]");
+		await waitFor("[data-test-boxel-menu-item-text=\"Base Workspace\"]");
+		await click("[data-test-boxel-menu-item-text=\"Base Workspace\"]");
+		assert.dom("[data-test-file=\"boolean.gts\"]").exists();
+		await click("[data-test-realm-dropdown-trigger]");
+		await waitFor("[data-test-boxel-menu-item-text=\"Test Workspace B\"]");
+		await click("[data-test-boxel-menu-item-text=\"Test Workspace B\"]");
+		await click("[data-test-file=\"person.gts\"]");
+		await click("[data-test-choose-file-modal-add-button]");
+		assert.dom("[data-test-attached-file]").exists({ count: 1 });
+		assert.dom("[data-test-attached-file]").hasText("person.gts");
+		await click("[data-test-attach-button]");
+		await click("[data-test-attach-file-btn]");
+		await click("[data-test-file=\"pet.gts\"]");
+		await click("[data-test-choose-file-modal-add-button]");
+		assert.dom("[data-test-attached-file]").exists({ count: 2 });
+		assert.dom(`[data-test-attached-file="${testRealmURL}person.gts"]`).hasText("person.gts");
+		assert.dom(`[data-test-attached-file="${testRealmURL}pet.gts"]`).hasText("pet.gts");
+		await click(`[data-test-attached-file="${testRealmURL}person.gts"] [data-test-remove-file-btn]`);
+		assert.dom("[data-test-attached-file]").hasText("pet.gts");
+		await fillIn("[data-test-message-field]", `Message With File`);
+		await click("[data-test-send-message-btn]");
+		assertMessages(assert, [{
+			from: "testuser",
+			message: "Message With File",
+			files: [{
+				sourceUrl: `${testRealmURL}pet.gts`,
+				name: "pet.gts"
+			}]
+		}]);
+	});
+	(0, import_qunit.test)("can display and remove auto attached file", async function(assert) {
+		await visitOperatorMode({
+			submode: "code",
+			stacks: [[{
+				id: `${testRealmURL}index`,
+				format: "isolated"
+			}]]
+		});
+		await click("[data-test-open-ai-assistant]");
+		await waitFor(`[data-room-settled]`);
+		await click("[data-test-file=\"person.gts\"]");
+		assert.dom("[data-test-autoattached-file]").exists();
+		assert.dom(`[data-test-autoattached-file]`).hasText("person.gts");
+		await click("[data-test-file-browser-toggle]");
+		await click(`[data-test-autoattached-file] [data-test-remove-file-btn]`);
+		assert.dom("[data-test-autoattached-file]").doesNotExist();
+		await click("[data-test-file-browser-toggle]");
+		await click("[data-test-file=\"pet.gts\"]");
+		assert.dom("[data-test-autoattached-file]").exists();
+		assert.dom(`[data-test-autoattached-file]`).hasText("pet.gts");
+		await click("[data-test-file-browser-toggle]");
+		await click("[data-test-file=\"person.gts\"]");
+		assert.dom("[data-test-autoattached-file]").exists();
+		assert.dom(`[data-test-autoattached-file]`).hasText("person.gts");
+	});
+	(0, import_qunit.test)("loads more AI rooms when scrolling", async function(assert) {
+		for (let i = 1; i <= 15; i++) createAndJoinRoom({
+			sender: "@testuser:localhost",
+			name: `AI Room ${i}`
+		});
+		await visitOperatorMode({ stacks: [[{
+			id: `${testRealmURL}index`,
+			format: "isolated"
+		}]] });
+		await click("[data-test-open-ai-assistant]");
+		await waitFor(`[data-room-settled]`);
+		await click("[data-test-past-sessions-button]");
+		assert.dom("[data-test-past-sessions]").exists();
+		await waitUntil(() => document.querySelectorAll("[data-test-joined-room]").length >= 10);
+		let initialRoomCount = document.querySelectorAll("[data-test-joined-room]").length;
+		assert.ok(initialRoomCount >= 10, `Expected at least 10 rooms, got ${initialRoomCount}`);
+		let pastSessionsElement = document.querySelector("[data-test-past-sessions] .body ul");
+		if (pastSessionsElement) pastSessionsElement.scrollTop = pastSessionsElement.scrollHeight;
+		await waitUntil(() => {
+			return document.querySelectorAll("[data-test-joined-room]").length >= Math.min(initialRoomCount + 1, 16);
+		});
+		assert.dom("[data-test-joined-room]").exists({ count: 16 });
+	});
+	(0, import_qunit.test)("preserves ai assistant panel open/closed status", async function(assert) {
+		let operatorModeStateParam = wrapper_default({
+			stacks: [[{
+				id: `${testRealmURL}index`,
+				format: "isolated"
+			}]],
+			aiAssistantOpen: false
+		});
+		await visit(`/?operatorModeEnabled=true&operatorModeState=${encodeURIComponent(operatorModeStateParam)}`);
+		assert.dom("[data-test-ai-assistant-panel]").doesNotExist();
+		await click("[data-test-open-ai-assistant]");
+		await waitFor(`[data-room-settled]`);
+		assert.dom("[data-test-ai-assistant-panel]").exists();
+		let operatorModeStateService = getService("operator-mode-state-service");
+		assert.true(operatorModeStateService.aiAssistantOpen, "URL state should have aiAssistantOpen: true");
+		await click("[data-test-close-ai-assistant]");
+		assert.dom("[data-test-ai-assistant-panel]").doesNotExist();
+		assert.false(operatorModeStateService.aiAssistantOpen, "URL state should have aiAssistantOpen: false");
+		await visitOperatorMode({
+			stacks: [[{
+				id: `${testRealmURL}index`,
+				format: "isolated"
+			}]],
+			aiAssistantOpen: true
+		});
+		assert.dom("[data-test-ai-assistant-panel]").exists();
+	});
+	(0, import_qunit.test)("auto-attached cards behaviour", async function(assert) {
+		await visitOperatorMode({
+			submode: "interact",
+			codePath: `${testRealmURL}index.json`,
+			stacks: [[{
+				id: `${testRealmURL}index`,
+				format: "isolated"
+			}]]
+		});
+		await click("[data-test-boxel-filter-list-button=\"All Cards\"]");
+		await click(`[data-test-cards-grid-item="${testRealmURL}Person/fadhlan"] .field-component-card`);
+		await click("[data-test-open-ai-assistant]");
+		await waitFor(`[data-room-settled]`);
+		assert.dom("[data-test-autoattached-file]").doesNotExist();
+		assert.dom("[data-test-autoattached-card]").exists({ count: 1 });
+		assert.dom(`[data-test-attached-card="${testRealmURL}Person/fadhlan"][data-test-autoattached-card]`).exists();
+		await click("[data-test-add-card-right-stack]");
+		await fillIn("[data-test-search-field]", "Mango");
+		await click(`[data-test-search-result="${testRealmURL}Pet/mango"]`);
+		assert.dom("[data-test-autoattached-card]").exists({ count: 2 });
+		assert.dom(`[data-test-attached-card="${testRealmURL}Person/fadhlan"][data-test-autoattached-card]`).exists();
+		assert.dom(`[data-test-attached-card="${testRealmURL}Pet/mango"][data-test-autoattached-card]`).exists();
+		await click("[data-test-attach-button]");
+		await click("[data-test-attach-card-btn]");
+		await fillIn("[data-test-search-field]", "Mango");
+		await click(`[data-test-card-catalog-item="${testRealmURL}Pet/mango"]`);
+		await click("[data-test-card-catalog-go-button]");
+		assert.dom("[data-test-autoattached-card]").exists({ count: 1 });
+		assert.dom(`[data-test-attached-card="${testRealmURL}Person/fadhlan"][data-test-autoattached-card]`).exists();
+		assert.dom(`[data-test-attached-card="${testRealmURL}Pet/mango"][data-test-autoattached-card]`).doesNotExist();
+		assert.dom(`[data-test-attached-card="${testRealmURL}Pet/mango"]`).exists();
+		await click("[data-test-submode-switcher-button]");
+		await click("[data-test-boxel-menu-item-text=\"Code\"]");
+		assert.dom(`[data-test-attached-card="${testRealmURL}Person/fadhlan"][data-test-autoattached-card]`).doesNotExist();
+		assert.dom(`[data-test-attached-card="${testRealmURL}Pet/mango"][data-test-autoattached-card]`).doesNotExist();
+		assert.dom(`[data-test-attached-card="${testRealmURL}Pet/mango"]`).exists();
+		await click("[data-test-file-browser-toggle]");
+		await click("[data-test-directory=\"Person/\"]");
+		await click("[data-test-file=\"Person/fadhlan.json\"]");
+		assert.dom("[data-test-attached-card]").exists({ count: 2 });
+		assert.dom("[data-test-autoattached-card]").exists({ count: 1 });
+		assert.dom("[data-test-autoattached-file]").exists({ count: 2 });
+		assert.dom(`[data-test-attached-file="${testRealmURL}Person/fadhlan.json"][data-test-autoattached-file]`).exists();
+		assert.dom(`[data-test-attached-file="${testRealmURL}person.gts"][data-test-autoattached-file]`).exists();
+		assert.dom(`[data-test-attached-card="${testRealmURL}Pet/mango"]`).exists();
+		assert.dom(`[data-test-attached-card="${testRealmURL}Person/fadhlan"][data-test-autoattached-card]`).exists();
+		await click("[data-test-file=\"country.gts\"]");
+		await click("[data-test-module-inspector-view=\"preview\"]");
+		assert.dom("[data-test-attached-card]").exists({ count: 2 });
+		assert.dom("[data-test-autoattached-card]").exists({ count: 1 });
+		assert.dom("[data-test-autoattached-file]").exists({ count: 1 });
+		assert.dom(`[data-test-attached-card="${testRealmURL}Pet/mango"]`).exists();
+		assert.dom(`[data-test-attached-card="${testRealmURL}Country/indonesia"][data-test-autoattached-card]`).exists();
+		assert.dom(`[data-test-attached-file="${testRealmURL}country.gts"][data-test-autoattached-file]`).exists();
+		await click(`[data-test-attached-card="${testRealmURL}Country/indonesia"] [data-test-remove-card-btn]`);
+		assert.dom(`[data-test-attached-card="${testRealmURL}Country/indonesia"]`).doesNotExist();
+	});
+	(0, import_qunit.test)("displays \"Generating results...\" when streaming", async function(assert) {
+		await visitOperatorMode({
+			submode: "interact",
+			codePath: `${testRealmURL}index.json`,
+			stacks: [[{
+				id: `${testRealmURL}index`,
+				format: "isolated"
+			}]]
+		});
+		await click("[data-test-boxel-filter-list-button=\"All Cards\"]");
+		await click(`[data-test-cards-grid-item="${testRealmURL}Person/fadhlan"] .field-component-card`);
+		await click("[data-test-open-ai-assistant]");
+		await waitFor(`[data-room-settled]`);
+		let eventId = simulateRemoteMessage(matrixRoomId, "@aibot:localhost", {
+			body: "Streaming...",
+			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
+			format: "org.matrix.custom.html",
+			isStreamingFinished: false
+		});
+		await waitFor("[data-test-ai-assistant-action-bar]");
+		assert.dom("[data-test-ai-assistant-action-bar]").containsText("Generating results...");
+		assert.dom("[data-test-stop-generating]").exists();
+		simulateRemoteMessage(matrixRoomId, "@aibot:localhost", {
+			body: "Streaming finished",
+			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
+			format: "org.matrix.custom.html",
+			isStreamingFinished: true,
+			"m.relates_to": {
+				event_id: eventId,
+				rel_type: "m.replace"
+			}
+		});
+		await waitUntil(() => !document.querySelector("[data-test-ai-assistant-action-bar]"));
+	});
+	(0, import_qunit.test)("displays \"Generation Cancelled\" in the bottom of the message", async function(assert) {
+		await visitOperatorMode({
+			submode: "interact",
+			codePath: `${testRealmURL}index.json`,
+			stacks: [[{
+				id: `${testRealmURL}index`,
+				format: "isolated"
+			}]]
+		});
+		await click("[data-test-boxel-filter-list-button=\"All Cards\"]");
+		await click(`[data-test-cards-grid-item="${testRealmURL}Person/fadhlan"] .field-component-card`);
+		await click("[data-test-open-ai-assistant]");
+		await waitFor(`[data-room-settled]`);
+		let eventId = simulateRemoteMessage(matrixRoomId, "@aibot:localhost", {
+			body: "Lorem ipsum dolor sit amet, consectetur adipiscing elit.",
+			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
+			format: "org.matrix.custom.html",
+			isStreamingFinished: false,
+			isCanceled: false
+		});
+		await waitFor("[data-test-ai-assistant-message]");
+		assert.dom("[data-test-ai-assistant-action-bar]").exists();
+		assert.dom("[data-test-ai-assistant-action-bar]").containsText("Generating results...");
+		assert.dom("[data-test-stop-generating]").exists();
+		assert.dom("[data-test-ai-message-content]").hasText("Lorem ipsum dolor sit amet, consectetur adipiscing elit.");
+		simulateRemoteMessage(matrixRoomId, "@aibot:localhost", {
+			body: "Lorem ipsum dolor sit amet, consectetur adipiscing elit.",
+			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
+			format: "org.matrix.custom.html",
+			isStreamingFinished: true,
+			isCanceled: true,
+			"m.relates_to": {
+				event_id: eventId,
+				rel_type: "m.replace"
+			}
+		});
+		await waitUntil(() => !document.querySelector("[data-test-ai-assistant-action-bar]"));
+		assert.dom("[data-test-ai-message-content]").hasText("Lorem ipsum dolor sit amet, consectetur adipiscing elit. {Generation Cancelled}");
+	});
+	(0, import_qunit.test)(`displays "Generation Cancelled" in the bottom of the message when it's stopped during reasoning`, async function(assert) {
+		await visitOperatorMode({
+			submode: "interact",
+			codePath: `${testRealmURL}index.json`,
+			stacks: [[{
+				id: `${testRealmURL}index`,
+				format: "isolated"
+			}]]
+		});
+		await click("[data-test-boxel-filter-list-button=\"All Cards\"]");
+		await click(`[data-test-cards-grid-item="${testRealmURL}Person/fadhlan"] .field-component-card`);
+		await click("[data-test-open-ai-assistant]");
+		await waitFor(`[data-room-settled]`);
+		let eventId = simulateRemoteMessage(matrixRoomId, "@aibot:localhost", {
+			[APP_BOXEL_REASONING_CONTENT_KEY]: "This message will be cancelled before the reasoning is finished",
+			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
+			format: "org.matrix.custom.html",
+			isStreamingFinished: false,
+			isCanceled: false
+		});
+		await waitFor("[data-test-ai-assistant-message]");
+		assert.dom("[data-test-ai-assistant-action-bar]").exists();
+		assert.dom("[data-test-ai-assistant-action-bar]").containsText("Generating results...");
+		assert.dom("[data-test-stop-generating]").exists();
+		assert.dom("[data-test-ai-message-content]").containsText("Thinking...");
+		assert.dom("[data-test-ai-message-content]").doesNotContainText("{Generation Cancelled}");
+		assert.dom("[data-test-reasoning]").containsText("This message will be cancelled before the reasoning is finished");
+		simulateRemoteMessage(matrixRoomId, "@aibot:localhost", {
+			[APP_BOXEL_REASONING_CONTENT_KEY]: "This message will be cancelled before the reasoning is finished",
+			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
+			format: "org.matrix.custom.html",
+			isStreamingFinished: true,
+			isCanceled: true,
+			"m.relates_to": {
+				event_id: eventId,
+				rel_type: "m.replace"
+			}
+		});
+		await waitUntil(() => !document.querySelector("[data-test-ai-assistant-action-bar]"));
+		assert.dom("[data-test-ai-message-content]").containsText("Thinking...");
+		assert.dom("[data-test-ai-message-content]").containsText("{Generation Cancelled}");
+		await click("[data-test-reasoning]");
+		assert.dom("[data-test-reasoning]").containsText("This message will be cancelled before the reasoning is finished");
+	});
+	(0, import_qunit.test)(`should not display action bar when there is no code patch block`, async function(assert) {
+		await visitOperatorMode({
+			submode: "interact",
+			codePath: `${testRealmURL}index.json`,
+			stacks: [[{
+				id: `${testRealmURL}index`,
+				format: "isolated"
+			}]]
+		});
+		await click("[data-test-boxel-filter-list-button=\"All Cards\"]");
+		await click(`[data-test-cards-grid-item="${testRealmURL}Person/fadhlan"] .field-component-card`);
+		await click("[data-test-open-ai-assistant]");
+		await waitFor(`[data-room-settled]`);
+		simulateRemoteMessage(matrixRoomId, "@aibot:localhost", {
+			body: `\`\`\`
+  { "name": "test" }
+\`\`\``,
+			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
+			format: "org.matrix.custom.html",
+			isStreamingFinished: true
+		});
+		await waitFor("[data-test-ai-assistant-message]");
+		assert.dom("[data-test-ai-assistant-action-bar]").doesNotExist();
+	});
+	(0, import_qunit.test)("code mode context sent with message", async function(assert) {
+		await visitOperatorMode({
+			submode: "code",
+			codePath: `${testRealmURL}Plant/highbush-blueberry.json`,
+			stacks: [[{
+				id: `${testRealmURL}index`,
+				format: "isolated"
+			}, {
+				id: `${testRealmURL}Plant/highbush-blueberry`,
+				format: "isolated"
+			}]]
+		});
+		await click("[data-test-open-ai-assistant]");
+		await waitFor(`[data-room-settled]`);
+		assert.dom("[data-test-focus-pill-main]").containsText("Card");
+		assert.dom("[data-test-focus-pill-meta]").exists({ count: 1 }, "FocusPill shows one meta pill");
+		let metaEls = document.querySelectorAll("[data-test-focus-pill-meta]");
+		assert.dom(metaEls[0]).hasText("Isolated", "FocusPill shows item type \"Format\"");
+		await click("[data-test-format-chooser=\"embedded\"]");
+		assert.dom("[data-test-focus-pill-meta]").exists({ count: 1 }, "FocusPill shows one meta pill");
+		metaEls = document.querySelectorAll("[data-test-focus-pill-meta]");
+		assert.dom(metaEls[0]).hasText("Embedded", "FocusPill shows item type \"Format\"");
+		await fillIn("[data-test-message-field]", `Message - 1`);
+		await click("[data-test-send-message-btn]");
+		let roomEvents = mockMatrixUtils.getRoomEvents(matrixRoomId);
+		let lastMessageEvent = roomEvents[roomEvents.length - 1];
+		let contextSent = JSON.parse(lastMessageEvent.content.data).context;
+		assert.strictEqual(contextSent.realmUrl, testRealmURL, "Context sent with message contains correct realmUrl");
+		assert.strictEqual(contextSent.submode, "code", "Context sent with message contains correct submode");
+		assert.deepEqual(contextSent.openCardIds, [`${testRealmURL}Plant/highbush-blueberry`], "Context sent with message contains correct openCardIds");
+		assert.strictEqual(contextSent.codeMode.currentFile, `${testRealmURL}Plant/highbush-blueberry.json`, "Context sent with message contains correct currentFile");
+		assert.deepEqual(contextSent.codeMode.selectionRange, {
+			startLine: 1,
+			startColumn: 1,
+			endLine: 1,
+			endColumn: 1
+		}, "Context sent with message contains correct selectionRange");
+		assert.strictEqual(contextSent.codeMode.moduleInspectorPanel, "preview", "Context sent with message contains correct moduleInspectorPanel");
+		assert.deepEqual(contextSent.codeMode.previewPanelSelection, {
+			cardId: `${testRealmURL}Plant/highbush-blueberry`,
+			format: "embedded"
+		}, "Context sent with message contains correct previewPanelSelection");
+		assert.deepEqual(contextSent.codeMode.selectedCodeRef, void 0, "Context sent with message contains correct selectedCodeRef");
+		assert.deepEqual(contextSent.codeMode.inheritanceChain, void 0, "Context sent with message contains undefined inheritanceChain when no selectedCodeRef");
+		assert.strictEqual(contextSent.codeMode.activeSpecId, void 0, "Context sent with message contains undefined activeSpecId when spec panel is not active");
+		assert.deepEqual(contextSent.realmPermissions, {
+			canRead: true,
+			canWrite: true
+		}, "Context sent with message contains correct realmPermissions");
+		await click("[data-test-clickable-definition-container]");
+		await waitFor("[data-test-focus-pill-main]");
+		assert.dom("[data-test-focus-pill-main]").containsText("Plant", "FocusPill shows selected code label");
+		assert.dom("[data-test-focus-pill-meta]").exists({ count: 1 }, "FocusPill shows one meta pill");
+		metaEls = document.querySelectorAll("[data-test-focus-pill-meta]");
+		assert.dom(metaEls[0]).hasText("Schema", "FocusPill shows item type \"Schema\"");
+		await fillIn("[data-test-message-field]", `Message - 2`);
+		await click("[data-test-send-message-btn]");
+		roomEvents = mockMatrixUtils.getRoomEvents(matrixRoomId);
+		lastMessageEvent = roomEvents[roomEvents.length - 1];
+		contextSent = JSON.parse(lastMessageEvent.content.data).context;
+		assert.strictEqual(contextSent.realmUrl, testRealmURL, "Context sent with message contains correct realmUrl");
+		assert.strictEqual(contextSent.submode, "code", "Context sent with message contains correct submode");
+		assert.deepEqual(contextSent.openCardIds, [], "Context sent with message contains correct openCardIds");
+		assert.strictEqual(contextSent.codeMode.currentFile, `${testRealmURL}plant.gts`, "Context sent with message contains correct currentFile");
+		assert.deepEqual(contextSent.codeMode.selectionRange, {
+			startLine: 3,
+			startColumn: 45,
+			endLine: 3,
+			endColumn: 45
+		}, "Context sent with message contains correct selectionRange");
+		assert.strictEqual(contextSent.codeMode.moduleInspectorPanel, "schema", "Context sent with message contains correct moduleInspectorPanel");
+		assert.strictEqual(contextSent.codeMode.previewPanelSelection, void 0, "Context sent with message contains correct previewPanelSelection");
+		assert.deepEqual(contextSent.codeMode.selectedCodeRef, {
+			module: rri("http://test-realm/test/plant"),
+			name: "Plant"
+		}, "Context sent with message contains correct selectedCodeRef");
+		assert.ok(contextSent.codeMode.inheritanceChain, "Context sent with message contains inheritanceChain");
+		assert.deepEqual(contextSent.codeMode.inheritanceChain[0].codeRef, {
+			module: rri("http://test-realm/test/plant"),
+			name: "Plant"
+		}, "First item in inheritanceChain is the Plant card");
+		assert.ok(Array.isArray(contextSent.codeMode.inheritanceChain[0].fields), "Plant card has fields array");
+		assert.ok(contextSent.codeMode.inheritanceChain[0].fields.includes("commonName"), "Plant card includes commonName field");
+		let lastInheritanceItem = contextSent.codeMode.inheritanceChain[contextSent.codeMode.inheritanceChain.length - 1];
+		assert.strictEqual(lastInheritanceItem.codeRef.name, "CardDef", "Last item in inheritanceChain is CardDef");
+		contextSent.codeMode.inheritanceChain.forEach((item, index) => {
+			assert.ok(Array.isArray(item.fields), `Inheritance chain item ${index} has fields array`);
+			assert.ok("codeRef" in item, `Inheritance chain item ${index} has codeRef property`);
+		});
+		assert.ok(lastInheritanceItem.codeRef.module.includes("card-api"), "Last item in inheritanceChain comes from card-api module");
+		assert.deepEqual(contextSent.realmPermissions, {
+			canRead: true,
+			canWrite: true
+		}, "Context sent with message contains correct realmPermissions");
+		await click("[data-test-boxel-button][data-test-module-inspector-view=\"preview\"]");
+		let editor = getService("monaco-service").editor;
+		if (editor?.setSelection) editor.setSelection({
+			startLineNumber: 3,
+			startColumn: 45,
+			endLineNumber: 6,
+			endColumn: 1
+		});
+		await waitFor("[data-test-focus-pill-main]");
+		await delay(20);
+		assert.dom("[data-test-focus-pill-main]").containsText("Plant", "FocusPill still shows selected code label");
+		assert.dom("[data-test-focus-pill-meta]").exists({ count: 3 }, "FocusPill shows three meta pills");
+		metaEls = document.querySelectorAll("[data-test-focus-pill-meta]");
+		assert.dom(metaEls[0]).hasText("Preview", "FocusPill shows item type \"Preview\"");
+		assert.dom(metaEls[1]).hasText("Isolated", "FocusPill shows format \"Isolated\"");
+		assert.dom(metaEls[2]).hasText("Lines 3-6", "FocusPill shows multi-line selection range \"Lines 3-6\"");
+		await click("[data-test-format-chooser=\"fitted\"]");
+		metaEls = document.querySelectorAll("[data-test-focus-pill-meta]");
+		assert.dom(metaEls[1]).hasText("Fitted", "FocusPill shows format \"Fitted\"");
+		await fillIn("[data-test-message-field]", `Message - 3`);
+		await click("[data-test-send-message-btn]");
+		roomEvents = mockMatrixUtils.getRoomEvents(matrixRoomId);
+		lastMessageEvent = roomEvents[roomEvents.length - 1];
+		contextSent = JSON.parse(lastMessageEvent.content.data).context;
+		assert.strictEqual(contextSent.realmUrl, testRealmURL, "Context sent with message contains correct realmUrl");
+		assert.strictEqual(contextSent.submode, "code", "Context sent with message contains correct submode");
+		assert.deepEqual(contextSent.openCardIds, [`${testRealmURL}Plant/highbush-blueberry`], "Context sent with message contains correct openCardIds");
+		assert.strictEqual(contextSent.codeMode.currentFile, `${testRealmURL}plant.gts`, "Context sent with message contains correct currentFile");
+		assert.deepEqual(contextSent.codeMode.selectionRange, {
+			startLine: 3,
+			startColumn: 45,
+			endLine: 6,
+			endColumn: 1
+		}, "Context sent with message contains correct selectionRange");
+		assert.strictEqual(contextSent.codeMode.moduleInspectorPanel, "preview", "Context sent with message contains correct moduleInspectorPanel");
+		assert.deepEqual(contextSent.codeMode.previewPanelSelection, {
+			cardId: `${testRealmURL}Plant/highbush-blueberry`,
+			format: "fitted"
+		}, "Context sent with message contains correct previewPanelSelection");
+		assert.deepEqual(contextSent.codeMode.selectedCodeRef, {
+			module: rri("http://test-realm/test/plant"),
+			name: "Plant"
+		}, "Context sent with message contains correct selectedCodeRef");
+		assert.strictEqual(contextSent.codeMode.activeSpecId, void 0, "Context sent with message contains undefined activeSpecId when spec panel is not active");
+		assert.deepEqual(contextSent.realmPermissions, {
+			canRead: true,
+			canWrite: true
+		}, "Context sent with message contains correct realmPermissions");
+		await click("[data-test-boxel-button][data-test-module-inspector-view=\"spec\"]");
+		await waitFor("[data-test-focus-pill-main]");
+		{
+			const metaEls = document.querySelectorAll("[data-test-focus-pill-meta]");
+			assert.dom(metaEls[0]).hasText("Spec", "FocusPill shows item type \"Spec\"");
+		}
+		await fillIn("[data-test-message-field]", `Message - 4`);
+		await click("[data-test-send-message-btn]");
+		roomEvents = mockMatrixUtils.getRoomEvents(matrixRoomId);
+		lastMessageEvent = roomEvents[roomEvents.length - 1];
+		contextSent = JSON.parse(lastMessageEvent.content.data).context;
+		assert.strictEqual(contextSent.realmUrl, testRealmURL, "Context sent with message contains correct realmUrl");
+		assert.strictEqual(contextSent.submode, "code", "Context sent with message contains correct submode");
+		assert.deepEqual(contextSent.openCardIds, ["http://test-realm/test/Spec/plant-spec"], "Context sent with message contains correct openCardIds");
+		assert.strictEqual(contextSent.codeMode.currentFile, `${testRealmURL}plant.gts`, "Context sent with message contains correct currentFile");
+		assert.strictEqual(contextSent.codeMode.moduleInspectorPanel, "spec", "Context sent with message contains correct moduleInspectorPanel");
+		assert.strictEqual(contextSent.codeMode.previewPanelSelection, void 0, "Context sent with message contains correct previewPanelSelection");
+		assert.deepEqual(contextSent.codeMode.selectedCodeRef, {
+			module: rri("http://test-realm/test/plant"),
+			name: "Plant"
+		}, "Context sent with message contains correct selectedCodeRef");
+		assert.ok(contextSent.codeMode.activeSpecId, "Context sent with message contains activeSpecId when spec panel is active");
+		assert.true(contextSent.codeMode.activeSpecId.startsWith(testRealmURL), "activeSpecId should start with test realm URL");
+		assert.deepEqual(contextSent.realmPermissions, {
+			canRead: true,
+			canWrite: true
+		}, "Context sent with message contains correct realmPermissions");
+	});
+	(0, import_qunit.test)("dashboard context sent with message", async function(assert) {
+		await visitOperatorMode({
+			submode: "interact",
+			workspaceChooserOpened: true,
+			stacks: [[]]
+		});
+		await click("[data-test-open-ai-assistant]");
+		await waitFor(`[data-room-settled]`);
+		await fillIn("[data-test-message-field]", `Message - 1`);
+		await click("[data-test-send-message-btn]");
+		let roomEvents = mockMatrixUtils.getRoomEvents(matrixRoomId);
+		let lastMessageEvent = roomEvents[roomEvents.length - 1];
+		let contextSent = JSON.parse(lastMessageEvent.content.data).context;
+		assert.strictEqual(contextSent.realmUrl, void 0, "Context sent with message does not contain realmUrl");
+		assert.strictEqual(contextSent.submode, "workspace-chooser", "Context sent with message contains correct submode");
+		assert.deepEqual(contextSent.workspaces, [
+			{
+				name: "Test Workspace B",
+				type: "user-workspace",
+				url: testRealmURL
+			},
+			catalogRealmURL && {
+				name: "Cardstack Catalog",
+				type: "catalog-workspace",
+				url: catalogRealmURL
+			},
+			{
+				name: "Boxel Skills",
+				type: "catalog-workspace",
+				url: skillsRealmURL
+			}
+		].filter(Boolean), "Context sent with message contains correct workspaces");
+	});
+	(0, import_qunit.test)("clicking auto-attached card makes it a chosen card", async function(assert) {
+		await visitOperatorMode({
+			submode: "interact",
+			stacks: [[{
+				id: `${testRealmURL}Person/fadhlan`,
+				format: "isolated"
+			}]]
+		});
+		await click("[data-test-open-ai-assistant]");
+		await waitFor(`[data-room-settled]`);
+		assert.dom("[data-test-autoattached-card]").exists({ count: 1 });
+		assert.dom(`[data-test-attached-card="${testRealmURL}Person/fadhlan"][data-test-autoattached-card]`).exists();
+		await click(`[data-test-attached-card="${testRealmURL}Person/fadhlan"][data-test-autoattached-card]`);
+		assert.dom("[data-test-autoattached-card]").doesNotExist();
+		assert.dom(`[data-test-attached-card="${testRealmURL}Person/fadhlan"]`).exists();
+		assert.dom(`[data-test-attached-card="${testRealmURL}Person/fadhlan"][data-test-autoattached-card]`).doesNotExist();
+		await click(`[data-test-attached-card="${testRealmURL}Person/fadhlan"] [data-test-remove-card-btn]`);
+		assert.dom(`[data-test-attached-card="${testRealmURL}Person/fadhlan"]`).doesNotExist();
+	});
+	(0, import_qunit.test)("clicking auto-attached file makes it a chosen file", async function(assert) {
+		await visitOperatorMode({
+			submode: "code",
+			codePath: `${testRealmURL}plant.gts`,
+			stacks: [[{
+				id: `${testRealmURL}index`,
+				format: "isolated"
+			}]]
+		});
+		await click("[data-test-open-ai-assistant]");
+		await waitFor(`[data-room-settled]`);
+		assert.dom("[data-test-autoattached-file]").exists({ count: 1 });
+		assert.dom(`[data-test-attached-file="${testRealmURL}plant.gts"][data-test-autoattached-file]`).exists();
+		await click(`[data-test-attached-file="${testRealmURL}plant.gts"][data-test-autoattached-file]`);
+		assert.dom("[data-test-autoattached-file]").doesNotExist();
+		assert.dom(`[data-test-attached-file="${testRealmURL}plant.gts"]`).exists();
+		assert.dom(`[data-test-attached-file="${testRealmURL}plant.gts"][data-test-autoattached-file]`).doesNotExist();
+		await click(`[data-test-attached-file="${testRealmURL}plant.gts"] [data-test-remove-file-btn]`);
+		assert.dom(`[data-test-attached-file="${testRealmURL}plant.gts"]`).doesNotExist();
+		await click("[data-test-module-inspector-view=\"spec\"]");
+		await waitFor("[data-test-spec-selector-item-path]");
+		assert.dom("[data-test-autoattached-card]").exists({ count: 1 });
+		let autoAttachedCards = document.querySelectorAll("[data-test-autoattached-card]");
+		let hasAutoAttachedSpec = Array.from(autoAttachedCards).some((card) => {
+			return card.getAttribute("data-test-attached-card")?.includes("Spec/plant-spec");
+		});
+		assert.ok(hasAutoAttachedSpec, "Auto-attached card should be the plant spec card");
+	});
+	(0, import_qunit.test)("auto-attaches spec card when spec panel is open and spec is selected", async function(assert) {
+		await visitOperatorMode({
+			submode: "code",
+			codePath: `${testRealmURL}plant.gts`,
+			stacks: [[{
+				id: `${testRealmURL}index`,
+				format: "isolated"
+			}]]
+		});
+		await click("[data-test-open-ai-assistant]");
+		await waitFor(`[data-room-settled]`);
+		await click("[data-test-module-inspector-view=\"spec\"]");
+		await waitFor("[data-test-spec-selector-item-path]");
+		assert.dom("[data-test-autoattached-card]").exists({ count: 1 });
+		let autoAttachedCards = document.querySelectorAll("[data-test-autoattached-card]");
+		let hasAutoAttachedSpec = Array.from(autoAttachedCards).some((card) => {
+			return card.getAttribute("data-test-attached-card")?.includes("Spec/plant-spec");
+		});
+		assert.ok(hasAutoAttachedSpec, "Auto-attached card should be the plant spec card");
+	});
+	(0, import_qunit.test)("does not auto-attach spec card when spec panel is closed", async function(assert) {
+		await visitOperatorMode({
+			submode: "code",
+			codePath: `${testRealmURL}plant.gts`,
+			stacks: [[{
+				id: `${testRealmURL}index`,
+				format: "isolated"
+			}]]
+		});
+		await click("[data-test-open-ai-assistant]");
+		await waitFor(`[data-room-settled]`);
+		await click("[data-test-module-inspector-view=\"spec\"]");
+		await waitFor("[data-test-spec-selector-item-path]");
+		await click("[data-test-module-inspector-view=\"schema\"]");
+		let autoAttachedCards = document.querySelectorAll("[data-test-autoattached-card]");
+		let hasAutoAttachedSpec = Array.from(autoAttachedCards).some((card) => {
+			return card.getAttribute("data-test-attached-card")?.includes("Spec/");
+		});
+		assert.false(hasAutoAttachedSpec, "No spec card should be auto-attached when spec panel is closed");
+	});
+	(0, import_qunit.test)("does not auto-attach spec card when no spec is selected", async function(assert) {
+		await visitOperatorMode({
+			submode: "code",
+			codePath: `${testRealmURL}country.gts`,
+			stacks: [[{
+				id: `${testRealmURL}index`,
+				format: "isolated"
+			}]]
+		});
+		await click("[data-test-open-ai-assistant]");
+		await waitFor(`[data-room-settled]`);
+		await click("[data-test-module-inspector-view=\"spec\"]");
+		assert.dom("[data-test-spec-selector-item-path]").doesNotExist();
+		let autoAttachedCards = document.querySelectorAll("[data-test-autoattached-card]");
+		let hasAutoAttachedSpec = Array.from(autoAttachedCards).some((card) => {
+			return card.getAttribute("data-test-attached-card")?.includes("Spec/");
+		});
+		assert.false(hasAutoAttachedSpec, "No spec card should be auto-attached when no spec is selected");
+	});
+	(0, import_qunit.test)("manually attached spec cards do not duplicate auto-attached ones", async function(assert) {
+		await visitOperatorMode({
+			submode: "code",
+			codePath: `${testRealmURL}plant.gts`,
+			stacks: [[{
+				id: `${testRealmURL}index`,
+				format: "isolated"
+			}]]
+		});
+		await click("[data-test-open-ai-assistant]");
+		await waitFor(`[data-room-settled]`);
+		await click("[data-test-module-inspector-view=\"spec\"]");
+		await waitFor("[data-test-spec-selector-item-path]");
+		await waitUntil(() => {
+			let autoAttachedCards = document.querySelectorAll("[data-test-autoattached-card]");
+			return Array.from(autoAttachedCards).some((card) => {
+				return card.getAttribute("data-test-attached-card")?.includes("Spec/plant-spec");
+			});
+		});
+		let autoAttachedCardsBefore = document.querySelectorAll("[data-test-autoattached-card]");
+		let autoAttachedSpecId = Array.from(autoAttachedCardsBefore).find((card) => {
+			return card.getAttribute("data-test-attached-card")?.includes("Spec/");
+		})?.getAttribute("data-test-attached-card");
+		if (autoAttachedSpecId) {
+			await click("[data-test-attach-button]");
+			await click("[data-test-attach-card-btn]");
+			await fillIn("[data-test-search-field]", "Plant spec");
+			await click(`[data-test-card-catalog-item="${autoAttachedSpecId}"]`);
+			await click("[data-test-card-catalog-go-button]");
+			let specCards = document.querySelectorAll(`[data-test-attached-card="${autoAttachedSpecId}"]`);
+			assert.strictEqual(specCards.length, 1, "Spec card should only appear once, not duplicated");
+			let remainingAutoAttachedCards = document.querySelectorAll("[data-test-autoattached-card]");
+			let hasAutoAttachedSpec = Array.from(remainingAutoAttachedCards).some((card) => {
+				return card.getAttribute("data-test-attached-card") === autoAttachedSpecId;
+			});
+			assert.false(hasAutoAttachedSpec, "Manually attached spec should no longer be auto-attached");
+		} else assert.ok(false, "Expected a spec card to be auto-attached, but none was found");
+	});
+	(0, import_qunit.test)("manually attached cards and files persist through reload without duplicating auto attachments", async function(assert) {
+		src_default.localStorage.removeItem(AiAssistantMessageDrafts);
+		await visitOperatorMode({
+			submode: "code",
+			codePath: `${testRealmURL}plant.gts`,
+			stacks: [[{
+				id: `${testRealmURL}index`,
+				format: "isolated"
+			}]],
+			aiAssistantOpen: true
+		});
+		await waitFor(`[data-room-settled]`);
+		await click("[data-test-module-inspector-view=\"spec\"]");
+		await waitFor("[data-test-spec-selector-item-path]");
+		let autoAttachedSpecId;
+		await waitUntil(() => {
+			let autoAttachedCards = document.querySelectorAll("[data-test-autoattached-card]");
+			let specCard = Array.from(autoAttachedCards).find((card) => {
+				return card.getAttribute("data-test-attached-card")?.includes("Spec/");
+			});
+			if (specCard) {
+				autoAttachedSpecId = specCard.getAttribute("data-test-attached-card");
+				return true;
+			}
+			return false;
+		});
+		assert.ok(autoAttachedSpecId, "expected a spec card to be auto-attached");
+		await click("[data-test-attach-button]");
+		await click("[data-test-attach-card-btn]");
+		await fillIn("[data-test-search-field]", "Plant spec");
+		await click(`[data-test-card-catalog-item="${autoAttachedSpecId}"]`);
+		await click("[data-test-card-catalog-go-button]");
+		await click("[data-test-attach-button]");
+		await click("[data-test-attach-file-btn]");
+		await click("[data-test-file=\"plant.gts\"]");
+		await click("[data-test-choose-file-modal-add-button]");
+		await fillIn("[data-test-message-field]", "Reload keeps my draft");
+		await visitOperatorMode({
+			submode: "code",
+			codePath: `${testRealmURL}plant.gts`,
+			stacks: [[{
+				id: `${testRealmURL}index`,
+				format: "isolated"
+			}]],
+			aiAssistantOpen: true
+		});
+		await waitFor(`[data-test-room-settled]`);
+		await click("[data-test-module-inspector-view=\"spec\"]");
+		await waitFor("[data-test-spec-selector-item-path]");
+		assert.dom("[data-test-message-field]").hasValue("Reload keeps my draft");
+		assert.dom(`[data-test-attached-card="${autoAttachedSpecId}"]`).exists({ count: 1 });
+		assert.dom(`[data-test-autoattached-card][data-test-attached-card="${autoAttachedSpecId}"]`).doesNotExist();
+		assert.dom(`[data-test-attached-file="${testRealmURL}plant.gts"]`).exists({ count: 1 });
+		assert.dom("[data-test-autoattached-file]").doesNotExist();
+	});
+	(0, import_qunit.test)("auto-attached spec card can be removed", async function(assert) {
+		await visitOperatorMode({
+			submode: "code",
+			codePath: `${testRealmURL}plant.gts`,
+			stacks: [[{
+				id: `${testRealmURL}index`,
+				format: "isolated"
+			}]]
+		});
+		await click("[data-test-open-ai-assistant]");
+		await waitFor(`[data-room-settled]`);
+		await click("[data-test-module-inspector-view=\"spec\"]");
+		await waitFor("[data-test-spec-selector-item-path]");
+		await waitUntil(() => {
+			let autoAttachedCards = document.querySelectorAll("[data-test-autoattached-card]");
+			return Array.from(autoAttachedCards).some((card) => {
+				return card.getAttribute("data-test-attached-card")?.includes("Spec/plant-spec");
+			});
+		});
+		let autoAttachedSpecCard = Array.from(document.querySelectorAll("[data-test-autoattached-card]")).find((card) => {
+			return card.getAttribute("data-test-attached-card")?.includes("Spec/");
+		});
+		if (autoAttachedSpecCard) {
+			let specCardId = autoAttachedSpecCard.getAttribute("data-test-attached-card");
+			await click(autoAttachedSpecCard.querySelector("[data-test-remove-card-btn]"));
+			assert.dom(`[data-test-attached-card="${specCardId}"]`).doesNotExist();
+		} else assert.ok(false, "Expected a spec card to be auto-attached, but none was found");
+	});
+	(0, import_qunit.test)("spec card re-auto-attaches when switching back to spec panel", async function(assert) {
+		await visitOperatorMode({
+			submode: "code",
+			codePath: `${testRealmURL}plant.gts`,
+			stacks: [[{
+				id: `${testRealmURL}index`,
+				format: "isolated"
+			}]]
+		});
+		await click("[data-test-open-ai-assistant]");
+		await waitFor(`[data-room-settled]`);
+		await click("[data-test-module-inspector-view=\"spec\"]");
+		await waitFor("[data-test-spec-selector-item-path]");
+		await waitUntil(() => {
+			let autoAttachedCards = document.querySelectorAll("[data-test-autoattached-card]");
+			return Array.from(autoAttachedCards).some((card) => {
+				return card.getAttribute("data-test-attached-card")?.includes("Spec/plant-spec");
+			});
+		});
+		let autoAttachedSpecCards = Array.from(document.querySelectorAll("[data-test-autoattached-card]")).filter((card) => {
+			return card.getAttribute("data-test-attached-card")?.includes("Spec/");
+		});
+		assert.ok(autoAttachedSpecCards.length > 0, "Spec card should be auto-attached when spec panel is open");
+		await click("[data-test-module-inspector-view=\"schema\"]");
+		let autoAttachedSpecCardsAfterSwitch = Array.from(document.querySelectorAll("[data-test-autoattached-card]")).filter((card) => {
+			return card.getAttribute("data-test-attached-card")?.includes("Spec/");
+		});
+		assert.strictEqual(autoAttachedSpecCardsAfterSwitch.length, 0, "Spec card should not be auto-attached when spec panel is closed");
+		await click("[data-test-module-inspector-view=\"spec\"]");
+		await waitUntil(() => {
+			let autoAttachedCards = document.querySelectorAll("[data-test-autoattached-card]");
+			return Array.from(autoAttachedCards).some((card) => {
+				return card.getAttribute("data-test-attached-card")?.includes("Spec/plant-spec");
+			});
+		});
+		let autoAttachedSpecCardsAfterReturn = Array.from(document.querySelectorAll("[data-test-autoattached-card]")).filter((card) => {
+			return card.getAttribute("data-test-attached-card")?.includes("Spec/");
+		});
+		assert.ok(autoAttachedSpecCardsAfterReturn.length > 0, "Spec card should be auto-attached again when returning to spec panel");
+	});
+	(0, import_qunit.test)("\"Add Same Skills\" copies skill configuration to new session", async function(assert) {
+		await visitOperatorMode({
+			stacks: [[{
+				id: `${testRealmURL}index`,
+				format: "isolated"
+			}]],
+			aiAssistantOpen: true
+		});
+		await waitFor(`[data-room-settled]`);
+		await addSkillToAiAssistant(`${testRealmURL}Skill/example`);
+		await addSkillToAiAssistant(`${testRealmURL}Skill/example2`);
+		await click("[data-test-skill-menu]");
+		await waitUntil(() => document.querySelectorAll("[data-test-skill-menu] [data-test-attached-card]")?.length === 2);
+		assert.dom(`[data-test-skill-menu] [data-test-attached-card="${testRealmURL}Skill/example"]`).exists();
+		assert.dom(`[data-test-skill-menu] [data-test-attached-card="${testRealmURL}Skill/example2"]`).exists();
+		assert.dom(`[data-test-skill-toggle="${testRealmURL}Skill/example-on"`).exists();
+		assert.dom(`[data-test-skill-toggle="${testRealmURL}Skill/example2-on"`).exists();
+		await click(`[data-test-skill-toggle="${testRealmURL}Skill/example2-on"`);
+		await waitFor(`[data-test-skill-toggle="${testRealmURL}Skill/example2-off"`);
+		assert.dom(`[data-test-skill-toggle="${testRealmURL}Skill/example2-off"`).exists();
+		await fillIn("[data-test-message-field]", "Enabling create new session button");
+		await click("[data-test-send-message-btn]");
+		let roomsBeforeSameSkills = getRoomIds();
+		await click("[data-test-create-room-btn]", { shiftKey: true });
+		await click("[data-test-new-session-settings-option=\"Add Same Skills\"]");
+		await click("[data-test-new-session-settings-create-button]");
+		await waitFor("[data-room-settled]");
+		let duplicatedSkillsRoomId = getRoomIds().find((roomId) => !roomsBeforeSameSkills.includes(roomId));
+		assert.ok(duplicatedSkillsRoomId, "Creating a new session with copied skills creates a new room");
+		if (duplicatedSkillsRoomId) {
+			let activeLLMState = getRoomState(duplicatedSkillsRoomId, APP_BOXEL_ACTIVE_LLM, "");
+			assert.strictEqual(typeof activeLLMState.toolsSupported, "boolean", "New room active LLM event includes toolsSupported metadata");
+			assert.true(Object.prototype.hasOwnProperty.call(activeLLMState, "reasoningEffort"), "New room active LLM event includes reasoningEffort metadata");
+		}
+		await click("[data-test-skill-menu][data-test-pill-menu-button]");
+		await waitFor("[data-test-skill-menu]");
+		await waitUntil(() => document.querySelectorAll("[data-test-skill-menu] [data-test-attached-card]")?.length === 2);
+		assert.dom(`[data-test-skill-menu] [data-test-attached-card="${testRealmURL}Skill/example"]`).exists();
+		assert.dom(`[data-test-skill-menu] [data-test-attached-card="${testRealmURL}Skill/example2"]`).exists();
+		assert.dom(`[data-test-skill-toggle="${testRealmURL}Skill/example-on"`).exists();
+		assert.dom(`[data-test-skill-toggle="${testRealmURL}Skill/example2-off"`).exists();
+		await fillIn("[data-test-message-field]", "Enabling create new session button");
+		await click("[data-test-send-message-btn]");
+		let roomsBeforeNewSession = getRoomIds();
+		await waitFor("[data-test-create-room-btn]:not([disabled])");
+		await click("[data-test-create-room-btn]");
+		await waitFor("[data-room-settled]");
+		let newlyCreatedRoomId = getRoomIds().find((roomId) => !roomsBeforeNewSession.includes(roomId));
+		assert.ok(newlyCreatedRoomId, "Creating a new session creates a new room");
+		if (newlyCreatedRoomId) {
+			let activeLLMState = getRoomState(newlyCreatedRoomId, APP_BOXEL_ACTIVE_LLM, "");
+			assert.strictEqual(typeof activeLLMState.toolsSupported, "boolean", "Newly created room includes toolsSupported metadata");
+			assert.true(Object.prototype.hasOwnProperty.call(activeLLMState, "reasoningEffort"), "Newly created room includes reasoningEffort metadata");
+		}
+		await click("[data-test-skill-menu][data-test-pill-menu-button]");
+		await waitFor("[data-test-skill-menu]");
+		try {
+			await waitUntil(() => document.querySelectorAll("[data-test-skill-menu] [data-test-attached-card]")?.length === 1);
+		} catch {
+			let attached = Array.from(document.querySelectorAll("[data-test-skill-menu] [data-test-attached-card]")).map((el) => el.getAttribute("data-test-attached-card"));
+			assert.ok(false, `Default skill never rendered on the new session's skill menu. Attached cards seen: ${JSON.stringify(attached)}; expected exactly [${envSkillId}].`);
+			return;
+		}
+		assert.dom("[data-test-skill-menu] [data-test-attached-card]").exists({ count: 1 });
+		assert.dom(`[data-test-skill-menu] [data-test-attached-card="${envSkillId}"]`).exists();
+	});
+	(0, import_qunit.test)("ask/act toggle defaults to ask on new session", async function(assert) {
+		await visitOperatorMode({ stacks: [[{
+			id: `${testRealmURL}index`,
+			format: "isolated"
+		}]] });
+		await click("[data-test-open-ai-assistant]");
+		await waitFor("[data-room-settled]");
+		assert.dom("[data-test-llm-mode-option=\"ask\"]").hasClass("selected", "Ask is selected by default on new session");
+		assert.dom("[data-test-llm-mode-option=\"act\"]").doesNotHaveClass("selected", "Act is not selected by default");
+	});
+	(0, import_qunit.test)("new session inherits llm mode from current room", async function(assert) {
+		await visitOperatorMode({ stacks: [[{
+			id: `${testRealmURL}index`,
+			format: "isolated"
+		}]] });
+		await click("[data-test-open-ai-assistant]");
+		await waitFor("[data-room-settled]");
+		await click("[data-test-llm-mode-option=\"act\"]");
+		assert.dom("[data-test-llm-mode-option=\"act\"]").hasClass("selected", "LLM mode is set to act");
+		await fillIn("[data-test-message-field]", "Enable create new session button");
+		await click("[data-test-send-message-btn]");
+		let roomsBeforeNewSession = getRoomIds();
+		await waitFor("[data-test-create-room-btn]:not([disabled])");
+		await click("[data-test-create-room-btn]");
+		await waitFor("[data-room-settled]");
+		let newlyCreatedRoomId = getRoomIds().find((roomId) => !roomsBeforeNewSession.includes(roomId));
+		assert.ok(newlyCreatedRoomId, "Creating a new session creates a new room");
+		if (newlyCreatedRoomId) {
+			let llmModeState = getRoomState(newlyCreatedRoomId, APP_BOXEL_LLM_MODE, "");
+			assert.strictEqual(llmModeState?.mode, "act", "New session inherits LLM mode from current room");
+		}
+	});
+	(0, import_qunit.test)("copies file history when creating new session with option checked", async function(assert) {
+		await visitOperatorMode({
+			submode: "interact",
+			stacks: [[{
+				id: `${testRealmURL}index`,
+				format: "isolated"
+			}]]
+		});
+		await click("[data-test-open-ai-assistant]");
+		await waitFor(`[data-room-settled]`);
+		await fillIn("[data-test-message-field]", "Message with card");
+		await selectCardFromCatalog(`${testRealmURL}Person/hassan`);
+		await click("[data-test-send-message-btn]");
+		await fillIn("[data-test-message-field]", "Message with file");
+		await click("[data-test-attach-button]");
+		await click("[data-test-attach-file-btn]");
+		await click("[data-test-file=\"pet.gts\"]");
+		await click("[data-test-choose-file-modal-add-button]");
+		await click("[data-test-send-message-btn]");
+		await fillIn("[data-test-message-field]", "Message with another card");
+		await selectCardFromCatalog(`${testRealmURL}Pet/mango`);
+		await click("[data-test-send-message-btn]");
+		assertMessages(assert, [
+			{
+				from: "testuser",
+				message: "Message with card",
+				cards: [{
+					id: `${testRealmURL}Person/hassan`,
+					cardTitle: "Hassan"
+				}]
+			},
+			{
+				from: "testuser",
+				message: "Message with file",
+				files: [{
+					sourceUrl: `${testRealmURL}pet.gts`,
+					name: "pet.gts"
+				}]
+			},
+			{
+				from: "testuser",
+				message: "Message with another card",
+				cards: [{
+					id: `${testRealmURL}Pet/mango`,
+					cardTitle: "Mango"
+				}]
+			}
+		]);
+		await click("[data-test-create-room-btn]", { shiftKey: true });
+		await click("[data-test-new-session-settings-option=\"Copy File History\"]");
+		await click("[data-test-new-session-settings-create-button]");
+		await waitFor(`[data-room-settled]`);
+		await waitForSessionPreparationToFinish();
+		await waitUntil(() => {
+			return document.querySelectorAll("[data-test-message-idx]").length === 1;
+		});
+		assertMessages(assert, [{
+			from: "testuser",
+			message: "This session includes files and cards from the previous conversation for context.",
+			cards: [{
+				id: `${testRealmURL}Person/hassan`,
+				cardTitle: "Hassan"
+			}, {
+				id: `${testRealmURL}Pet/mango`,
+				cardTitle: "Mango"
+			}],
+			files: [{
+				sourceUrl: `${testRealmURL}pet.gts`,
+				name: "pet.gts"
+			}]
+		}]);
+	});
+	(0, import_qunit.test)("summarizes current session when creating new session with option checked", async function(assert) {
+		await visitOperatorMode({
+			submode: "interact",
+			stacks: [[{
+				id: `${testRealmURL}index`,
+				format: "isolated"
+			}]]
+		});
+		await click("[data-test-open-ai-assistant]");
+		await waitFor(`[data-room-settled]`);
+		await fillIn("[data-test-message-field]", "Hello, I need help with my project");
+		await click("[data-test-send-message-btn]");
+		await fillIn("[data-test-message-field]", "I want to create a new card for a person");
+		await click("[data-test-send-message-btn]");
+		await fillIn("[data-test-message-field]", "The person should have a name and age field");
+		await click("[data-test-send-message-btn]");
+		assertMessages(assert, [
+			{
+				from: "testuser",
+				message: "Hello, I need help with my project"
+			},
+			{
+				from: "testuser",
+				message: "I want to create a new card for a person"
+			},
+			{
+				from: "testuser",
+				message: "The person should have a name and age field"
+			}
+		]);
+		await click("[data-test-create-room-btn]", { shiftKey: true });
+		await click("[data-test-new-session-settings-option=\"Summarize Current Session\"]");
+		await click("[data-test-new-session-settings-create-button]");
+		await waitFor(`[data-room-settled]`);
+		await waitForSessionPreparationToFinish();
+		await waitUntil(() => document.querySelectorAll("[data-test-message-idx]").length >= 1, {
+			timeout: 5e3,
+			timeoutMessage: "timed out waiting for summary message to arrive in new session"
+		});
+		assertMessages(assert, [{
+			from: "testuser",
+			message: "This is a summary of the previous conversation that should be included as context for our discussion: This conversation focused on project help, specifically creating a new card for a person with name and age fields. The user requested assistance with card creation and field definition."
+		}]);
+	});
+	(0, import_qunit.test)("summarizes current session with cards and files when creating new session", async function(assert) {
+		await visitOperatorMode({
+			submode: "interact",
+			stacks: [[{
+				id: `${testRealmURL}index`,
+				format: "isolated"
+			}]]
+		});
+		await click("[data-test-open-ai-assistant]");
+		await waitFor(`[data-room-settled]`);
+		await fillIn("[data-test-message-field]", "I have a person card here");
+		await selectCardFromCatalog(`${testRealmURL}Person/hassan`);
+		await click("[data-test-send-message-btn]");
+		await fillIn("[data-test-message-field]", "And here is the pet definition file");
+		await click("[data-test-attach-button]");
+		await click("[data-test-attach-file-btn]");
+		await click("[data-test-file=\"pet.gts\"]");
+		await click("[data-test-choose-file-modal-add-button]");
+		await click("[data-test-send-message-btn]");
+		await fillIn("[data-test-message-field]", "Can you help me understand this structure?");
+		await click("[data-test-send-message-btn]");
+		await waitFor(`[data-room-settled]`);
+		assertMessages(assert, [
+			{
+				from: "testuser",
+				message: "I have a person card here",
+				cards: [{
+					id: `${testRealmURL}Person/hassan`,
+					cardTitle: "Hassan"
+				}]
+			},
+			{
+				from: "testuser",
+				message: "And here is the pet definition file",
+				files: [{
+					sourceUrl: `${testRealmURL}pet.gts`,
+					name: "pet.gts"
+				}]
+			},
+			{
+				from: "testuser",
+				message: "Can you help me understand this structure?"
+			}
+		]);
+		await click("[data-test-create-room-btn]", { shiftKey: true });
+		await click("[data-test-new-session-settings-option=\"Summarize Current Session\"]");
+		await click("[data-test-new-session-settings-create-button]");
+		await waitFor(`[data-room-settled]`);
+		await waitForSessionPreparationToFinish();
+		await waitUntil(() => document.querySelectorAll("[data-test-message-idx]").length >= 1, { timeoutMessage: "timed out waiting for summary message to arrive in new session" });
+		assertMessages(assert, [{
+			from: "testuser",
+			message: "This is a summary of the previous conversation that should be included as context for our discussion: This conversation involved discussing a person card (Hassan) and a pet definition file. The user shared both a Person card and a pet.gts file, then asked for help understanding the structure."
+		}]);
+	});
+	(0, import_qunit.test)("handles summarization error gracefully when creating new session", async function(assert) {
+		await visitOperatorMode({
+			submode: "interact",
+			stacks: [[{
+				id: `${testRealmURL}index`,
+				format: "isolated"
+			}]]
+		});
+		await click("[data-test-open-ai-assistant]");
+		await waitFor(`[data-room-settled]`);
+		await fillIn("[data-test-message-field]", "Test message for summarization");
+		await click("[data-test-send-message-btn]");
+		const originalRequestForward = getService("realm-server").requestForward;
+		getService("realm-server").requestForward = async () => {
+			throw new Error("Summarization service unavailable");
+		};
+		await click("[data-test-create-room-btn]", { shiftKey: true });
+		await click("[data-test-new-session-settings-option=\"Summarize Current Session\"]");
+		await click("[data-test-new-session-settings-create-button]");
+		await waitFor(`[data-room-settled]`);
+		await waitForSessionPreparationToFinish();
+		assertMessages(assert, []);
+		getService("realm-server").requestForward = originalRequestForward;
+	});
+	(0, import_qunit.test)("skip button skips session preparation and shows correct wording", async function(assert) {
+		const matrixService = getService("matrix-service");
+		const originalGetPromptParts = matrixService.getPromptParts;
+		let summarizationDeferred = new Deferred();
+		matrixService.getPromptParts = async (roomId) => {
+			await summarizationDeferred.promise;
+			return originalGetPromptParts.call(matrixService, roomId);
+		};
+		await visitOperatorMode({
+			submode: "interact",
+			stacks: [[{
+				id: `${testRealmURL}index`,
+				format: "isolated"
+			}]]
+		});
+		await click("[data-test-open-ai-assistant]");
+		await waitFor(`[data-room-settled]`);
+		await fillIn("[data-test-message-field]", "Test message for summarization");
+		await click("[data-test-send-message-btn]");
+		await click("[data-test-create-room-btn]", { shiftKey: true });
+		await click("[data-test-new-session-settings-option=\"Summarize Current Session\"]");
+		await click("[data-test-new-session-settings-create-button]");
+		try {
+			await waitFor("[data-test-session-preparation]");
+			assert.dom("[data-test-session-preparation]").includesText("Summarizing previous session");
+			assert.dom("[data-test-session-preparation]").includesText("Takes 10-20 seconds");
+			await waitFor("[data-test-session-preparation-skip-button]");
+			assert.dom("[data-test-session-preparation-skip-button]").hasText("Skip");
+			await click("[data-test-session-preparation-skip-button]");
+			await waitFor("[data-test-session-preparation]", { count: 0 });
+			await waitFor("[data-test-message-field]");
+			await waitUntil(() => {
+				let field = document.querySelector("[data-test-message-field]");
+				return Boolean(field && !field.hasAttribute("disabled"));
+			});
+			assert.dom("[data-test-message-field]").isNotDisabled();
+			assertMessages(assert, []);
+		} finally {
+			summarizationDeferred.fulfill();
+			matrixService.getPromptParts = originalGetPromptParts;
+		}
+	});
+	(0, import_qunit.test)("ai assistant panel width persists to localStorage", async function(assert) {
+		src_default.localStorage.removeItem("ai-assistant-panel-width");
+		const testWidth = 60;
+		src_default.localStorage.setItem("ai-assistant-panel-width", String(testWidth));
+		let operatorModeStateParam = wrapper_default({
+			stacks: [[{
+				id: `${testRealmURL}index`,
+				format: "isolated"
+			}]],
+			aiAssistantOpen: true
+		});
+		await visit(`/?operatorModeEnabled=true&operatorModeState=${encodeURIComponent(operatorModeStateParam)}`);
+		assert.dom("[data-test-ai-assistant-panel]").exists();
+		let aiAssistantPanel = document.querySelector("[data-test-ai-assistant-panel]");
+		assert.ok(aiAssistantPanel, "AI assistant panel should exist");
+		let initialWidth = aiAssistantPanel.getBoundingClientRect().width;
+		assert.ok(initialWidth > 0, "AI assistant panel should have a width");
+		let submodeLayout = document.querySelector("[data-test-submode-layout]");
+		assert.ok(submodeLayout, "submode layout should exist");
+		let actualPercentageWidth = initialWidth / submodeLayout.getBoundingClientRect().width * 100;
+		let storedWidth = src_default.localStorage.getItem("ai-assistant-panel-width");
+		assert.ok(storedWidth, "Width should be in localStorage");
+		assert.strictEqual(Number(storedWidth), testWidth, "Stored width should match the test width");
+		assert.ok(Math.abs(actualPercentageWidth - testWidth) < 5, `Actual panel width percentage (${actualPercentageWidth.toFixed(1)}%) should be close to stored width (${testWidth}%)`);
+		let resizeHandle = document.querySelector("[data-boxel-panel-resize-handle-id]");
+		assert.ok(resizeHandle, "Resize handle should exist");
+		let resizeHandleRect = resizeHandle.getBoundingClientRect();
+		await triggerEvent(resizeHandle, "pointerdown", {
+			clientX: resizeHandleRect.x,
+			clientY: resizeHandleRect.y
+		});
+		await triggerEvent(resizeHandle, "pointermove", {
+			clientX: resizeHandleRect.x + 20,
+			clientY: resizeHandleRect.y
+		});
+		await triggerEvent(resizeHandle, "pointerup");
+		await waitFor("[data-test-ai-assistant-panel]");
+		let updatedStoredWidth = src_default.localStorage.getItem("ai-assistant-panel-width");
+		assert.ok(updatedStoredWidth, "Width should still be in localStorage after resize");
+		let updatedParsedWidth = Number(updatedStoredWidth);
+		assert.ok(updatedParsedWidth > 0, "Updated width should be a positive number");
+		assert.ok(updatedParsedWidth <= 100, "Updated width should be a percentage (<= 100)");
+		assert.notStrictEqual(updatedParsedWidth, testWidth, "Width should have changed after resize");
+		let resizedWidth = aiAssistantPanel.getBoundingClientRect().width;
+		assert.ok(resizedWidth > 0, "AI assistant panel should still have a width after resize");
+	});
+	(0, import_qunit.test)("creates new session with settings even when empty new session exists", async function(assert) {
+		await visitOperatorMode({ stacks: [[{
+			id: `${testRealmURL}index`,
+			format: "isolated"
+		}]] });
+		await click("[data-test-open-ai-assistant]");
+		await waitFor(`[data-room-settled]`);
+		await fillIn("[data-test-message-field]", "First message with card");
+		await selectCardFromCatalog(`${testRealmURL}Person/hassan`);
+		await click("[data-test-send-message-btn]");
+		await fillIn("[data-test-message-field]", "Second message with file");
+		await click("[data-test-attach-button]");
+		await click("[data-test-attach-file-btn]");
+		await click("[data-test-file=\"pet.gts\"]");
+		await click("[data-test-choose-file-modal-add-button]");
+		await click("[data-test-send-message-btn]");
+		await fillIn("[data-test-message-field]", "Third message with another card");
+		await selectCardFromCatalog(`${testRealmURL}Pet/mango`);
+		await click("[data-test-send-message-btn]");
+		assertMessages(assert, [
+			{
+				from: "testuser",
+				message: "First message with card",
+				cards: [{
+					id: `${testRealmURL}Person/hassan`,
+					cardTitle: "Hassan"
+				}]
+			},
+			{
+				from: "testuser",
+				message: "Second message with file",
+				files: [{
+					sourceUrl: `${testRealmURL}pet.gts`,
+					name: "pet.gts"
+				}]
+			},
+			{
+				from: "testuser",
+				message: "Third message with another card",
+				cards: [{
+					id: `${testRealmURL}Pet/mango`,
+					cardTitle: "Mango"
+				}]
+			}
+		]);
+		const matrixService = getService("matrix-service");
+		const firstRoomId = matrixService.currentRoomId;
+		assert.ok(firstRoomId, "Should have first room ID");
+		await click("[data-test-create-room-btn]");
+		await waitFor(`[data-room-settled]`);
+		const secondRoomId = matrixService.currentRoomId;
+		assert.ok(secondRoomId, "Should have second room ID");
+		assert.notStrictEqual(secondRoomId, firstRoomId, "Second room should be different from first room");
+		await click("[data-test-past-sessions-button]");
+		await waitFor(`[data-test-enter-room="${firstRoomId}"]`);
+		await click(`[data-test-enter-room="${firstRoomId}"]`);
+		await waitFor(`[data-room-settled]`);
+		assert.strictEqual(matrixService.currentRoomId, firstRoomId, "Should be back in the first room");
+		assertMessages(assert, [
+			{
+				from: "testuser",
+				message: "First message with card",
+				cards: [{
+					id: `${testRealmURL}Person/hassan`,
+					cardTitle: "Hassan"
+				}]
+			},
+			{
+				from: "testuser",
+				message: "Second message with file",
+				files: [{
+					sourceUrl: `${testRealmURL}pet.gts`,
+					name: "pet.gts"
+				}]
+			},
+			{
+				from: "testuser",
+				message: "Third message with another card",
+				cards: [{
+					id: `${testRealmURL}Pet/mango`,
+					cardTitle: "Mango"
+				}]
+			}
+		]);
+		await click("[data-test-create-room-btn]", { shiftKey: true });
+		await click("[data-test-new-session-settings-option=\"Copy File History\"]");
+		await click("[data-test-new-session-settings-create-button]");
+		await waitFor(`[data-room-settled]`);
+		await waitForSessionPreparationToFinish();
+		await waitFor("[data-test-user-message]");
+		const thirdRoomId = matrixService.currentRoomId;
+		assert.ok(thirdRoomId, "Should have third room ID");
+		assert.notStrictEqual(thirdRoomId, firstRoomId, "Third room should be different from first room");
+		assert.notStrictEqual(thirdRoomId, secondRoomId, "Third room should be different from second room");
+		assertMessages(assert, [{
+			from: "testuser",
+			message: "This session includes files and cards from the previous conversation for context.",
+			cards: [{
+				id: `${testRealmURL}Person/hassan`,
+				cardTitle: "Hassan"
+			}, {
+				id: `${testRealmURL}Pet/mango`,
+				cardTitle: "Mango"
+			}],
+			files: [{
+				sourceUrl: `${testRealmURL}pet.gts`,
+				name: "pet.gts"
+			}]
+		}]);
+	});
+	(0, import_qunit.test)("restores chat input of unsent messages", async function(assert) {
+		await visitOperatorMode({ stacks: [[{
+			id: `${testRealmURL}index`,
+			format: "isolated"
+		}]] });
+		await click("[data-test-open-ai-assistant]");
+		await waitFor(`[data-room-settled]`);
+		const matrixService = getService("matrix-service");
+		await waitFor(`[data-room-settled]`);
+		let firstRoomId = matrixService.currentRoomId;
+		assert.ok(firstRoomId, "Should have an initial room ID");
+		if (!firstRoomId) throw new Error("Missing room ID for initial session");
+		await waitFor(`[data-test-message-field="${firstRoomId}"]`);
+		await fillIn(`[data-test-message-field="${firstRoomId}"]`, "hey, could you do something for me?");
+		await click("[data-test-send-message-btn]");
+		await fillIn(`[data-test-message-field="${firstRoomId}"]`, "how old is the sun?");
+		await click("[data-test-create-room-btn]");
+		await waitFor(`[data-room-settled]`);
+		let secondRoomId = matrixService.currentRoomId;
+		assert.ok(secondRoomId, "Should have a second room ID");
+		if (!secondRoomId) throw new Error("Missing room ID for new session");
+		assert.notStrictEqual(secondRoomId, firstRoomId, "Second room should be different from first room");
+		await waitFor(`[data-test-message-field="${secondRoomId}"]`);
+		assert.dom(`[data-test-message-field="${secondRoomId}"]`).hasValue("", "New room starts with an empty chat input");
+		await click("[data-test-past-sessions-button]");
+		await waitFor(`[data-test-enter-room="${firstRoomId}"]`);
+		await click(`[data-test-enter-room="${firstRoomId}"]`);
+		await waitFor(`[data-room-settled]`);
+		await waitUntil(() => matrixService.currentRoomId === firstRoomId);
+		await waitFor(`[data-test-message-field="${firstRoomId}"]`);
+		assert.dom(`[data-test-message-field="${firstRoomId}"]`).hasValue("how old is the sun?", "Draft message is restored when returning to the original room");
+	});
+	(0, import_qunit.test)("shows an error and persists the prompt in case the message failed to send", async function(assert) {
+		await visitOperatorMode({ stacks: [[{
+			id: `${testRealmURL}index`,
+			format: "isolated"
+		}]] });
+		await click("[data-test-open-ai-assistant]");
+		await waitFor(`[data-room-settled]`);
+		const matrixService = getService("matrix-service");
+		let roomId = matrixService.currentRoomId;
+		assert.ok(roomId, "Should have a room ID");
+		if (!roomId) throw new Error("Missing room ID for message failure test");
+		await waitFor(`[data-test-message-field="${roomId}"]`);
+		const originalSendMessage = matrixService.sendMessage;
+		let sendAttempts = 0;
+		matrixService.sendMessage = async function(..._args) {
+			sendAttempts++;
+			throw new Error("Intentional failure for test");
+		};
+		const failingMessage = "This message should trigger an error";
+		try {
+			await fillIn(`[data-test-message-field="${roomId}"]`, failingMessage);
+			await waitUntil(() => matrixService.getMessageToSend(roomId) === failingMessage);
+			await click("[data-test-send-message-btn]");
+			await waitFor("[data-test-boxel-alert=\"error\"]");
+			assert.strictEqual(sendAttempts, 1, "sendMessage was attempted once");
+			assert.dom("[data-test-boxel-alert=\"error\"] [data-test-alert-message=\"0\"]").hasText("There was an error sending your message. This could be due to network issues, or serialization issues with the cards or files you are trying to send. It might be helpful to refresh the page and try again.");
+			await waitUntil(() => matrixService.getMessageToSend(roomId) === failingMessage);
+			assert.dom(`[data-test-message-field="${roomId}"]`).hasValue(failingMessage, "Draft message is restored after a failed send attempt");
+		} finally {
+			matrixService.sendMessage = originalSendMessage;
+		}
+	});
+});
+//#endregion