diff --git a/packages/ai-bot/tests/prompt-construction-test.ts b/packages/ai-bot/tests/prompt-construction-test.ts
index 12a81443fb2..5cc83406b63 100644
--- a/packages/ai-bot/tests/prompt-construction-test.ts
+++ b/packages/ai-bot/tests/prompt-construction-test.ts
@@ -2763,6 +2763,115 @@ Attached Files (files with newer versions don't show their content):
     assert.equal(messageText(result[5]).trim(), expected.trim());
   });
 
+  test('a later applied result supersedes an earlier failed result for the same request', async () => {
+    // A tool can fail and then succeed on a user Retry; both result events
+    // stay in the room forever. The prompt must reflect the latest one, or
+    // the model is permanently told the call failed and may re-issue it.
+    const history: DiscreteMatrixEvent[] = [
+      {
+        type: 'm.room.message',
+        room_id: 'room-id-1',
+        sender: '@user:localhost',
+        content: {
+          body: 'set the title',
+          msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
+          format: 'org.matrix.custom.html',
+          data: { context: { tools: [], functions: [] } },
+        },
+        origin_server_ts: 1722242847000,
+        unsigned: { age: 1000, transaction_id: 't0' },
+        event_id: 'user-event-id-1',
+        status: EventStatus.SENT,
+      },
+      {
+        type: 'm.room.message',
+        room_id: 'room-id-1',
+        sender: '@aibot:localhost',
+        content: {
+          body: 'Setting the title',
+          msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
+          format: 'org.matrix.custom.html',
+          data: { context: { functions: [] } },
+          [APP_BOXEL_TOOL_REQUESTS_KEY]: [
+            {
+              id: 'retried-tool-call-id-1',
+              name: 'patchCardInstance',
+              arguments: JSON.stringify({
+                attributes: { description: 'Set the title' },
+              }),
+            },
+          ],
+        },
+        origin_server_ts: 1722242849000,
+        unsigned: { age: 900, transaction_id: 't1' },
+        event_id: 'retried-command-event-id-1',
+        status: EventStatus.SENT,
+      },
+      {
+        type: APP_BOXEL_TOOL_RESULT_EVENT_TYPE,
+        room_id: 'room-id-1',
+        sender: '@user:localhost',
+        content: {
+          'm.relates_to': {
+            event_id: 'retried-command-event-id-1',
+            rel_type: APP_BOXEL_TOOL_RESULT_REL_TYPE,
+            key: 'failed',
+          },
+          msgtype: APP_BOXEL_TOOL_RESULT_WITH_NO_OUTPUT_MSGTYPE,
+          commandRequestId: 'retried-tool-call-id-1',
+          failureReason: 'store exploded',
+          data: { context: { tools: [], functions: [] } },
+        },
+        origin_server_ts: 1722242853000,
+        unsigned: { age: 800, transaction_id: 't2' },
+        event_id: 'failed-result-id-1',
+        status: EventStatus.SENT,
+      },
+      {
+        type: APP_BOXEL_TOOL_RESULT_EVENT_TYPE,
+        room_id: 'room-id-1',
+        sender: '@user:localhost',
+        content: {
+          'm.relates_to': {
+            event_id: 'retried-command-event-id-1',
+            rel_type: APP_BOXEL_TOOL_RESULT_REL_TYPE,
+            key: 'applied',
+          },
+          msgtype: APP_BOXEL_TOOL_RESULT_WITH_NO_OUTPUT_MSGTYPE,
+          commandRequestId: 'retried-tool-call-id-1',
+          data: { context: { tools: [], functions: [] } },
+        },
+        origin_server_ts: 1722242857000,
+        unsigned: { age: 700, transaction_id: 't3' },
+        event_id: 'applied-result-id-1',
+        status: EventStatus.SENT,
+      },
+    ];
+    const result = await buildPromptForModel(
+      history,
+      '@aibot:localhost',
+      [],
+      [],
+      [],
+      fakeMatrixClient,
+    );
+    let toolMessages = result.filter((m) => m.role === 'tool');
+    assert.equal(toolMessages.length, 1, 'one tool message per request');
+    assert.equal(
+      (toolMessages[0] as { tool_call_id?: string }).tool_call_id,
+      'retried-tool-call-id-1',
+    );
+    let content = messageText(toolMessages[0]);
+    assert.true(
+      content.includes('executed'),
+      `the retried call reads as executed, got: ${content}`,
+    );
+    assert.false(
+      content.includes('failed'),
+      `no stale failure text survives the retry, got: ${content}`,
+    );
+  });
+
   test('pairs a pre-rename request/result (legacy wire keys) with the same tool_call_id', async () => {
     // A room whose history predates the command → tool rename replays events
     // with the legacy spellings forever; prompt assembly must pair them
diff --git a/packages/host/app/components/matrix/room-message-tool.gts b/packages/host/app/components/matrix/room-message-tool.gts
index 15d8727476f..98c011438ad 100644
--- a/packages/host/app/components/matrix/room-message-tool.gts
+++ b/packages/host/app/components/matrix/room-message-tool.gts
@@ -225,6 +225,13 @@ export default class RoomMessageTool extends Component<Signature> {
     return this.matrixService.failedToolState.get(toolRequest.id);
   }
 
+  // Execution failure reported through a room event (as opposed to
+  // failedToolState, which is this tab's in-memory state for a failure it
+  // produced itself).
+  private get failedToolCallState() {
+    return this.args.messageTool.status === 'failed' && !this.failedToolState;
+  }
+
   private get invalidToolCallState() {
     return (
       this.args.messageTool.status === 'invalid' &&
@@ -237,7 +244,11 @@ export default class RoomMessageTool extends Component<Signature> {
   }
 
   private get hasFailedState() {
-    return !!(this.failedToolState || this.didFailCorrectnessCheck);
+    return !!(
+      this.failedToolState ||
+      this.failedToolCallState ||
+      this.didFailCorrectnessCheck
+    );
   }
 
   <template>
@@ -301,6 +312,19 @@ export default class RoomMessageTool extends Component<Signature> {
             <Alert.Messages @messages={{array this.failedToolState.message}} />
             <Alert.Action @action={{@runCommand}} @actionName='Retry' />
           </Alert>
+        {{else if this.failedToolCallState}}
+          <Alert @type='error' as |Alert|>
+            <Alert.Messages
+              @messages={{array
+                (if
+                  @messageTool.failureReason
+                  @messageTool.failureReason
+                  'Tool call failed.'
+                )
+              }}
+            />
+            <Alert.Action @action={{@runCommand}} @actionName='Retry' />
+          </Alert>
         {{else if this.invalidToolCallState}}
           <Alert @type='warning' as |Alert|>
             <Alert.Messages @messages={{array @messageTool.failureReason}} />
diff --git a/packages/host/app/lib/matrix-classes/message-builder.ts b/packages/host/app/lib/matrix-classes/message-builder.ts
index d6e5ff953fe..7ee46c04c16 100644
--- a/packages/host/app/lib/matrix-classes/message-builder.ts
+++ b/packages/host/app/lib/matrix-classes/message-builder.ts
@@ -371,23 +371,33 @@ export default class MessageBuilder {
     message: Message,
     toolRequest: Partial<ToolRequest>,
   ) {
-    let toolResultEvent =
-      this.builderContext.toolResultEvent ??
-      (this.builderContext.events.find((e: any) => {
-        let r = e.content['m.relates_to'];
-        // Correlate the result to its command by commandRequestId (the
-        // globally unique LLM tool-call id), not by the result's
-        // m.relates_to.event_id. A reload strips the m.replace edits and loads
-        // only the original event, so the result's link id — pointing at the
-        // final edit — matches no loaded event. commandRequestId is stable
-        // across edits and present on every one, so it resolves the command on
-        // both the live and reload paths.
-        return (
+    let toolResultEvent = this.builderContext.toolResultEvent;
+    if (!toolResultEvent) {
+      // Correlate the result to its command by commandRequestId (the
+      // globally unique LLM tool-call id), not by the result's
+      // m.relates_to.event_id. A reload strips the m.replace edits and loads
+      // only the original event, so the result's link id — pointing at the
+      // final edit — matches no loaded event. commandRequestId is stable
+      // across edits and present on every one, so it resolves the command on
+      // both the live and reload paths.
+      //
+      // Scan newest-first: a request can have several result events (a
+      // 'failed' first attempt, an 'applied' retry) and the latest one is
+      // the call's actual outcome.
+      let events = this.builderContext.events;
+      for (let i = events.length - 1; i >= 0; i--) {
+        let e = events[i] as any;
+        let r = e.content?.['m.relates_to'];
+        if (
           isToolResultEventType(e.type) &&
           isToolResultRelType(r?.rel_type) &&
           e.content.commandRequestId === toolRequest.id
-        );
-      }) as ToolResultEvent | undefined);
+        ) {
+          toolResultEvent = e as ToolResultEvent;
+          break;
+        }
+      }
+    }
 
     // ai-bot ran this one itself (e.g. readRealmFile), so the host never
     // resolves a command class or runs it. Skip the skill lookup below — it's
diff --git a/packages/host/app/lib/matrix-classes/message-tool.ts b/packages/host/app/lib/matrix-classes/message-tool.ts
index 9540075a577..bc408b12be4 100644
--- a/packages/host/app/lib/matrix-classes/message-tool.ts
+++ b/packages/host/app/lib/matrix-classes/message-tool.ts
@@ -18,7 +18,7 @@ import type { Message } from './message';
 import type { CardDef } from '@cardstack/base/card-api';
 import type { SerializedFile } from '@cardstack/base/file-api';
 
-type ToolCallStatus = 'applied' | 'ready' | 'applying' | 'invalid';
+type ToolCallStatus = 'applied' | 'ready' | 'applying' | 'invalid' | 'failed';
 
 export default class MessageTool {
   @tracked toolRequest: Partial<ToolRequest>;
diff --git a/packages/host/app/services/tool-service.ts b/packages/host/app/services/tool-service.ts
index 5c32288b622..dd9dc3262de 100644
--- a/packages/host/app/services/tool-service.ts
+++ b/packages/host/app/services/tool-service.ts
@@ -28,6 +28,7 @@ import { AI_BOT_EXECUTOR } from '@cardstack/runtime-common/commands';
 import { basicMappings } from '@cardstack/runtime-common/helpers/ai';
 import { getToolRequests } from '@cardstack/runtime-common/matrix-constants';
 
+import ENV from '@cardstack/host/config/environment';
 import type MatrixService from '@cardstack/host/services/matrix-service';
 import type Realm from '@cardstack/host/services/realm';
 import CheckCorrectnessTool from '@cardstack/host/tools/check-correctness';
@@ -65,6 +66,52 @@ const STUCK_PROCESSING_TIMEOUT_MS = isTesting() ? 1000 : 60_000;
 // result either way). Requeues are ~100ms apart (the drain debounce), so
 // this allows well over the normal sub-second catch-up.
 const MAX_TOOL_FINALIZATION_RETRIES = isTesting() ? 10 : 100;
+// How many times drainToolProcessingQueue requeues a message's tools while
+// that same message still has code patches pending auto-apply. Tools
+// routinely target the very cards those patches create (a show-card for the
+// instance a patch writes), so running them concurrently races the realm
+// write/index. Requeues are ~100ms apart; on exhaustion the tools run
+// anyway and the execute timeout below is the backstop.
+const MAX_TOOL_PATCH_WAIT_RETRIES = isTesting() ? 20 : 600;
+// How many times drainToolProcessingQueue requeues a message's tools while
+// the index invalidations tracked for its patched files are still pending.
+// Applied patches mean the write landed, not that the index has caught up —
+// a tool loading a just-created card would still miss it. Requeues are
+// ~100ms apart, so the production budget approximates the card render
+// timeout; on exhaustion the tools run anyway and the execute timeout is
+// the backstop.
+const MAX_TOOL_INDEX_WAIT_RETRIES = isTesting() ? 20 : 300;
+// Upper bound on a single tool execution. A tool awaiting a card that never
+// becomes loadable would otherwise hang forever, and the result event —
+// which is what un-sticks both the UI spinner and the waiting ai-bot — is
+// only sent once execute settles.
+const TOOL_EXECUTE_TIMEOUT_MS = isTesting() ? 3_000 : 120_000;
+
+// Promise.race with a cleared timer: the losing execute keeps running (we
+// cannot cancel it), but the run task settles and reports. That means a
+// timed-out execute may still commit its side effects later, and the Retry
+// the failure UI offers can then double-apply — idempotent for a re-write
+// of the same attributes, a genuine duplicate for a tool that creates
+// something. Real cancellation needs an abort signal threaded through
+// Command.execute.
+async function withTimeout<T>(
+  promise: Promise<T>,
+  ms: number,
+  label: string,
+): Promise<T> {
+  let timer: ReturnType<typeof setTimeout>;
+  let timedOut = new Promise<never>((_, reject) => {
+    timer = setTimeout(
+      () => reject(new Error(`${label} did not complete within ${ms}ms`)),
+      ms,
+    );
+  });
+  try {
+    return await Promise.race([promise, timedOut]);
+  } finally {
+    clearTimeout(timer!);
+  }
+}
 
 type GenericCommand = Command<
   typeof CardDef | undefined,
@@ -105,16 +152,31 @@ export default class ToolService extends Service {
       roomId: string;
       targetHref: string;
       deferred: Deferred<void>;
+      // Whether the index event arrived. Deferred has no synchronous
+      // inspection, and the tool drain must be able to ask "has this
+      // landed?" without awaiting — see hasPendingPatchInvalidations.
+      settled: boolean;
     }
   >();
   private aiAssistantInvalidationWaiters = new Map<
     string,
     { unsubscribe: () => void; timeoutId: ReturnType<typeof setTimeout> }
   >();
+  // Where a code patch actually landed when the requested file already
+  // existed and patch-code collision-renamed it: requested key -> final URL.
+  // The invalidation tracker keys on the final URL, so waits that arrive
+  // with the requested URL resolve through this map.
+  private patchedFileRedirects = new Map<string, string>();
   private toolProcessingEventQueue: string[] = [];
   // How many times each queued event has been requeued waiting for the room
   // resource to fold the event's finalized content into its Message.
   private toolFinalizationRetries = new Map<string, number>();
+  // How many times each queued event's tools have been requeued waiting for
+  // that message's own code patches to finish auto-applying.
+  private toolPatchWaitRetries = new Map<string, number>();
+  // How many times each queued event's tools have been requeued waiting for
+  // the index invalidations tracked for that message's patched files.
+  private toolIndexWaitRetries = new Map<string, number>();
   private codePatchProcessingEventQueue: string[] = [];
   private flushToolProcessingQueue: Promise<void> | undefined;
   private flushCodePatchProcessingQueue: Promise<void> | undefined;
@@ -137,8 +199,11 @@ export default class ToolService extends Service {
     for (let key of this.aiAssistantInvalidationWaiters.keys()) {
       this.cleanupInvalidationWaiter(key);
     }
+    this.patchedFileRedirects.clear();
     this.toolProcessingEventQueue = [];
     this.toolFinalizationRetries.clear();
+    this.toolPatchWaitRetries.clear();
+    this.toolIndexWaitRetries.clear();
     this.codePatchProcessingEventQueue = [];
     this.flushToolProcessingQueue = undefined;
     this.flushCodePatchProcessingQueue = undefined;
@@ -181,7 +246,7 @@ export default class ToolService extends Service {
     let normalizedTarget = fileUrl.endsWith('.json')
       ? fileUrl.replace(/\.json$/, '')
       : fileUrl;
-    let key = `${roomId}::${normalizedTarget}`;
+    let key = this.invalidationKey(roomId, fileUrl);
 
     let realmURL: string | undefined;
     try {
@@ -201,6 +266,7 @@ export default class ToolService extends Service {
       roomId,
       targetHref: normalizedTarget,
       deferred,
+      settled: false,
     });
 
     let unsubscribe = this.messageService.subscribe(realmURL, (event) => {
@@ -216,13 +282,19 @@ export default class ToolService extends Service {
       }
       this.cleanupInvalidationWaiter(key);
       let current = this.aiAssistantInvalidations.get(key);
-      current?.deferred.fulfill();
+      if (current) {
+        current.settled = true;
+        current.deferred.fulfill();
+      }
     });
     let timeoutId = setTimeout(
       () => {
         this.cleanupInvalidationWaiter(key);
         let current = this.aiAssistantInvalidations.get(key);
-        current?.deferred.fulfill();
+        if (current) {
+          current.settled = true;
+          current.deferred.fulfill();
+        }
         this.aiAssistantInvalidations.delete(key);
       },
       5 * 60 * 1000,
@@ -234,6 +306,13 @@ export default class ToolService extends Service {
     return clientRequestId;
   }
 
+  private invalidationKey(roomId: string, targetHref: string): string {
+    let normalizedTarget = targetHref.endsWith('.json')
+      ? targetHref.replace(/\.json$/, '')
+      : targetHref;
+    return `${roomId}::${normalizedTarget}`;
+  }
+
   private cleanupInvalidationWaiter(key: string) {
     let waiter = this.aiAssistantInvalidationWaiters.get(key);
     if (!waiter) {
@@ -252,24 +331,26 @@ export default class ToolService extends Service {
     if (!roomId || !targetHref) {
       return;
     }
-    let normalizedTarget = targetHref.endsWith('.json')
-      ? targetHref.replace(/\.json$/, '')
-      : targetHref;
-    let key = `${roomId}::${normalizedTarget}`;
+    let key = this.invalidationKey(roomId, targetHref);
+    let redirectedTarget = this.patchedFileRedirects.get(key);
+    if (redirectedTarget) {
+      key = this.invalidationKey(roomId, redirectedTarget);
+    }
     let existing = this.aiAssistantInvalidations.get(key);
     if (!existing) {
       return;
     }
 
-    let waitPromise: Promise<void> = existing.deferred.promise;
-    if (timeoutMs) {
-      waitPromise = Promise.race([
-        waitPromise,
-        delay(timeoutMs).then(() => {}),
-      ]);
+    let invalidated = existing.deferred.promise.then(() => true);
+    let settled = timeoutMs
+      ? await Promise.race([invalidated, delay(timeoutMs).then(() => false)])
+      : await invalidated;
+    // Only a real invalidation consumes the entry. On timeout the deferred is
+    // still live, and a later caller (e.g. checkCorrectness after the drain's
+    // bounded wait) must still be able to wait on it.
+    if (settled) {
+      this.aiAssistantInvalidations.delete(key);
     }
-    await waitPromise;
-    this.aiAssistantInvalidations.delete(key);
   }
 
   public queueEventForToolProcessing(event: Partial<IEvent>) {
@@ -424,6 +505,68 @@ export default class ToolService extends Service {
           continue;
         }
 
+        // A message can carry both code patches and tool requests, and the
+        // tools routinely target the very cards those patches create (a
+        // show-card for the instance a patch writes). Running them while the
+        // patches are still applying races the realm write/index, so when
+        // this message still has patches the host is going to auto-apply
+        // ('act' mode), requeue the tools until those patches settle.
+        // Bounded: on exhaustion the tools run anyway and the execute
+        // timeout is the backstop.
+        if (
+          roomResource.getActiveLLMModeForMessage(message.eventId) === 'act' &&
+          this.messageHasUnsettledCodePatches(message)
+        ) {
+          let compoundKey = `${roomId}|${eventId}`;
+          let retries = this.toolPatchWaitRetries.get(compoundKey) ?? 0;
+          if (retries < MAX_TOOL_PATCH_WAIT_RETRIES) {
+            this.toolPatchWaitRetries.set(compoundKey, retries + 1);
+            if (!this.toolProcessingEventQueue.includes(compoundKey)) {
+              this.toolProcessingEventQueue.push(compoundKey);
+            }
+            debounce(this, this.drainToolProcessingQueue, 100);
+            continue;
+          }
+          console.error(
+            `Tools on event ${eventId} in room ${roomId} ran before its code patches settled (waited ${MAX_TOOL_PATCH_WAIT_RETRIES} rounds)`,
+          );
+        }
+        this.toolPatchWaitRetries.delete(`${roomId}|${eventId}`);
+
+        // Applied patches mean the write landed, not that the index has
+        // caught up — a tool loading a just-created card would still miss
+        // it. Requeue until the tracked index invalidations of this
+        // message's patched files settle, the same milestone
+        // checkCorrectness waits on. The check is synchronous and the wait
+        // happens through requeues because this loop drains every room's
+        // tools — awaiting here would park unrelated rooms behind one slow
+        // index event. A no-op when nothing was tracked (e.g. the patches
+        // were applied by another session). Bounded: on exhaustion the
+        // tools run anyway with the execute timeout as the backstop, and
+        // the still-pending entry is deliberately left in place so a later
+        // checkCorrectness can wait on it.
+        let patchedFileUrls = this.patchedFileUrls(message);
+        if (
+          patchedFileUrls.length > 0 &&
+          this.messageHasUnresolvedTools(message) &&
+          this.hasPendingPatchInvalidations(roomId!, patchedFileUrls)
+        ) {
+          let compoundKey = `${roomId}|${eventId}`;
+          let retries = this.toolIndexWaitRetries.get(compoundKey) ?? 0;
+          if (retries < MAX_TOOL_INDEX_WAIT_RETRIES) {
+            this.toolIndexWaitRetries.set(compoundKey, retries + 1);
+            if (!this.toolProcessingEventQueue.includes(compoundKey)) {
+              this.toolProcessingEventQueue.push(compoundKey);
+            }
+            debounce(this, this.drainToolProcessingQueue, 100);
+            continue;
+          }
+          console.error(
+            `Tools on event ${eventId} in room ${roomId} ran before the index invalidations of its patched files settled (waited ${MAX_TOOL_INDEX_WAIT_RETRIES} rounds)`,
+          );
+        }
+        this.toolIndexWaitRetries.delete(`${roomId}|${eventId}`);
+
         // Collect all ready commands for this message
         let readyTools: any[] = [];
         for (let messageTool of message.tools) {
@@ -440,9 +583,14 @@ export default class ToolService extends Service {
           if (this.executedToolRequestIds.has(messageTool.id!)) {
             continue;
           }
+          // 'failed' is terminal for auto-execution too: the model has been
+          // told the call failed, so re-running it unattended (e.g. on a
+          // reload that replays room history) would produce a second,
+          // contradictory result. The Retry affordance is the user's path.
           if (
             messageTool.status === 'applied' ||
-            messageTool.status === 'invalid'
+            messageTool.status === 'invalid' ||
+            messageTool.status === 'failed'
           ) {
             continue;
           }
@@ -460,7 +608,49 @@ export default class ToolService extends Service {
             this.claimedToolRequestIds.add(messageTool.id);
           }
 
-          let isValid = await this.validate(messageTool);
+          // validate() loads the tool's module and input schema over the
+          // loader; against a realm that is busy (e.g. indexing files this
+          // same message just created) that can throw. Without this catch a
+          // single throw killed the whole drain pass silently: the request
+          // stayed claimed forever, its spinner never cleared, and the bot
+          // waited forever. Report it as a failed result instead.
+          let isValid = false;
+          try {
+            isValid = await this.validate(messageTool);
+          } catch (e) {
+            let error = e instanceof Error ? e : new Error(String(e));
+            console.error(
+              `Tool processing failed for "${messageTool.name}" (${messageTool.id}):`,
+              e,
+            );
+            try {
+              await this.matrixService.sendToolResultEvent({
+                roomId: roomId!,
+                invokedToolFromEventId:
+                  this.getCurrentEventIdForCommandRequest(
+                    roomId!,
+                    messageTool.id,
+                  ) ?? messageTool.eventId,
+                toolCallId: messageTool.id!,
+                status: 'failed',
+                failureReason: error.message,
+                context:
+                  await this.operatorModeStateService.getSummaryForAIBot(),
+              });
+            } catch (sendError) {
+              console.error(
+                'could not send failed tool result event to the room',
+                sendError,
+              );
+              // The room never got a terminal result, so nothing else will
+              // clear this tool's spinner — the local failed state at least
+              // restores the Retry affordance in this tab.
+              if (messageTool.id) {
+                this.matrixService.failedToolState.set(messageTool.id, error);
+              }
+            }
+            continue;
+          }
           if (!isValid) {
             continue;
           }
@@ -539,7 +729,8 @@ export default class ToolService extends Service {
       }
       if (
         messageTool.status === 'applied' ||
-        messageTool.status === 'invalid'
+        messageTool.status === 'invalid' ||
+        messageTool.status === 'failed'
       ) {
         continue;
       }
@@ -759,6 +950,10 @@ export default class ToolService extends Service {
         commandRequestId,
       ) ?? command.eventId;
     let resultCard: CardDef | undefined;
+    // Distinguishes "the tool never ran" from "the tool ran, the aftermath
+    // failed" — the catch below must not tell the room a committed write
+    // failed.
+    let didExecute = false;
     // There may be some race conditions where the command is already being executed when this task starts
     if (
       this.currentlyExecutingToolRequestIds.has(commandRequestId!) ||
@@ -770,63 +965,85 @@ export default class ToolService extends Service {
       this.matrixService.failedToolState.delete(commandRequestId!);
       this.currentlyExecutingToolRequestIds.add(commandRequestId!);
 
-      let toolToRun;
-
-      // If we don't find it in the one-offs, start searching for
-      // one in the skills we can construct
-      let toolCodeRef = command.codeRef;
-      if (toolCodeRef) {
-        let ToolConstructor = (await getClass(
-          toolCodeRef,
-          this.loaderService.loader,
-        )) as { new (context: ToolContext): Command<any, any> };
-        toolToRun = new ToolConstructor(this.toolContext);
-      }
-
-      if (!toolToRun && command.name === CHECK_CORRECTNESS_COMMAND_NAME) {
-        toolToRun = new CheckCorrectnessTool(this.toolContext);
-      }
+      // The timeout brackets everything between claiming the request and
+      // having a result in hand: module resolution and input construction
+      // hang the same way a slow execute does (e.g. a loader or store.add
+      // blocked on a card that never becomes loadable), and the result event
+      // that un-sticks the UI and the waiting ai-bot is only sent once this
+      // settles.
+      let performTool = async (): Promise<CardDef | undefined> => {
+        let toolToRun;
+
+        // If we don't find it in the one-offs, start searching for
+        // one in the skills we can construct
+        let toolCodeRef = command.codeRef;
+        if (toolCodeRef) {
+          let ToolConstructor = (await getClass(
+            toolCodeRef,
+            this.loaderService.loader,
+          )) as { new (context: ToolContext): Command<any, any> };
+          toolToRun = new ToolConstructor(this.toolContext);
+        }
 
-      if (toolToRun) {
-        let typedInput = await this.instantiateToolInput(
-          toolToRun,
-          payload?.attributes,
-          payload?.relationships,
-        );
+        if (!toolToRun && command.name === CHECK_CORRECTNESS_COMMAND_NAME) {
+          toolToRun = new CheckCorrectnessTool(this.toolContext);
+        }
 
-        [resultCard] = await all([
-          await toolToRun.execute(typedInput as any),
-          await timeout(DELAY_FOR_APPLYING_UI), // leave a beat for the "applying" state of the UI to be shown
-        ]);
-      } else if (command.name === 'patchCardInstance') {
-        if (!hasPatchData(payload)) {
+        if (toolToRun) {
+          let typedInput = await this.instantiateToolInput(
+            toolToRun,
+            payload?.attributes,
+            payload?.relationships,
+          );
+          return (await toolToRun.execute(typedInput as any)) as
+            | CardDef
+            | undefined;
+        } else if (command.name === 'patchCardInstance') {
+          if (!hasPatchData(payload)) {
+            throw new Error(
+              "Patch command can't run because it doesn't have all the fields in arguments returned by open ai",
+            );
+          }
+          let cardId = payload.attributes.cardId;
+
+          let clientRequestId = this.trackAiAssistantCardRequest({
+            action: 'patch-instance',
+            roomId: command.message.roomId,
+            fileUrl: `${cardId}.json`,
+          });
+
+          await this.store.patch(
+            cardId,
+            {
+              attributes: payload?.attributes?.patch?.attributes,
+              relationships: payload?.attributes?.patch?.relationships,
+            },
+            { doNotWaitForPersist: true, clientRequestId },
+          );
+          return undefined;
+        } else {
+          // Unrecognized tool. This can happen if a programmatically-provided
+          // tool is no longer available due to a browser refresh.
           throw new Error(
-            "Patch command can't run because it doesn't have all the fields in arguments returned by open ai",
+            `Unrecognized tool: ${command.name}. This tool may have been associated with a previous browser session.`,
           );
         }
-        let cardId = payload.attributes.cardId;
-
-        let clientRequestId = this.trackAiAssistantCardRequest({
-          action: 'patch-instance',
-          roomId: command.message.roomId,
-          fileUrl: `${cardId}.json`,
-        });
+      };
 
-        await this.store.patch(
-          cardId,
-          {
-            attributes: payload?.attributes?.patch?.attributes,
-            relationships: payload?.attributes?.patch?.relationships,
-          },
-          { doNotWaitForPersist: true, clientRequestId },
-        );
-      } else {
-        // Unrecognized tool. This can happen if a programmatically-provided
-        // tool is no longer available due to a browser refresh.
-        throw new Error(
-          `Unrecognized tool: ${command.name}. This tool may have been associated with a previous browser session.`,
-        );
-      }
+      // checkCorrectness legitimately waits out one index-invalidation
+      // window and then does prerender/refresh work that can take
+      // comparably long, so it gets that much headroom on top of the
+      // standard bound.
+      let executeTimeoutMs =
+        command.name === CHECK_CORRECTNESS_COMMAND_NAME
+          ? TOOL_EXECUTE_TIMEOUT_MS + 2 * ENV.cardRenderTimeout
+          : TOOL_EXECUTE_TIMEOUT_MS;
+
+      [resultCard] = await all([
+        withTimeout(performTool(), executeTimeoutMs, `Tool "${command.name}"`),
+        timeout(DELAY_FOR_APPLYING_UI), // leave a beat for the "applying" state of the UI to be shown
+      ]);
+      didExecute = true;
       this.executedToolRequestIds.add(commandRequestId!);
       await this.matrixService.updateSkillsAndToolsIfNeeded(
         command.message.roomId,
@@ -843,6 +1060,12 @@ export default class ToolService extends Service {
         context: userContextForAiBot,
       });
     } catch (e) {
+      // The timeout's raw setTimeout can reject after the owner is torn down
+      // (e.g. a test that ends with a tool in flight); the services this
+      // branch touches are gone by then.
+      if (this.isDestroying || this.isDestroyed) {
+        return;
+      }
       let error =
         typeof e === 'string'
           ? new Error(e)
@@ -851,7 +1074,50 @@ export default class ToolService extends Service {
             : new Error('Tool call failed.');
       console.error(error);
       await timeout(DELAY_FOR_APPLYING_UI); // leave a beat for the "applying" state of the UI to be shown
+      if (didExecute) {
+        // The tool's side effects landed; only post-execution bookkeeping
+        // (skill refresh, context collection, or sending the result event)
+        // failed. Publishing 'failed' would tell the model to re-issue a
+        // call whose effect already exists — and the Retry it offers would
+        // be inert, since the request is recorded as executed. Best-effort
+        // send the truthful terminal result instead.
+        try {
+          await this.matrixService.sendToolResultEvent({
+            roomId: command.message.roomId,
+            invokedToolFromEventId: eventId,
+            toolCallId: commandRequestId!,
+            status: 'applied',
+            resultCard,
+          });
+        } catch (sendError) {
+          console.error(
+            'could not send applied tool result event after a post-execution failure',
+            sendError,
+          );
+          this.matrixService.failedToolState.set(commandRequestId!, error);
+        }
+        return;
+      }
       this.matrixService.failedToolState.set(commandRequestId!, error);
+      // Report the failure to the room: the result event is what clears the
+      // UI spinner in other sessions and lets ai-bot react to the failure
+      // instead of waiting forever. The local failedToolState above still
+      // drives this tab's immediate Retry affordance.
+      try {
+        await this.matrixService.sendToolResultEvent({
+          roomId: command.message.roomId,
+          invokedToolFromEventId: eventId,
+          toolCallId: commandRequestId!,
+          status: 'failed',
+          failureReason: error.message,
+          context: await this.operatorModeStateService.getSummaryForAIBot(),
+        });
+      } catch (sendError) {
+        console.error(
+          'could not send failed tool result event to the room',
+          sendError,
+        );
+      }
     } finally {
       this.currentlyExecutingToolRequestIds.delete(commandRequestId!);
     }
@@ -1018,6 +1284,18 @@ export default class ToolService extends Service {
         roomId,
       });
       finalFileIdentifier = patchCodeResult.finalFileIdentifier;
+      let requestedKey = this.invalidationKey(roomId, fileUrl);
+      if (finalFileIdentifier && finalFileIdentifier !== fileUrl) {
+        // The invalidation tracker keys on where the write actually landed;
+        // waits keyed on the requested URL resolve through this redirect.
+        this.patchedFileRedirects.set(requestedKey, finalFileIdentifier);
+      } else {
+        // The write landed at the requested URL, so a redirect left by an
+        // earlier collision-rename of this file no longer describes it —
+        // leaving it in place would point this file's index waits at an
+        // entry that was already consumed.
+        this.patchedFileRedirects.delete(requestedKey);
+      }
 
       for (let i = 0; i < codeDataItems.length; i++) {
         const codeData = codeDataItems[i];
@@ -1078,6 +1356,91 @@ export default class ToolService extends Service {
     }
   };
 
+  // Whether any of these files' tracked index invalidations is still
+  // outstanding. Synchronous so the tool drain can requeue instead of
+  // awaiting — the drain serves every room, and blocking it on one
+  // message's index event would stall unrelated rooms.
+  private hasPendingPatchInvalidations(
+    roomId: string,
+    fileUrls: string[],
+  ): boolean {
+    return fileUrls.some((fileUrl) => {
+      let key = this.invalidationKey(roomId, fileUrl);
+      let redirectedTarget = this.patchedFileRedirects.get(key);
+      if (redirectedTarget) {
+        key = this.invalidationKey(roomId, redirectedTarget);
+      }
+      let entry = this.aiAssistantInvalidations.get(key);
+      return !!entry && !entry.settled;
+    });
+  }
+
+  // The distinct file URLs this message's code patches target.
+  private patchedFileUrls(message: {
+    htmlParts?: Array<{ codeData: CodeData | null }> | null;
+  }): string[] {
+    let urls = new Set<string>();
+    for (let part of message.htmlParts ?? []) {
+      let codeData = part.codeData;
+      if (codeData?.searchReplaceBlock && codeData.fileUrl) {
+        urls.add(codeData.fileUrl);
+      }
+    }
+    return [...urls];
+  }
+
+  // Whether any tool on the message could still be run by a drain pass —
+  // the same synchronous guards the ready-tool collection applies. When
+  // nothing is runnable (e.g. a requeued pass whose tools all resolved),
+  // waiting on index invalidations first would be pure latency.
+  private messageHasUnresolvedTools(message: {
+    tools: MessageTool[];
+  }): boolean {
+    return message.tools.some((messageTool) => {
+      if (messageTool.executedBy === AI_BOT_EXECUTOR) {
+        return false;
+      }
+      if (!messageTool.name || !messageTool.id) {
+        return false;
+      }
+      if (
+        this.currentlyExecutingToolRequestIds.has(messageTool.id) ||
+        this.executedToolRequestIds.has(messageTool.id) ||
+        this.claimedToolRequestIds.has(messageTool.id)
+      ) {
+        return false;
+      }
+      return (
+        messageTool.status !== 'applied' &&
+        messageTool.status !== 'invalid' &&
+        messageTool.status !== 'failed'
+      );
+    });
+  }
+
+  // True while any code patch in the message has not reached a terminal
+  // state ('applied' or 'failed') — i.e. it is still 'ready' (queued for
+  // auto-apply) or 'applying'.
+  private messageHasUnsettledCodePatches(message: {
+    htmlParts?: Array<{ codeData: CodeData | null }> | null;
+  }): boolean {
+    if (!message.htmlParts) {
+      return false;
+    }
+    return message.htmlParts.some((part) => {
+      let codeData = part.codeData;
+      // A block with no resolvable file URL is never applied
+      // (executeReadyCodePatches skips it), so its status stays 'ready'
+      // forever — counting it here would stall the message's tools for the
+      // whole retry budget with nothing to wait for.
+      if (!codeData?.searchReplaceBlock || !codeData.fileUrl) {
+        return false;
+      }
+      let status = this.getCodePatchStatus(codeData);
+      return status === 'ready' || status === 'applying';
+    });
+  }
+
   getReadyCodePatches = (
     htmlParts: Array<{ codeData: CodeData | null }>,
   ): CodeData[] => {
diff --git a/packages/host/tests/acceptance/code-patches-test.gts b/packages/host/tests/acceptance/code-patches-test.gts
index 47761810d93..36a9a84ec0d 100644
--- a/packages/host/tests/acceptance/code-patches-test.gts
+++ b/packages/host/tests/acceptance/code-patches-test.gts
@@ -25,6 +25,7 @@ import {
   APP_BOXEL_MESSAGE_MSGTYPE,
   APP_BOXEL_DEBUG_MESSAGE_EVENT_TYPE,
   APP_BOXEL_TOOL_REQUESTS_KEY,
+  APP_BOXEL_TOOL_RESULT_EVENT_TYPE,
   APP_BOXEL_LLM_MODE,
   APP_BOXEL_CONTINUATION_OF_CONTENT_KEY,
   APP_BOXEL_HAS_CONTINUATION_CONTENT_KEY,
@@ -2051,4 +2052,428 @@ ${REPLACE_MARKER}\n\`\`\``;
       'code patch result event is dispatched',
     );
   });
+
+  test("tools on a message auto-run only after that message's code patches settle", async function (assert) {
+    await visitOperatorMode({
+      submode: 'code',
+      codePath: `${testRealmURL}hello.txt`,
+    });
+    await click('[data-test-open-ai-assistant]');
+    let roomId = getRoomIds().pop()!;
+
+    await click('[data-test-llm-mode-option="act"]');
+
+    // One message carrying both a code patch and a tool request — the
+    // shape that used to race: the tool executed while the patch was
+    // still being applied. The spy on store.patch records the patch's
+    // status at the exact moment the tool executes.
+    let store = getService('store');
+    let toolService = getService('tool-service');
+    let statusWhenToolRan: string | undefined;
+    let originalPatch = store.patch.bind(store);
+    let eventId: string;
+    store.patch = ((...args: Parameters<typeof originalPatch>) => {
+      statusWhenToolRan = toolService.getCodePatchStatus({
+        roomId,
+        eventId,
+        codeBlockIndex: 0,
+      });
+      return originalPatch(...args);
+    }) as typeof store.patch;
+
+    let codeBlock = `\`\`\`
+http://test-realm/test/hello.txt
+${SEARCH_MARKER}
+Hello, world!
+${SEPARATOR_MARKER}
+Sequenced, world!
+${REPLACE_MARKER}
+\`\`\``;
+
+    eventId = simulateRemoteMessage(roomId, '@aibot:localhost', {
+      body: codeBlock,
+      msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
+      format: 'org.matrix.custom.html',
+      isStreamingFinished: true,
+      [APP_BOXEL_TOOL_REQUESTS_KEY]: [
+        {
+          id: 'tool-after-patches',
+          name: 'patchCardInstance',
+          arguments: JSON.stringify({
+            attributes: {
+              cardId: `${testRealmURL}index`,
+              patch: { attributes: {} },
+            },
+          }),
+        },
+      ],
+      data: {
+        context: {
+          agentId: getService('matrix-service').agentId,
+        },
+      },
+    });
+
+    await waitFor(
+      '[data-test-message-idx="0"] [data-test-apply-state="applied"]',
+    );
+    await waitUntil(
+      () =>
+        getRoomEvents(roomId).some(
+          (event) =>
+            event.type === APP_BOXEL_TOOL_RESULT_EVENT_TYPE &&
+            event.content['m.relates_to']?.key === 'applied' &&
+            event.content.commandRequestId === 'tool-after-patches',
+        ),
+      { timeout: 5000 },
+    );
+
+    let events = getRoomEvents(roomId);
+    let patchResultIndex = events.findIndex(
+      (event) =>
+        event.type === APP_BOXEL_CODE_PATCH_RESULT_EVENT_TYPE &&
+        event.content['m.relates_to']?.key === 'applied',
+    );
+    let toolResultIndex = events.findIndex(
+      (event) =>
+        event.type === APP_BOXEL_TOOL_RESULT_EVENT_TYPE &&
+        event.content['m.relates_to']?.key === 'applied' &&
+        event.content.commandRequestId === 'tool-after-patches',
+    );
+    assert.true(patchResultIndex >= 0, 'code patch result event exists');
+    assert.true(toolResultIndex >= 0, 'tool result event exists');
+    assert.true(
+      patchResultIndex < toolResultIndex,
+      `code patch settles before the tool runs (patch result at ${patchResultIndex}, tool result at ${toolResultIndex})`,
+    );
+    assert.strictEqual(
+      statusWhenToolRan,
+      'applied',
+      'at the moment the tool executed, the patch had already settled',
+    );
+  });
+
+  test("tools on a message auto-run only after its .gts patches' index invalidations settle", async function (assert) {
+    await visitOperatorMode({
+      submode: 'code',
+      codePath: `${testRealmURL}test-card.gts`,
+    });
+    await click('[data-test-open-ai-assistant]');
+    let roomId = getRoomIds().pop()!;
+
+    await click('[data-test-llm-mode-option="act"]');
+
+    // The layer past patch settlement: an applied .gts patch means the
+    // write landed, not that the index caught up. The spy on store.patch
+    // records, at the exact moment the tool executes, whether the patched
+    // file's tracked index invalidation was still pending — and that one
+    // was tracked at all, so the pending check cannot pass vacuously.
+    let store = getService('store');
+    let toolService = getService('tool-service') as any;
+    let gtsFileUrl = `${testRealmURL}test-card.gts`;
+    let invalidationTrackedWhenToolRan: boolean | undefined;
+    let pendingWhenToolRan: boolean | undefined;
+    let originalPatch = store.patch.bind(store);
+    store.patch = ((...args: Parameters<typeof originalPatch>) => {
+      let key = toolService.invalidationKey(roomId, gtsFileUrl);
+      invalidationTrackedWhenToolRan =
+        !!toolService.aiAssistantInvalidations.get(key);
+      pendingWhenToolRan = toolService.hasPendingPatchInvalidations(roomId, [
+        gtsFileUrl,
+      ]);
+      return originalPatch(...args);
+    }) as typeof store.patch;
+
+    let codeBlock = `\`\`\`
+${gtsFileUrl}
+${SEARCH_MARKER}
+  static displayName = 'Test Card';
+${SEPARATOR_MARKER}
+  static displayName = 'Sequenced Card';
+${REPLACE_MARKER}
+\`\`\``;
+
+    simulateRemoteMessage(roomId, '@aibot:localhost', {
+      body: codeBlock,
+      msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
+      format: 'org.matrix.custom.html',
+      isStreamingFinished: true,
+      [APP_BOXEL_TOOL_REQUESTS_KEY]: [
+        {
+          id: 'tool-after-gts-index',
+          name: 'patchCardInstance',
+          arguments: JSON.stringify({
+            attributes: {
+              cardId: `${testRealmURL}index`,
+              patch: { attributes: {} },
+            },
+          }),
+        },
+      ],
+      data: {
+        context: {
+          agentId: getService('matrix-service').agentId,
+        },
+      },
+    });
+
+    await waitFor(
+      '[data-test-message-idx="0"] [data-test-apply-state="applied"]',
+    );
+    await waitUntil(
+      () =>
+        getRoomEvents(roomId).some(
+          (event) =>
+            event.type === APP_BOXEL_TOOL_RESULT_EVENT_TYPE &&
+            event.content['m.relates_to']?.key === 'applied' &&
+            event.content.commandRequestId === 'tool-after-gts-index',
+        ),
+      { timeout: 5000 },
+    );
+
+    assert.true(
+      invalidationTrackedWhenToolRan,
+      'an index invalidation was tracked for the patched .gts file',
+    );
+    assert.false(
+      pendingWhenToolRan,
+      'at the moment the tool executed, the tracked index invalidation had settled',
+    );
+  });
+
+  test('a timed-out index wait leaves the tracked invalidation in place for a later waiter', async function (assert) {
+    await visitOperatorMode({
+      submode: 'code',
+      codePath: `${testRealmURL}hello.txt`,
+    });
+    let roomId = 'a-room-id';
+    let fileUrl = `${testRealmURL}some-card.gts`;
+    let toolService = getService('tool-service') as any;
+
+    let clientRequestId = toolService.trackAiAssistantCardRequest({
+      action: 'patch-code',
+      roomId,
+      fileUrl,
+    });
+    assert.ok(clientRequestId, 'invalidation was tracked');
+    let key = toolService.invalidationKey(roomId, fileUrl);
+
+    // No index event will ever arrive for this synthetic request, so this
+    // bounded wait times out.
+    await toolService.waitForInvalidationAfterAIAssistantRequest(
+      roomId,
+      fileUrl,
+      50,
+    );
+    let entry = toolService.aiAssistantInvalidations.get(key);
+    assert.ok(
+      entry,
+      'a timed-out wait does not consume the tracked invalidation',
+    );
+
+    // A later waiter (e.g. checkCorrectness after the drain gave up) must
+    // still resolve when the invalidation actually lands.
+    let laterWait = toolService.waitForInvalidationAfterAIAssistantRequest(
+      roomId,
+      fileUrl,
+      5000,
+    );
+    entry.settled = true;
+    entry.deferred.fulfill();
+    await laterWait;
+    assert.notOk(
+      toolService.aiAssistantInvalidations.get(key),
+      'a real invalidation consumes the entry',
+    );
+    toolService.cleanupInvalidationWaiter(key);
+  });
+
+  test('a tool whose execution fails posts a failed tool result event', async function (assert) {
+    await visitOperatorMode({
+      submode: 'code',
+      codePath: `${testRealmURL}hello.txt`,
+    });
+    await click('[data-test-open-ai-assistant]');
+    let roomId = getRoomIds().pop()!;
+
+    // Deterministic execution failure, independent of how the store treats
+    // an unknown card id.
+    let store = getService('store');
+    store.patch = () => Promise.reject(new Error('patch exploded'));
+
+    simulateRemoteMessage(roomId, '@aibot:localhost', {
+      body: 'Patching a card via a store that rejects',
+      msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
+      format: 'org.matrix.custom.html',
+      isStreamingFinished: true,
+      [APP_BOXEL_TOOL_REQUESTS_KEY]: [
+        {
+          id: 'tool-that-fails',
+          name: 'patchCardInstance',
+          arguments: JSON.stringify({
+            attributes: {
+              cardId: `${testRealmURL}index`,
+              patch: { attributes: { name: 'x' } },
+            },
+          }),
+        },
+      ],
+      data: {
+        context: {
+          agentId: getService('matrix-service').agentId,
+        },
+      },
+    });
+
+    await waitFor('[data-test-message-idx="0"] [data-test-tool-call-apply]');
+    await click('[data-test-message-idx="0"] [data-test-tool-call-apply]');
+
+    await waitUntil(
+      () =>
+        getRoomEvents(roomId).some(
+          (event) =>
+            event.type === APP_BOXEL_TOOL_RESULT_EVENT_TYPE &&
+            event.content['m.relates_to']?.key === 'failed' &&
+            event.content.commandRequestId === 'tool-that-fails',
+        ),
+      { timeout: 5000 },
+    );
+
+    let failedEvent = getRoomEvents(roomId).find(
+      (event) =>
+        event.type === APP_BOXEL_TOOL_RESULT_EVENT_TYPE &&
+        event.content['m.relates_to']?.key === 'failed',
+    );
+    assert.ok(
+      failedEvent?.content.failureReason,
+      'failed tool result event carries the failure reason',
+    );
+  });
+
+  test('a tool whose validation throws posts a failed tool result event instead of killing the drain', async function (assert) {
+    await visitOperatorMode({
+      submode: 'code',
+      codePath: `${testRealmURL}hello.txt`,
+    });
+    await click('[data-test-open-ai-assistant]');
+    let roomId = getRoomIds().pop()!;
+
+    await click('[data-test-llm-mode-option="act"]');
+
+    // Simulate the field failure: validate() loads the tool's module and
+    // input schema over the loader, which can throw against a busy realm.
+    let toolService = getService('tool-service');
+    toolService.validate = () => {
+      throw new Error('loader exploded');
+    };
+
+    simulateRemoteMessage(roomId, '@aibot:localhost', {
+      body: 'Running a tool whose validation throws',
+      msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
+      format: 'org.matrix.custom.html',
+      isStreamingFinished: true,
+      [APP_BOXEL_TOOL_REQUESTS_KEY]: [
+        {
+          id: 'tool-validate-throws',
+          name: 'patchCardInstance',
+          arguments: JSON.stringify({
+            attributes: {
+              cardId: `${testRealmURL}index`,
+              patch: { attributes: {} },
+            },
+          }),
+        },
+      ],
+      data: {
+        context: {
+          agentId: getService('matrix-service').agentId,
+        },
+      },
+    });
+
+    await waitUntil(
+      () =>
+        getRoomEvents(roomId).some(
+          (event) =>
+            event.type === APP_BOXEL_TOOL_RESULT_EVENT_TYPE &&
+            event.content['m.relates_to']?.key === 'failed' &&
+            event.content.commandRequestId === 'tool-validate-throws',
+        ),
+      { timeout: 5000 },
+    );
+
+    let failedEvent = getRoomEvents(roomId).find(
+      (event) =>
+        event.type === APP_BOXEL_TOOL_RESULT_EVENT_TYPE &&
+        event.content['m.relates_to']?.key === 'failed',
+    );
+    assert.ok(
+      failedEvent?.content.failureReason?.includes('loader exploded'),
+      'failure reason carries the thrown error',
+    );
+  });
+
+  test('a tool whose execution hangs times out and posts a failed tool result event', async function (assert) {
+    await visitOperatorMode({
+      submode: 'code',
+      codePath: `${testRealmURL}hello.txt`,
+    });
+    await click('[data-test-open-ai-assistant]');
+    let roomId = getRoomIds().pop()!;
+
+    // Simulate the hang observed in the field: an execute that never
+    // settles (e.g. loading a card that never becomes available).
+    let store = getService('store');
+    store.patch = () => new Promise(() => {});
+
+    simulateRemoteMessage(roomId, '@aibot:localhost', {
+      body: 'Patching via a store that never answers',
+      msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
+      format: 'org.matrix.custom.html',
+      isStreamingFinished: true,
+      [APP_BOXEL_TOOL_REQUESTS_KEY]: [
+        {
+          id: 'tool-that-hangs',
+          name: 'patchCardInstance',
+          arguments: JSON.stringify({
+            attributes: {
+              cardId: `${testRealmURL}index`,
+              patch: { attributes: {} },
+            },
+          }),
+        },
+      ],
+      data: {
+        context: {
+          agentId: getService('matrix-service').agentId,
+        },
+      },
+    });
+
+    await waitFor('[data-test-message-idx="0"] [data-test-tool-call-apply]');
+    await click('[data-test-message-idx="0"] [data-test-tool-call-apply]');
+
+    // The test timeout for tool execution is 3s; the failed result must
+    // land on its own once it elapses.
+    await waitUntil(
+      () =>
+        getRoomEvents(roomId).some(
+          (event) =>
+            event.type === APP_BOXEL_TOOL_RESULT_EVENT_TYPE &&
+            event.content['m.relates_to']?.key === 'failed' &&
+            event.content.commandRequestId === 'tool-that-hangs',
+        ),
+      { timeout: 10_000 },
+    );
+
+    let failedEvent = getRoomEvents(roomId).find(
+      (event) =>
+        event.type === APP_BOXEL_TOOL_RESULT_EVENT_TYPE &&
+        event.content['m.relates_to']?.key === 'failed',
+    );
+    assert.ok(
+      failedEvent?.content.failureReason?.includes('did not complete'),
+      'failure reason reports the timeout',
+    );
+  });
 });
diff --git a/packages/host/tests/acceptance/tools-test.gts b/packages/host/tests/acceptance/tools-test.gts
index c4cd411c7bf..d18c80322e3 100644
--- a/packages/host/tests/acceptance/tools-test.gts
+++ b/packages/host/tests/acceptance/tools-test.gts
@@ -1957,23 +1957,39 @@ module('Acceptance | Tools tests', function (hooks) {
       });
 
       await settled();
-      let commandResultEvents = await getRoomEvents(roomId).filter(
-        (event) => event.type === APP_BOXEL_TOOL_RESULT_EVENT_TYPE,
+      // The failure is reported to the room so the bot can react and other
+      // sessions' spinners clear.
+      let failedResultEvents = await getRoomEvents(roomId).filter(
+        (event) =>
+          event.type === APP_BOXEL_TOOL_RESULT_EVENT_TYPE &&
+          event.content['m.relates_to']?.key === 'failed',
       );
       assert.strictEqual(
-        commandResultEvents.length,
+        failedResultEvents.length,
+        1,
+        'failed command result event dispatched',
+      );
+      let appliedResultEvents = await getRoomEvents(roomId).filter(
+        (event) =>
+          event.type === APP_BOXEL_TOOL_RESULT_EVENT_TYPE &&
+          event.content['m.relates_to']?.key === 'applied',
+      );
+      assert.strictEqual(
+        appliedResultEvents.length,
         0,
-        'No command result event dispatched',
+        'no applied command result event dispatched',
       );
       maybeBoomShouldBoom = false;
       await click('[data-test-alert-action-button="Retry"]');
-      commandResultEvents = await getRoomEvents(roomId).filter(
-        (event) => event.type === APP_BOXEL_TOOL_RESULT_EVENT_TYPE,
+      appliedResultEvents = await getRoomEvents(roomId).filter(
+        (event) =>
+          event.type === APP_BOXEL_TOOL_RESULT_EVENT_TYPE &&
+          event.content['m.relates_to']?.key === 'applied',
       );
       assert.strictEqual(
-        commandResultEvents.length,
+        appliedResultEvents.length,
         1,
-        'Command result event was dispatched',
+        'applied command result event was dispatched after retry',
       );
       assert.dom('[data-test-apply-state="applied"]').exists();
     });
diff --git a/packages/runtime-common/ai/prompt.ts b/packages/runtime-common/ai/prompt.ts
index 4b3267acf8f..8ac2a996991 100644
--- a/packages/runtime-common/ai/prompt.ts
+++ b/packages/runtime-common/ai/prompt.ts
@@ -1148,7 +1148,11 @@ async function toResultMessages(
     (getToolRequests<Partial<EncodedToolRequest>>(messageContent) ?? []).map(
       async (toolRequest: Partial<EncodedToolRequest>) => {
         let decodedToolRequest = decodeToolRequestSafe(toolRequest);
-        let toolResult = toolResults.find(
+        // A request can accumulate several result events — a 'failed' from a
+        // first attempt and an 'applied' from a later retry — and the latest
+        // one is the call's actual outcome.
+        let toolResult = findLast(
+          toolResults,
           (toolResult) =>
             (isToolResultWithOutputMsgtype(toolResult.content.msgtype) ||
               isToolResultWithNoOutputMsgtype(toolResult.content.msgtype)) &&
@@ -2078,7 +2082,10 @@ function gatherPatchedCards(
   let cards: CodePatchCorrectnessCard[] = [];
   let seen = new Set<string>();
   for (let request of toolRequests) {
-    let result = toolResults.find(
+    // Latest result wins: a retry that succeeds supersedes an earlier
+    // 'failed' event for the same request.
+    let result = findLast(
+      toolResults,
       (toolResult) => toolResult.content.commandRequestId === request.id,
     );
     if (!result) {