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

package/bundled-test-harness/assets/tools-test-Cvau5219.js

@@ -0,0 +1,3204 @@
+import { s as __toESM } from "./chunk-Rp0pCe6z.js";
+import { r as initializeDeferredDecorator, t as decorateFieldV2 } from "./runtime--fcdnjmJ-BoCBNIsz.js";
+import { Bn as APP_BOXEL_CONTINUATION_OF_CONTENT_KEY, Br as testRealmURL, Jo as isCardInstance, Kn as APP_BOXEL_MESSAGE_MSGTYPE, Rc as Deferred, Un as APP_BOXEL_EXTERNAL_FIELDS_KEY, Wn as APP_BOXEL_HAS_CONTINUATION_CONTENT_KEY, Wr as AI_BOT_EXECUTOR, Yr as buildToolFunctionNameFromResolvedRef, ar as APP_BOXEL_TOOL_REQUESTS_KEY, cr as APP_BOXEL_TOOL_RESULT_WITH_NO_OUTPUT_MSGTYPE, lr as APP_BOXEL_TOOL_RESULT_WITH_OUTPUT_MSGTYPE, or as APP_BOXEL_TOOL_RESULT_EVENT_TYPE, rr as APP_BOXEL_STOP_GENERATING_EVENT_TYPE, sr as APP_BOXEL_TOOL_RESULT_REL_TYPE, tr as APP_BOXEL_RESPONSE_STREAM_EVENT_TYPE } from "./runtime-common-BTaLJEw-.js";
+import { T as rri } from "./paths-C9-NYXnM.js";
+import { q as skillCardRef } from "./constants-Icc0nFW-.js";
+import { t as config } from "./environment-DIUJgBKt.js";
+import { wt as setComponentTemplate } from "./cache-DtDz7X5V-Wn8jRDfL.js";
+import { H as templateFactory } from "./index-DaCZcoCY-CgzbilMy.js";
+import { n as Submodes } from "./submode-switcher-BpDa9Rui.js";
+import "./component-BJO47HTh.js";
+import { t as Component } from "./dist-CkA1rgqO.js";
+import "./template-factory-ds9s0u8l.js";
+import { t as OperatorModeContainer } from "./container-CBZZ8uFw.js";
+import { t as STOPPED_TOOL_CALL_REASON } from "./stop-lrhqMDul.js";
+import { M as waitUntil, T as settled, a as find, d as click, o as waitFor, s as fillIn } from "./dist-BOAdzfkP.js";
+import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
+import { D as realmConfigCardJSON, Et as percySnapshot, F as setupLocalIndexing, I as setupOnSave, L as setupRealmCacheTeardown, M as setupCardLogs, P as setupIntegrationTestRealm, Z as withCachedRealmSetup, g as delay, lt as setupRenderingTest, o as addSkillToAiAssistant, ot as setupOperatorModeStateCleanup, t as setupMockMatrix } from "./mock-matrix-FjsXmU7-.js";
+import { r as getService } from "./dist-CPfIHBla.js";
+import { A as field, H as linksTo, U as linksToMany, a as CardDef, l as FieldDef, s as Component$1, w as contains } from "./card-api-Cc8uZunB.js";
+import { t as string_default } from "./string-5IAMEUit.js";
+import { n as renderComponent } from "./render-component-B15Z0e2v.js";
+//#region tests/integration/components/ai-assistant-panel/e75beeb704.css
+var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
+//#endregion
+//#region tests/integration/components/ai-assistant-panel/tools-test.gts
+function registeredRealmPrefixes() {
+	let { virtualNetwork } = getService("network");
+	return Object.fromEntries(virtualNetwork.knownRealms().map((prefix) => [prefix, virtualNetwork.toURLHref(prefix)]));
+}
+function menuItem(label) {
+	return [...document.querySelectorAll("[data-test-pretui-menu-panel] [role=\"menuitem\"]")].find((row) => row.textContent?.trim() === label);
+}
+(0, import_qunit.module)("Integration | ai-assistant-panel | tools", function(hooks) {
+	const realmName = "Operator Mode Workspace";
+	const readOnlyRealmName = "Read Only Workspace";
+	const readOnlyRealmURL = "http://test-realm/read-only/";
+	const searchCardsToolName = buildToolFunctionNameFromResolvedRef({
+		module: "@cardstack/boxel-host/commands/search-cards",
+		name: "SearchCardsByTypeAndTitleTool"
+	});
+	let loader;
+	let operatorModeStateService;
+	setupRenderingTest(hooks);
+	setupOperatorModeStateCleanup(hooks);
+	hooks.beforeEach(function() {
+		loader = getService("loader-service").loader;
+	});
+	setupLocalIndexing(hooks);
+	setupRealmCacheTeardown(hooks);
+	setupOnSave(hooks);
+	setupCardLogs(hooks, async () => await loader.import("@cardstack/base/card-api"));
+	let mockMatrixUtils = setupMockMatrix(hooks, {
+		loggedInAs: "@testuser:localhost",
+		activeRealms: [testRealmURL, readOnlyRealmURL],
+		realmPermissions: {
+			[testRealmURL]: ["read", "write"],
+			[readOnlyRealmURL]: ["read"]
+		},
+		autostart: true,
+		now: (() => {
+			let clock = new Date(2024, 8, 19).getTime();
+			return () => clock += 10;
+		})()
+	});
+	let { createAndJoinRoom, simulateRemoteMessage, simulateToDeviceEvent, getRoomEvents } = mockMatrixUtils;
+	let noop = () => {};
+	hooks.beforeEach(async function() {
+		operatorModeStateService = getService("operator-mode-state-service");
+		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, "cardTitle", [field], function() {
+					return contains(string_default, { computeVia: function() {
+						return this.name;
+					} });
+				});
+			}
+			#cardTitle = (initializeDeferredDecorator(this, "cardTitle"), void 0);
+			static fitted = class Fitted extends Component$1 {
+				static {
+					setComponentTemplate(templateFactory({
+						"id": "IHMPzHnr",
+						"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/integration/components/ai-assistant-panel/tools-test.gts",
+						"isStrictMode": true
+					}), this);
+				}
+			};
+		}
+		class Address extends FieldDef {
+			static displayName = "Address";
+			static {
+				decorateFieldV2(this.prototype, "city", [field], function() {
+					return contains(string_default);
+				});
+			}
+			#city = (initializeDeferredDecorator(this, "city"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "country", [field], function() {
+					return contains(string_default);
+				});
+			}
+			#country = (initializeDeferredDecorator(this, "country"), void 0);
+			static embedded = class Embedded extends Component$1 {
+				static {
+					setComponentTemplate(templateFactory({
+						"id": "0uTOjQm9",
+						"block": "[[[10,0],[14,\"data-test-address\",\"\"],[12],[1,\"\\n  \"],[10,\"h3\"],[15,\"data-test-city\",[30,1,[\"city\"]]],[12],[1,\"\\n    \"],[8,[30,2,[\"city\"]],null,null,null],[1,\"\\n  \"],[13],[1,\"\\n  \"],[10,\"h3\"],[15,\"data-test-country\",[30,1,[\"country\"]]],[12],[1,\"\\n    \"],[8,[30,2,[\"country\"]],null,null,null],[1,\"\\n  \"],[13],[1,\"\\n\"],[13]],[\"@model\",\"@fields\"],[]]",
+						"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/components/ai-assistant-panel/tools-test.gts",
+						"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, "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() {
+						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;
+					} });
+				});
+			}
+			#cardTitle = (initializeDeferredDecorator(this, "cardTitle"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "address", [field], function() {
+					return contains(Address);
+				});
+			}
+			#address = (initializeDeferredDecorator(this, "address"), void 0);
+			static isolated = class Isolated extends Component$1 {
+				static {
+					setComponentTemplate(templateFactory({
+						"id": "86ylgsLt",
+						"block": "[[[10,\"h2\"],[15,\"data-test-person\",[30,1,[\"firstName\"]]],[14,\"data-scopedcss-a14586af1f-8d94048c9a\",\"\"],[12],[1,\"\\n  \"],[8,[30,2,[\"firstName\"]],[[24,\"data-scopedcss-a14586af1f-8d94048c9a\",\"\"]],null,null],[1,\"\\n\"],[13],[1,\"\\n\"],[10,2],[15,\"data-test-first-letter-of-the-name\",[30,1,[\"firstLetterOfTheName\"]]],[14,\"data-scopedcss-a14586af1f-8d94048c9a\",\"\"],[12],[1,\"\\n  \"],[8,[30,2,[\"firstLetterOfTheName\"]],[[24,\"data-scopedcss-a14586af1f-8d94048c9a\",\"\"]],null,null],[1,\"\\n\"],[13],[1,\"\\nPet:\\n\"],[10,0],[14,0,\"pet-container\"],[14,\"data-scopedcss-a14586af1f-8d94048c9a\",\"\"],[12],[1,\"\\n  \"],[8,[30,2,[\"pet\"]],[[24,\"data-scopedcss-a14586af1f-8d94048c9a\",\"\"]],null,null],[1,\"\\n\"],[13],[1,\"\\nFriends:\\n\"],[8,[30,2,[\"friends\"]],[[24,\"data-scopedcss-a14586af1f-8d94048c9a\",\"\"]],null,null],[1,\"\\n\"],[10,0],[14,\"data-test-addresses\",\"\"],[14,\"data-scopedcss-a14586af1f-8d94048c9a\",\"\"],[12],[1,\"Address: \"],[8,[30,2,[\"address\"]],[[24,\"data-scopedcss-a14586af1f-8d94048c9a\",\"\"]],null,null],[13],[1,\"\\n\"]],[\"@model\",\"@fields\"],[]]",
+						"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/components/ai-assistant-panel/tools-test.gts",
+						"isStrictMode": true
+					}), this);
+				}
+			};
+		}
+		let petMango = new Pet({ name: "Mango" });
+		let petJackie = new Pet({ name: "Jackie" });
+		await withCachedRealmSetup(async () => {
+			await setupIntegrationTestRealm({
+				mockMatrixUtils,
+				contents: {
+					"address.gts": { Address },
+					"hello.txt": "Hello, world!",
+					"person.gts": { Person },
+					"pet.gts": { Pet },
+					"Pet/mango.json": petMango,
+					"Pet/jackie.json": petJackie,
+					"Person/fadhlan.json": new Person({
+						firstName: "Fadhlan",
+						address: new Address({
+							city: "Bandung",
+							country: "Indonesia"
+						}),
+						pet: petMango
+					}),
+					"Person/burcu.json": new Person({
+						firstName: "Burcu",
+						friends: [petJackie, petMango]
+					}),
+					"Person/mickey.json": new Person({ firstName: "Mickey" }),
+					"Person/justin.json": new Person({ firstName: "Justin" }),
+					"Person/ian.json": new Person({ firstName: "Ian" }),
+					"Person/matic.json": new Person({ firstName: "Matic" }),
+					"Person/buck.json": new Person({ firstName: "Buck" }),
+					"Person/hassan.json": new Person({ firstName: "Hassan" }),
+					"Skill/boxel-environment.json": { data: {
+						attributes: {
+							title: "Boxel Environment",
+							description: "Test environment skill",
+							instructions: "Test skill card for environment commands",
+							commands: [
+								{
+									codeRef: {
+										name: "SearchCardsByTypeAndTitleTool",
+										module: "@cardstack/boxel-host/commands/search-cards"
+									},
+									requiresApproval: false
+								},
+								{
+									codeRef: {
+										name: "SearchCardsByQueryTool",
+										module: "@cardstack/boxel-host/commands/search-cards"
+									},
+									requiresApproval: false
+								},
+								{
+									codeRef: {
+										name: "default",
+										module: "@cardstack/boxel-host/commands/read-file-for-ai-assistant"
+									},
+									requiresApproval: false
+								},
+								{
+									codeRef: {
+										name: "default",
+										module: "@cardstack/boxel-host/commands/read-card-for-ai-assistant"
+									},
+									requiresApproval: false
+								}
+							]
+						},
+						meta: { adoptsFrom: skillCardRef }
+					} },
+					"realm.json": realmConfigCardJSON({ name: realmName })
+				}
+			});
+			await setupIntegrationTestRealm({
+				mockMatrixUtils,
+				realmURL: readOnlyRealmURL,
+				contents: {
+					"pet.gts": `
+            import { contains, field, CardDef } from "@cardstack/base/card-api";
+            import StringField from "@cardstack/base/string";
+            export class Pet extends CardDef {
+              static displayName = 'Pet';
+              @field name = contains(StringField);
+            }
+          `,
+					"person.gts": `
+            import { contains, field, linksTo, CardDef } from "@cardstack/base/card-api";
+            import StringField from "@cardstack/base/string";
+            import { Pet } from "./pet";
+            export class Person extends CardDef {
+              static displayName = 'Person';
+              @field firstName = contains(StringField);
+              @field pet = linksTo(Pet);
+            }
+          `,
+					"Person/ian.json": { data: {
+						type: "card",
+						attributes: { firstName: "Ian" },
+						relationships: { pet: { data: {
+							type: "card",
+							id: `${readOnlyRealmURL}Pet/rose`
+						} } },
+						meta: { adoptsFrom: {
+							module: "./person",
+							name: "Person"
+						} }
+					} },
+					"Pet/rose.json": { data: {
+						type: "card",
+						attributes: { name: "Rose" },
+						meta: { adoptsFrom: {
+							module: "./pet",
+							name: "Pet"
+						} }
+					} },
+					"realm.json": realmConfigCardJSON({ name: readOnlyRealmName })
+				}
+			});
+		});
+	});
+	function setCardInOperatorModeState(cardURL, format = "isolated") {
+		operatorModeStateService.restore({ stacks: cardURL ? [[{
+			id: cardURL,
+			format
+		}]] : [[]] });
+	}
+	async function openAiAssistant() {
+		await waitFor("[data-test-open-ai-assistant]");
+		await click("[data-test-open-ai-assistant]");
+		await waitFor("[data-test-room-settled]");
+		let roomId = document.querySelector("[data-test-room]")?.getAttribute("data-test-room");
+		if (!roomId) throw new Error("Expected a room ID");
+		return roomId;
+	}
+	async function renderAiAssistantPanel(id) {
+		setCardInOperatorModeState(id);
+		await renderComponent(class TestDriver extends Component {
+			static {
+				setComponentTemplate(templateFactory({
+					"id": "hk0qKyFP",
+					"block": "[[[8,[32,0],null,[[\"@onClose\"],[[32,1]]],null]],[],[]]",
+					"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/components/ai-assistant-panel/tools-test.gts",
+					"scope": () => [OperatorModeContainer, noop],
+					"isStrictMode": true
+				}), this);
+			}
+		});
+		return await openAiAssistant();
+	}
+	const TOOL_RESULT_TIMEOUT_MS = 1e4;
+	async function waitForToolResult(selector = "[data-test-tool-result-header]") {
+		let startedAt = performance.now();
+		try {
+			await waitFor(selector, { timeout: TOOL_RESULT_TIMEOUT_MS });
+		} catch (e) {
+			let applyButtons = [...document.querySelectorAll("[data-test-tool-call-apply]")].map((el) => el.getAttribute("data-test-tool-call-apply"));
+			console.error(`[tool-result-wait] no ${selector} after ${Math.round(performance.now() - startedAt)}ms; messages=${document.querySelectorAll("[data-test-message-idx]").length}; applyStates=${JSON.stringify(applyButtons)} (a tool that reached "applied" points at the result card load; see any [tool-result-card] lines)`);
+			throw e;
+		}
+		console.log(`[tool-result-wait] ${selector} after ${Math.round(performance.now() - startedAt)}ms`);
+	}
+	(0, import_qunit.test)("it allows chat commands to change cards in the stack", async function(assert) {
+		assert.expect(4);
+		let roomId = await renderAiAssistantPanel(`${testRealmURL}Person/fadhlan`);
+		await waitFor("[data-test-person]");
+		assert.dom("[data-test-boxel-card-header-title]").hasText("Person - Fadhlan");
+		assert.dom("[data-test-person]").hasText("Fadhlan");
+		simulateRemoteMessage(roomId, "@aibot:localhost", {
+			body: "i am the body",
+			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
+			format: "org.matrix.custom.html",
+			isStreamingFinished: true,
+			[APP_BOXEL_TOOL_REQUESTS_KEY]: [{
+				id: "change-cards-in-stack",
+				name: "patchCardInstance",
+				arguments: JSON.stringify({ attributes: {
+					cardId: `${testRealmURL}Person/fadhlan`,
+					patch: { attributes: { firstName: "Dave" } }
+				} })
+			}],
+			"m.relates_to": {
+				rel_type: "m.replace",
+				event_id: "patch1"
+			}
+		});
+		await waitFor("[data-test-tool-call-apply]");
+		this.onSave((_, json) => {
+			if (typeof json === "string") throw new Error("expected JSON save data");
+			assert.strictEqual(json.data.attributes?.firstName, "Dave");
+		});
+		await click("[data-test-pretui-tool-gate-action=\"apply\"]");
+		await waitFor("[data-test-tool-call-card-idle]");
+		assert.dom("[data-test-person]").hasText("Dave");
+	});
+	(0, import_qunit.test)("when a command is being prepared, apply button is shown in preparing state", async function(assert) {
+		setCardInOperatorModeState(`${testRealmURL}Person/fadhlan`);
+		await renderComponent(class TestDriver extends Component {
+			static {
+				setComponentTemplate(templateFactory({
+					"id": "hk0qKyFP",
+					"block": "[[[8,[32,0],null,[[\"@onClose\"],[[32,1]]],null]],[],[]]",
+					"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/components/ai-assistant-panel/tools-test.gts",
+					"scope": () => [OperatorModeContainer, noop],
+					"isStrictMode": true
+				}), this);
+			}
+		});
+		await waitFor("[data-test-person=\"Fadhlan\"]");
+		let roomId = createAndJoinRoom({
+			sender: "@testuser:localhost",
+			name: "test room 1"
+		});
+		let initialEventId = simulateRemoteMessage(roomId, "@aibot:localhost", {
+			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
+			body: "Changing",
+			format: "org.matrix.custom.html",
+			isStreamingFinished: false
+		});
+		simulateRemoteMessage(roomId, "@aibot:localhost", {
+			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
+			body: "Changing first name to Evie",
+			format: "org.matrix.custom.html",
+			isStreamingFinished: false,
+			[APP_BOXEL_TOOL_REQUESTS_KEY]: [{
+				id: "6545dc5a-01a1-47d6-b2f7-493d2ff5a0c2",
+				name: "patchCardInstance"
+			}],
+			"m.relates_to": {
+				rel_type: "m.replace",
+				event_id: initialEventId
+			}
+		});
+		await settled();
+		await click("[data-test-open-ai-assistant]");
+		await waitFor("[data-test-room-name=\"test room 1\"]");
+		assert.dom("[data-test-message-idx]").exists({ count: 1 });
+		await waitFor("[data-test-message-idx=\"0\"] [data-test-pretui-tool-row][data-state=\"streaming\"]");
+		assert.dom("[data-test-message-idx=\"0\"] [data-test-pretui-tool-row][data-state=\"streaming\"]").exists();
+	});
+	(0, import_qunit.test)("it does not display the streaming indicator when ai bot sends a command", async function(assert) {
+		simulateRemoteMessage(await renderAiAssistantPanel(), "@aibot:localhost", {
+			body: "i am the body",
+			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
+			format: "org.matrix.custom.html",
+			isStreamingFinished: true,
+			[APP_BOXEL_TOOL_REQUESTS_KEY]: [{
+				id: "fb8fef81-2142-4861-a902-d5614b0aea52",
+				name: "patchCardInstance",
+				arguments: JSON.stringify({ attributes: {
+					cardId: `${testRealmURL}Person/fadhlan`,
+					patch: { attributes: { firstName: "Dave" } }
+				} })
+			}]
+		});
+		await waitFor("[data-test-message-idx=\"0\"]");
+		assert.dom("[data-test-message-idx=\"0\"] [data-test-ai-avatar]").doesNotHaveClass("ai-avatar-animated", "ai bot patch message does not have a spinner");
+	});
+	(0, import_qunit.test)("when command is done streaming, apply button is shown in ready state", async function(assert) {
+		setCardInOperatorModeState(`${testRealmURL}Person/fadhlan`);
+		await renderComponent(class TestDriver extends Component {
+			static {
+				setComponentTemplate(templateFactory({
+					"id": "hk0qKyFP",
+					"block": "[[[8,[32,0],null,[[\"@onClose\"],[[32,1]]],null]],[],[]]",
+					"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/components/ai-assistant-panel/tools-test.gts",
+					"scope": () => [OperatorModeContainer, noop],
+					"isStrictMode": true
+				}), this);
+			}
+		});
+		await waitFor("[data-test-person=\"Fadhlan\"]");
+		let roomId = createAndJoinRoom({
+			sender: "@testuser:localhost",
+			name: "test room 1"
+		});
+		let initialEventId = simulateRemoteMessage(roomId, "@aibot:localhost", {
+			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
+			body: "Changing",
+			format: "org.matrix.custom.html",
+			isStreamingFinished: false
+		});
+		simulateRemoteMessage(roomId, "@aibot:localhost", {
+			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
+			body: "Changing first names",
+			format: "org.matrix.custom.html",
+			[APP_BOXEL_TOOL_REQUESTS_KEY]: [{
+				id: "6545dc5a-01a1-47d6-b2f7-493d2ff5a0c2",
+				name: "patchCardInstance"
+			}],
+			isStreamingFinished: false,
+			"m.relates_to": {
+				rel_type: "m.replace",
+				event_id: initialEventId
+			}
+		});
+		await settled();
+		await click("[data-test-open-ai-assistant]");
+		await waitFor("[data-test-room-name=\"test room 1\"]");
+		assert.dom("[data-test-message-idx]").exists({ count: 1 });
+		await waitFor("[data-test-message-idx=\"0\"] [data-test-pretui-tool-row][data-state=\"streaming\"]");
+		assert.dom("[data-test-message-idx=\"0\"] [data-test-pretui-tool-row][data-state=\"streaming\"]").exists();
+		simulateRemoteMessage(roomId, "@aibot:localhost", {
+			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
+			body: "Changing first names",
+			format: "org.matrix.custom.html",
+			[APP_BOXEL_TOOL_REQUESTS_KEY]: [{
+				id: "6545dc5a-01a1-47d6-b2f7-493d2ff5a0c2",
+				name: "patchCardInstance",
+				arguments: JSON.stringify({ attributes: {
+					cardId: `${testRealmURL}Person/fadhlan`,
+					patch: { attributes: { firstName: "Evie" } }
+				} })
+			}, {
+				id: "f2da5504-b92f-480a-986a-56ec606d240e",
+				name: "patchCardInstance",
+				arguments: JSON.stringify({ attributes: {
+					cardId: `${testRealmURL}Person/hassan`,
+					patch: { attributes: { firstName: "Ivana" } }
+				} })
+			}],
+			isStreamingFinished: false,
+			"m.relates_to": {
+				rel_type: "m.replace",
+				event_id: initialEventId
+			}
+		});
+		await settled();
+		assert.dom("[data-test-message-idx]").exists({ count: 1 });
+		await waitFor("[data-test-message-idx=\"0\"] [data-test-pretui-tool-row][data-state=\"streaming\"]");
+		assert.dom("[data-test-message-idx=\"0\"] [data-test-pretui-tool-row][data-state=\"streaming\"]").exists({ count: 2 }, "each call still arriving is a streaming row");
+		simulateRemoteMessage(roomId, "@aibot:localhost", {
+			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
+			body: "Changing first names",
+			format: "org.matrix.custom.html",
+			[APP_BOXEL_TOOL_REQUESTS_KEY]: [{
+				id: "6545dc5a-01a1-47d6-b2f7-493d2ff5a0c2",
+				name: "patchCardInstance",
+				arguments: JSON.stringify({ attributes: {
+					cardId: `${testRealmURL}Person/fadhlan`,
+					patch: { attributes: { firstName: "Evie" } }
+				} })
+			}, {
+				id: "f2da5504-b92f-480a-986a-56ec606d240e",
+				name: "patchCardInstance",
+				arguments: JSON.stringify({ attributes: {
+					cardId: `${testRealmURL}Person/hassan`,
+					patch: { attributes: { firstName: "Ivana" } }
+				} })
+			}],
+			isStreamingFinished: true,
+			"m.relates_to": {
+				rel_type: "m.replace",
+				event_id: initialEventId
+			}
+		});
+		await settled();
+		assert.dom("[data-test-message-idx]").exists({ count: 1 });
+		await waitFor("[data-test-message-idx=\"0\"] [data-test-tool-call-apply]");
+		assert.dom("[data-test-message-idx=\"0\"] [data-test-pretui-tool-row][data-state=\"streaming\"]").doesNotExist("every call has arrived");
+		assert.dom("[data-test-message-idx=\"0\"] [data-test-tool-call-apply=\"ready\"]").exists({ count: 2 });
+	});
+	(0, import_qunit.test)("after command is executed, a command result event will be dispatched", async function(assert) {
+		setCardInOperatorModeState(`${testRealmURL}Person/fadhlan`);
+		await renderComponent(class TestDriver extends Component {
+			static {
+				setComponentTemplate(templateFactory({
+					"id": "hk0qKyFP",
+					"block": "[[[8,[32,0],null,[[\"@onClose\"],[[32,1]]],null]],[],[]]",
+					"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/components/ai-assistant-panel/tools-test.gts",
+					"scope": () => [OperatorModeContainer, noop],
+					"isStrictMode": true
+				}), this);
+			}
+		});
+		await waitFor("[data-test-person=\"Fadhlan\"]");
+		let roomId = createAndJoinRoom({
+			sender: "@testuser:localhost",
+			name: "test room 1"
+		});
+		simulateRemoteMessage(roomId, "@aibot:localhost", {
+			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
+			body: "Changing first name to Evie",
+			format: "org.matrix.custom.html",
+			isStreamingFinished: true,
+			[APP_BOXEL_TOOL_REQUESTS_KEY]: [{
+				id: "result-event-dispatch",
+				name: "patchCardInstance",
+				arguments: JSON.stringify({ attributes: {
+					cardId: `${testRealmURL}Person/fadhlan`,
+					patch: { attributes: { firstName: "Evie" } }
+				} })
+			}]
+		});
+		let commandResultEvents = getRoomEvents(roomId).filter((event) => event.type === "app.boxel.toolResult" && event.content["m.relates_to"]?.rel_type === "app.boxel.toolAnnotation" && event.content["m.relates_to"]?.key === "applied");
+		assert.strictEqual(commandResultEvents.length, 0, "command result event is not dispatched");
+		await settled();
+		await click("[data-test-open-ai-assistant]");
+		await waitFor("[data-test-room-name=\"test room 1\"]");
+		await waitFor("[data-test-message-idx=\"0\"] [data-test-tool-call-apply]");
+		await click("[data-test-message-idx=\"0\"] [data-test-pretui-tool-gate-action=\"apply\"]");
+		await waitFor("[data-test-tool-call-card-idle]");
+		assert.dom("[data-test-message-idx=\"0\"] [data-test-tool-call-apply=\"applied\"]").exists();
+		commandResultEvents = getRoomEvents(roomId).filter((event) => event.type === "app.boxel.toolResult" && event.content["m.relates_to"]?.rel_type === "app.boxel.toolAnnotation" && event.content["m.relates_to"]?.key === "applied");
+		assert.strictEqual(commandResultEvents.length, 1, "command result event is dispatched");
+		assert.deepEqual(JSON.parse(commandResultEvents[0].content.data).context, {
+			agentId: getService("matrix-service").agentId,
+			submode: "interact",
+			debug: false,
+			openCardIds: ["http://test-realm/test/Person/fadhlan"],
+			realmPrefixes: registeredRealmPrefixes(),
+			realmUrl: "http://test-realm/test/",
+			realmPermissions: {
+				canRead: true,
+				canWrite: true
+			}
+		}, "command result event contains the context");
+	});
+	(0, import_qunit.test)("after search command is executed, a command result event is dispatched", async function(assert) {
+		setCardInOperatorModeState(`${testRealmURL}Person/fadhlan`);
+		await renderComponent(class TestDriver extends Component {
+			static {
+				setComponentTemplate(templateFactory({
+					"id": "hk0qKyFP",
+					"block": "[[[8,[32,0],null,[[\"@onClose\"],[[32,1]]],null]],[],[]]",
+					"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/components/ai-assistant-panel/tools-test.gts",
+					"scope": () => [OperatorModeContainer, noop],
+					"isStrictMode": true
+				}), this);
+			}
+		});
+		await waitFor("[data-test-person=\"Fadhlan\"]");
+		let roomId = createAndJoinRoom({
+			sender: "@testuser:localhost",
+			name: "test room 1"
+		});
+		simulateRemoteMessage(roomId, "@aibot:localhost", {
+			body: "Changing first name to Evie",
+			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
+			format: "org.matrix.custom.html",
+			isStreamingFinished: true,
+			[APP_BOXEL_TOOL_REQUESTS_KEY]: [{
+				id: "search-result-dispatch",
+				name: "patchCardInstance",
+				arguments: JSON.stringify({ attributes: {
+					cardId: `${testRealmURL}Person/fadhlan`,
+					patch: { attributes: { firstName: "Evie" } }
+				} })
+			}]
+		});
+		let commandResultEvents = getRoomEvents(roomId).filter((event) => event.type === APP_BOXEL_TOOL_RESULT_EVENT_TYPE);
+		assert.strictEqual(commandResultEvents.length, 0, "command result event is not dispatched");
+		await settled();
+		await click("[data-test-open-ai-assistant]");
+		await waitFor("[data-test-room-name=\"test room 1\"]");
+		await waitFor("[data-test-message-idx=\"0\"] [data-test-tool-call-apply]");
+		await click("[data-test-message-idx=\"0\"] [data-test-pretui-tool-gate-action=\"apply\"]");
+		await waitFor("[data-test-tool-call-card-idle]");
+		assert.dom("[data-test-message-idx=\"0\"] [data-test-tool-call-apply=\"applied\"]").exists();
+		commandResultEvents = getRoomEvents(roomId).filter((event) => event.type === APP_BOXEL_TOOL_RESULT_EVENT_TYPE);
+		assert.strictEqual(commandResultEvents.length, 1, "command result event is dispatched");
+		assert.deepEqual(JSON.parse(commandResultEvents[0].content.data).context, {
+			agentId: getService("matrix-service").agentId,
+			submode: "interact",
+			debug: false,
+			openCardIds: ["http://test-realm/test/Person/fadhlan"],
+			realmPrefixes: registeredRealmPrefixes(),
+			realmUrl: "http://test-realm/test/",
+			realmPermissions: {
+				canRead: true,
+				canWrite: true
+			}
+		}, "command result event contains the context");
+	});
+	(0, import_qunit.test)("it can search for card instances that is of the same card type as the card shared", async function(assert) {
+		let roomId = await renderAiAssistantPanel(`${testRealmURL}Pet/mango.json`);
+		await addSkillToAiAssistant(`${testRealmURL}Skill/boxel-environment`);
+		simulateRemoteMessage(roomId, "@aibot:localhost", {
+			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
+			body: "Search for the following card",
+			format: "org.matrix.custom.html",
+			isStreamingFinished: true,
+			[APP_BOXEL_TOOL_REQUESTS_KEY]: [{
+				id: "search1",
+				name: searchCardsToolName,
+				arguments: JSON.stringify({
+					description: "Searching for card",
+					attributes: { type: {
+						module: `${testRealmURL}pet`,
+						name: "Pet"
+					} }
+				})
+			}],
+			data: { context: { agentId: getService("matrix-service").agentId } }
+		});
+		await waitForToolResult();
+		assert.dom("[data-test-ai-message-content]").containsText("Search for the following card");
+		assert.dom("[data-test-ai-message-content] [data-test-pretui-tool-row-toggle]").exists({ count: 1 });
+		assert.dom("[data-test-message-idx=\"0\"] [data-test-tool-result-header]").containsText("SearchCardsByTypeAndTitle", "the result's meta line names the call");
+		assert.dom(".result-list li").exists({ count: 2 });
+		assert.dom(".result-list li:nth-child(1)").containsText("Jackie");
+		assert.dom(".result-list li:nth-child(2)").containsText("Mango");
+		assert.dom("[data-test-toggle-show-button]").doesNotExist();
+	});
+	(0, import_qunit.test)("it can search for card instances based upon title of card", async function(assert) {
+		let roomId = await renderAiAssistantPanel(`${testRealmURL}Pet/mango.json`);
+		await addSkillToAiAssistant(`${testRealmURL}Skill/boxel-environment`);
+		simulateRemoteMessage(roomId, "@aibot:localhost", {
+			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
+			body: "Search for the following card",
+			format: "org.matrix.custom.html",
+			isStreamingFinished: true,
+			[APP_BOXEL_TOOL_REQUESTS_KEY]: [{
+				id: "search1",
+				name: searchCardsToolName,
+				arguments: JSON.stringify({
+					description: "Searching for card",
+					attributes: { cardTitle: "Mango" }
+				})
+			}],
+			data: { context: { agentId: getService("matrix-service").agentId } }
+		});
+		await waitForToolResult();
+		assert.dom("[data-test-ai-message-content]").containsText("Search for the following card");
+		assert.dom("[data-test-ai-message-content] [data-test-pretui-tool-row-toggle]").exists({ count: 1 });
+		assert.dom("[data-test-message-idx=\"0\"] [data-test-boxel-tool-call-result]").exists("the search results card shows in the row");
+		assert.dom(".result-list li:nth-child(1)").containsText("Mango");
+		assert.dom("[data-test-toggle-show-button]").doesNotExist();
+	});
+	(0, import_qunit.test)("toggle more search results", async function(assert) {
+		let roomId = await renderAiAssistantPanel(`${testRealmURL}Person/fadhlan.json`);
+		await addSkillToAiAssistant(`${testRealmURL}Skill/boxel-environment`);
+		simulateRemoteMessage(roomId, "@aibot:localhost", {
+			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
+			body: "Search for the following card",
+			format: "org.matrix.custom.html",
+			isStreamingFinished: true,
+			[APP_BOXEL_TOOL_REQUESTS_KEY]: [{
+				id: "721c8c78-d8c1-4cc1-a7e9-51d2d3143e4d",
+				name: searchCardsToolName,
+				arguments: JSON.stringify({
+					description: "Searching for card",
+					attributes: { type: {
+						module: `${testRealmURL}person`,
+						name: "Person"
+					} }
+				})
+			}],
+			data: { context: { agentId: getService("matrix-service").agentId } }
+		});
+		await waitForToolResult();
+		let resultCard = find("[data-test-message-idx=\"0\"] [data-test-boxel-tool-call-result]");
+		let cardStyle = window.getComputedStyle(resultCard);
+		assert.notStrictEqual(cardStyle.color, cardStyle.backgroundColor, "result body text contrasts with its background");
+		assert.dom(".result-list li:nth-child(6)").doesNotExist();
+		assert.dom("[data-test-toggle-show-button]").containsText("Show 3 more results");
+		await click("[data-test-toggle-show-button]");
+		await waitFor(".result-list li", { count: 8 });
+		assert.dom("[data-test-toggle-show-button]").containsText("See Less");
+		assert.dom(".result-list li:nth-child(1)").containsText("Buck");
+		assert.dom(".result-list li:nth-child(2)").containsText("Burcu");
+		assert.dom(".result-list li:nth-child(3)").containsText("Fadhlan");
+		assert.dom(".result-list li:nth-child(4)").containsText("Hassan");
+		assert.dom(".result-list li:nth-child(5)").containsText("Ian");
+		assert.dom(".result-list li:nth-child(6)").containsText("Justin");
+		assert.dom(".result-list li:nth-child(7)").containsText("Matic");
+		assert.dom(".result-list li:nth-child(8)").containsText("Mickey");
+		await click("[data-test-toggle-show-button]");
+		assert.dom(".result-list li:nth-child(1)").containsText("Buck");
+		assert.dom(".result-list li:nth-child(2)").containsText("Burcu");
+		assert.dom(".result-list li:nth-child(3)").containsText("Fadhlan");
+		assert.dom(".result-list li:nth-child(4)").containsText("Hassan");
+		assert.dom(".result-list li:nth-child(5)").containsText("Ian");
+		assert.dom(".result-list li:nth-child(6)").doesNotExist();
+	});
+	(0, import_qunit.test)("it can copy search results card to workspace", async function(assert) {
+		const id = `${testRealmURL}Person/fadhlan`;
+		const roomId = await renderAiAssistantPanel(`${id}.json`);
+		await addSkillToAiAssistant(`${testRealmURL}Skill/boxel-environment`);
+		const toolArgs = {
+			description: "Search for Person cards",
+			attributes: { type: {
+				module: `${testRealmURL}person`,
+				name: "Person"
+			} }
+		};
+		simulateRemoteMessage(roomId, "@aibot:localhost", {
+			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
+			body: "Search for the following card",
+			format: "org.matrix.custom.html",
+			isStreamingFinished: true,
+			[APP_BOXEL_TOOL_REQUESTS_KEY]: [{
+				id: "fd4515fb-ed4d-4005-9782-4e844d7d4d9c",
+				name: searchCardsToolName,
+				arguments: JSON.stringify(toolArgs)
+			}],
+			data: { context: { agentId: getService("matrix-service").agentId } }
+		});
+		await waitForToolResult();
+		assert.dom(`[data-test-stack-card="${id}"]`).exists();
+		assert.dom("[data-test-message-idx=\"0\"] [data-test-boxel-tool-call-result]").exists("the search results card shows in the row");
+		let resultListItem = "[data-test-result-list] > li";
+		assert.dom(`${resultListItem}:nth-child(1)`).containsText("Buck");
+		assert.dom(`${resultListItem}:nth-child(5)`).containsText("Ian");
+		const rightStackItem = "[data-test-operator-mode-stack=\"1\"] [data-test-stack-card-index=\"0\"]";
+		assert.dom(rightStackItem).doesNotExist();
+		await click("[data-test-tool-result-container] [data-test-more-options-button]");
+		await click(menuItem("Copy to Workspace"));
+		assert.dom(`${rightStackItem} [data-test-boxel-card-header-title]`).hasText("Search Results - Search Results");
+		const savedCard = `[data-test-card="${document.querySelector(rightStackItem)?.getAttribute("data-stack-card")}"] [data-test-tool-result-isolated]`;
+		assert.dom(`${savedCard} header`).hasText("Search Results 8 Results");
+		assert.dom(`${savedCard} [data-test-boxel-field]`).exists({ count: 2 });
+		assert.dom(`${savedCard} [data-test-boxel-field]:nth-child(1)`).hasText(`Description Query: { "type": { "module": "http://test-realm/test/person", "name": "Person" } }`);
+		resultListItem = `${savedCard} ${resultListItem}`;
+		assert.dom(resultListItem).exists({ count: 8 });
+		assert.dom(`${resultListItem}:nth-child(1)`).containsText("Buck");
+		assert.dom(`${resultListItem}:nth-child(6)`).containsText("Justin");
+		assert.dom(`${resultListItem}:nth-child(8)`).containsText("Mickey");
+	});
+	(0, import_qunit.test)("copy to workspace menu item is shown for writable realm", async function(assert) {
+		const roomId = await renderAiAssistantPanel(`${`${testRealmURL}Person/fadhlan`}.json`);
+		await addSkillToAiAssistant(`${testRealmURL}Skill/boxel-environment`);
+		const toolArgs = {
+			description: "Search for Person cards",
+			attributes: { type: {
+				module: `${testRealmURL}person`,
+				name: "Person"
+			} }
+		};
+		simulateRemoteMessage(roomId, "@aibot:localhost", {
+			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
+			body: "Search for the following card",
+			format: "org.matrix.custom.html",
+			isStreamingFinished: true,
+			[APP_BOXEL_TOOL_REQUESTS_KEY]: [{
+				id: "9a5b7422-87de-4a93-9f07-9b7c40b75b1e",
+				name: searchCardsToolName,
+				arguments: JSON.stringify(toolArgs)
+			}],
+			data: { context: { agentId: getService("matrix-service").agentId } }
+		});
+		await waitForToolResult();
+		await click("[data-test-tool-result-container] [data-test-more-options-button]");
+		assert.ok(menuItem("Copy to Workspace"), "the menu offers the copy");
+	});
+	(0, import_qunit.test)("copy to workspace menu item is hidden for read-only realm", async function(assert) {
+		const roomId = await renderAiAssistantPanel(`${`${readOnlyRealmURL}Person/ian`}.json`);
+		await addSkillToAiAssistant(`${testRealmURL}Skill/boxel-environment`);
+		const toolArgs = {
+			description: "Search for Person cards",
+			attributes: { type: {
+				module: `${testRealmURL}person`,
+				name: "Person"
+			} }
+		};
+		simulateRemoteMessage(roomId, "@aibot:localhost", {
+			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
+			body: "Search for the following card",
+			format: "org.matrix.custom.html",
+			isStreamingFinished: true,
+			[APP_BOXEL_TOOL_REQUESTS_KEY]: [{
+				id: "6c6e2d73-8e09-4b44-a0d9-688f36b73be8",
+				name: searchCardsToolName,
+				arguments: JSON.stringify(toolArgs)
+			}],
+			data: { context: { agentId: getService("matrix-service").agentId } }
+		});
+		await waitForToolResult();
+		assert.dom("[data-test-tool-result-container] [data-test-more-options-button]").doesNotExist();
+		assert.notOk(menuItem("Copy to Workspace"), "no copy is offered");
+	});
+	(0, import_qunit.test)("it can copy search results card to workspace (no cards in stack)", async function(assert) {
+		const id = `${testRealmURL}Person/fadhlan`;
+		const roomId = await renderAiAssistantPanel(`${id}.json`);
+		await addSkillToAiAssistant(`${testRealmURL}Skill/boxel-environment`);
+		const toolArgs = {
+			description: "Search for Person cards",
+			attributes: { type: {
+				module: `${testRealmURL}person`,
+				name: "Person"
+			} }
+		};
+		simulateRemoteMessage(roomId, "@aibot:localhost", {
+			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
+			body: "Search for the following card",
+			format: "org.matrix.custom.html",
+			isStreamingFinished: true,
+			[APP_BOXEL_TOOL_REQUESTS_KEY]: [{
+				id: "ffd1a3d0-0bd4-491a-a907-b96ec9d8902c",
+				name: searchCardsToolName,
+				arguments: JSON.stringify(toolArgs)
+			}],
+			data: { context: { agentId: getService("matrix-service").agentId } }
+		});
+		await waitForToolResult();
+		assert.dom(`[data-test-stack-card="${id}"]`).exists();
+		await click("[data-test-close-button]");
+		assert.dom(`[data-test-stack-card="${id}"]`).doesNotExist();
+		assert.dom(`[data-test-stack-card="${testRealmURL}index"]`).exists();
+		await click("[data-test-close-button]");
+		assert.dom("[data-test-message-idx=\"0\"] [data-test-boxel-tool-call-result]").exists("the search results card shows in the row");
+		assert.dom("[data-test-message-idx=\"0\"] [data-test-toggle-show-button]").containsText("Show 3 more results");
+		let resultListItem = "[data-test-result-list] > li";
+		assert.dom(`${resultListItem}:nth-child(1)`).containsText("Buck");
+		assert.dom(`${resultListItem}:nth-child(5)`).containsText("Ian");
+		const stackItem = "[data-test-operator-mode-stack=\"0\"] [data-test-stack-card-index=\"0\"]";
+		assert.dom(stackItem).doesNotExist();
+		await click("[data-test-tool-result-container] [data-test-more-options-button]");
+		await click(menuItem("Copy to Workspace"));
+		assert.dom(`${stackItem} [data-test-boxel-card-header-title]`).hasText("Search Results - Search Results");
+		const savedCard = `[data-test-card="${document.querySelector(stackItem)?.getAttribute("data-stack-card")}"] [data-test-tool-result-isolated]`;
+		assert.dom(`${savedCard} header`).hasText("Search Results 8 Results");
+		assert.dom(`${savedCard} [data-test-boxel-field]`).exists({ count: 2 });
+		assert.dom(`${savedCard} [data-test-boxel-field]:nth-child(1)`).hasText(`Description Query: { "type": { "module": "http://test-realm/test/person", "name": "Person" } }`);
+		resultListItem = `${savedCard} ${resultListItem}`;
+		assert.dom(resultListItem).exists({ count: 8 });
+		assert.dom(`${resultListItem}:nth-child(1)`).containsText("Buck");
+		assert.dom(`${resultListItem}:nth-child(6)`).containsText("Justin");
+		assert.dom(`${resultListItem}:nth-child(8)`).containsText("Mickey");
+	});
+	(0, import_qunit.test)("it maintains status of View Code panel as additional events stream in", async function(assert) {
+		setCardInOperatorModeState(`${testRealmURL}Person/fadhlan`);
+		await renderComponent(class TestDriver extends Component {
+			static {
+				setComponentTemplate(templateFactory({
+					"id": "hk0qKyFP",
+					"block": "[[[8,[32,0],null,[[\"@onClose\"],[[32,1]]],null]],[],[]]",
+					"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/components/ai-assistant-panel/tools-test.gts",
+					"scope": () => [OperatorModeContainer, noop],
+					"isStrictMode": true
+				}), this);
+			}
+		});
+		await waitFor("[data-test-person=\"Fadhlan\"]");
+		simulateRemoteMessage(createAndJoinRoom({
+			sender: "@testuser:localhost",
+			name: "test room 1"
+		}), "@aibot:localhost", {
+			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
+			body: "Changing first name to Evie",
+			format: "org.matrix.custom.html",
+			isStreamingFinished: true,
+			[APP_BOXEL_TOOL_REQUESTS_KEY]: [{
+				id: "view-code-panel-status",
+				name: "patchCardInstance",
+				arguments: JSON.stringify({ attributes: {
+					cardId: `${testRealmURL}Person/fadhlan`,
+					patch: { attributes: { firstName: "Evie" } }
+				} })
+			}]
+		});
+		await settled();
+		await click("[data-test-open-ai-assistant]");
+		await waitFor("[data-test-room-name=\"test room 1\"]");
+		assert.dom("[data-test-ai-message-content] [data-test-pretui-code]").doesNotExist("View Code panel should not yet be open");
+		await click("[data-test-pretui-tool-row-toggle]");
+		assert.dom("[data-test-ai-message-content] [data-test-pretui-code]").exists("View Code panel should be open");
+		await fillIn("[data-test-message-field]", "Asking a question about what I saw in the proposed code...");
+		await click("[data-test-send-message-btn]");
+		assert.dom("[data-test-ai-message-content] [data-test-pretui-code]").exists("View Code panel should remain open");
+		await percySnapshot(assert);
+	});
+	(0, import_qunit.test)("\"Hide Info\" collapses the code area even after the message re-mounts while expanded", async function(assert) {
+		setCardInOperatorModeState(`${testRealmURL}Person/fadhlan`);
+		await renderComponent(class TestDriver extends Component {
+			static {
+				setComponentTemplate(templateFactory({
+					"id": "hk0qKyFP",
+					"block": "[[[8,[32,0],null,[[\"@onClose\"],[[32,1]]],null]],[],[]]",
+					"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/components/ai-assistant-panel/tools-test.gts",
+					"scope": () => [OperatorModeContainer, noop],
+					"isStrictMode": true
+				}), this);
+			}
+		});
+		await waitFor("[data-test-person=\"Fadhlan\"]");
+		simulateRemoteMessage(createAndJoinRoom({
+			sender: "@testuser:localhost",
+			name: "test room 1"
+		}), "@aibot:localhost", {
+			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
+			body: "Changing first name to Evie",
+			format: "org.matrix.custom.html",
+			isStreamingFinished: true,
+			[APP_BOXEL_TOOL_REQUESTS_KEY]: [{
+				id: "hide-info-height",
+				name: "patchCardInstance",
+				arguments: JSON.stringify({ attributes: {
+					cardId: `${testRealmURL}Person/fadhlan`,
+					patch: { attributes: { firstName: "Evie" } }
+				} })
+			}]
+		});
+		await settled();
+		await click("[data-test-open-ai-assistant]");
+		await waitFor("[data-test-room-name=\"test room 1\"]");
+		await click("[data-test-pretui-tool-row-toggle]");
+		await waitFor("[data-test-pretui-code]");
+		await click("[data-test-close-ai-assistant]");
+		await click("[data-test-open-ai-assistant]");
+		await waitFor("[data-test-pretui-code]");
+		await settled();
+		await click("[data-test-pretui-tool-row-toggle]");
+		assert.dom("[data-test-pretui-code]").doesNotExist("code editor is removed after Hide Info");
+		let codeBlockSelector = "[data-test-tool-call-id=\"hide-info-height\"] [data-test-tool-code-block]";
+		assert.dom(codeBlockSelector).exists("tool code block element exists");
+		let codeBlock = find(codeBlockSelector);
+		assert.strictEqual(codeBlock.style.height, "", "no inline height is left behind so the block collapses to its header-only height");
+	});
+	(0, import_qunit.test)("expanding a tall tool call does not leave an empty gap below the code", async function(assert) {
+		setCardInOperatorModeState(`${testRealmURL}Person/fadhlan`);
+		await renderComponent(class TestDriver extends Component {
+			static {
+				setComponentTemplate(templateFactory({
+					"id": "hk0qKyFP",
+					"block": "[[[8,[32,0],null,[[\"@onClose\"],[[32,1]]],null]],[],[]]",
+					"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/components/ai-assistant-panel/tools-test.gts",
+					"scope": () => [OperatorModeContainer, noop],
+					"isStrictMode": true
+				}), this);
+			}
+		});
+		await waitFor("[data-test-person=\"Fadhlan\"]");
+		let roomId = createAndJoinRoom({
+			sender: "@testuser:localhost",
+			name: "test room 1"
+		});
+		let attributes = Object.fromEntries(Array.from({ length: 30 }, (_, i) => [`field${i}`, `value ${i}`]));
+		simulateRemoteMessage(roomId, "@aibot:localhost", {
+			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
+			body: "Applying a large patch",
+			format: "org.matrix.custom.html",
+			isStreamingFinished: true,
+			[APP_BOXEL_TOOL_REQUESTS_KEY]: [{
+				id: "tall-tool-call",
+				name: "patchCardInstance",
+				arguments: JSON.stringify({ attributes: {
+					cardId: `${testRealmURL}Person/fadhlan`,
+					patch: { attributes }
+				} })
+			}]
+		});
+		await settled();
+		await click("[data-test-open-ai-assistant]");
+		await waitFor("[data-test-room-name=\"test room 1\"]");
+		await click("[data-test-pretui-tool-row-toggle]");
+		await waitFor("[data-test-pretui-code]");
+		await settled();
+		let codeBlockSelector = "[data-test-tool-call-id=\"tall-tool-call\"] [data-test-pretui-code]";
+		assert.dom(codeBlockSelector).exists("tool code block element exists");
+		let codeBlock = find(codeBlockSelector);
+		assert.strictEqual(codeBlock.style.height, "", "no inline height is stamped when the code is expanded");
+		let childrenHeight = [...codeBlock.children].reduce((sum, child) => sum + child.offsetHeight, 0);
+		assert.ok(codeBlock.offsetHeight <= childrenHeight + 4, `expanded code block height (${codeBlock.offsetHeight}px) should not exceed its rendered children (${childrenHeight}px)`);
+	});
+	(0, import_qunit.test)("when command in a message with continuations is done streaming, apply button is shown in ready state", async function(assert) {
+		setCardInOperatorModeState(`${testRealmURL}Person/fadhlan`);
+		await renderComponent(class TestDriver extends Component {
+			static {
+				setComponentTemplate(templateFactory({
+					"id": "hk0qKyFP",
+					"block": "[[[8,[32,0],null,[[\"@onClose\"],[[32,1]]],null]],[],[]]",
+					"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/components/ai-assistant-panel/tools-test.gts",
+					"scope": () => [OperatorModeContainer, noop],
+					"isStrictMode": true
+				}), this);
+			}
+		});
+		await waitFor("[data-test-person=\"Fadhlan\"]");
+		let roomId = createAndJoinRoom({
+			sender: "@testuser:localhost",
+			name: "test room 1"
+		});
+		let initialEventId = simulateRemoteMessage(roomId, "@aibot:localhost", {
+			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
+			body: "Changing",
+			format: "org.matrix.custom.html",
+			isStreamingFinished: false
+		});
+		simulateRemoteMessage(roomId, "@aibot:localhost", {
+			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
+			body: "Changing first",
+			format: "org.matrix.custom.html",
+			isStreamingFinished: true,
+			[APP_BOXEL_HAS_CONTINUATION_CONTENT_KEY]: true,
+			"m.relates_to": {
+				rel_type: "m.replace",
+				event_id: initialEventId
+			}
+		});
+		let continuationEventId = simulateRemoteMessage(roomId, "@aibot:localhost", {
+			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
+			body: "Changing first names",
+			format: "org.matrix.custom.html",
+			[APP_BOXEL_CONTINUATION_OF_CONTENT_KEY]: initialEventId,
+			[APP_BOXEL_TOOL_REQUESTS_KEY]: [{
+				id: "6545dc5a-01a1-47d6-b2f7-493d2ff5a0c2",
+				name: "patchCard"
+			}],
+			isStreamingFinished: false
+		});
+		await settled();
+		await click("[data-test-open-ai-assistant]");
+		await waitFor("[data-test-room-name=\"test room 1\"]");
+		assert.dom("[data-test-message-idx]").exists({ count: 1 });
+		await waitFor("[data-test-message-idx=\"0\"] [data-test-pretui-tool-row][data-state=\"streaming\"]");
+		assert.dom("[data-test-message-idx=\"0\"] [data-test-pretui-tool-row][data-state=\"streaming\"]").exists();
+		simulateRemoteMessage(roomId, "@aibot:localhost", {
+			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
+			body: "Changing first names",
+			format: "org.matrix.custom.html",
+			[APP_BOXEL_CONTINUATION_OF_CONTENT_KEY]: initialEventId,
+			[APP_BOXEL_TOOL_REQUESTS_KEY]: [{
+				id: "6545dc5a-01a1-47d6-b2f7-493d2ff5a0c2",
+				name: "patchCard",
+				arguments: JSON.stringify({ attributes: {
+					cardId: `${testRealmURL}Person/fadhlan`,
+					patch: { attributes: { firstName: "Evie" } }
+				} })
+			}, {
+				id: "f2da5504-b92f-480a-986a-56ec606d240e",
+				name: "patchCard",
+				arguments: JSON.stringify({ attributes: {
+					cardId: `${testRealmURL}Person/hassan`,
+					patch: { attributes: { firstName: "Ivana" } }
+				} })
+			}],
+			isStreamingFinished: false,
+			"m.relates_to": {
+				rel_type: "m.replace",
+				event_id: continuationEventId
+			}
+		});
+		await settled();
+		assert.dom("[data-test-message-idx]").exists({ count: 1 });
+		await waitFor("[data-test-message-idx=\"0\"] [data-test-pretui-tool-row][data-state=\"streaming\"]");
+		assert.dom("[data-test-message-idx=\"0\"] [data-test-pretui-tool-row][data-state=\"streaming\"]").exists({ count: 2 }, "each call still arriving is a streaming row");
+		simulateRemoteMessage(roomId, "@aibot:localhost", {
+			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
+			body: "Changing first names",
+			format: "org.matrix.custom.html",
+			[APP_BOXEL_CONTINUATION_OF_CONTENT_KEY]: initialEventId,
+			[APP_BOXEL_TOOL_REQUESTS_KEY]: [{
+				id: "6545dc5a-01a1-47d6-b2f7-493d2ff5a0c2",
+				name: "patchCard",
+				arguments: JSON.stringify({ attributes: {
+					cardId: `${testRealmURL}Person/fadhlan`,
+					patch: { attributes: { firstName: "Evie" } }
+				} })
+			}, {
+				id: "f2da5504-b92f-480a-986a-56ec606d240e",
+				name: "patchCard",
+				arguments: JSON.stringify({ attributes: {
+					cardId: `${testRealmURL}Person/hassan`,
+					patch: { attributes: { firstName: "Ivana" } }
+				} })
+			}],
+			isStreamingFinished: true,
+			"m.relates_to": {
+				rel_type: "m.replace",
+				event_id: continuationEventId
+			}
+		});
+		await settled();
+		assert.dom("[data-test-message-idx]").exists({ count: 1 });
+		await waitFor("[data-test-message-idx=\"0\"] [data-test-tool-call-apply]");
+		assert.dom("[data-test-message-idx=\"0\"] [data-test-pretui-tool-row][data-state=\"streaming\"]").doesNotExist("every call has arrived");
+		assert.dom("[data-test-message-idx=\"0\"] [data-test-tool-call-apply=\"ready\"]").exists({ count: 2 });
+	});
+	(0, import_qunit.skip)("command that returns a FileForAttachmentCard result is specially handled to attach the file", async function(assert) {
+		setCardInOperatorModeState(`${testRealmURL}Person/fadhlan`);
+		await renderComponent(class TestDriver extends Component {
+			static {
+				setComponentTemplate(templateFactory({
+					"id": "hk0qKyFP",
+					"block": "[[[8,[32,0],null,[[\"@onClose\"],[[32,1]]],null]],[],[]]",
+					"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/components/ai-assistant-panel/tools-test.gts",
+					"scope": () => [OperatorModeContainer, noop],
+					"isStrictMode": true
+				}), this);
+			}
+		});
+		await waitFor("[data-test-person=\"Fadhlan\"]");
+		let roomId = createAndJoinRoom({
+			sender: "@testuser:localhost",
+			name: "test room 1"
+		});
+		await settled();
+		await click("[data-test-open-ai-assistant]");
+		await waitFor("[data-test-room-name=\"test room 1\"]", { timeout: 1e4 });
+		await addSkillToAiAssistant(`${testRealmURL}Skill/boxel-environment`);
+		simulateRemoteMessage(roomId, "@aibot:localhost", {
+			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
+			body: "Reading hello file",
+			format: "org.matrix.custom.html",
+			isStreamingFinished: true,
+			[APP_BOXEL_TOOL_REQUESTS_KEY]: [{
+				id: "0ce51dc1-c819-4d6d-9f4f-77fbf60e9a0a",
+				name: "read-file-for-ai-assistant_a831",
+				arguments: JSON.stringify({ attributes: { fileIdentifier: `${testRealmURL}hello.txt` } })
+			}]
+		});
+		let commandResultEvents = getRoomEvents(roomId).filter((event) => event.type === "app.boxel.toolResult" && event.content["m.relates_to"]?.rel_type === "app.boxel.toolAnnotation" && event.content["m.relates_to"]?.key === "applied");
+		assert.strictEqual(commandResultEvents.length, 0, "command result event is not dispatched");
+		await settled();
+		await waitFor("[data-test-message-idx=\"0\"] [data-test-tool-call-apply]");
+		await click("[data-test-message-idx=\"0\"] [data-test-pretui-tool-gate-action=\"apply\"]");
+		await waitFor("[data-test-tool-call-card-idle]");
+		assert.dom("[data-test-message-idx=\"0\"] [data-test-tool-call-apply=\"applied\"]").exists();
+		commandResultEvents = getRoomEvents(roomId).filter((event) => event.type === "app.boxel.toolResult" && event.content["m.relates_to"]?.rel_type === "app.boxel.toolAnnotation" && event.content["m.relates_to"]?.key === "applied");
+		assert.strictEqual(commandResultEvents.length, 1, "command result event is dispatched");
+		assert.deepEqual(JSON.parse(commandResultEvents[0].content.data).attachedFiles.length, 1, "command result event contains an attached file");
+		assert.deepEqual(JSON.parse(commandResultEvents[0].content.data).attachedFiles[0].name, "hello.txt", "command result event contains attached file");
+		assert.deepEqual(JSON.parse(commandResultEvents[0].content.data).attachedFiles[0].sourceUrl, "http://test-realm/test/hello.txt", "command result event contains file whose url was reference in the input of the command as an attached file");
+	});
+	(0, import_qunit.skip)("command that returns a CardForAttachmentCard result is specially handled to attach the card", async function(assert) {
+		setCardInOperatorModeState(`${testRealmURL}Person/fadhlan`);
+		await renderComponent(class TestDriver extends Component {
+			static {
+				setComponentTemplate(templateFactory({
+					"id": "hk0qKyFP",
+					"block": "[[[8,[32,0],null,[[\"@onClose\"],[[32,1]]],null]],[],[]]",
+					"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/components/ai-assistant-panel/tools-test.gts",
+					"scope": () => [OperatorModeContainer, noop],
+					"isStrictMode": true
+				}), this);
+			}
+		});
+		await waitFor("[data-test-person=\"Fadhlan\"]");
+		let roomId = createAndJoinRoom({
+			sender: "@testuser:localhost",
+			name: "test room 1"
+		});
+		await settled();
+		await click("[data-test-open-ai-assistant]");
+		await waitFor("[data-test-room-name=\"test room 1\"]", { timeout: 1e4 });
+		await addSkillToAiAssistant(`${testRealmURL}Skill/boxel-environment`);
+		simulateRemoteMessage(roomId, "@aibot:localhost", {
+			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
+			body: "Reading card",
+			format: "org.matrix.custom.html",
+			isStreamingFinished: true,
+			[APP_BOXEL_TOOL_REQUESTS_KEY]: [{
+				id: "1ef9a66a-2201-4874-a156-9705acb1ac13",
+				name: "read-card-for-ai-assistant_dd38",
+				arguments: JSON.stringify({ attributes: { cardId: `${testRealmURL}Pet/mango` } })
+			}]
+		});
+		let commandResultEvents = getRoomEvents(roomId).filter((event) => event.type === "app.boxel.toolResult" && event.content["m.relates_to"]?.rel_type === "app.boxel.toolAnnotation" && event.content["m.relates_to"]?.key === "applied");
+		assert.strictEqual(commandResultEvents.length, 0, "command result event is not dispatched");
+		await settled();
+		await waitFor("[data-test-message-idx=\"0\"] [data-test-tool-call-apply]");
+		await click("[data-test-message-idx=\"0\"] [data-test-pretui-tool-gate-action=\"apply\"]");
+		await waitFor("[data-test-tool-call-card-idle]");
+		assert.dom("[data-test-message-idx=\"0\"] [data-test-tool-call-apply=\"applied\"]").exists();
+		commandResultEvents = getRoomEvents(roomId).filter((event) => event.type === "app.boxel.toolResult" && event.content["m.relates_to"]?.rel_type === "app.boxel.toolAnnotation" && event.content["m.relates_to"]?.key === "applied");
+		assert.strictEqual(commandResultEvents.length, 1, "command result event is dispatched");
+		assert.deepEqual(JSON.parse(commandResultEvents[0].content.data).attachedCards.length, 1, "command result event contains an attached file");
+		assert.deepEqual(JSON.parse(commandResultEvents[0].content.data).attachedCards[0].name, "Mango", "command result event contains attached card");
+		assert.deepEqual(JSON.parse(commandResultEvents[0].content.data).attachedCards[0].sourceUrl, "http://test-realm/test/Pet/mango", "command result event contains file whose url was reference in the input of the command as an attached file");
+	});
+	(0, import_qunit.test)("commandResult event_id is sourced from current room state, not a streaming snapshot", async function(assert) {
+		setCardInOperatorModeState(`${testRealmURL}Person/fadhlan`);
+		await renderComponent(class TestDriver extends Component {
+			static {
+				setComponentTemplate(templateFactory({
+					"id": "hk0qKyFP",
+					"block": "[[[8,[32,0],null,[[\"@onClose\"],[[32,1]]],null]],[],[]]",
+					"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/components/ai-assistant-panel/tools-test.gts",
+					"scope": () => [OperatorModeContainer, noop],
+					"isStrictMode": true
+				}), this);
+			}
+		});
+		await waitFor("[data-test-person=\"Fadhlan\"]");
+		let roomId = createAndJoinRoom({
+			sender: "@testuser:localhost",
+			name: "test room 1"
+		});
+		let commandRequestId = "cmd-request-id";
+		let streamingEventId = simulateRemoteMessage(roomId, "@aibot:localhost", {
+			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
+			body: "Changing",
+			format: "org.matrix.custom.html",
+			isStreamingFinished: false
+		});
+		let replacedEventId = simulateRemoteMessage(roomId, "@aibot:localhost", {
+			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
+			body: "Changing first name to Evie",
+			format: "org.matrix.custom.html",
+			isStreamingFinished: true,
+			[APP_BOXEL_TOOL_REQUESTS_KEY]: [{
+				id: commandRequestId,
+				name: "patchCardInstance",
+				arguments: JSON.stringify({ attributes: {
+					cardId: `${testRealmURL}Person/fadhlan`,
+					patch: { attributes: { firstName: "Evie" } }
+				} })
+			}],
+			"m.relates_to": {
+				rel_type: "m.replace",
+				event_id: streamingEventId
+			}
+		});
+		await settled();
+		await click("[data-test-open-ai-assistant]");
+		await waitFor("[data-test-room-name=\"test room 1\"]");
+		await waitFor("[data-test-message-idx=\"0\"] [data-test-tool-call-apply]");
+		await click("[data-test-message-idx=\"0\"] [data-test-pretui-tool-gate-action=\"apply\"]");
+		await waitFor("[data-test-tool-call-card-idle]");
+		assert.dom("[data-test-message-idx=\"0\"] [data-test-tool-call-apply=\"applied\"]").exists("MessageTool status should flip to applied even though commandResult.m.relates_to.event_id is the m.replace id, not the streaming id the cache is keyed by");
+		let commandResultEvents = getRoomEvents(roomId).filter((event) => event.type === "app.boxel.toolResult" && event.content["m.relates_to"]?.rel_type === "app.boxel.toolAnnotation");
+		assert.strictEqual(commandResultEvents.length, 1, "exactly one commandResult should be dispatched");
+		assert.strictEqual(commandResultEvents[0].content["m.relates_to"]?.event_id, replacedEventId, "commandResult.m.relates_to.event_id should be the bot message event_id currently in room.events that owns the toolRequest, not a stale snapshot of the streaming/original id");
+		assert.notStrictEqual(commandResultEvents[0].content["m.relates_to"]?.event_id, streamingEventId, "commandResult should not reference the original/streaming event_id once a later event in room.events owns the toolRequest");
+	});
+	(0, import_qunit.test)("an applied command on a streamed bot message still renders applied after reload (m.replace edits stripped)", async function(assert) {
+		setCardInOperatorModeState(`${testRealmURL}Person/fadhlan`);
+		await renderComponent(class TestDriver extends Component {
+			static {
+				setComponentTemplate(templateFactory({
+					"id": "hk0qKyFP",
+					"block": "[[[8,[32,0],null,[[\"@onClose\"],[[32,1]]],null]],[],[]]",
+					"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/components/ai-assistant-panel/tools-test.gts",
+					"scope": () => [OperatorModeContainer, noop],
+					"isStrictMode": true
+				}), this);
+			}
+		});
+		await waitFor("[data-test-person=\"Fadhlan\"]");
+		let roomId = createAndJoinRoom({
+			sender: "@testuser:localhost",
+			name: "test room 1"
+		});
+		let commandRequestId = "cmd-request-id";
+		let strippedEditEventId = "stripped-edit-event-id";
+		simulateRemoteMessage(roomId, "@aibot:localhost", {
+			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
+			body: "Changing first name to Evie",
+			format: "org.matrix.custom.html",
+			isStreamingFinished: true,
+			[APP_BOXEL_TOOL_REQUESTS_KEY]: [{
+				id: commandRequestId,
+				name: "patchCardInstance",
+				arguments: JSON.stringify({ attributes: {
+					cardId: `${testRealmURL}Person/fadhlan`,
+					patch: { attributes: { firstName: "Evie" } }
+				} })
+			}]
+		});
+		simulateRemoteMessage(roomId, "@aibot:localhost", {
+			msgtype: APP_BOXEL_TOOL_RESULT_WITH_NO_OUTPUT_MSGTYPE,
+			commandRequestId,
+			"m.relates_to": {
+				rel_type: APP_BOXEL_TOOL_RESULT_REL_TYPE,
+				key: "applied",
+				event_id: strippedEditEventId
+			},
+			data: {}
+		}, { type: APP_BOXEL_TOOL_RESULT_EVENT_TYPE });
+		await settled();
+		await click("[data-test-open-ai-assistant]");
+		await waitFor("[data-test-room-name=\"test room 1\"]");
+		await waitFor("[data-test-message-idx=\"0\"]");
+		assert.dom("[data-test-message-idx=\"0\"] [data-test-tool-call-apply=\"applied\"]").exists("a command applied before reload still renders applied even though its commandResult links to a stripped m.replace edit id; correlation is by commandRequestId, not the dangling event_id");
+	});
+	(0, import_qunit.test)("an applied commandResult flips only its own bot message, not a sibling message that also carries a command", async function(assert) {
+		setCardInOperatorModeState(`${testRealmURL}Person/fadhlan`);
+		await renderComponent(class TestDriver extends Component {
+			static {
+				setComponentTemplate(templateFactory({
+					"id": "hk0qKyFP",
+					"block": "[[[8,[32,0],null,[[\"@onClose\"],[[32,1]]],null]],[],[]]",
+					"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/components/ai-assistant-panel/tools-test.gts",
+					"scope": () => [OperatorModeContainer, noop],
+					"isStrictMode": true
+				}), this);
+			}
+		});
+		await waitFor("[data-test-person=\"Fadhlan\"]");
+		let roomId = createAndJoinRoom({
+			sender: "@testuser:localhost",
+			name: "test room 1"
+		});
+		let firstCommandRequestId = "first-cmd-request-id";
+		let secondCommandRequestId = "second-cmd-request-id";
+		let strippedEditEventId = "stripped-edit-event-id";
+		simulateRemoteMessage(roomId, "@aibot:localhost", {
+			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
+			body: "Changing first name to Evie",
+			format: "org.matrix.custom.html",
+			isStreamingFinished: true,
+			[APP_BOXEL_TOOL_REQUESTS_KEY]: [{
+				id: firstCommandRequestId,
+				name: "patchCardInstance",
+				arguments: JSON.stringify({ attributes: {
+					cardId: `${testRealmURL}Person/fadhlan`,
+					patch: { attributes: { firstName: "Evie" } }
+				} })
+			}]
+		});
+		simulateRemoteMessage(roomId, "@aibot:localhost", {
+			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
+			body: "Changing first name to Mango",
+			format: "org.matrix.custom.html",
+			isStreamingFinished: true,
+			[APP_BOXEL_TOOL_REQUESTS_KEY]: [{
+				id: secondCommandRequestId,
+				name: "patchCardInstance",
+				arguments: JSON.stringify({ attributes: {
+					cardId: `${testRealmURL}Person/fadhlan`,
+					patch: { attributes: { firstName: "Mango" } }
+				} })
+			}]
+		});
+		simulateRemoteMessage(roomId, "@aibot:localhost", {
+			msgtype: APP_BOXEL_TOOL_RESULT_WITH_NO_OUTPUT_MSGTYPE,
+			commandRequestId: secondCommandRequestId,
+			"m.relates_to": {
+				rel_type: APP_BOXEL_TOOL_RESULT_REL_TYPE,
+				key: "applied",
+				event_id: strippedEditEventId
+			},
+			data: {}
+		}, { type: APP_BOXEL_TOOL_RESULT_EVENT_TYPE });
+		await settled();
+		await click("[data-test-open-ai-assistant]");
+		await waitFor("[data-test-room-name=\"test room 1\"]");
+		await waitFor("[data-test-message-idx=\"1\"]");
+		assert.dom("[data-test-message-idx=\"1\"] [data-test-tool-call-apply=\"applied\"]").exists("the bot message whose commandRequestId owns the applied result renders applied");
+		assert.dom("[data-test-message-idx=\"0\"] [data-test-tool-call-apply=\"ready\"]").exists("the sibling bot message, which has no result of its own, stays ready — the applied status did not bleed across messages");
+	});
+	(0, import_qunit.test)("Accept All bar does not flash for an always-auto-executed command (checkCorrectness)", async function(assert) {
+		simulateRemoteMessage(await renderAiAssistantPanel(), "@aibot:localhost", {
+			body: "checking correctness",
+			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
+			format: "org.matrix.custom.html",
+			isStreamingFinished: true,
+			[APP_BOXEL_TOOL_REQUESTS_KEY]: [{
+				id: "cs-11647-check-correctness",
+				name: "checkCorrectness",
+				arguments: "{}"
+			}],
+			data: { context: { agentId: getService("matrix-service").agentId } }
+		});
+		await waitFor("[data-test-message-idx=\"0\"]");
+		assert.dom("[data-test-accept-all]").doesNotExist("Accept All button must not paint in the debounce window before auto-execute starts");
+		await settled();
+		assert.dom("[data-test-accept-all]").doesNotExist("Accept All button still hidden after the auto-execute debounce window elapses");
+	});
+	(0, import_qunit.test)("Accept All bar does not flash for a requiresApproval=false command", async function(assert) {
+		setCardInOperatorModeState(`${testRealmURL}Person/fadhlan`);
+		await renderComponent(class TestDriver extends Component {
+			static {
+				setComponentTemplate(templateFactory({
+					"id": "hk0qKyFP",
+					"block": "[[[8,[32,0],null,[[\"@onClose\"],[[32,1]]],null]],[],[]]",
+					"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/components/ai-assistant-panel/tools-test.gts",
+					"scope": () => [OperatorModeContainer, noop],
+					"isStrictMode": true
+				}), this);
+			}
+		});
+		await waitFor("[data-test-person=\"Fadhlan\"]");
+		createAndJoinRoom({
+			sender: "@testuser:localhost",
+			name: "auto-exec via skill"
+		});
+		await settled();
+		await click("[data-test-open-ai-assistant]");
+		await waitFor("[data-test-room-name=\"auto-exec via skill\"]", { timeout: 1e4 });
+		await addSkillToAiAssistant(`${testRealmURL}Skill/boxel-environment`);
+		simulateRemoteMessage(document.querySelector("[data-test-room]").getAttribute("data-test-room"), "@aibot:localhost", {
+			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
+			body: "Reading hello file",
+			format: "org.matrix.custom.html",
+			isStreamingFinished: true,
+			[APP_BOXEL_TOOL_REQUESTS_KEY]: [{
+				id: "cs-11647-no-approval",
+				name: "read-file-for-ai-assistant_a831",
+				arguments: JSON.stringify({ attributes: { fileIdentifier: `${testRealmURL}hello.txt` } })
+			}],
+			data: { context: { agentId: getService("matrix-service").agentId } }
+		});
+		await waitFor("[data-test-message-idx=\"0\"]");
+		assert.dom("[data-test-accept-all]").doesNotExist("Accept All button suppressed for requiresApproval=false commands");
+	});
+	(0, import_qunit.test)("per-command Apply button does not flash Run before auto-execute starts", async function(assert) {
+		simulateRemoteMessage(await renderAiAssistantPanel(), "@aibot:localhost", {
+			body: "checking correctness",
+			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
+			format: "org.matrix.custom.html",
+			isStreamingFinished: true,
+			[APP_BOXEL_TOOL_REQUESTS_KEY]: [{
+				id: "cs-11647-apply-button",
+				name: "checkCorrectness",
+				arguments: "{}"
+			}],
+			data: { context: { agentId: getService("matrix-service").agentId } }
+		});
+		await waitFor("[data-test-message-idx=\"0\"] [data-test-tool-call-apply]");
+		assert.dom("[data-test-message-idx=\"0\"] [data-test-tool-call-apply=\"ready\"]").doesNotExist("per-command Apply button must not show the ready/Run state for an auto-executed command");
+		assert.dom("[data-test-message-idx=\"0\"] [data-test-tool-call-apply=\"applying\"]").exists("per-command Apply button shows the applying spinner instead");
+		assert.dom("[data-test-message-idx=\"0\"] [data-test-tool-call-card-idle]").doesNotExist("data-test-tool-call-card-idle agrees with applyButtonState while the synthetic spinner is on");
+	});
+	(0, import_qunit.test)("stuck-processing helper dispatches an invalid commandResult for each auto-executable command", async function(assert) {
+		let roomId = await renderAiAssistantPanel();
+		let matrixService = getService("matrix-service");
+		let toolService = getService("tool-service");
+		simulateRemoteMessage(roomId, "@aibot:localhost", {
+			body: "checking correctness",
+			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
+			format: "org.matrix.custom.html",
+			isStreamingFinished: true,
+			[APP_BOXEL_TOOL_REQUESTS_KEY]: [{
+				id: "cs-11647-stuck-auto",
+				name: "checkCorrectness",
+				arguments: "{}"
+			}, {
+				id: "cs-11647-stuck-manual",
+				name: "patchCardInstance",
+				arguments: JSON.stringify({ attributes: {
+					cardId: `${testRealmURL}Person/fadhlan`,
+					patch: { attributes: { firstName: "Dave" } }
+				} })
+			}],
+			data: { context: { agentId: matrixService.agentId } }
+		});
+		await waitFor("[data-test-message-idx=\"0\"] [data-test-tool-call-apply]");
+		let roomResource = matrixService.roomResources.get(roomId);
+		let message = roomResource.messages.find((m) => m.tools?.length === 2);
+		assert.ok(message, "two-command bot message lands in the room resource");
+		let captured = [];
+		let originalSend = matrixService.sendToolResultEvent.bind(matrixService);
+		matrixService.sendToolResultEvent = async (params) => {
+			captured.push({
+				toolCallId: params.toolCallId,
+				failureReason: params.failureReason
+			});
+		};
+		try {
+			await toolService.invalidateAutoExecutableToolsForStuckProcessing(roomResource, roomId, message.eventId);
+		} finally {
+			matrixService.sendToolResultEvent = originalSend;
+		}
+		assert.strictEqual(captured.length, 1, "only the auto-executable command is invalidated; manual-approval command is left in ready");
+		assert.strictEqual(captured[0]?.toolCallId, "cs-11647-stuck-auto", "the dispatched invalid event targets the auto-executable command");
+		assert.true((captured[0]?.failureReason ?? "").startsWith("Room processing did not finish within"), "failureReason surfaces the stuck-processing cause for the invalidToolCallState alert");
+	});
+	(0, import_qunit.test)("an invalid result is terminal for auto-execution: a later drain pass does not re-resolve the request", async function(assert) {
+		let roomId = await renderAiAssistantPanel();
+		let matrixService = getService("matrix-service");
+		let toolService = getService("tool-service");
+		let captured = [];
+		let originalSend = matrixService.sendToolResultEvent.bind(matrixService);
+		matrixService.sendToolResultEvent = async (params) => {
+			captured.push({
+				toolCallId: params.toolCallId,
+				status: params.status
+			});
+		};
+		try {
+			let eventId = simulateRemoteMessage(roomId, "@aibot:localhost", {
+				body: "Do the thing",
+				msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
+				format: "org.matrix.custom.html",
+				isStreamingFinished: true,
+				[APP_BOXEL_TOOL_REQUESTS_KEY]: [{
+					id: "cs-12103-invalid-terminal",
+					name: "no-such-command",
+					arguments: JSON.stringify({
+						description: "do it",
+						attributes: {}
+					})
+				}],
+				data: { context: { agentId: matrixService.agentId } }
+			});
+			await settled();
+			assert.deepEqual(captured, [{
+				toolCallId: "cs-12103-invalid-terminal",
+				status: "invalid"
+			}], "validation resolves the request invalid exactly once");
+			assert.true(toolService.claimedToolRequestIds.has("cs-12103-invalid-terminal"), "the terminal resolution is recorded locally, not just in the (still in-flight) result event");
+			toolService.queueEventForToolProcessing({
+				event_id: eventId,
+				room_id: roomId,
+				content: {}
+			});
+			await settled();
+			assert.strictEqual(captured.length, 1, "the resolved request gets no second result and is not executed");
+		} finally {
+			matrixService.sendToolResultEvent = originalSend;
+		}
+	});
+	(0, import_qunit.test)("overlapping drain passes resolve a tool request exactly once", async function(assert) {
+		let roomId = await renderAiAssistantPanel();
+		let matrixService = getService("matrix-service");
+		let toolService = getService("tool-service");
+		let captured = [];
+		let originalSend = matrixService.sendToolResultEvent.bind(matrixService);
+		matrixService.sendToolResultEvent = async (params) => {
+			captured.push({
+				toolCallId: params.toolCallId,
+				status: params.status
+			});
+		};
+		let overlapAgentId = "overlap-test-agent";
+		let originalAgentId = matrixService.agentId;
+		try {
+			let eventId = simulateRemoteMessage(roomId, "@aibot:localhost", {
+				body: "Do the thing",
+				msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
+				format: "org.matrix.custom.html",
+				isStreamingFinished: true,
+				[APP_BOXEL_TOOL_REQUESTS_KEY]: [{
+					id: "overlap-victim",
+					name: "checkCorrectness",
+					arguments: "not parseable json, so validation resolves invalid"
+				}],
+				data: { context: { agentId: overlapAgentId } }
+			});
+			await settled();
+			assert.strictEqual(captured.length, 0, "the not-our-agent message is left unresolved by the timeline drain");
+			matrixService.agentId = overlapAgentId;
+			let svc = toolService;
+			svc.toolProcessingEventQueue.push(`${roomId}|${eventId}`);
+			let firstPass = svc.drainToolProcessingQueue();
+			await Promise.resolve();
+			svc.flushToolProcessingQueue = void 0;
+			svc.toolProcessingEventQueue.push(`${roomId}|${eventId}`);
+			let secondPass = svc.drainToolProcessingQueue();
+			await Promise.all([firstPass, secondPass]);
+			await settled();
+			assert.deepEqual(captured, [{
+				toolCallId: "overlap-victim",
+				status: "invalid"
+			}], "the request gets exactly one terminal result across both passes");
+		} finally {
+			matrixService.agentId = originalAgentId;
+			matrixService.sendToolResultEvent = originalSend;
+		}
+	});
+	const discoveredSkillUrl = `${testRealmURL}Skill/boxel-environment`;
+	const discoveredHostToolName = buildToolFunctionNameFromResolvedRef({
+		module: "@cardstack/boxel-host/commands/read-file-for-ai-assistant",
+		name: "default"
+	});
+	function simulateDiscoveredToolResult(roomId) {
+		simulateRemoteMessage(roomId, "@aibot:localhost", {
+			msgtype: APP_BOXEL_TOOL_RESULT_WITH_OUTPUT_MSGTYPE,
+			commandRequestId: "earlier-skill-read",
+			"m.relates_to": {
+				rel_type: APP_BOXEL_TOOL_RESULT_REL_TYPE,
+				key: "applied",
+				event_id: "earlier-bot-message"
+			},
+			data: {
+				attachedFiles: [],
+				discoveredTools: [{
+					sourceSkillUrl: discoveredSkillUrl,
+					codeRef: {
+						module: "@cardstack/boxel-host/commands/read-file-for-ai-assistant",
+						name: "default"
+					},
+					functionName: discoveredHostToolName,
+					requiresApproval: false,
+					definition: {
+						type: "function",
+						function: {
+							name: discoveredHostToolName,
+							description: "Read a file",
+							parameters: {
+								type: "object",
+								properties: {}
+							}
+						}
+					}
+				}]
+			}
+		}, { type: APP_BOXEL_TOOL_RESULT_EVENT_TYPE });
+	}
+	async function seedDiscoveredHostToolTurn(roomId) {
+		let agentId = getService("matrix-service").agentId;
+		simulateDiscoveredToolResult(roomId);
+		let streamingEventId = simulateRemoteMessage(roomId, "@aibot:localhost", {
+			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
+			body: "Reading",
+			format: "org.matrix.custom.html",
+			isStreamingFinished: false,
+			data: { context: { agentId } }
+		});
+		await settled();
+		return streamingEventId;
+	}
+	function holdDiscoveredSkillLoads() {
+		let store = getService("store");
+		let toolService = getService("tool-service");
+		let originalValidateTimeoutMs = toolService.validateTimeoutMs;
+		toolService.validateTimeoutMs = 6e4;
+		let release = new Deferred();
+		let heldLoads = 0;
+		let originalGet = store.get;
+		store.get = async (id, ...rest) => {
+			if (id === discoveredSkillUrl) {
+				heldLoads++;
+				await release.promise;
+			}
+			return originalGet.call(store, id, ...rest);
+		};
+		return {
+			get heldLoads() {
+				return heldLoads;
+			},
+			async reached() {
+				await waitUntil(() => heldLoads > 0, {
+					timeout: 5e3,
+					timeoutMessage: "the final edit never started resolving the discovered host tool (no load of its skill within 5s)"
+				});
+			},
+			release() {
+				release.fulfill();
+				store.get = originalGet;
+				toolService.validateTimeoutMs = originalValidateTimeoutMs;
+			}
+		};
+	}
+	function failDiscoveredSkillLoads() {
+		let store = getService("store");
+		let originalGet = store.get;
+		store.get = async (id, ...rest) => {
+			if (id === discoveredSkillUrl) throw new Error("simulated skill load failure");
+			return originalGet.call(store, id, ...rest);
+		};
+		return { restore() {
+			store.get = originalGet;
+		} };
+	}
+	function failCommandModuleImport() {
+		let loaderPrototype = Object.getPrototypeOf(getService("loader-service").loader);
+		let originalImport = loaderPrototype.import;
+		let importsRefused = 0;
+		loaderPrototype.import = async function(moduleId, ...rest) {
+			if (String(moduleId).includes("read-file-for-ai-assistant")) {
+				importsRefused++;
+				throw new Error("simulated command module load failure");
+			}
+			return originalImport.call(this, moduleId, ...rest);
+		};
+		return {
+			get importsRefused() {
+				return importsRefused;
+			},
+			restore() {
+				loaderPrototype.import = originalImport;
+			}
+		};
+	}
+	function finalEditWithHostTool(streamingEventId, body, toolRequests) {
+		return {
+			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
+			body,
+			format: "org.matrix.custom.html",
+			isStreamingFinished: true,
+			[APP_BOXEL_TOOL_REQUESTS_KEY]: [...toolRequests, {
+				id: "slow-host-read",
+				name: discoveredHostToolName,
+				arguments: JSON.stringify({ attributes: { fileIdentifier: `${testRealmURL}hello.txt` } })
+			}],
+			"m.relates_to": {
+				rel_type: "m.replace",
+				event_id: streamingEventId
+			},
+			data: { context: { agentId: getService("matrix-service").agentId } }
+		};
+	}
+	async function drainIsValidating(toolCallId) {
+		let toolService = getService("tool-service");
+		await waitUntil(() => toolService.validationSteps.has(toolCallId), {
+			timeout: 5e3,
+			timeoutMessage: `the tool drain never started validating ${toolCallId}`
+		});
+	}
+	(0, import_qunit.test)("a host tool whose resolution outlasts a room-processing restart still runs", async function(assert) {
+		let roomId = await renderAiAssistantPanel();
+		let streamingEventId = await seedDiscoveredHostToolTurn(roomId);
+		let hold = holdDiscoveredSkillLoads();
+		try {
+			simulateRemoteMessage(roomId, "@aibot:localhost", finalEditWithHostTool(streamingEventId, "Reading", [{
+				id: "bot-run-read",
+				name: "readRealmFile",
+				arguments: JSON.stringify({ path: "hello.txt" }),
+				executedBy: AI_BOT_EXECUTOR
+			}]));
+			await hold.reached();
+			simulateRemoteMessage(roomId, "@aibot:localhost", {
+				msgtype: APP_BOXEL_TOOL_RESULT_WITH_NO_OUTPUT_MSGTYPE,
+				commandRequestId: "bot-run-read",
+				"m.relates_to": {
+					rel_type: APP_BOXEL_TOOL_RESULT_REL_TYPE,
+					key: "applied",
+					event_id: streamingEventId
+				}
+			}, { type: APP_BOXEL_TOOL_RESULT_EVENT_TYPE });
+			await drainIsValidating("slow-host-read");
+			assert.strictEqual(hold.heldLoads, 1, "neither the restarted room pass nor the drain starts a second resolution");
+		} finally {
+			hold.release();
+		}
+		await settled();
+		let hostToolResults = getRoomEvents(roomId).filter((event) => event.type === "app.boxel.toolResult" && event.content.commandRequestId === "slow-host-read");
+		assert.strictEqual(hostToolResults.length, 1, "the host tool resolved after the restart is run and its result posted");
+		assert.strictEqual(hostToolResults[0]?.content["m.relates_to"]?.key, "applied", `the host tool ran successfully (failure reason: ${hostToolResults[0]?.content.failureReason ?? "none"})`);
+		assert.dom("[data-test-tool-call-apply=\"applying\"]").doesNotExist("no tool is left spinning in the applying state");
+	});
+	(0, import_qunit.test)("a response-stream preview that arrives while the final edit resolves its tools does not overwrite it", async function(assert) {
+		let roomId = await renderAiAssistantPanel();
+		let streamingEventId = await seedDiscoveredHostToolTurn(roomId);
+		let matrixService = getService("matrix-service");
+		let hold = holdDiscoveredSkillLoads();
+		try {
+			simulateRemoteMessage(roomId, "@aibot:localhost", finalEditWithHostTool(streamingEventId, "The final answer.", []));
+			await hold.reached();
+			simulateToDeviceEvent(APP_BOXEL_RESPONSE_STREAM_EVENT_TYPE, {
+				roomId,
+				parentEventId: streamingEventId,
+				sequence: 99,
+				body: "A stale preview.",
+				reasoning: "",
+				toolRequests: []
+			}, matrixService.aiBotUserId);
+			await delay(100);
+		} finally {
+			hold.release();
+		}
+		await settled();
+		let message = matrixService.roomResources.get(roomId).messageForEventId(streamingEventId);
+		assert.strictEqual(message.body, "The final answer.", "the final edit keeps its body");
+		assert.true(message.isStreamingFinished, "the message stays finished");
+		assert.dom(`[data-test-room="${roomId}"]`).doesNotContainText("A stale preview.");
+	});
+	(0, import_qunit.test)("a host tool whose command never resolves gets a terminal invalid result and the room keeps processing", async function(assert) {
+		let roomId = await renderAiAssistantPanel();
+		let streamingEventId = await seedDiscoveredHostToolTurn(roomId);
+		let fail = failDiscoveredSkillLoads();
+		try {
+			simulateRemoteMessage(roomId, "@aibot:localhost", finalEditWithHostTool(streamingEventId, "Reading", []));
+			await settled();
+		} finally {
+			fail.restore();
+		}
+		await settled();
+		let hostToolResults = getRoomEvents(roomId).filter((event) => event.type === "app.boxel.toolResult" && event.content.commandRequestId === "slow-host-read");
+		assert.strictEqual(hostToolResults.length, 1, "exactly one terminal result is posted for the request that never resolved");
+		assert.strictEqual(hostToolResults[0]?.content["m.relates_to"]?.key, "invalid", "the unresolvable tool is reported invalid");
+		assert.dom("[data-test-tool-call-apply=\"applying\"]").doesNotExist("no tool is left spinning in the applying state");
+		simulateRemoteMessage(roomId, "@aibot:localhost", {
+			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
+			body: "Still alive",
+			format: "org.matrix.custom.html",
+			isStreamingFinished: true,
+			data: { context: { agentId: getService("matrix-service").agentId } }
+		});
+		await settled();
+		assert.dom(`[data-test-room="${roomId}"]`).containsText("Still alive", "the room keeps processing later events");
+	});
+	(0, import_qunit.test)("a host tool renamed by the final edit runs as the renamed tool, not the stale one", async function(assert) {
+		let roomId = await renderAiAssistantPanel();
+		let streamingEventId = await seedDiscoveredHostToolTurn(roomId);
+		simulateRemoteMessage(roomId, "@aibot:localhost", {
+			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
+			body: "Reading",
+			format: "org.matrix.custom.html",
+			isStreamingFinished: false,
+			[APP_BOXEL_TOOL_REQUESTS_KEY]: [{
+				id: "slow-host-read",
+				name: "read-file-for"
+			}],
+			"m.relates_to": {
+				rel_type: "m.replace",
+				event_id: streamingEventId
+			},
+			data: { context: { agentId: getService("matrix-service").agentId } }
+		});
+		await settled();
+		let hold = holdDiscoveredSkillLoads();
+		try {
+			simulateRemoteMessage(roomId, "@aibot:localhost", finalEditWithHostTool(streamingEventId, "Reading", []));
+			await hold.reached();
+			await drainIsValidating("slow-host-read");
+			assert.strictEqual(getRoomEvents(roomId).filter((event) => event.type === "app.boxel.toolResult" && event.content.commandRequestId === "slow-host-read").length, 0, "the drain waits for the renamed tool instead of validating the stale name");
+		} finally {
+			hold.release();
+		}
+		await settled();
+		let hostToolResults = getRoomEvents(roomId).filter((event) => event.type === "app.boxel.toolResult" && event.content.commandRequestId === "slow-host-read");
+		assert.strictEqual(hostToolResults.length, 1, "exactly one result");
+		assert.strictEqual(hostToolResults[0]?.content["m.relates_to"]?.key, "applied", `the renamed tool ran (failure reason: ${hostToolResults[0]?.content.failureReason ?? "none"})`);
+	});
+	(0, import_qunit.test)("a call that already has a result is not answered again when its command no longer resolves", async function(assert) {
+		let roomId = await renderAiAssistantPanel();
+		let streamingEventId = await seedDiscoveredHostToolTurn(roomId);
+		let fail = failDiscoveredSkillLoads();
+		try {
+			simulateRemoteMessage(roomId, "@aibot:localhost", finalEditWithHostTool(streamingEventId, "Reading", []));
+			simulateRemoteMessage(roomId, "@testuser:localhost", {
+				msgtype: APP_BOXEL_TOOL_RESULT_WITH_NO_OUTPUT_MSGTYPE,
+				commandRequestId: "slow-host-read",
+				"m.relates_to": {
+					rel_type: APP_BOXEL_TOOL_RESULT_REL_TYPE,
+					key: "applied",
+					event_id: streamingEventId
+				}
+			}, { type: APP_BOXEL_TOOL_RESULT_EVENT_TYPE });
+			await settled();
+		} finally {
+			fail.restore();
+		}
+		let hostToolResults = getRoomEvents(roomId).filter((event) => event.type === "app.boxel.toolResult" && event.content.commandRequestId === "slow-host-read");
+		assert.deepEqual(hostToolResults.map((event) => event.content["m.relates_to"]?.key), ["applied"], "only the existing result, no contradictory invalid");
+	});
+	(0, import_qunit.test)("a call whose command fails to load gets a terminal invalid result saying it could not be prepared", async function(assert) {
+		let roomId = await renderAiAssistantPanel();
+		let streamingEventId = await seedDiscoveredHostToolTurn(roomId);
+		let toolService = getService("tool-service");
+		let originalValidateTimeoutMs = toolService.validateTimeoutMs;
+		toolService.validateTimeoutMs = 6e4;
+		let fail = failCommandModuleImport();
+		try {
+			simulateRemoteMessage(roomId, "@aibot:localhost", finalEditWithHostTool(streamingEventId, "Reading", []));
+			await settled();
+		} finally {
+			fail.restore();
+			toolService.validateTimeoutMs = originalValidateTimeoutMs;
+		}
+		let hostToolResults = getRoomEvents(roomId).filter((event) => event.type === "app.boxel.toolResult" && event.content.commandRequestId === "slow-host-read");
+		assert.strictEqual(hostToolResults.length, 1, "exactly one result");
+		assert.strictEqual(hostToolResults[0]?.content["m.relates_to"]?.key, "invalid", "the call is reported invalid");
+		assert.true(String(hostToolResults[0]?.content.failureReason).includes("could not be prepared (simulated command module load failure)"), `the reason names the load failure: ${hostToolResults[0]?.content.failureReason}`);
+		assert.dom("[data-test-tool-call-apply=\"applying\"]").doesNotExist("no tool is left spinning in the applying state");
+	});
+	(0, import_qunit.test)("a validation that times out and then finds the call invalid leaves only the failed result", async function(assert) {
+		let roomId = await renderAiAssistantPanel();
+		let streamingEventId = await seedDiscoveredHostToolTurn(roomId);
+		let toolService = getService("tool-service");
+		let originalValidateTimeoutMs = toolService.validateTimeoutMs;
+		let hold = holdDiscoveredSkillLoads();
+		toolService.validateTimeoutMs = 200;
+		let fail = failCommandModuleImport();
+		let toolResults = () => getRoomEvents(roomId).filter((event) => event.type === "app.boxel.toolResult" && event.content.commandRequestId === "slow-host-read");
+		try {
+			simulateRemoteMessage(roomId, "@aibot:localhost", finalEditWithHostTool(streamingEventId, "Reading", []));
+			await hold.reached();
+			await waitUntil(() => toolResults().length > 0, {
+				timeout: 5e3,
+				timeoutMessage: "the drain never reported the validation timeout"
+			});
+		} finally {
+			hold.release();
+		}
+		try {
+			await waitUntil(() => toolService.validationsInFlight === 0, {
+				timeout: 1e4,
+				timeoutMessage: "the timed-out validation never finished"
+			});
+			await settled();
+		} finally {
+			fail.restore();
+			toolService.validateTimeoutMs = originalValidateTimeoutMs;
+		}
+		assert.true(fail.importsRefused > 0, "the timed-out validation went on to the command module import");
+		assert.deepEqual(toolResults().map((event) => event.content["m.relates_to"]?.key), ["failed"], "only the timeout result, no contradictory invalid");
+	});
+	(0, import_qunit.test)("a call whose invalid result cannot be sent still gets a failed result", async function(assert) {
+		let roomId = await renderAiAssistantPanel();
+		let streamingEventId = await seedDiscoveredHostToolTurn(roomId);
+		let toolService = getService("tool-service");
+		let originalValidateTimeoutMs = toolService.validateTimeoutMs;
+		toolService.validateTimeoutMs = 6e4;
+		let matrixService = getService("matrix-service");
+		let originalSend = matrixService.sendToolResultEvent;
+		let refusedSends = 0;
+		matrixService.sendToolResultEvent = async function(params, ...rest) {
+			if (params.status === "invalid") {
+				refusedSends++;
+				throw new Error("simulated invalid result send failure");
+			}
+			return originalSend.call(matrixService, params, ...rest);
+		};
+		let fail = failCommandModuleImport();
+		try {
+			simulateRemoteMessage(roomId, "@aibot:localhost", finalEditWithHostTool(streamingEventId, "Reading", []));
+			await settled();
+		} finally {
+			fail.restore();
+			matrixService.sendToolResultEvent = originalSend;
+			toolService.validateTimeoutMs = originalValidateTimeoutMs;
+		}
+		let hostToolResults = getRoomEvents(roomId).filter((event) => event.type === "app.boxel.toolResult" && event.content.commandRequestId === "slow-host-read");
+		assert.strictEqual(refusedSends, 1, "the invalid result was refused");
+		assert.deepEqual(hostToolResults.map((event) => event.content["m.relates_to"]?.key), ["failed"], "the call still gets a terminal result");
+		let failureReason = String(hostToolResults[0]?.content.failureReason);
+		assert.true(failureReason.includes("could not be prepared (simulated command module load failure)"), `the reason still says why the call was invalid: ${failureReason}`);
+		assert.true(failureReason.includes("simulated invalid result send failure"), `the reason names the send failure: ${failureReason}`);
+	});
+	(0, import_qunit.test)("another agent's call that first resolved to no command is resolved again when its request finishes", async function(assert) {
+		let roomId = await renderAiAssistantPanel();
+		let otherAgentContext = { context: { agentId: "another-agent" } };
+		let streamingEventId = simulateRemoteMessage(roomId, "@aibot:localhost", {
+			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
+			body: "Reading",
+			format: "org.matrix.custom.html",
+			isStreamingFinished: false,
+			[APP_BOXEL_TOOL_REQUESTS_KEY]: [{
+				id: "other-agent-read",
+				name: discoveredHostToolName
+			}],
+			data: otherAgentContext
+		});
+		await settled();
+		let roomResource = getService("matrix-service").roomResources.get(roomId);
+		let tool = () => roomResource.messageForEventId(streamingEventId).tools.find((t) => t.id === "other-agent-read");
+		assert.strictEqual(tool().codeRef, void 0, "no command is found yet");
+		simulateDiscoveredToolResult(roomId);
+		simulateRemoteMessage(roomId, "@aibot:localhost", {
+			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
+			body: "Reading",
+			format: "org.matrix.custom.html",
+			isStreamingFinished: true,
+			[APP_BOXEL_TOOL_REQUESTS_KEY]: [{
+				id: "other-agent-read",
+				name: discoveredHostToolName,
+				arguments: JSON.stringify({ attributes: { fileIdentifier: `${testRealmURL}hello.txt` } })
+			}],
+			"m.relates_to": {
+				rel_type: "m.replace",
+				event_id: streamingEventId
+			},
+			data: otherAgentContext
+		});
+		await settled();
+		assert.strictEqual(tool().codeRef?.module, "@cardstack/boxel-host/commands/read-file-for-ai-assistant", "the finished call resolves to its command in a tab whose drain doesn't run it");
+		assert.strictEqual(tool().actionVerb, "Send", "the command's action verb");
+		assert.strictEqual(getRoomEvents(roomId).filter((event) => event.type === "app.boxel.toolResult" && event.content.commandRequestId === "other-agent-read").length, 0, "this tab does not run another agent's call");
+	});
+	(0, import_qunit.test)("Accept All bar still renders for a command that requires user approval", async function(assert) {
+		simulateRemoteMessage(await renderAiAssistantPanel(`${testRealmURL}Person/fadhlan`), "@aibot:localhost", {
+			body: "patching",
+			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
+			format: "org.matrix.custom.html",
+			isStreamingFinished: true,
+			[APP_BOXEL_TOOL_REQUESTS_KEY]: [{
+				id: "cs-11647-patch",
+				name: "patchCardInstance",
+				arguments: JSON.stringify({ attributes: {
+					cardId: `${testRealmURL}Person/fadhlan`,
+					patch: { attributes: { firstName: "Dave" } }
+				} })
+			}]
+		});
+		await waitFor("[data-test-accept-all]");
+		assert.dom("[data-test-accept-all]").exists("manual approval bar still renders for commands that need user approval");
+		assert.dom("[data-test-stop-generating]").doesNotExist("nothing runs until the user approves, so there is no Stop");
+	});
+	function stubToolValidation({ held = false, heldToolIds, rejectSend } = {}) {
+		let toolService = getService("tool-service");
+		let matrixService = getService("matrix-service");
+		let release;
+		let released = held || heldToolIds ? new Promise((resolve) => release = resolve) : Promise.resolve();
+		let validating = /* @__PURE__ */ new Set();
+		let originalValidate = toolService.validate;
+		toolService.validate = async (messageTool) => {
+			if (messageTool.id) validating.add(messageTool.id);
+			if (!heldToolIds || heldToolIds.includes(messageTool.id ?? "")) await released;
+			return { valid: true };
+		};
+		let results = [];
+		let originalSend = matrixService.sendToolResultEvent;
+		matrixService.sendToolResultEvent = async function(params) {
+			results.push({
+				toolCallId: params.toolCallId,
+				status: params.status,
+				failureReason: params.failureReason,
+				resumesAssistant: params.resumesAssistant
+			});
+			if (rejectSend?.(params)) throw new Error("the result could not be sent");
+			return originalSend.call(this, params);
+		};
+		return {
+			results,
+			validating,
+			release: () => release?.(),
+			restore() {
+				release?.();
+				toolService.validate = originalValidate;
+				matrixService.sendToolResultEvent = originalSend;
+			}
+		};
+	}
+	function checkCorrectnessCall(toolCallId) {
+		return {
+			[APP_BOXEL_TOOL_REQUESTS_KEY]: [{
+				id: toolCallId,
+				name: "checkCorrectness",
+				arguments: "{}"
+			}],
+			data: { context: { agentId: getService("matrix-service").agentId } }
+		};
+	}
+	async function stopWhileStreaming(roomId, toolCallId, stop, toolRequests = checkCorrectnessCall(toolCallId)) {
+		let streamingEventId = simulateRemoteMessage(roomId, "@aibot:localhost", {
+			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
+			body: "Checking",
+			format: "org.matrix.custom.html",
+			isStreamingFinished: false,
+			data: { context: { agentId: getService("matrix-service").agentId } }
+		});
+		await waitFor("[data-test-stop-generating]");
+		await stop();
+		await waitUntil(() => !document.querySelector("[data-test-stop-generating]"), { timeout: 5e3 });
+		simulateRemoteMessage(roomId, "@aibot:localhost", {
+			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
+			body: "Checking correctness",
+			format: "org.matrix.custom.html",
+			isStreamingFinished: true,
+			...toolRequests,
+			"m.relates_to": {
+				rel_type: "m.replace",
+				event_id: streamingEventId
+			}
+		});
+		return streamingEventId;
+	}
+	function patchPersonCall(toolCallId) {
+		return {
+			[APP_BOXEL_TOOL_REQUESTS_KEY]: [{
+				id: toolCallId,
+				name: "patchCardInstance",
+				arguments: JSON.stringify({ attributes: {
+					cardId: `${testRealmURL}Person/fadhlan`,
+					patch: { attributes: { firstName: "Dave" } }
+				} })
+			}],
+			data: { context: { agentId: getService("matrix-service").agentId } }
+		};
+	}
+	(0, import_qunit.test)("Stop is offered while a tool of the answer runs", async function(assert) {
+		let roomId = await renderAiAssistantPanel();
+		let stub = stubToolValidation({ held: true });
+		try {
+			simulateRemoteMessage(roomId, "@aibot:localhost", {
+				body: "checking correctness",
+				msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
+				format: "org.matrix.custom.html",
+				isStreamingFinished: true,
+				...checkCorrectnessCall("running-tool")
+			});
+			await waitFor("[data-test-stop-generating]");
+			assert.dom("[data-test-ai-assistant-action-bar]").containsText("Running tools", "the bar says tools are running");
+		} finally {
+			stub.restore();
+		}
+	});
+	(0, import_qunit.test)("a tool the user stopped before it started never runs", async function(assert) {
+		let roomId = await renderAiAssistantPanel();
+		let stub = stubToolValidation();
+		try {
+			await stopWhileStreaming(roomId, "stopped-before-run", () => click("[data-test-stop-generating]"));
+			await waitUntil(() => stub.results.length > 0, { timeout: 1e4 });
+			await settled();
+			assert.strictEqual(JSON.stringify(stub.results), JSON.stringify([{
+				toolCallId: "stopped-before-run",
+				status: "canceled",
+				failureReason: STOPPED_TOOL_CALL_REASON
+			}]), "the tool is answered as canceled instead of run");
+			assert.dom("[data-test-tool-call-apply=\"canceled\"]").exists("the tool reads as canceled");
+			assert.dom("[data-test-stop-generating]").doesNotExist("Stop is not offered again for the stopped loop");
+		} finally {
+			stub.restore();
+		}
+	});
+	(0, import_qunit.test)("a stop sent from the user's other client keeps a tool here from starting", async function(assert) {
+		let roomId = await renderAiAssistantPanel();
+		let stub = stubToolValidation();
+		try {
+			await stopWhileStreaming(roomId, "stopped-elsewhere", async () => {
+				simulateRemoteMessage(roomId, "@testuser:localhost", {}, { type: APP_BOXEL_STOP_GENERATING_EVENT_TYPE });
+			});
+			await waitUntil(() => stub.results.length > 0, { timeout: 1e4 });
+			await settled();
+			assert.strictEqual(JSON.stringify(stub.results.map(({ toolCallId, status }) => ({
+				toolCallId,
+				status
+			}))), JSON.stringify([{
+				toolCallId: "stopped-elsewhere",
+				status: "canceled"
+			}]));
+		} finally {
+			stub.restore();
+		}
+	});
+	(0, import_qunit.test)("a stop whose timestamp reads earlier than the answer still stops that answer", async function(assert) {
+		let roomId = await renderAiAssistantPanel();
+		let stub = stubToolValidation();
+		try {
+			await stopWhileStreaming(roomId, "stopped-with-skewed-clock", async () => {
+				simulateRemoteMessage(roomId, "@testuser:localhost", {}, {
+					type: APP_BOXEL_STOP_GENERATING_EVENT_TYPE,
+					origin_server_ts: 1
+				});
+			});
+			await waitUntil(() => stub.results.length > 0, { timeout: 1e4 });
+			await settled();
+			assert.strictEqual(JSON.stringify(stub.results.map(({ toolCallId, status }) => ({
+				toolCallId,
+				status
+			}))), JSON.stringify([{
+				toolCallId: "stopped-with-skewed-clock",
+				status: "canceled"
+			}]));
+		} finally {
+			stub.restore();
+		}
+	});
+	(0, import_qunit.test)("a stop the server has not confirmed yet holds although its clock reads earlier than the prompt", async function(assert) {
+		let roomId = await renderAiAssistantPanel();
+		let stub = stubToolValidation();
+		let releaseSend;
+		let held = false;
+		mockMatrixUtils.setSendEventInterceptor(async () => {
+			if (held) return;
+			held = true;
+			await new Promise((resolve) => releaseSend = resolve);
+		});
+		try {
+			let serverAhead = Date.now() + 3600 * 1e3;
+			simulateRemoteMessage(roomId, "@testuser:localhost", {
+				body: "check it",
+				msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
+				format: "org.matrix.custom.html"
+			}, { origin_server_ts: serverAhead });
+			let streamingEventId = simulateRemoteMessage(roomId, "@aibot:localhost", {
+				msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
+				body: "Checking",
+				format: "org.matrix.custom.html",
+				isStreamingFinished: false,
+				data: { context: { agentId: getService("matrix-service").agentId } }
+			}, { origin_server_ts: serverAhead + 1 });
+			await waitFor("[data-test-stop-generating]");
+			let matrixService = getService("matrix-service");
+			matrixService.sendStopGeneratingEvent(roomId);
+			let roomResource = matrixService.roomResources.get(roomId);
+			await waitUntil(() => roomResource.events.some((event) => event.type === "app.boxel.stopGenerating" && event.status === "sending"));
+			simulateRemoteMessage(roomId, "@aibot:localhost", {
+				msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
+				body: "Checking correctness",
+				format: "org.matrix.custom.html",
+				isStreamingFinished: true,
+				...checkCorrectnessCall("stopped-while-sending"),
+				"m.relates_to": {
+					rel_type: "m.replace",
+					event_id: streamingEventId
+				}
+			}, { origin_server_ts: serverAhead + 2 });
+			await waitUntil(() => stub.results.length > 0, { timeout: 1e4 });
+			await settled();
+			assert.strictEqual(JSON.stringify(stub.results.map(({ toolCallId, status }) => ({
+				toolCallId,
+				status
+			}))), JSON.stringify([{
+				toolCallId: "stopped-while-sending",
+				status: "canceled"
+			}]));
+		} finally {
+			mockMatrixUtils.setSendEventInterceptor(void 0);
+			releaseSend?.();
+			stub.restore();
+		}
+	});
+	(0, import_qunit.test)("a stop during a later tool's validation keeps the tools validated before it from starting", async function(assert) {
+		let roomId = await renderAiAssistantPanel();
+		let stub = stubToolValidation({ heldToolIds: ["validated-last"] });
+		try {
+			simulateRemoteMessage(roomId, "@aibot:localhost", {
+				body: "checking correctness twice",
+				msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
+				format: "org.matrix.custom.html",
+				isStreamingFinished: true,
+				[APP_BOXEL_TOOL_REQUESTS_KEY]: [{
+					id: "validated-first",
+					name: "checkCorrectness",
+					arguments: "{}"
+				}, {
+					id: "validated-last",
+					name: "checkCorrectness",
+					arguments: "{}"
+				}],
+				data: { context: { agentId: getService("matrix-service").agentId } }
+			});
+			await waitUntil(() => stub.validating.has("validated-last"), { timeout: 1e4 });
+			simulateRemoteMessage(roomId, "@testuser:localhost", {}, { type: APP_BOXEL_STOP_GENERATING_EVENT_TYPE });
+			let roomResource = getService("matrix-service").roomResources.get(roomId);
+			await waitUntil(() => roomResource.stopState.inForce !== void 0);
+			stub.release();
+			await waitUntil(() => stub.results.length === 2, { timeout: 1e4 });
+			await settled();
+			assert.strictEqual(JSON.stringify(stub.results.map(({ toolCallId, status }) => ({
+				toolCallId,
+				status
+			}))), JSON.stringify([{
+				toolCallId: "validated-first",
+				status: "canceled"
+			}, {
+				toolCallId: "validated-last",
+				status: "canceled"
+			}]), "neither tool had started when the user stopped, so neither runs");
+		} finally {
+			stub.restore();
+		}
+	});
+	(0, import_qunit.test)("Stop is not offered for a tool another of the user's clients runs", async function(assert) {
+		simulateRemoteMessage(await renderAiAssistantPanel(), "@aibot:localhost", {
+			body: "checking correctness",
+			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
+			format: "org.matrix.custom.html",
+			isStreamingFinished: true,
+			[APP_BOXEL_TOOL_REQUESTS_KEY]: [{
+				id: "other-client-tool",
+				name: "checkCorrectness",
+				arguments: "{}"
+			}],
+			data: { context: { agentId: "another-client-agent" } }
+		});
+		let offered = "[data-test-accept-all], [data-test-tool-call-id=\"other-client-tool\"] [data-test-pretui-tool-gate-action=\"apply\"]";
+		await waitFor(offered);
+		assert.dom("[data-test-stop-generating]").doesNotExist("only the client that runs the tool offers Stop for it");
+		assert.dom(offered).exists("this client offers the call like any other");
+	});
+	(0, import_qunit.test)("a message from the user after a stop lets the next tools run", async function(assert) {
+		let roomId = await renderAiAssistantPanel();
+		let stub = stubToolValidation();
+		try {
+			await stopWhileStreaming(roomId, "stopped-first", () => click("[data-test-stop-generating]"));
+			await waitUntil(() => stub.results.length > 0, { timeout: 1e4 });
+			simulateRemoteMessage(roomId, "@testuser:localhost", {
+				body: "try again",
+				msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
+				format: "org.matrix.custom.html"
+			});
+			simulateRemoteMessage(roomId, "@aibot:localhost", {
+				body: "checking correctness again",
+				msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
+				format: "org.matrix.custom.html",
+				isStreamingFinished: true,
+				...checkCorrectnessCall("after-new-message")
+			});
+			await waitUntil(() => stub.results.some((r) => r.toolCallId === "after-new-message"), { timeout: 2e4 });
+			await settled();
+			assert.notStrictEqual(stub.results.find((r) => r.toolCallId === "after-new-message")?.status, "canceled", "the stop no longer applies after the user writes again");
+		} finally {
+			stub.restore();
+		}
+	});
+	(0, import_qunit.test)("running a tool of the stopped answer by hand resumes the assistant", async function(assert) {
+		let roomId = await renderAiAssistantPanel(`${testRealmURL}Person/fadhlan`);
+		let stub = stubToolValidation();
+		try {
+			await stopWhileStreaming(roomId, "run-after-stop", () => click("[data-test-stop-generating]"), patchPersonCall("run-after-stop"));
+			await waitFor("[data-test-tool-call-apply=\"ready\"]");
+			let roomResource = getService("matrix-service").roomResources.get(roomId);
+			assert.ok(roomResource.stopState.inForce, "the stop is in force");
+			await click("[data-test-pretui-tool-gate-action=\"apply\"]");
+			await waitUntil(() => stub.results.length > 0, { timeout: 1e4 });
+			await settled();
+			assert.strictEqual(JSON.stringify(stub.results), JSON.stringify([{
+				toolCallId: "run-after-stop",
+				status: "applied",
+				resumesAssistant: true
+			}]), "the result says the user asked for the call to go ahead");
+			assert.notOk(roomResource.stopState.inForce, "the result lifts the stop");
+			simulateRemoteMessage(roomId, "@aibot:localhost", {
+				msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
+				body: "Applied, now",
+				format: "org.matrix.custom.html",
+				isStreamingFinished: false,
+				data: { context: { agentId: getService("matrix-service").agentId } }
+			});
+			await waitFor("[data-test-stop-generating]");
+			assert.dom("[data-test-stop-generating]").exists("Stop is offered again for the answer that follows");
+		} finally {
+			stub.restore();
+		}
+	});
+	(0, import_qunit.test)("every answer sends a result; the last call waiting on a message also gets a reaction", async function(assert) {
+		let roomId = await renderAiAssistantPanel();
+		let stub = stubToolValidation();
+		let matrixService = getService("matrix-service");
+		let originalReact = matrixService.sendReactionEvent;
+		let reactions = [];
+		matrixService.sendReactionEvent = async (_roomId, eventId, key) => {
+			reactions.push({
+				eventId,
+				key
+			});
+			return { event_id: "$reaction" };
+		};
+		try {
+			let eventId = simulateRemoteMessage(roomId, "@aibot:localhost", {
+				body: "may I read these?",
+				msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
+				format: "org.matrix.custom.html",
+				isStreamingFinished: true,
+				[APP_BOXEL_TOOL_REQUESTS_KEY]: ["approved-read", "declined-read"].map((id) => ({
+					id,
+					name: "readUrl",
+					arguments: JSON.stringify({ url: `https://example.com/${id}` }),
+					executedBy: AI_BOT_EXECUTOR,
+					approvalRequired: true
+				}))
+			});
+			let roomResource = getService("matrix-service").roomResources.get(roomId);
+			await waitUntil(() => roomResource.messages[0]?.tools.length === 2, { timeout: 1e4 });
+			let [approved, declined] = roomResource.messages[0].tools;
+			let toolService = getService("tool-service");
+			await toolService.answerApproval.unlinked().perform(approved, "approve");
+			await toolService.answerApproval.unlinked().perform(declined, "decline");
+			await settled();
+			assert.strictEqual(JSON.stringify(stub.results.map(({ toolCallId, status, resumesAssistant }) => ({
+				toolCallId,
+				status,
+				resumesAssistant
+			}))), JSON.stringify([{
+				toolCallId: "approved-read",
+				status: "approved",
+				resumesAssistant: true
+			}, {
+				toolCallId: "declined-read",
+				status: "invalid"
+			}]), "each answer is a result ai-bot acts on");
+			assert.deepEqual(reactions, [{
+				eventId,
+				key: "👎"
+			}], "only the last call waiting on the message adds a 👎, since a reaction answers the whole message");
+		} finally {
+			matrixService.sendReactionEvent = originalReact;
+			stub.restore();
+		}
+	});
+	(0, import_qunit.test)("a reaction after each call has its result changes neither answer", async function(assert) {
+		let roomId = await renderAiAssistantPanel();
+		let eventId = simulateRemoteMessage(roomId, "@aibot:localhost", {
+			body: "may I read these?",
+			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
+			format: "org.matrix.custom.html",
+			isStreamingFinished: true,
+			[APP_BOXEL_TOOL_REQUESTS_KEY]: ["approved-read", "declined-read"].map((id) => ({
+				id,
+				name: "readUrl",
+				arguments: JSON.stringify({ url: `https://example.com/${id}` }),
+				executedBy: AI_BOT_EXECUTOR,
+				approvalRequired: true
+			}))
+		});
+		let roomResource = getService("matrix-service").roomResources.get(roomId);
+		await waitUntil(() => roomResource.messages[0]?.tools.length === 2, { timeout: 1e4 });
+		for (let [commandRequestId, key] of [["approved-read", "approved"], ["declined-read", "invalid"]]) simulateRemoteMessage(roomId, "@testuser:localhost", {
+			msgtype: APP_BOXEL_TOOL_RESULT_WITH_NO_OUTPUT_MSGTYPE,
+			commandRequestId,
+			"m.relates_to": {
+				rel_type: APP_BOXEL_TOOL_RESULT_REL_TYPE,
+				key,
+				event_id: eventId
+			},
+			data: {}
+		}, { type: APP_BOXEL_TOOL_RESULT_EVENT_TYPE });
+		simulateRemoteMessage(roomId, "@testuser:localhost", { "m.relates_to": {
+			rel_type: "m.annotation",
+			event_id: eventId,
+			key: "👎"
+		} }, { type: "m.reaction" });
+		await settled();
+		let [approved, declined] = roomResource.messages[0].tools;
+		assert.strictEqual(approved.toolCallStatus, "approved");
+		assert.strictEqual(approved.approvalAnswer, void 0, "the 👎 that follows the last answer does not decline the approved call");
+		assert.strictEqual(declined.toolCallStatus, "invalid");
+	});
+	(0, import_qunit.test)("a 👍 from a room member approves the held call and says who", async function(assert) {
+		let roomId = await renderAiAssistantPanel();
+		let stub = stubToolValidation();
+		try {
+			let eventId = simulateRemoteMessage(roomId, "@aibot:localhost", {
+				body: "may I read this?",
+				msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
+				format: "org.matrix.custom.html",
+				isStreamingFinished: true,
+				[APP_BOXEL_TOOL_REQUESTS_KEY]: [{
+					id: "held-read",
+					name: "readUrl",
+					arguments: JSON.stringify({ url: "https://example.com/a" }),
+					executedBy: AI_BOT_EXECUTOR,
+					approvalRequired: true
+				}]
+			});
+			await waitFor("[data-test-tool-call-id=\"held-read\"] [data-test-tool-call-approval]");
+			simulateRemoteMessage(roomId, "@rupert:localhost", { "m.relates_to": {
+				rel_type: "m.annotation",
+				event_id: eventId,
+				key: "👍"
+			} }, { type: "m.reaction" });
+			await waitFor("[data-test-tool-call-approval-answer=\"approve\"]");
+			assert.dom("[data-test-tool-call-approval-answer=\"approve\"]").includesText("👍");
+			assert.dom("[data-test-tool-call-id=\"held-read\"] [data-test-tool-call-approval]").doesNotExist("the call no longer asks");
+			assert.strictEqual(stub.results.length, 0, "the host sends no result of its own");
+		} finally {
+			stub.restore();
+		}
+	});
+	(0, import_qunit.test)("a canceled result that cannot be sent shows the tool as failed, not spinning", async function(assert) {
+		let roomId = await renderAiAssistantPanel();
+		let stub = stubToolValidation({ rejectSend: ({ status }) => status === "canceled" });
+		try {
+			await stopWhileStreaming(roomId, "canceled-send-fails", () => click("[data-test-stop-generating]"));
+			await waitUntil(() => stub.results.length > 0, { timeout: 1e4 });
+			await settled();
+			assert.strictEqual(stub.results[0]?.status, "canceled");
+			assert.dom("[data-test-tool-call-apply=\"failed\"]").exists("the tool offers Retry instead of a spinner");
+		} finally {
+			stub.restore();
+		}
+	});
+	(0, import_qunit.test)("a tool already running when the user stops keeps its spinner until its result lands", async function(assert) {
+		let roomId = await renderAiAssistantPanel();
+		let toolService = getService("tool-service");
+		toolService.currentlyExecutingToolRequestIds.add("already-running");
+		try {
+			let eventId = await stopWhileStreaming(roomId, "already-running", () => click("[data-test-stop-generating]"));
+			await waitFor("[data-test-tool-call-apply=\"applying\"]");
+			assert.dom("[data-test-tool-call-apply=\"canceled\"]").doesNotExist("a running tool is not shown as canceled");
+			await settled();
+			toolService.currentlyExecutingToolRequestIds.delete("already-running");
+			simulateRemoteMessage(roomId, "@testuser:localhost", {
+				msgtype: APP_BOXEL_TOOL_RESULT_WITH_NO_OUTPUT_MSGTYPE,
+				commandRequestId: "already-running",
+				"m.relates_to": {
+					rel_type: APP_BOXEL_TOOL_RESULT_REL_TYPE,
+					key: "applied",
+					event_id: eventId
+				}
+			}, { type: APP_BOXEL_TOOL_RESULT_EVENT_TYPE });
+			await waitFor("[data-test-tool-call-apply=\"applied\"]", { timeout: 1e4 });
+			assert.dom("[data-test-tool-call-apply=\"applied\"]").exists("its result still lands");
+		} finally {
+			toolService.currentlyExecutingToolRequestIds.delete("already-running");
+		}
+	});
+	(0, import_qunit.test)("Stop is not offered for an answer that ended in an error", async function(assert) {
+		simulateRemoteMessage(await renderAiAssistantPanel(), "@aibot:localhost", {
+			body: "reading",
+			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
+			format: "org.matrix.custom.html",
+			isStreamingFinished: true,
+			errorMessage: "The model stopped answering",
+			[APP_BOXEL_TOOL_REQUESTS_KEY]: [{
+				id: "read-that-never-ran",
+				name: "readUrl",
+				arguments: JSON.stringify({ url: "https://example.com" }),
+				executedBy: AI_BOT_EXECUTOR
+			}]
+		});
+		await waitFor("[data-test-message-idx=\"0\"]");
+		await settled();
+		assert.dom("[data-test-stop-generating]").doesNotExist("the bot never reached its call, so nothing is running");
+	});
+	(0, import_qunit.test)("Stop is not offered for a tool whose result could not be sent", async function(assert) {
+		let roomId = await renderAiAssistantPanel();
+		let stub = stubToolValidation({ held: true });
+		try {
+			simulateRemoteMessage(roomId, "@aibot:localhost", {
+				body: "checking correctness",
+				msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
+				format: "org.matrix.custom.html",
+				isStreamingFinished: true,
+				...checkCorrectnessCall("result-never-sent")
+			});
+			await waitFor("[data-test-stop-generating]");
+			getService("matrix-service").failedToolState.set("result-never-sent", /* @__PURE__ */ new Error("the result could not be sent"));
+			await settled();
+			assert.dom("[data-test-stop-generating]").doesNotExist("no result will ever come, so nothing is running");
+		} finally {
+			stub.restore();
+		}
+	});
+	(0, import_qunit.test)("a stopped answer's tool stays stopped after the user writes again", async function(assert) {
+		let roomId = await renderAiAssistantPanel();
+		let stub = stubToolValidation({ held: true });
+		try {
+			simulateRemoteMessage(roomId, "@aibot:localhost", {
+				body: "checking correctness",
+				msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
+				format: "org.matrix.custom.html",
+				isStreamingFinished: true,
+				...checkCorrectnessCall("stopped-then-written")
+			});
+			await waitUntil(() => stub.validating.has("stopped-then-written"), { timeout: 1e4 });
+			simulateRemoteMessage(roomId, "@testuser:localhost", {}, { type: APP_BOXEL_STOP_GENERATING_EVENT_TYPE });
+			simulateRemoteMessage(roomId, "@testuser:localhost", {
+				body: "never mind",
+				msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
+				format: "org.matrix.custom.html"
+			});
+			let roomResource = getService("matrix-service").roomResources.get(roomId);
+			await waitUntil(() => roomResource.messages.length === 2);
+			assert.notOk(roomResource.stopState.inForce, "the stop is lifted");
+			stub.release();
+			await waitUntil(() => stub.results.length > 0, { timeout: 1e4 });
+			await settled();
+			assert.strictEqual(stub.results[0]?.status, "canceled", "the tool the user stopped never runs, lifted stop or not");
+		} finally {
+			stub.restore();
+		}
+	});
+	(0, import_qunit.test)("running one tool of a stopped answer by hand does not start its others", async function(assert) {
+		let roomId = await renderAiAssistantPanel();
+		let stub = stubToolValidation({ heldToolIds: ["left-over"] });
+		try {
+			let eventId = await stopWhileStreaming(roomId, "left-over", () => click("[data-test-stop-generating]"), {
+				[APP_BOXEL_TOOL_REQUESTS_KEY]: [...patchPersonCall("run-by-hand")[APP_BOXEL_TOOL_REQUESTS_KEY], {
+					id: "left-over",
+					name: "checkCorrectness",
+					arguments: "{}"
+				}],
+				data: { context: { agentId: getService("matrix-service").agentId } }
+			});
+			await waitUntil(() => stub.validating.has("left-over"), { timeout: 1e4 });
+			simulateRemoteMessage(roomId, "@testuser:localhost", {
+				msgtype: APP_BOXEL_TOOL_RESULT_WITH_NO_OUTPUT_MSGTYPE,
+				commandRequestId: "run-by-hand",
+				resumesAssistant: true,
+				"m.relates_to": {
+					rel_type: APP_BOXEL_TOOL_RESULT_REL_TYPE,
+					key: "applied",
+					event_id: eventId
+				}
+			}, { type: APP_BOXEL_TOOL_RESULT_EVENT_TYPE });
+			let roomResource = getService("matrix-service").roomResources.get(roomId);
+			await waitUntil(() => !roomResource.stopState.inForce);
+			stub.release();
+			await waitUntil(() => stub.results.length > 0, { timeout: 1e4 });
+			await settled();
+			assert.strictEqual(JSON.stringify(stub.results.map(({ toolCallId, status }) => ({
+				toolCallId,
+				status
+			}))), JSON.stringify([{
+				toolCallId: "left-over",
+				status: "canceled"
+			}]), "the user asked for one call, not the rest");
+		} finally {
+			stub.restore();
+		}
+	});
+	(0, import_qunit.test)("a call's latest result and the room's last activity follow the timeline, not the order events arrived in", async function(assert) {
+		let roomId = await renderAiAssistantPanel(`${testRealmURL}Person/fadhlan`);
+		let now = Date.now();
+		let eventId = simulateRemoteMessage(roomId, "@aibot:localhost", {
+			body: "patching",
+			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
+			format: "org.matrix.custom.html",
+			isStreamingFinished: true,
+			...patchPersonCall("retried-patch")
+		}, { origin_server_ts: now });
+		let result = (key, origin_server_ts) => simulateRemoteMessage(roomId, "@testuser:localhost", {
+			msgtype: APP_BOXEL_TOOL_RESULT_WITH_NO_OUTPUT_MSGTYPE,
+			commandRequestId: "retried-patch",
+			"m.relates_to": {
+				rel_type: APP_BOXEL_TOOL_RESULT_REL_TYPE,
+				key,
+				event_id: eventId
+			}
+		}, {
+			type: APP_BOXEL_TOOL_RESULT_EVENT_TYPE,
+			origin_server_ts
+		});
+		result("applied", now + 2e3);
+		await waitFor("[data-test-tool-call-apply=\"applied\"]");
+		result("failed", now + 1e3);
+		await settled();
+		assert.dom("[data-test-tool-call-apply=\"applied\"]").exists("the later result is the outcome, whenever it arrived");
+		let roomResource = getService("matrix-service").roomResources.get(roomId);
+		assert.strictEqual(roomResource.lastActiveTimestamp, now + 2e3, "the room was last active at its newest event");
+	});
+	function simulateShowCardResult(roomId, snapshotFirstName, cardId = `${testRealmURL}Person/fadhlan`) {
+		let snapshotUrl = "mxc://mock-server/fadhlan-snapshot";
+		let matrixService = getService("matrix-service");
+		let originalDownload = matrixService.downloadCardFileDef.bind(matrixService);
+		matrixService.downloadCardFileDef = async (serializedFile) => {
+			if (serializedFile.url !== snapshotUrl) return originalDownload(serializedFile);
+			return { data: {
+				id: cardId,
+				type: "card",
+				attributes: { firstName: snapshotFirstName },
+				meta: { adoptsFrom: {
+					module: `${testRealmURL}person`,
+					name: "Person"
+				} }
+			} };
+		};
+		let commandRequestId = "show-card-request-id";
+		simulateRemoteMessage(roomId, "@aibot:localhost", {
+			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
+			body: "Showing the card",
+			format: "org.matrix.custom.html",
+			isStreamingFinished: true,
+			[APP_BOXEL_TOOL_REQUESTS_KEY]: [{
+				id: commandRequestId,
+				name: "showCard",
+				arguments: JSON.stringify({ attributes: { cardId } })
+			}]
+		});
+		simulateRemoteMessage(roomId, "@aibot:localhost", {
+			msgtype: APP_BOXEL_TOOL_RESULT_WITH_OUTPUT_MSGTYPE,
+			commandRequestId,
+			"m.relates_to": {
+				rel_type: APP_BOXEL_TOOL_RESULT_REL_TYPE,
+				key: "applied",
+				event_id: "bot-message-event-id"
+			},
+			data: { card: {
+				url: snapshotUrl,
+				sourceUrl: cardId,
+				name: "Fadhlan",
+				contentType: "application/vnd.card+json"
+			} }
+		}, { type: APP_BOXEL_TOOL_RESULT_EVENT_TYPE });
+	}
+	(0, import_qunit.test)("rendering a tool result that snapshots a card already in the store leaves the live instance untouched", async function(assert) {
+		let roomId = await renderAiAssistantPanel(`${testRealmURL}Person/fadhlan`);
+		await waitFor("[data-test-person=\"Fadhlan\"]");
+		let savedFirstNames = [];
+		this.onSave((_, json) => {
+			if (typeof json === "string") throw new Error("expected JSON save data");
+			savedFirstNames.push(json.data.attributes?.firstName);
+		});
+		simulateShowCardResult(roomId, "Stale");
+		await waitForToolResult("[data-test-boxel-tool-call-result]");
+		await settled();
+		assert.dom("[data-test-person]").hasText("Fadhlan", "the card in the stack still shows the live data");
+		let live = getService("store").peek(`${testRealmURL}Person/fadhlan`);
+		assert.strictEqual(live?.firstName, "Fadhlan", "the resident instance keeps its live fields");
+		assert.dom("[data-test-boxel-tool-call-result]").containsText("Fadhlan", "the tool result renders the live card");
+		assert.deepEqual(savedFirstNames, [], "rendering the tool result does not save anything");
+		live.firstName = "Fadhlan Updated";
+		await settled();
+		assert.dom("[data-test-boxel-tool-call-result]").containsText("Fadhlan Updated", "the tool result follows the resident instance");
+		assert.deepEqual(savedFirstNames, ["Fadhlan Updated"], "the autosave writes the live value");
+	});
+	(0, import_qunit.test)("rendering a tool result that snapshots a card not yet in the store loads the live card instead of the snapshot", async function(assert) {
+		let roomId = await renderAiAssistantPanel();
+		this.onSave(() => {
+			assert.ok(false, "rendering a tool result must not trigger a save");
+		});
+		simulateShowCardResult(roomId, "Stale");
+		await waitForToolResult("[data-test-boxel-tool-call-result]");
+		await settled();
+		let live = getService("store").peek(`${testRealmURL}Person/fadhlan`);
+		assert.strictEqual(live?.firstName, "Fadhlan", "the store holds the live card, not the room snapshot");
+		assert.dom("[data-test-boxel-tool-call-result]").containsText("Fadhlan", "the tool result renders the live card");
+	});
+	(0, import_qunit.test)("rendering a tool result whose live card no longer exists renders the snapshot without installing it under the card id", async function(assert) {
+		let roomId = await renderAiAssistantPanel();
+		this.onSave(() => {
+			assert.ok(false, "rendering a tool result must not trigger a save");
+		});
+		let deletedId = `${testRealmURL}Person/deleted`;
+		simulateShowCardResult(roomId, "Snapshot", deletedId);
+		await waitForToolResult("[data-test-boxel-tool-call-result]");
+		await settled();
+		assert.dom("[data-test-boxel-tool-call-result]").containsText("Snapshot", "the tool result falls back to rendering the snapshot");
+		let store = getService("store");
+		assert.false(isCardInstance(store.peek(deletedId)), "the snapshot is not installed in the store under the realm id");
+	});
+	(0, import_qunit.test)("opening a fold of messages that each ran the same tool shows every call", async function(assert) {
+		let roomId = await renderAiAssistantPanel();
+		let renameTo = (name) => {
+			let requestId = `rename-${name}`;
+			simulateRemoteMessage(roomId, "@aibot:localhost", {
+				msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
+				body: "",
+				format: "org.matrix.custom.html",
+				isStreamingFinished: true,
+				[APP_BOXEL_TOOL_REQUESTS_KEY]: [{
+					id: requestId,
+					name: "patchCardInstance",
+					arguments: JSON.stringify({
+						description: `Rename to ${name}`,
+						attributes: {
+							cardId: `${testRealmURL}Person/fadhlan`,
+							patch: { attributes: { firstName: name } }
+						}
+					})
+				}]
+			});
+			simulateRemoteMessage(roomId, "@aibot:localhost", {
+				msgtype: APP_BOXEL_TOOL_RESULT_WITH_NO_OUTPUT_MSGTYPE,
+				commandRequestId: requestId,
+				"m.relates_to": {
+					rel_type: APP_BOXEL_TOOL_RESULT_REL_TYPE,
+					key: "applied",
+					event_id: requestId
+				},
+				data: {}
+			}, { type: APP_BOXEL_TOOL_RESULT_EVENT_TYPE });
+		};
+		for (let name of [
+			"Ada",
+			"Bea",
+			"Cy",
+			"Dee"
+		]) renameTo(name);
+		await waitFor("[data-test-message-idx=\"3\"] [data-test-tool-run-group=\"4\"]");
+		for (let index of [
+			0,
+			1,
+			2
+		]) assert.dom(`[data-test-message-idx="${index}"]`).doesNotExist(`the earlier message ${index} folds into the latest`);
+		assert.dom("[data-test-message-idx=\"3\"] [data-test-pretui-tool-group-header]").containsText("×4", "the latest message reads as the whole run");
+		await click("[data-test-message-idx=\"3\"] [data-test-pretui-tool-group-header]");
+		assert.dom("[data-test-message-idx=\"3\"] [data-test-tool-run-group] [data-test-tool-call-apply=\"applied\"]").exists({ count: 4 }, "opening the fold shows every call of the run");
+		for (let name of [
+			"Ada",
+			"Bea",
+			"Cy",
+			"Dee"
+		]) assert.dom("[data-test-message-idx=\"3\"] [data-test-tool-run-group]").containsText(`to ${name}`, `the call renaming to ${name} shows`);
+		renameTo("Eve");
+		await waitFor("[data-test-message-idx=\"4\"] [data-test-tool-run-group=\"5\"]");
+		assert.dom("[data-test-message-idx=\"4\"] [data-test-tool-run-group] [data-test-tool-call-apply=\"applied\"]").exists({ count: 5 }, "the fold stays open as the run grows");
+		await click("[data-test-message-idx=\"4\"] [data-test-pretui-tool-group-header]");
+		renameTo("Fay");
+		await waitFor("[data-test-message-idx=\"5\"] [data-test-tool-run-group=\"6\"]");
+		assert.dom("[data-test-message-idx=\"5\"] [data-test-pretui-tool-group-header]").hasAttribute("aria-expanded", "false", "the fold stays closed as the run grows");
+	});
+	(0, import_qunit.test)("a run of two messages that each ran the same tool folds into one group", async function(assert) {
+		let roomId = await renderAiAssistantPanel();
+		for (let name of ["Ada", "Bea"]) {
+			let requestId = `rename-${name}`;
+			simulateRemoteMessage(roomId, "@aibot:localhost", {
+				msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
+				body: "",
+				format: "org.matrix.custom.html",
+				isStreamingFinished: true,
+				[APP_BOXEL_TOOL_REQUESTS_KEY]: [{
+					id: requestId,
+					name: "patchCardInstance",
+					arguments: JSON.stringify({
+						description: `Rename to ${name}`,
+						attributes: {
+							cardId: `${testRealmURL}Person/fadhlan`,
+							patch: { attributes: { firstName: name } }
+						}
+					})
+				}]
+			});
+			simulateRemoteMessage(roomId, "@aibot:localhost", {
+				msgtype: APP_BOXEL_TOOL_RESULT_WITH_NO_OUTPUT_MSGTYPE,
+				commandRequestId: requestId,
+				"m.relates_to": {
+					rel_type: APP_BOXEL_TOOL_RESULT_REL_TYPE,
+					key: "applied",
+					event_id: requestId
+				},
+				data: {}
+			}, { type: APP_BOXEL_TOOL_RESULT_EVENT_TYPE });
+		}
+		await waitFor("[data-test-message-idx=\"1\"] [data-test-tool-run-group=\"2\"]");
+		assert.dom("[data-test-message-idx=\"0\"]").doesNotExist("the earlier message folds into the latest");
+		assert.dom("[data-test-message-idx=\"1\"] [data-test-pretui-tool-group-header]").containsText("×2", "the latest message reads as both calls");
+		await click("[data-test-message-idx=\"1\"] [data-test-pretui-tool-group-header]");
+		assert.dom("[data-test-message-idx=\"1\"] [data-test-tool-run-group] [data-test-tool-call-apply=\"applied\"]").exists({ count: 2 }, "opening the fold shows both calls");
+	});
+	function simulateToolResult(roomId, { requestId, toolName, resultDoc, args = {}, inMedia = false }) {
+		let resultUrl = `mxc://mock-server/${requestId}-result`;
+		let matrixService = getService("matrix-service");
+		let originalDownload = matrixService.downloadCardFileDef.bind(matrixService);
+		matrixService.downloadCardFileDef = async (serializedFile) => {
+			if (serializedFile.url !== resultUrl) return originalDownload(serializedFile);
+			return resultDoc;
+		};
+		let toolRequests = [{
+			id: requestId,
+			name: toolName,
+			arguments: JSON.stringify(args)
+		}];
+		let requestsField = { [APP_BOXEL_TOOL_REQUESTS_KEY]: toolRequests };
+		if (inMedia) {
+			let requestsUrl = `mxc://mock-server/${requestId}-requests`;
+			let mediaId = requestsUrl.slice(18);
+			let originalFetch = matrixService.fetchMatrixHostedFile.bind(matrixService);
+			matrixService.fetchMatrixHostedFile = async (url) => url.endsWith(`/${mediaId}`) ? new Response(JSON.stringify(toolRequests)) : originalFetch(url);
+			requestsField = { [APP_BOXEL_EXTERNAL_FIELDS_KEY]: { [APP_BOXEL_TOOL_REQUESTS_KEY]: requestsUrl } };
+		}
+		simulateRemoteMessage(roomId, "@aibot:localhost", {
+			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
+			body: `Running ${toolName}`,
+			format: "org.matrix.custom.html",
+			isStreamingFinished: true,
+			...requestsField
+		});
+		simulateRemoteMessage(roomId, "@aibot:localhost", {
+			msgtype: APP_BOXEL_TOOL_RESULT_WITH_OUTPUT_MSGTYPE,
+			commandRequestId: requestId,
+			"m.relates_to": {
+				rel_type: APP_BOXEL_TOOL_RESULT_REL_TYPE,
+				key: "applied",
+				event_id: "bot-message-event-id"
+			},
+			data: { card: {
+				url: resultUrl,
+				sourceUrl: resultUrl,
+				name: `${toolName} result`,
+				contentType: "application/vnd.card+json"
+			} }
+		}, { type: APP_BOXEL_TOOL_RESULT_EVENT_TYPE });
+	}
+	function baseCommandResultDoc(name, attributes) {
+		return { data: {
+			type: "card",
+			attributes,
+			meta: { adoptsFrom: {
+				module: rri("@cardstack/base/command"),
+				name
+			} }
+		} };
+	}
+	(0, import_qunit.test)("a result card whose type has no view of its own stays out of the chat", async function(assert) {
+		simulateToolResult(await renderAiAssistantPanel(), {
+			requestId: "data-only-result",
+			toolName: "oneShotLLMRequest",
+			resultDoc: baseCommandResultDoc("OneShotLLMRequestResult", { output: "a reply for the model" })
+		});
+		await waitFor("[data-test-message-idx=\"0\"] [data-test-tool-call-apply]");
+		await settled();
+		assert.dom("[data-test-message-idx=\"0\"] [data-test-tool-call-apply=\"applied\"]").exists("the tool row shows the call as applied");
+		assert.dom("[data-test-tool-result-container]").doesNotExist("the data-only result card is not rendered");
+	});
+	(0, import_qunit.test)("a result card whose type has its own embedded view is shown", async function(assert) {
+		simulateToolResult(await renderAiAssistantPanel(), {
+			requestId: "patch-fields-result",
+			toolName: "patchFields",
+			resultDoc: baseCommandResultDoc("PatchFieldsOutput", {
+				success: true,
+				updatedFields: ["firstName"],
+				errors: {}
+			})
+		});
+		await waitForToolResult();
+		assert.dom("[data-test-tool-result-header]").containsText("patchFields", "the result's meta line names the call");
+		assert.dom("[data-test-boxel-tool-call-result]").containsText("Updated 1 field: firstName.");
+	});
+	(0, import_qunit.test)("a failed correctness check shows its failed state without a result card", async function(assert) {
+		simulateToolResult(await renderAiAssistantPanel(), {
+			requestId: "failed-correctness-check",
+			toolName: "checkCorrectness",
+			resultDoc: baseCommandResultDoc("CorrectnessResultCard", {
+				correct: false,
+				errors: ["The card does not render"],
+				warnings: []
+			})
+		});
+		await waitFor("[data-test-message-idx=\"0\"] [data-test-tool-call-apply=\"applied-with-error\"]");
+		assert.dom("[data-test-message-idx=\"0\"] .room-message-tool.is-failed").exists("the tool row shows the failed check");
+		assert.dom("[data-test-tool-result-container]").doesNotExist("the correctness result card is not rendered");
+	});
+	(0, import_qunit.test)("a check of several targets lists its errors and counts the rest", async function(assert) {
+		let roomId = await renderAiAssistantPanel();
+		let target = (n) => `${testRealmURL}Product/${n}`;
+		simulateToolResult(roomId, {
+			requestId: "batched-correctness-check",
+			toolName: "checkCorrectness",
+			args: {
+				description: "Check 3 cards and 1 file",
+				attributes: { targets: [
+					{
+						type: "file",
+						ref: `${testRealmURL}product.gts`
+					},
+					{
+						type: "card",
+						ref: target(1)
+					},
+					{
+						type: "card",
+						ref: target(2)
+					},
+					{
+						type: "card",
+						ref: target(3)
+					}
+				] }
+			},
+			resultDoc: baseCommandResultDoc("CorrectnessResultCard", {
+				correct: false,
+				errors: [`${target(2)}: price must be a number`],
+				warnings: [],
+				targetResults: [{
+					targetType: "card",
+					targetRef: target(2),
+					errors: [`${target(2)}: price must be a number`],
+					warnings: []
+				}],
+				checkedCount: 4,
+				passedCount: 3
+			})
+		});
+		await waitFor("[data-test-message-idx=\"0\"] [data-test-tool-call-apply=\"applied-with-error\"]");
+		await click("[data-test-message-idx=\"0\"] [data-test-pretui-tool-row-toggle]");
+		await waitFor("[data-test-message-idx=\"0\"] [data-test-check-outcome]");
+		assert.dom("[data-test-message-idx=\"0\"] [data-test-pretui-tool-row-title]").hasText("Checked 3 cards and 1 file · errors", "the row counts what it checked");
+		assert.dom("[data-test-message-idx=\"0\"] [data-test-check-outcome]").containsText(`${target(2)}: price must be a number`, "the error is listed").containsText("No errors in the other 2 cards and 1 file", "the passing targets are counted");
+	});
+	(0, import_qunit.test)("a check request carried in Matrix media is shown like an inline one", async function(assert) {
+		let roomId = await renderAiAssistantPanel();
+		let target = (n) => `${testRealmURL}Product/${n}`;
+		simulateToolResult(roomId, {
+			requestId: "media-correctness-check",
+			toolName: "checkCorrectness",
+			inMedia: true,
+			args: {
+				description: "Check 2 cards",
+				attributes: { targets: [{
+					type: "card",
+					ref: target(1)
+				}, {
+					type: "card",
+					ref: target(2)
+				}] }
+			},
+			resultDoc: baseCommandResultDoc("CorrectnessResultCard", {
+				correct: true,
+				errors: [],
+				warnings: [],
+				targetResults: [],
+				checkedCount: 2,
+				passedCount: 2
+			})
+		});
+		await waitFor("[data-test-message-idx=\"0\"] [data-test-pretui-tool-row-title]");
+		assert.dom("[data-test-message-idx=\"0\"] [data-test-pretui-tool-row-title]").containsText("Checked 2 cards", "the request was read from media");
+	});
+	(0, import_qunit.test)("a view-visually result shows the image the assistant looked at", async function(assert) {
+		let roomId = await renderAiAssistantPanel();
+		let imageUrl = new URL("/_matrix/client/v1/media/download/localhost/brand-guide-capture", config.matrixURL).href;
+		let pngBytes = Uint8Array.from(atob("iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg=="), (c) => c.charCodeAt(0));
+		mockMatrixUtils.getUploadedContents().set(imageUrl, pngBytes.buffer);
+		simulateToolResult(roomId, {
+			requestId: "view-visually-result",
+			toolName: "view-visually",
+			resultDoc: baseCommandResultDoc("ViewVisuallyResult", {
+				sourceUrl: `${testRealmURL}brand-guide.html`,
+				kind: "file",
+				format: "isolated",
+				attachedImages: [{
+					name: "brand-guide.html (isolated).png",
+					url: imageUrl,
+					contentType: "image/png"
+				}]
+			})
+		});
+		await waitFor("[data-test-view-visually-image][src^=\"blob:\"]");
+		assert.dom("[data-test-view-visually-title]").hasText("View of brand-guide.html");
+		assert.dom("[data-test-boxel-tool-call-result]").containsText(`${testRealmURL}brand-guide.html`);
+		let image = find("[data-test-view-visually-image]");
+		await image.decode();
+		assert.strictEqual(image.naturalWidth, 1, "the image loads from the room media downloaded with the session");
+	});
+	(0, import_qunit.test)("room media is loaded with the Matrix session only from the homeserver", async function(assert) {
+		let matrixService = getService("matrix-service");
+		let elsewhere = "https://elsewhere.example/_matrix/client/v1/media/download/x/y";
+		assert.strictEqual(await matrixService.loadRoomMedia(elsewhere), elsewhere, "a URL on another origin comes back unchanged, without a download");
+		let realmFile = `${testRealmURL}brand-guide.png`;
+		assert.strictEqual(await matrixService.loadRoomMedia(realmFile), realmFile, "a URL that is not room media comes back unchanged");
+		let homeserverApi = new URL("/_matrix/client/v3/sync", config.matrixURL).href;
+		assert.strictEqual(await matrixService.loadRoomMedia(homeserverApi), homeserverApi, "a homeserver URL outside its media downloads comes back unchanged");
+	});
+	(0, import_qunit.test)("a run-realm-code result lists the files it saved and the captures it took", async function(assert) {
+		let roomId = await renderAiAssistantPanel();
+		let captureUrl = new URL("/_matrix/client/v1/media/download/localhost/run-capture", config.matrixURL).href;
+		let pngBytes = Uint8Array.from(atob("iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg=="), (c) => c.charCodeAt(0));
+		mockMatrixUtils.getUploadedContents().set(captureUrl, pngBytes.buffer);
+		let savedFile = `${testRealmURL}brand-guide.html`;
+		simulateToolResult(roomId, {
+			requestId: "run-realm-code-result",
+			toolName: "run-realm-code",
+			resultDoc: baseCommandResultDoc("RunRealmCodeResult", {
+				files: [{
+					fileUrl: savedFile,
+					status: "saved"
+				}],
+				scriptResult: "done",
+				captures: [{
+					name: "brand-guide.html (isolated).png",
+					url: captureUrl,
+					contentType: "image/png"
+				}]
+			})
+		});
+		await waitFor("[data-test-realm-code-capture][src^=\"blob:\"]");
+		assert.dom(`[data-test-realm-code-file="${savedFile}"]`).exists("the saved file is listed; its check says it was saved");
+		assert.dom("[data-test-boxel-tool-call-result]").doesNotContainText("done", "the script's own result stays out of the chat");
+	});
+	(0, import_qunit.test)("a file in a turn's changed files opens in code mode", async function(assert) {
+		let roomId = await renderAiAssistantPanel();
+		let changedFile = `${testRealmURL}hello-world.gts`;
+		simulateRemoteMessage(roomId, "@testuser:localhost", {
+			body: "Change the greeting",
+			msgtype: "m.text"
+		});
+		simulateToolResult(roomId, {
+			requestId: "run-realm-code-edit",
+			toolName: "run-realm-code",
+			resultDoc: baseCommandResultDoc("RunRealmCodeResult", { files: [{
+				fileUrl: changedFile,
+				status: "saved",
+				diff: "-  greeting = 'Hello';\n+  greeting = 'Hi';"
+			}] })
+		});
+		simulateRemoteMessage(roomId, "@aibot:localhost", {
+			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
+			body: "Changed the greeting.",
+			format: "org.matrix.custom.html",
+			isStreamingFinished: true
+		});
+		await waitFor("[data-test-pretui-turn-changes-file$=\"hello-world.gts\"]");
+		assert.strictEqual(operatorModeStateService.state.submode, Submodes.Interact, "the app starts in interact mode");
+		await click("[data-test-pretui-turn-changes-file$=\"hello-world.gts\"]");
+		await waitUntil(() => operatorModeStateService.state.submode === Submodes.Code);
+		assert.strictEqual(operatorModeStateService.state.codePath, rri(changedFile), "code mode opens on the changed file, not on the previous one");
+	});
+	(0, import_qunit.test)("a run-realm-code result says why it could not show a card", async function(assert) {
+		simulateToolResult(await renderAiAssistantPanel(), {
+			requestId: "run-realm-code-not-shown",
+			toolName: "run-realm-code",
+			resultDoc: baseCommandResultDoc("RunRealmCodeResult", {
+				files: [],
+				scriptResult: JSON.stringify({ show: "images/red.png" }),
+				captures: [],
+				showError: "The card was not shown. images/red.png is a file"
+			})
+		});
+		await waitFor("[data-test-realm-code-show-error]");
+		assert.dom("[data-test-realm-code-show-error]").containsText("The card was not shown", "the reason is shown");
+	});
+	(0, import_qunit.test)("a run-realm-code result lists its UI moves, a failed one with why", async function(assert) {
+		simulateToolResult(await renderAiAssistantPanel(), {
+			requestId: "run-realm-code-ui-actions",
+			toolName: "run-realm-code",
+			resultDoc: baseCommandResultDoc("RunRealmCodeResult", {
+				files: [],
+				scriptResult: "",
+				captures: [],
+				uiActions: [{
+					action: "openFile",
+					target: `${testRealmURL}pet.gts`,
+					status: "done"
+				}, {
+					action: "previewFormat",
+					target: `${testRealmURL}Pet/mango (fitted)`,
+					status: "failed",
+					detail: "Card not found"
+				}]
+			})
+		});
+		await waitFor("[data-test-realm-code-ui-action=\"previewFormat\"]");
+		assert.dom("[data-test-realm-code-ui-action=\"openFile\"]").exists("a done UI move is said too, so the reader sees what moved");
+		assert.dom("[data-test-realm-code-ui-action=\"previewFormat\"]").containsText("Card not found", "a failed action says why");
+	});
+	(0, import_qunit.test)("a run-realm-code result lists the workspaces it created and deleted", async function(assert) {
+		let roomId = await renderAiAssistantPanel();
+		let created = "http://test-realm/new-workspace/";
+		let deleted = "http://test-realm/old-workspace/";
+		simulateToolResult(roomId, {
+			requestId: "run-realm-code-workspaces",
+			toolName: "run-realm-code",
+			resultDoc: baseCommandResultDoc("RunRealmCodeResult", {
+				files: [],
+				scriptResult: "",
+				captures: [],
+				createdWorkspaces: [created],
+				deletedWorkspaces: [deleted]
+			})
+		});
+		await waitFor("[data-test-realm-code-created-workspace]");
+		assert.dom("[data-test-realm-code-created-workspace]").containsText(created, "the created workspace is listed");
+		assert.dom("[data-test-realm-code-deleted-workspace]").containsText(deleted, "the deleted workspace is listed");
+	});
+	(0, import_qunit.test)("a run-realm-code result that wrote nothing and had no failure stays out of the chat", async function(assert) {
+		let roomId = await renderAiAssistantPanel();
+		let store = getService("store");
+		let addWithoutPersisting = store.addWithoutPersisting.bind(store);
+		let resultCardMade = new Promise((resolve) => {
+			store.addWithoutPersisting = async (...args) => {
+				let card = await addWithoutPersisting(...args);
+				resolve();
+				return card;
+			};
+		});
+		simulateToolResult(roomId, {
+			requestId: "run-realm-code-read-only",
+			toolName: "run-realm-code",
+			resultDoc: baseCommandResultDoc("RunRealmCodeResult", {
+				files: [],
+				scriptResult: JSON.stringify({ show: "Pet/mango" }),
+				captures: [{
+					name: "pet.gts (isolated).png",
+					url: new URL("/_matrix/client/v1/media/download/localhost/read-only-capture", config.matrixURL).href,
+					contentType: "image/png"
+				}],
+				shownCard: `${testRealmURL}Pet/mango`,
+				uiActions: [{
+					action: "switchSubmode",
+					target: "code",
+					status: "done"
+				}, {
+					action: "openFile",
+					target: `${testRealmURL}pet.gts`,
+					status: "done"
+				}]
+			})
+		});
+		await resultCardMade;
+		await settled();
+		assert.dom("[data-test-message-idx=\"0\"] [data-test-tool-call-apply=\"applied\"]").exists("the tool row shows the call as applied");
+		assert.dom("[data-test-message-idx=\"0\"] [data-test-pretui-card-embed]").doesNotExist("a run that only read, captured, and opened things has no result card");
+	});
+});
+//#endregion