@cardstack/boxel-cli 0.9.0 → 0.10.0-unstable.0

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

@@ -0,0 +1,2211 @@
+import { s as __toESM } from "./chunk-Rp0pCe6z.js";
+import { r as initializeDeferredDecorator, t as decorateFieldV2 } from "./runtime--fcdnjmJ-BoCBNIsz.js";
+import { Ar as testRealmURL, Bn as APP_BOXEL_LLM_MODE, Sc as Deferred, Ss as wrapper_default, Vn as APP_BOXEL_MESSAGE_MSGTYPE, jn as APP_BOXEL_ACTIVE_LLM, qn as APP_BOXEL_REASONING_CONTENT_KEY, uo as SupportedMimeType } from "./runtime-common-ClpqhbwG.js";
+import { y as rri } from "./paths-BYHDgqsT.js";
+import { D as baseRealm, E as baseRRI, J as skillCardRef } from "./constants-CqKWhRfY.js";
+import { wt as setComponentTemplate } from "./cache-DtDz7X5V-Wn8jRDfL.js";
+import { H as templateFactory } from "./index-DaCZcoCY-CgzbilMy.js";
+import { n as src_default } from "./src-DPaAwa4H.js";
+import { t as AiAssistantMessageDrafts } from "./local-storage-keys-CS7XLz7J.js";
+import "./component-BJO47HTh.js";
+import "./template-factory-ds9s0u8l.js";
+import { O as GridContainer } from "./components-Ct_agx0G.js";
+import { a as skillsIndexId, o as skillsRealmURL, t as catalogRealmURL } from "./utils-DZFRsMFd.js";
+import { M as waitUntil, d as click, k as visit, l as triggerEvent, o as waitFor, s as fillIn } from "./dist-BOAdzfkP.js";
+import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
+import { D as realmConfigCardJSON, F as setupLocalIndexing, I as setupOnSave, L as setupRealmCacheTeardown, R as setupRealmServerEndpoints, S as getMonacoContent, Z as withCachedRealmSetup, a as SYSTEM_CARD_FIXTURE_CONTENTS, ct as setupApplicationTest, g as delay, i as getRoomIdForRealmAndUser, j as setupAcceptanceTestRealm, o as addSkillToAiAssistant, pt as setupAuthEndpoints, s as assertMessages, st as visitOperatorMode, t as setupMockMatrix, z as setupUserSubscription } from "./mock-matrix-DPQ0j2MD.js";
+import { r as getService } from "./dist-CPfIHBla.js";
+import { A as field, H as linksTo, U as linksToMany, a as CardDef, o as CardInfoField, s as Component, w as contains } from "./card-api-Dzje0smT.js";
+import { t as string_default } from "./string-BHZZwNlZ.js";
+import { t as CardsGrid } from "./cards-grid-CWG41hZE.js";
+import { C as ModelConfiguration, R as SystemCard, vt as setupBaseRealm } from "./base-realm-B17zVqh6.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-item-button="${cardId}"]`);
+	await click("[data-test-card-chooser-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 '@cardstack/base/card-api';
+  import StringField from '@cardstack/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);
+	setupRealmCacheTeardown(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();
+			const contentText = (content) => {
+				if (typeof content === "string") return content;
+				if (Array.isArray(content)) return content.filter((part) => part.type === "text").map((part) => part.text ?? "").join("");
+				return "";
+			};
+			if (body.url.includes("openrouter.ai/api/v1/chat/completions")) {
+				const requestBody = JSON.parse(body.requestBody);
+				if (requestBody.messages && requestBody.messages.some((msg) => contentText(msg.content).includes("Please provide a concise summary"))) {
+					const conversationText = requestBody.messages.filter((msg) => msg.role === "user" && !contentText(msg.content).includes("Please provide a concise summary")).map((msg) => contentText(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(string_default);
+				});
+			}
+			#name = (initializeDeferredDecorator(this, "name"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "favoriteTreat", [field], function() {
+					return contains(string_default);
+				});
+			}
+			#favoriteTreat = (initializeDeferredDecorator(this, "favoriteTreat"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "cardTitle", [field], function() {
+					return contains(string_default, { 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(string_default);
+				});
+			}
+			#firstName = (initializeDeferredDecorator(this, "firstName"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "lastName", [field], function() {
+					return contains(string_default);
+				});
+			}
+			#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(string_default, { 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(string_default, { 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 withCachedRealmSetup(async () => {
+			await setupAcceptanceTestRealm({
+				mockMatrixUtils,
+				contents: {
+					...SYSTEM_CARD_FIXTURE_CONTENTS,
+					"person.gts": { Person },
+					"pet.gts": { Pet },
+					"broken-card.gts": `
+          import { CardDef, field, contains } from '@cardstack/base/card-api';
+          import StringField from '@cardstack/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 '@cardstack/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: "@cardstack/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: "/test-fixtures/realm-images/pawel-czerwinski-Ly-ZLa-A5jti-Y-unsplash.jpg",
+						iconURL: "/test-fixtures/realm-images/boxel-logo.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)("\"Go to current system card\" closes the workspace chooser", async function(assert) {
+		await visitOperatorMode({
+			workspaceChooserOpened: true,
+			stacks: [[{
+				id: `${testRealmURL}index`,
+				format: "isolated"
+			}]]
+		});
+		assert.dom("[data-test-workspace-chooser]").exists("workspace chooser is open");
+		await click("[data-test-open-ai-assistant]");
+		await waitFor("[data-room-settled]");
+		await click("[data-test-llm-select-selected]");
+		await click("[data-test-go-to-system-card]");
+		assert.dom("[data-test-workspace-chooser]").doesNotExist("workspace chooser is closed after going to system card");
+		assert.dom(`[data-test-stack-card="${testRealmURL}SystemCard/default"]`).exists("the system card is shown on the stack");
+		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)("auto-attaches the module of a card whose adoptsFrom is prefix-form", async function(assert) {
+		await visitOperatorMode({
+			submode: "code",
+			codePath: `${testRealmURL}index.json`,
+			stacks: [[]]
+		});
+		await click("[data-test-open-ai-assistant]");
+		await waitFor(`[data-room-settled]`);
+		let indexJSON = await (await getService("network").authedFetch(`${testRealmURL}index.json`, { headers: { Accept: SupportedMimeType.CardSource } })).json();
+		assert.strictEqual(indexJSON.data.meta.adoptsFrom.module, "@cardstack/base/cards-grid", "the fixture adopts from a prefix-form module");
+		let cardsGridModuleURL = getService("network").virtualNetwork.toURL(rri("@cardstack/base/cards-grid.gts")).href;
+		assert.dom("[data-test-autoattached-file]").exists({ count: 2 });
+		assert.dom(`[data-test-attached-file="${testRealmURL}index.json"][data-test-autoattached-file]`).exists();
+		assert.dom(`[data-test-attached-file="${cardsGridModuleURL}"][data-test-autoattached-file]`).exists("the prefix-form module resolves to the base realm");
+	});
+	(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-item-button="${baseRealm.url}types/card"]`);
+		await click(`[data-test-card-chooser-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 = await waitFor("[data-test-past-sessions] [data-test-panel-popover-body]");
+		pastSessionsElement.scrollTop = pastSessionsElement.scrollHeight;
+		await triggerEvent(pastSessionsElement, "scroll");
+		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)("ai assistant panel is closed by default when the URL omits aiAssistantOpen", async function(assert) {
+		let operatorModeStateParam = wrapper_default({ stacks: [[{
+			id: `${testRealmURL}index`,
+			format: "isolated"
+		}]] });
+		await visit(`/?operatorModeEnabled=true&operatorModeState=${encodeURIComponent(operatorModeStateParam)}`);
+		assert.dom("[data-test-ai-assistant-panel]").doesNotExist();
+		assert.false(getService("operator-mode-state-service").aiAssistantOpen, "panel is closed by default with no URL param and no persisted preference");
+	});
+	(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-item-button="${testRealmURL}Pet/mango"]`);
+		await click("[data-test-card-chooser-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)("code mode context names a base module by its prefix form", async function(assert) {
+		let { virtualNetwork } = getService("network");
+		await visitOperatorMode({
+			submode: "code",
+			codePath: virtualNetwork.toURLHref(baseRRI("card-api.gts")),
+			stacks: [[]]
+		});
+		await click("[data-test-open-ai-assistant]");
+		await waitFor(`[data-room-settled]`);
+		await fillIn("[data-test-message-field]", `Message`);
+		await click("[data-test-send-message-btn]");
+		let roomEvents = mockMatrixUtils.getRoomEvents(matrixRoomId);
+		let contextSent = JSON.parse(roomEvents[roomEvents.length - 1].content.data).context;
+		assert.strictEqual(contextSent.codeMode.currentFile, baseRRI("card-api.gts"), "currentFile is the prefix form");
+		assert.strictEqual(contextSent.realmPrefixes?.[baseRRI("")], virtualNetwork.toURLHref(baseRRI("")), "the context maps the base prefix to the URL it is served from");
+	});
+	(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-item-button="${autoAttachedSpecId}"]`);
+			await click("[data-test-card-chooser-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-item-button="${autoAttachedSpecId}"]`);
+		await click("[data-test-card-chooser-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 [${skillsIndexId}].`);
+			return;
+		}
+		assert.dom("[data-test-skill-menu] [data-test-attached-card]").exists({ count: 1 });
+		assert.dom(`[data-test-skill-menu] [data-test-attached-card="${skillsIndexId}"]`).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)("failed send leaves a failed bubble + retry alert; input clears at click-time", 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-user-message]").exists({ count: 1 });
+			assert.dom("[data-test-card-error]").containsText("Failed to send");
+			assert.dom("[data-test-alert-action-button=\"Retry\"]").exists();
+			assert.dom(`[data-test-message-field="${roomId}"]`).hasValue("", "input clears at click-time — the message lives in the bubble now");
+		} finally {
+			matrixService.sendMessage = originalSendMessage;
+		}
+	});
+});
+//#endregion