@genesislcap/ai-assistant 14.452.1 → 14.453.0

package/dist/esm/main/main.styles.js

@@ -593,6 +593,32 @@ export const styles = css `
     background-color: var(--neutral-layer-2);
   }
 
+  /* Right-hand control column, mirroring .input-left-controls — holds the
+     Stop button (shown while a turn runs) stacked above the Send button. The
+     Stop button is an icon (stop → spinner), so the column width is driven by
+     Send and stays stable whether a turn is running or idle. */
+  .input-right-controls {
+    display: flex;
+    flex-direction: column;
+    align-items: stretch;
+    gap: calc(var(--design-unit) * 1px);
+  }
+
+  /* The "stopping" state shows a spinner — rotate it (the icon set's glyph is
+     static). Transform-only, so it never affects layout/width. */
+  @keyframes ai-stop-spin {
+    to {
+      transform: rotate(360deg);
+    }
+  }
+
+  .stop-icon-spinning {
+    /* inline-block so the icon host is transformable — an inline element
+       ignores the transform, which is why the spinner appeared frozen. */
+    display: inline-block;
+    animation: ai-stop-spin 0.8s linear infinite;
+  }
+
   .input-left-controls {
     display: flex;
     flex-direction: column;

package/dist/esm/main/main.template.js

@@ -15,7 +15,7 @@
  *   lines let the formatter inject whitespace between them.
  */
 import { isChatToolCallUnknown } from '@genesislcap/foundation-ai';
-import { html, ref, repeat, when } from '@genesislcap/web-core';
+import { classNames, html, ref, repeat, when } from '@genesislcap/web-core';
 import { ANIMATION_DEFS } from './main.types';
 function unknownToolPayload(tc) {
     if (!isChatToolCallUnknown(tc))
@@ -206,7 +206,7 @@ ${(tc) => { var _a; return (((_a = tc.foldPath) === null || _a === void 0 ? void
       part="agent-toggle-button"
       appearance="stealth"
       title=${(x) => x.agentToggleTitle}
-      ?disabled=${(x) => x.state === 'loading' || x.pinLocked}
+      ?disabled=${(x) => x.busy || x.pinLocked}
       @click=${(x) => x.toggleAgentPicker()}
     >
       ${when((x) => x.agentPickerOpen, html `<${iconTag} name="chevron-down"></${iconTag}>`)}
@@ -227,7 +227,7 @@ ${(tc) => { var _a; return (((_a = tc.foldPath) === null || _a === void 0 ? void
       part="attach-button"
       appearance="stealth"
       title=${(x) => { var _a; return `Attach file (${(_a = x.chatConfig.ui) === null || _a === void 0 ? void 0 : _a.acceptedFiles})`; }}
-      ?disabled=${(x) => x.state === 'loading'}
+      ?disabled=${(x) => x.busy}
       @click=${(x) => x.triggerFileInput()}
     ><${iconTag} name="paperclip"></${iconTag}></${buttonTag}>
   `;
@@ -496,7 +496,7 @@ ${(tc) => { var _a; return (((_a = tc.foldPath) === null || _a === void 0 ? void
         `)}
       ${when((x) => x.agentPickerEnabled && x.agentPickerOpen, agentPickerPanelTemplate)}
       ${when((x) => !x.composerHiddenByConfig &&
-        !(x.state === 'loading' && x.effectiveChatInputDuringExecution === 'hidden'), html `
+        !(x.busy && x.effectiveChatInputDuringExecution === 'hidden'), html `
           <div class="input-row" part="input-row">
             ${when((x) => { var _a; return x.agentPickerEnabled || !!((_a = x.chatConfig.ui) === null || _a === void 0 ? void 0 : _a.acceptedFiles); }, inputLeftControlsTemplate)}
             <${textareaTag}
@@ -505,7 +505,7 @@ ${(tc) => { var _a; return (((_a = tc.foldPath) === null || _a === void 0 ? void
               part="input"
               placeholder=${(x) => x.effectivePlaceholder}
               :value=${(x) => x.inputValue}
-              ?disabled=${(x) => x.state === 'loading'}
+              ?disabled=${(x) => x.busy}
               @input=${(x, c) => (x.inputValue = c.event.target.value)}
               @keydown=${(x, c) => {
         if (c.event.key === 'Enter' &&
@@ -517,12 +517,28 @@ ${(tc) => { var _a; return (((_a = tc.foldPath) === null || _a === void 0 ? void
         return true;
     }}
             ></${textareaTag}>
-            <${buttonTag}
-              class="send-button"
-              part="send-button"
-              ?disabled=${(x) => x.state === 'loading' || (!x.inputValue.trim() && !x.attachments.length)}
-              @click=${(x) => x.handleSendClick()}
-            >Send</${buttonTag}>
+            <div class="input-right-controls">
+              ${when((x) => { var _a; return x.busy && !((_a = x.chatConfig.ui) === null || _a === void 0 ? void 0 : _a.hideStopButton); }, html `
+                  <${buttonTag}
+                    class="stop-button"
+                    part="stop-button"
+                    appearance="stealth"
+                    title="${(x) => (x.state === 'cancelling' ? 'Stopping…' : 'Stop')}"
+                    aria-label="${(x) => (x.state === 'cancelling' ? 'Stopping' : 'Stop')}"
+                    ?disabled=${(x) => x.state === 'cancelling'}
+                    @click=${(x) => x.handleStopClick()}
+                  ><${iconTag}
+                      class="${(x) => classNames('stop-icon', ['stop-icon-spinning', x.state === 'cancelling'])}"
+                      name="${(x) => (x.state === 'cancelling' ? 'spinner' : 'stop')}"
+                    ></${iconTag}></${buttonTag}>
+                `)}
+              <${buttonTag}
+                class="send-button"
+                part="send-button"
+                ?disabled=${(x) => x.busy || (!x.inputValue.trim() && !x.attachments.length)}
+                @click=${(x) => x.handleSendClick()}
+              >Send</${buttonTag}>
+            </div>
           </div>
         `)}
       <ai-halo-overlay

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@genesislcap/ai-assistant",
   "description": "Genesis AI Assistant micro-frontend",
-  "version": "14.452.1",
+  "version": "14.453.0",
   "license": "SEE LICENSE IN license.txt",
   "main": "dist/esm/index.js",
   "types": "dist/ai-assistant.d.ts",
@@ -64,24 +64,24 @@
     }
   },
   "devDependencies": {
-    "@genesislcap/foundation-testing": "14.452.1",
-    "@genesislcap/genx": "14.452.1",
-    "@genesislcap/rollup-builder": "14.452.1",
-    "@genesislcap/ts-builder": "14.452.1",
-    "@genesislcap/uvu-playwright-builder": "14.452.1",
-    "@genesislcap/vite-builder": "14.452.1",
-    "@genesislcap/webpack-builder": "14.452.1",
+    "@genesislcap/foundation-testing": "14.453.0",
+    "@genesislcap/genx": "14.453.0",
+    "@genesislcap/rollup-builder": "14.453.0",
+    "@genesislcap/ts-builder": "14.453.0",
+    "@genesislcap/uvu-playwright-builder": "14.453.0",
+    "@genesislcap/vite-builder": "14.453.0",
+    "@genesislcap/webpack-builder": "14.453.0",
     "@types/dompurify": "^3.0.5",
     "@types/marked": "^5.0.2"
   },
   "dependencies": {
-    "@genesislcap/foundation-ai": "14.452.1",
-    "@genesislcap/foundation-logger": "14.452.1",
-    "@genesislcap/foundation-redux": "14.452.1",
-    "@genesislcap/foundation-ui": "14.452.1",
-    "@genesislcap/foundation-utils": "14.452.1",
-    "@genesislcap/rapid-design-system": "14.452.1",
-    "@genesislcap/web-core": "14.452.1",
+    "@genesislcap/foundation-ai": "14.453.0",
+    "@genesislcap/foundation-logger": "14.453.0",
+    "@genesislcap/foundation-redux": "14.453.0",
+    "@genesislcap/foundation-ui": "14.453.0",
+    "@genesislcap/foundation-utils": "14.453.0",
+    "@genesislcap/rapid-design-system": "14.453.0",
+    "@genesislcap/web-core": "14.453.0",
     "dompurify": "^3.3.1",
     "marked": "^17.0.3"
   },
@@ -93,5 +93,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "57cd7afd42c9a1554432603c66e4e5f750c3dc08"
+  "gitHead": "510e12f2d2b7d210c77d629427fa4081912bd99f"
 }

package/src/components/ai-driver/ai-driver.ts

@@ -83,4 +83,19 @@ export interface AiDriver extends EventTarget {
    * @beta
    */
   getActiveProviderName(): string;
+
+  /**
+   * Tear down the driver, aborting any in-flight provider request. Called by
+   * the host when it swaps in a replacement driver. Optional because not every
+   * implementation needs teardown; the host invokes it when present.
+   */
+  dispose?(): void | Promise<void>;
+
+  /**
+   * Stop the current turn in response to a user "stop" action. Aborts the
+   * in-flight provider request; a tool already executing runs to completion and
+   * the loop stops at the next boundary. The driver stays usable afterwards.
+   * Optional; the host wires the stop button to it when present.
+   */
+  cancel?(): void;
 }

package/src/components/chat-driver/chat-driver.test.ts

@@ -319,6 +319,233 @@ stale('splits stale vs hallucinated tools on the unknown-tool-limit error', asyn
 
 stale.run();
 
+// ---------------------------------------------------------------------------
+// timeout handling — a transport `TimeoutError` surfaces a distinct message
+// ---------------------------------------------------------------------------
+
+const timeout = createLogicSuite('ChatDriver timeout handling');
+
+/** A provider whose `chat` rejects with the `TimeoutError` the transports tag
+ * a request timeout with (see gemini/anthropic `post`). */
+const timesOutProvider = (): AIProvider => ({
+  chat: async (): Promise<ChatMessage> => {
+    throw new DOMException('Gemini request timed out', 'TimeoutError');
+  },
+});
+
+timeout('surfaces a timeout-specific message instead of the generic failure', async () => {
+  clearMetaEventRegistry();
+  const config = agent({
+    name: 'Static',
+    toolDefinitions: [def('noop')],
+    toolHandlers: { noop: async () => 'ok' },
+  });
+  const sessionKey = 'timeout-test';
+  const driver = makeDriver(config, timesOutProvider(), sessionKey);
+
+  const result = await driver.sendMessage('go');
+  assert.is(result.reason, 'done');
+
+  // The turn ends with the timeout message, NOT the generic "something went wrong".
+  const last = driver.getHistory().at(-1);
+  assert.ok(last?.role === 'assistant', 'turn ends with an assistant message');
+  assert.ok(last!.content.includes('timed out'), 'message names the timeout');
+  assert.not.ok(
+    last!.content.includes('something went wrong'),
+    'must not fall through to the generic catch',
+  );
+
+  // Recorded distinctly in the debug log: a turn.error tagged TimeoutError,
+  // not swallowed silently.
+  const err = getMetaEvents(sessionKey).find((e) => e.type === 'turn.error');
+  assert.ok(err, 'a turn.error should be recorded');
+  assert.is(err!.detail?.reason, 'exception');
+  assert.is(err!.detail?.name, 'TimeoutError');
+});
+
+timeout.run();
+
+// ---------------------------------------------------------------------------
+// cancellation — dispose() aborts the in-flight provider call (lifecycle signal)
+// ---------------------------------------------------------------------------
+
+const cancel = createLogicSuite('ChatDriver cancellation');
+
+cancel('threads a non-aborted signal into the provider call by default', async () => {
+  const config = agent({
+    name: 'Static',
+    toolDefinitions: [def('noop')],
+    toolHandlers: { noop: async () => 'ok' },
+  });
+  const capture: { signal?: AbortSignal } = {};
+  const provider: AIProvider = {
+    chat: async (_h, _m, options): Promise<ChatMessage> => {
+      capture.signal = options?.signal;
+      return { role: 'assistant', content: 'hi' };
+    },
+  };
+  const driver = makeDriver(config, provider, 'signal-plumb');
+
+  await driver.sendMessage('go');
+
+  assert.ok(capture.signal, 'provider received an options.signal');
+  assert.not.ok(capture.signal!.aborted, 'and it is not aborted on a normal turn');
+});
+
+cancel('dispose() aborts the in-flight request and stops quietly', async () => {
+  clearMetaEventRegistry();
+  const config = agent({
+    name: 'Static',
+    toolDefinitions: [def('noop')],
+    toolHandlers: { noop: async () => 'ok' },
+  });
+  // A provider that hangs until its signal aborts, then rejects with the
+  // signal's reason — mirroring how the transport surfaces an aborted fetch.
+  const capture: { signal?: AbortSignal } = {};
+  const provider: AIProvider = {
+    chat: (_h, _m, options): Promise<ChatMessage> => {
+      const signal = options?.signal;
+      capture.signal = signal;
+      return new Promise<ChatMessage>((_resolve, reject) => {
+        if (!signal) return;
+        if (signal.aborted) {
+          reject(signal.reason);
+          return;
+        }
+        signal.addEventListener('abort', () => reject(signal.reason), { once: true });
+      });
+    },
+  };
+  const driver = makeDriver(config, provider, 'cancel-test');
+
+  const pending = driver.sendMessage('go');
+  driver.dispose();
+  const result = await pending;
+
+  assert.is(result.reason, 'done');
+  assert.ok(capture.signal?.aborted, 'the provider signal aborted on dispose');
+  assert.is(capture.signal!.reason.name, 'AbortError');
+
+  // Quiet: no assistant message appended (would otherwise pollute cached history).
+  const assistantMsgs = driver.getHistory().filter((m) => m.role === 'assistant');
+  assert.is(assistantMsgs.length, 0, 'no message appended on a disposal abort');
+  assert.not.ok(
+    driver.getHistory().some((m) => m.content?.includes('something went wrong')),
+    'must not surface the generic failure',
+  );
+});
+
+cancel(
+  'cancel() stops the turn with a "Stopped." marker and leaves the driver usable',
+  async () => {
+    clearMetaEventRegistry();
+    const config = agent({
+      name: 'Static',
+      toolDefinitions: [def('noop')],
+      toolHandlers: { noop: async () => 'ok' },
+    });
+    let call = 0;
+    const provider: AIProvider = {
+      chat: (_h, _m, options): Promise<ChatMessage> => {
+        call += 1;
+        if (call === 1) {
+          // First turn hangs until its signal aborts (the user cancel). Must also
+          // handle the already-aborted case: cancel can land before chat runs
+          // (during the provider-resolution await), so the signal may arrive
+          // aborted — mirror how real fetch rejects immediately in that case.
+          const signal = options!.signal!;
+          return new Promise<ChatMessage>((_resolve, reject) => {
+            if (signal.aborted) {
+              reject(signal.reason);
+              return;
+            }
+            signal.addEventListener('abort', () => reject(signal.reason), { once: true });
+          });
+        }
+        // Second turn resolves normally — proves the driver wasn't bricked.
+        return Promise.resolve({ role: 'assistant', content: 'second response' });
+      },
+    };
+    const driver = makeDriver(config, provider, 'cancel-stop');
+
+    const pending = driver.sendMessage('go');
+    driver.cancel();
+    const result = await pending;
+
+    assert.is(result.reason, 'done');
+    // Subtle 'Stopped.' marker (system-event, not a generic failure).
+    const last = driver.getHistory().at(-1);
+    assert.is(last?.role, 'system-event');
+    assert.is(last?.content, 'Stopped.');
+
+    // The driver is still usable for the next message.
+    const second = await driver.sendMessage('again');
+    assert.is(second.reason, 'done');
+    assert.ok(
+      driver.getHistory().some((m) => m.content === 'second response'),
+      'a fresh turn runs after a cancel',
+    );
+  },
+);
+
+cancel('a tool already running finishes, then the loop stops at the boundary', async () => {
+  let toolFinished = false;
+  let secondChatCalled = false;
+  const config = agent({
+    name: 'Static',
+    toolDefinitions: [def('slow')],
+    toolHandlers: {
+      slow: async () => {
+        // Cancel mid-tool: the tool must still run to completion.
+        driver.cancel();
+        await Promise.resolve();
+        toolFinished = true;
+        return 'tool done';
+      },
+    },
+  });
+  let call = 0;
+  const provider: AIProvider = {
+    chat: async (): Promise<ChatMessage> => {
+      call += 1;
+      if (call === 1) {
+        return {
+          role: 'assistant',
+          content: '',
+          toolCalls: [{ id: 't1', name: 'slow', args: {} }],
+        };
+      }
+      secondChatCalled = true;
+      return { role: 'assistant', content: 'should not be reached' };
+    },
+  };
+  const driver = makeDriver(config, provider, 'cancel-tool');
+
+  const result = await driver.sendMessage('go');
+
+  assert.is(result.reason, 'done');
+  assert.ok(toolFinished, 'the in-flight tool ran to completion (tools are atomic)');
+  assert.not.ok(secondChatCalled, 'no further LLM call is made after cancel');
+  const last = driver.getHistory().at(-1);
+  assert.is(last?.role, 'system-event');
+  assert.is(last?.content, 'Stopped.');
+});
+
+cancel('cancel() is a no-op when no turn is running', () => {
+  const config = agent({
+    name: 'Static',
+    toolDefinitions: [def('noop')],
+    toolHandlers: { noop: async () => 'ok' },
+  });
+  const driver = makeDriver(config, scriptedProvider([]), 'cancel-idle');
+
+  driver.cancel(); // must not throw or append anything while idle
+
+  assert.is(driver.getHistory().length, 0);
+});
+
+cancel.run();
+
 // ---------------------------------------------------------------------------
 // sub-agents — forced tool use + typed completion/failure union (GENC-1312)
 //

package/src/components/chat-driver/chat-driver.ts

@@ -273,6 +273,28 @@ export class ChatDriver extends EventTarget implements AiDriver {
   private debugSnapshotter?: () => unknown;
   private readonly maxTurnSnapshots: number;
 
+  /**
+   * Aborted by `dispose()` on driver teardown (e.g. an agent-config swap).
+   * Threaded into every provider call as `ChatRequestOptions.signal`, so a
+   * disposed driver's in-flight LLM request is cancelled instead of running on
+   * to completion or the transport timeout. Also passed to prompt/tool
+   * factories via `SystemPromptContext.signal`.
+   */
+  private readonly lifecycleController = new AbortController();
+
+  /**
+   * Per-turn abort controller, reset at the start of every turn by `beginTurn`.
+   * Aborted by `cancel()` (user stop) and chained to `lifecycleController` so a
+   * driver dispose also ends the current turn. Its signal — not the lifecycle
+   * one — is what reaches the provider call, so a turn can be cancelled without
+   * bricking the driver for the next message.
+   */
+  private turnController = new AbortController();
+  /** True when the current turn was stopped via `cancel()` (vs a dispose). Drives the "Stopped." marker. */
+  private turnCancelled = false;
+  /** Detaches the lifecycle→turn abort link at turn end; set by `beginTurn`. */
+  private unlinkLifecycleFromTurn?: () => void;
+
   /**
    * Active agent's provider selector (static name or per-turn resolver).
    * `undefined` means "use the registry default".
@@ -322,6 +344,67 @@ export class ChatDriver extends EventTarget implements AiDriver {
     this.maxTurnSnapshots = maxTurnSnapshots;
   }
 
+  /**
+   * Tear down the driver: aborts the lifecycle signal so any in-flight provider
+   * request (and prompt/tool factories awaiting it) cancels instead of running
+   * on to completion or the transport timeout. Called by the host on driver
+   * swap and by `OrchestratingDriver.dispose()`. Idempotent.
+   */
+  dispose(): void {
+    this.lifecycleController.abort(new DOMException('AI assistant driver disposed', 'AbortError'));
+  }
+
+  /**
+   * Stop the current turn (user "stop" button). Aborts the in-flight provider
+   * request immediately; if a tool is mid-execution it runs to completion and
+   * the loop bails at the next boundary (tools are atomic). No-op when idle.
+   * The driver stays usable for the next message.
+   */
+  cancel(): void {
+    if (!this.busy) return;
+    this.turnCancelled = true;
+    this.turnController.abort(new DOMException('Cancelled by user', 'AbortError'));
+  }
+
+  /**
+   * Start a fresh per-turn abort scope. Chains `lifecycleController` into the
+   * new `turnController` so a dispose mid-turn also aborts the request.
+   */
+  private beginTurn(): void {
+    this.turnCancelled = false;
+    this.turnController = new AbortController();
+    const lifecycle = this.lifecycleController.signal;
+    if (lifecycle.aborted) {
+      this.turnController.abort(lifecycle.reason);
+      this.unlinkLifecycleFromTurn = undefined;
+      return;
+    }
+    const onDispose = () => this.turnController.abort(lifecycle.reason);
+    lifecycle.addEventListener('abort', onDispose, { once: true });
+    this.unlinkLifecycleFromTurn = () => lifecycle.removeEventListener('abort', onDispose);
+  }
+
+  /** Detach the lifecycle→turn link so a long-lived lifecycle signal doesn't accumulate listeners. */
+  private endTurn(): void {
+    this.unlinkLifecycleFromTurn?.();
+    this.unlinkLifecycleFromTurn = undefined;
+  }
+
+  /**
+   * Finish a turn whose signal aborted. A user cancel adds a subtle "Stopped."
+   * marker; a dispose-driven abort stops quietly (the widget is gone and the
+   * cached history would otherwise gain a stray marker on remount).
+   */
+  private completeAbortedTurn(): ChatDriverResult {
+    if (this.turnCancelled) {
+      logger.warn('ChatDriver: turn cancelled by user');
+      this.appendToHistory({ role: 'system-event', content: 'Stopped.' });
+    } else {
+      logger.warn('ChatDriver: turn aborted (driver disposed)');
+    }
+    return { reason: 'done' };
+  }
+
   /**
    * Swap in a new agent's configuration. Called by OrchestratingDriver before
    * each specialist turn so the shared driver runs with the right tools and prompt.
@@ -822,6 +905,7 @@ export class ChatDriver extends EventTarget implements AiDriver {
     if (this.busy || (!userInput.trim() && !attachments?.length)) return { reason: 'done' };
 
     this.busy = true;
+    this.beginTurn();
     this.subAgentCompletion = undefined;
     this.subAgentFailure = undefined;
     this.agentReleaseRequested = false;
@@ -856,6 +940,7 @@ export class ChatDriver extends EventTarget implements AiDriver {
         durationMs: Date.now() - this.turnStartedAt,
       });
       this.busy = false;
+      this.endTurn();
       agenticActivityBus.publish('tool-loop-end', undefined);
     }
   }
@@ -963,6 +1048,15 @@ export class ChatDriver extends EventTarget implements AiDriver {
     // Mark before the first turn so the child forces tool use and reports a
     // typed failure (rather than user-facing text) if it never completes.
     child.markAsSubAgent();
+    // Propagate disposal: if this (parent) driver is torn down while the
+    // sub-agent is mid-flight, dispose the child too so its in-flight request
+    // aborts. Detached in the `finally` below once the sub-agent completes.
+    const disposeChild = () => child.dispose();
+    if (this.lifecycleController.signal.aborted) {
+      disposeChild();
+    } else {
+      this.lifecycleController.signal.addEventListener('abort', disposeChild, { once: true });
+    }
     child.applyAgent({ ...subConfig, primerHistory: effectivePrimer });
     // Route interactions back through this driver so widgets render in the
     // parent's (ultimately the root's) history and resolve via the same
@@ -1002,6 +1096,7 @@ export class ChatDriver extends EventTarget implements AiDriver {
     try {
       await child.sendMessage(task ?? '');
     } finally {
+      this.lifecycleController.signal.removeEventListener('abort', disposeChild);
       child.removeEventListener('history-updated', forwardTrace);
       child.removeEventListener('provider-changed', forwardProviderChanged);
       this.dispatchEvent(new CustomEvent('sub-agent-stop', { detail: lifecycleDetail }));
@@ -1042,6 +1137,7 @@ export class ChatDriver extends EventTarget implements AiDriver {
     if (this.busy) return { reason: 'done' };
 
     this.busy = true;
+    this.beginTurn();
     this.subAgentCompletion = undefined;
     this.subAgentFailure = undefined;
     this.turnStartedAt = Date.now();
@@ -1073,6 +1169,7 @@ export class ChatDriver extends EventTarget implements AiDriver {
         durationMs: Date.now() - this.turnStartedAt,
       });
       this.busy = false;
+      this.endTurn();
       agenticActivityBus.publish('tool-loop-end', undefined);
     }
   }
@@ -1278,11 +1375,18 @@ export class ChatDriver extends EventTarget implements AiDriver {
     while (iterations < this.maxToolIterations) {
       iterations += 1;
 
+      // A cancel (or dispose) that landed while the previous iteration's tool
+      // batch was running takes effect here — before issuing another LLM call.
+      // An abort during the call itself is handled by the catch below.
+      if (this.turnController.signal.aborted) {
+        return this.completeAbortedTurn();
+      }
+
       const promptCtx: SystemPromptContext = {
         agentName: this.activeAgentName ?? '',
         history: this.history,
         turnIndex: iterations - 1,
-        signal: new AbortController().signal,
+        signal: this.turnController.signal,
       };
 
       // Re-resolve dynamic tool definitions before each LLM call. The static
@@ -1377,6 +1481,9 @@ export class ChatDriver extends EventTarget implements AiDriver {
         // Strip fold-only properties (foldEvent, foldPath) before sending to provider
         tools: this.toolDefinitions.length ? this.toolDefinitions : undefined,
         attachments: attachmentsForCall,
+        // Per-turn signal: aborts on user cancel, and (via beginTurn's chain)
+        // on driver dispose. Cancels the in-flight request either way.
+        signal: this.turnController.signal,
         // Sub-agents must finish by calling a tool (their completion tool), never
         // by emitting a free-text turn — force tool use so the provider can't
         // return a bare text answer. Top-level agents stay on the default 'auto'.
@@ -1431,6 +1538,34 @@ export class ChatDriver extends EventTarget implements AiDriver {
           }
           return { reason: 'done' };
         }
+        // A request timeout from the transport (tagged `TimeoutError`) is not a
+        // bug on our end — surface it distinctly instead of letting it fall
+        // through to the generic "something went wrong" catch. No auto-retry:
+        // the timeout ceiling is already minutes long, so a silent retry would
+        // just make the user wait again.
+        if (e instanceof DOMException && e.name === 'TimeoutError') {
+          logger.error('ChatDriver: request timed out', e);
+          recordTurnError(this.sessionKey, 'exception', {
+            agent: this.activeAgentName,
+            provider: this.lastResolvedProviderName,
+            name: e.name,
+            message: e.message,
+          });
+          this.appendToHistory({
+            role: 'assistant',
+            content:
+              'The request timed out. You can ask me to try again, or break this into a smaller step.',
+          });
+          return { reason: 'done' };
+        }
+        // The request was aborted: either a user cancel (turnController) or a
+        // driver dispose (lifecycleController, chained into the turn). A user
+        // cancel adds a "Stopped." marker; a dispose stops quietly. Handled
+        // before the transient-retry below so an intentional abort/timeout is
+        // never retried.
+        if (e instanceof DOMException && e.name === 'AbortError') {
+          return this.completeAbortedTurn();
+        }
         // A transient provider/transport error should retry the SAME iteration a bounded
         // number of times rather than tearing down the whole turn (which strands the
         // agent's unflushed buffer behind an opaque error message).