diff --git a/apps/hub/src/index.ts b/apps/hub/src/index.ts
index 6b0d5c2b3..b3292a08b 100644
--- a/apps/hub/src/index.ts
+++ b/apps/hub/src/index.ts
@@ -73,6 +73,7 @@ import {
   createWorkbenchSubscriberRegistry,
   createWorkbenchTenancyRoutes,
   createWorkbenchTurnQueue,
+  createTurnCancelRegistry,
   createChatOrchestrator,
   createChatRoutes,
   joinRunParticipant,
@@ -1358,6 +1359,10 @@ export async function createHub(config: HubConfig) {
     claims: createInMemoryTurnClaimStore({ ttlMs: DEFAULT_TURN_CLAIM_TTL_MS }),
     publish: workbenchSubscribers.publish,
   });
+  // The live abort seam a running turn is reachable through (CL-7201) —
+  // shared the same way `turnQueue` above is, so a cancel request lands
+  // wherever a workbench's turn was actually dispatched from.
+  const turnCancellation = createTurnCancelRegistry();
   // The room timeline store (CL-6327): a workbench's own messages, held
   // as workbench data rather than platform mail.
   const roomMessages = createDrizzleRoomMessageStore(db);
@@ -1572,6 +1577,7 @@ export async function createHub(config: HubConfig) {
     clientIds: createDrizzleClientIdStore(db),
     workbenchSubscribers,
     turnQueue,
+    turnCancellation,
     requireGrant: createRequireGrant({
       grantStore: chatGrantStore,
       conditionRegistry: chatConditionRegistry,
@@ -1618,6 +1624,7 @@ export async function createHub(config: HubConfig) {
       roomMessages,
       publish: workbenchSubscribers.publish,
       turnQueue,
+      turnCancellation,
       authenticator: createWorkflowRunAuthenticator({ db }),
       tenancy: chatTenancy,
       sessionFor,
@@ -1641,6 +1648,7 @@ export async function createHub(config: HubConfig) {
     sessionFor,
     workbenchSubscribers,
     turnQueue,
+    turnCancellation,
   });
   // Tells the routine trigger popover whether a Slack-bound webhook
   // trigger is honestly offerable in this deployment — no session or
@@ -2800,6 +2808,7 @@ export async function createHub(config: HubConfig) {
               roomMessages,
               publish: workbenchSubscribers.publish,
               turnQueue,
+              turnCancellation,
             },
             {
               tenantId: input.tenantId,
diff --git a/apps/hub/src/slack-tag-mount.ts b/apps/hub/src/slack-tag-mount.ts
index 341b455ea..a3af480eb 100644
--- a/apps/hub/src/slack-tag-mount.ts
+++ b/apps/hub/src/slack-tag-mount.ts
@@ -26,6 +26,7 @@ import {
   type WorkbenchSubscriberRegistry,
   type WorkbenchTenancyStore,
   type WorkbenchTurnQueue,
+  type TurnCancelRegistry,
   type ChatPlatform,
   type ChatStore,
   type RoomMessageStore,
@@ -72,6 +73,9 @@ export type MountWorkbenchSlackTagDeps = {
    * send and a person's own message for the same channel serialize
    * against each other too. */
   readonly turnQueue: WorkbenchTurnQueue;
+  /** The same cancellation registry `createChatRoutes` is given
+   * (CL-7201) — shared, never a second instance. */
+  readonly turnCancellation: TurnCancelRegistry;
 };
 
 export type MountedWorkbenchSlackTag = { readonly mounted: boolean };
@@ -211,6 +215,7 @@ export async function mountWorkbenchSlackTag(
           roomMessages: deps.roomMessages,
           publish: deps.workbenchSubscribers.publish,
           turnQueue: deps.turnQueue,
+          turnCancellation: deps.turnCancellation,
         },
         {
           tenantId: input.tenantId,
diff --git a/docs/CHAT.md b/docs/CHAT.md
index ec50c955f..f641ef8bd 100644
--- a/docs/CHAT.md
+++ b/docs/CHAT.md
@@ -171,6 +171,56 @@ agents replying in one room under distinct occurrences, three rapid
 messages serializing into ordered turns, and a sidecar killed
 mid-occurrence leaving both the room and the section alive.
 
+## Stopping a turn (CL-7201)
+
+Before this, the only bound on a wedged turn was the dispatch and
+wait-until-free timeouts themselves — minutes long, and no way for a
+user watching an agent go wrong to do anything but wait or reload.
+`POST /workbenches/:id/turns/cancel` (`packages/chat/src/routes.ts`)
+closes that gap, calling `cancelWorkbenchTurn`
+(`packages/chat/src/workbench-service.ts`), which runs two independent
+mechanisms together because a turn can be in either place when the user
+asks to stop it:
+
+- **Still on our own call stack.** `dispatchTurnBatch` registers one
+  `AbortController` per recipient it dispatches, via a workbench-keyed
+  `TurnCancelRegistry` (`packages/chat/src/turn-cancellation.ts`) —
+  the same "one instance, shared" pattern `WorkbenchTurnQueue` follows.
+  Its signal is composed into each `withTimeout` call (`waitUntilFree`,
+  `dispatchTurn`) as an **external signal** — `withTimeout` (CL-7193)
+  already gives `work` an `AbortSignal` the moment its own timeout wins;
+  CL-7201 extends it to also fire (with the external caller's own
+  reason, not its own timeout message) the moment that external signal
+  aborts, whichever comes first. `dispatchTurn`'s abort-close handler
+  tells a deliberate cancellation apart from a timeout by checking
+  whether the abort reason is a `TurnCancelledError`, and closes the
+  turn row `cancelled` rather than `failed`.
+- **Already off our call stack.** `sendMail` has no cancellable
+  primitive of its own (CL-7230) — once it resolves, the agent is
+  generating (or parked on a `message_response` gate somewhere in the
+  execution plane this package cannot see into) with nothing left
+  registered to abort. `cancelWorkbenchTurn` snapshots every turn
+  `AgentTurnStore.findRunningTurns` reports for the workbench _before_
+  triggering the registry above (so a row the abort path already
+  claimed is still counted), then sweeps it directly through the same
+  `finishTurn` compare-and-set.
+
+Both mechanisms race the same compare-and-set, so whichever reaches a
+given row first is the only one that ever settles it or posts a notice
+— `postCancelledNotice`, a `turnCancelled` text part distinct from
+`postUndeliveredNotice`'s `turnFailed` (a cancellation is not a
+failure, and the timeline says so). CL-7230's ceiling is honest, not
+silent: settling the row is not the same as stopping the underlying
+agent process. A late `connector.reply` that lands anyway finds no
+`running` row left to attach to, and `postReply` will not fall back to
+posting it unattached onto a 1:1 membership whose latest turn is
+`cancelled`. The composer offers a Stop affordance
+(`packages/chat-ui/src/composer.tsx`) whenever `isAwaitingReply`
+(`streaming-reply.ts`) is true — the whole in-flight phase, including
+after tokens have started streaming — independent of its own `sending`
+state. A follow-up message can still be typed and queued while a turn
+runs.
+
 ## Threads: workbench → thread → sub-thread
 
 A workbench's timeline is itself a thread — its **root thread**, one per
diff --git a/packages/chat-ui/src/api.ts b/packages/chat-ui/src/api.ts
index 2a6e39f62..761b631c9 100644
--- a/packages/chat-ui/src/api.ts
+++ b/packages/chat-ui/src/api.ts
@@ -1318,7 +1318,7 @@ const AgentTurnWire = type({
   workbenchId: "string",
   agentAddress: "string",
   childRunId: "string",
-  status: "'running' | 'completed' | 'failed'",
+  status: "'running' | 'completed' | 'failed' | 'cancelled'",
   "replyMessageId?": "string | null",
 });
 export type AgentTurnSummary = typeof AgentTurnWire.infer;
@@ -1354,6 +1354,31 @@ export function getWorkbenchTurn(
   );
 }
 
+const CancelWorkbenchTurnWire = type({ cancelledCount: "number" });
+export type CancelWorkbenchTurnResult = typeof CancelWorkbenchTurnWire.infer;
+
+/**
+ * Stops a workbench's in-flight turn(s) (CL-7201) — `POST
+ * .../turns/cancel` in `packages/chat/src/routes.ts`. `cancelledCount`
+ * is the honest count of turns actually settled `cancelled`, not a
+ * promise that the underlying agent process stopped (see CL-7230): the
+ * composer's own Stop affordance treats any non-throwing response as
+ * "asked," and relies on the timeline's cancelled-turn notice — not this
+ * response — to clear the typing indicator.
+ */
+export function cancelWorkbenchTurn(
+  tenantId: string,
+  workbenchId: string,
+): Promise<CancelWorkbenchTurnResult> {
+  return request(
+    `${turnsPath(tenantId, workbenchId)}/cancel`,
+    CancelWorkbenchTurnWire,
+    {
+      method: "POST",
+    },
+  );
+}
+
 /**
  * The newest still-`running` turn for `agentAddress`, or `null` if none —
  * what a remounting workbench asks on mount to know whether to hydrate its
diff --git a/packages/chat-ui/src/chat-workspace.tsx b/packages/chat-ui/src/chat-workspace.tsx
index fd7d4a2d3..c96ff38bd 100644
--- a/packages/chat-ui/src/chat-workspace.tsx
+++ b/packages/chat-ui/src/chat-workspace.tsx
@@ -28,6 +28,7 @@ import type { ReactNode } from "react";
 import {
   workbenchesQueryKey,
   workbenchesQueryKeyPrefix,
+  cancelWorkbenchTurn,
   describeChatError,
   fetchRunningTurn,
   inviteAgent,
@@ -59,7 +60,11 @@ import { SLASH_COMMANDS } from "./slash-commands";
 
 import { CHAT_STRINGS } from "./strings";
 import { displayWorkbenchTitle } from "./workbench-display-title";
-import { useStreamingReply, typingAgentNames } from "./streaming-reply";
+import {
+  useStreamingReply,
+  isAwaitingReply,
+  typingAgentNames,
+} from "./streaming-reply";
 import { useTurnActivity, TurnActivityStrip } from "./turn-activity";
 import type { StreamingReplyState } from "./streaming-reply";
 import {
@@ -807,6 +812,21 @@ function ChatWorkspaceInner({
     [tenantId, activeWorkbenchId],
   );
 
+  // CL-7201: unlike the reaction/pin handlers above, this rethrows after
+  // toasting — the composer's own `onStop` awaits the returned promise
+  // and re-enables its Stop button on rejection, so a genuinely failed
+  // request (network, a denied grant) never leaves the button stuck
+  // disabled for the rest of the turn. The timeline's cancelled-turn
+  // notice, not this response, is what actually clears the typing
+  // indicator once (or if) the turn settles.
+  const handleStopTurn = useCallback(() => {
+    if (activeWorkbenchId === null) return Promise.resolve();
+    return cancelWorkbenchTurn(tenantId, activeWorkbenchId).catch((err) => {
+      toast(CHAT_STRINGS.turnCancelError);
+      throw err;
+    });
+  }, [tenantId, activeWorkbenchId]);
+
   const handlePinMessage = useCallback(
     (messageId: string) => {
       if (activeWorkbenchId === null) return;
@@ -1636,6 +1656,8 @@ function ChatWorkspaceInner({
                       bringInLoadError={bringInLoadError}
                       placeholder={composerPlaceholderFor(activeWorkbench)}
                       onSend={handleSend}
+                      running={isAwaitingReply(streamingReply)}
+                      onStop={handleStopTurn}
                       onInviteAgent={() => setInviteDialogOpen(true)}
                       onOpenAgentsSettings={() =>
                         openWorkbenchSettings("agents")
diff --git a/packages/chat-ui/src/composer.test.tsx b/packages/chat-ui/src/composer.test.tsx
index 19b3e3ac9..e705121b1 100644
--- a/packages/chat-ui/src/composer.test.tsx
+++ b/packages/chat-ui/src/composer.test.tsx
@@ -1,6 +1,7 @@
 import { describe, expect, test } from "bun:test";
 
-import { insertTextAtCaret } from "./composer";
+import { canStopComposer, insertTextAtCaret } from "./composer";
+import { isAwaitingReply } from "./streaming-reply";
 
 describe("insertTextAtCaret", () => {
   test("splices the insertion in at the caret", () => {
@@ -21,3 +22,27 @@ describe("insertTextAtCaret", () => {
     expect(result.caret).toBe(6);
   });
 });
+
+// CL-7201: the composer's stop affordance is a stand-in for "is there a
+// turn to cancel" — offered whenever the host says a turn is running,
+// independent of the composer's own `sending`/`preparing` state (queuing
+// a follow-up message while a turn runs is still allowed, so the stop
+// affordance and the send button coexist rather than one gating the
+// other).
+describe("canStopComposer", () => {
+  test("offers Stop while the host reports a turn running", () => {
+    expect(canStopComposer({ running: true })).toBe(true);
+  });
+
+  test("offers nothing when no turn is running", () => {
+    expect(canStopComposer({ running: false })).toBe(false);
+  });
+
+  test("offers Stop while awaiting a turn that already has streamed text", () => {
+    expect(
+      canStopComposer({
+        running: isAwaitingReply({ phase: "awaiting", text: "Hello" }),
+      }),
+    ).toBe(true);
+  });
+});
diff --git a/packages/chat-ui/src/composer.tsx b/packages/chat-ui/src/composer.tsx
index 96bb5686c..06cefa1f9 100644
--- a/packages/chat-ui/src/composer.tsx
+++ b/packages/chat-ui/src/composer.tsx
@@ -7,9 +7,10 @@
 // does not compose with an inline mention popover.
 
 import { Avatar, Button } from "@corbits/react-ui";
-import { ArrowUp, CircleNotch, Paperclip, X } from "@corbits/icons";
+import { ArrowUp, CircleNotch, Paperclip, Stop, X } from "@corbits/icons";
 import {
   forwardRef,
+  useEffect,
   useImperativeHandle,
   useLayoutEffect,
   useRef,
@@ -251,6 +252,20 @@ export function canSendComposerAction(
   return canSendComposer(text, attachments);
 }
 
+/**
+ * Whether the composer offers a Stop affordance (CL-7201) — a stand-in
+ * for "is there a turn to cancel," reported by the host from its own
+ * `isAwaitingReply` signal (the whole in-flight phase, including after
+ * tokens have started streaming — not the tokenless `isPendingReply`
+ * pulse). Deliberately independent of `sending`/
+ * `preparing`: a follow-up message can still be typed and queued while a
+ * turn runs (`turn-queue.ts` batches it), so Stop and Send coexist
+ * rather than one gating the other.
+ */
+export function canStopComposer(state: { readonly running: boolean }): boolean {
+  return state.running;
+}
+
 /** Attach stays blocked while a send or file read is in flight. */
 export function canAttachComposer(state: {
   readonly sending: boolean;
@@ -334,6 +349,20 @@ export const Composer = forwardRef<
     readonly onCreateRoutineInSpace: () => void;
     /** Defaults to the generic workbench copy — a chat passes one naming its counterpart. */
     readonly placeholder?: string;
+    /** Whether a turn is currently running for this workbench (CL-7201) —
+     * typically the host's own `isAwaitingReply(streamingReply)`. Absent
+     * or `false` renders no Stop affordance at all. */
+    readonly running?: boolean;
+    /**
+     * Cancels the running turn — `POST .../turns/cancel`. Required
+     * whenever `running` can be `true`; the composer never guesses at
+     * how to stop a turn on its own. May return a promise: a rejection
+     * re-enables the button immediately (the request itself failed —
+     * network, a denied grant — not merely a slow cancel, so there is
+     * no reason to make the person wait for `running` to change before
+     * they can try again).
+     */
+    readonly onStop?: () => void | Promise<unknown>;
   }
 >(function Composer(
   {
@@ -347,6 +376,8 @@ export const Composer = forwardRef<
     onOpenAgentsSettings,
     onCreateRoutineInSpace,
     placeholder = CHAT_STRINGS.composerPlaceholder,
+    running = false,
+    onStop,
   },
   ref,
 ) {
@@ -366,6 +397,12 @@ export const Composer = forwardRef<
   const [preparing, setPreparing] = useState(false);
   const [errorMessage, setErrorMessage] = useState<string | null>(null);
   const [focused, setFocused] = useState(false);
+  // CL-7201: guards Stop against a double-click firing two cancel
+  // requests. A second cancel is harmless server-side (compare-and-set),
+  // but there is no reason to send it. Resets once the host reports the
+  // turn is no longer running -- not on a timer, since a slow cancel
+  // (CL-7230's ceiling) must stay disabled rather than re-arm early.
+  const [stopping, setStopping] = useState(false);
   const textareaRef = useRef<HTMLTextAreaElement>(null);
   const fileInputRef = useRef<HTMLInputElement>(null);
   const attachGenerationRef = useRef(0);
@@ -377,6 +414,10 @@ export const Composer = forwardRef<
   // call in the same tick is turned away (CL-7198).
   const sendInFlightRef = useRef(false);
 
+  useEffect(() => {
+    if (!running) setStopping(false);
+  }, [running]);
+
   /** Auto-grow: the textarea reports its own content height, so the
    * measurement resets to the CSS-declared min-height before reading
    * `scrollHeight` — otherwise a shrinking draft would get stuck at its
@@ -701,6 +742,18 @@ export const Composer = forwardRef<
     void addFiles(event.target.files);
   }
 
+  function handleStop() {
+    if (stopping || onStop === undefined) return;
+    setStopping(true);
+    // CL-7201 (Critique finding): a rejected stop request is a FAILED
+    // cancel, not a slow one -- the `useEffect` above only re-enables
+    // once the host reports `running` has gone false, which never
+    // happens for a request that never reached the server. Without
+    // this catch the button stayed disabled for the rest of the turn's
+    // life with no way to retry.
+    Promise.resolve(onStop()).catch(() => setStopping(false));
+  }
+
   return (
     <div className="chat-composer">
       {slash !== null && (
@@ -907,6 +960,20 @@ export const Composer = forwardRef<
           >
             {CHAT_STRINGS.composerKeyboardHint}
           </span>
+          {canStopComposer({ running }) ? (
+            <Button
+              type="button"
+              variant="ghost"
+              size="sm"
+              className="chat-composer-icon-button"
+              disabled={stopping}
+              onClick={handleStop}
+              aria-label={CHAT_STRINGS.composerStop}
+              title={CHAT_STRINGS.composerStop}
+            >
+              <Stop aria-hidden="true" />
+            </Button>
+          ) : null}
           <Button
             type="button"
             variant={sendVisualState === "empty" ? "ghost" : "primary"}
diff --git a/packages/chat-ui/src/streaming-reply.test.ts b/packages/chat-ui/src/streaming-reply.test.ts
index 2605a2f7e..86318645b 100644
--- a/packages/chat-ui/src/streaming-reply.test.ts
+++ b/packages/chat-ui/src/streaming-reply.test.ts
@@ -2,6 +2,7 @@ import { describe, expect, test } from "bun:test";
 
 import {
   hydrateStreamingReplyFromTurn,
+  isAwaitingReply,
   isPendingReply,
   nextStreamingReplyState,
   openPendingReply,
@@ -217,6 +218,130 @@ describe("nextStreamingReplyState (CL-6376: the typing pulse clears on a dispatc
   });
 });
 
+// CL-7201: a user-cancelled turn clears the same pulse a failed one does
+// — `postCancelledNotice` carries `turnCancelled`, not `turnFailed`, so
+// this is its own case rather than reusing the failure fixture above.
+describe("nextStreamingReplyState (CL-7201: the typing pulse clears on a user cancellation too)", () => {
+  test("a chat.message carrying a turnCancelled part settles the turn as replied", () => {
+    const state = awaiting("");
+    expect(
+      nextStreamingReplyState(state, {
+        eventType: "chat.message",
+        data: {
+          id: "msg_1",
+          parts: [
+            {
+              kind: "text",
+              text: "This turn was cancelled.",
+              turnCancelled: true,
+            },
+          ],
+        },
+      }),
+    ).toEqual({ phase: "replied" });
+  });
+
+  test("a chat.message from the cancelled agent's own address is never mistaken for a rendered reply", () => {
+    const state = awaiting("");
+    expect(
+      nextStreamingReplyState(state, {
+        eventType: "chat.message",
+        data: {
+          id: "msg_1",
+          sender: { name: null, address: MYRA.address },
+          parts: [
+            {
+              kind: "text",
+              text: "This turn was cancelled.",
+              turnCancelled: true,
+            },
+          ],
+        },
+      }),
+    ).toEqual({ phase: "replied" });
+  });
+
+  test("inference.start after a turnCancelled notice does not reopen the pulse", () => {
+    let state = nextStreamingReplyState(awaiting("Hello"), {
+      eventType: "chat.message",
+      data: {
+        id: "msg_1",
+        parts: [
+          {
+            kind: "text",
+            text: "This turn was cancelled.",
+            turnCancelled: true,
+          },
+        ],
+      },
+    });
+    state = nextStreamingReplyState(
+      state,
+      agentEvent({ type: "inference.start", seq: 9, data: { model: "x" } }),
+    );
+    expect(isPendingReply(state)).toBe(false);
+    expect(isAwaitingReply(state)).toBe(false);
+  });
+
+  test("a late text delta after a turnCancelled notice does not reopen the pulse", () => {
+    let state = nextStreamingReplyState(awaiting("Hel"), {
+      eventType: "chat.message",
+      data: {
+        id: "msg_1",
+        parts: [
+          {
+            kind: "text",
+            text: "This turn was cancelled.",
+            turnCancelled: true,
+          },
+        ],
+      },
+    });
+    state = nextStreamingReplyState(state, delta("Hello"));
+    expect(isPendingReply(state)).toBe(false);
+    expect(isAwaitingReply(state)).toBe(false);
+  });
+
+  test("reactor.start after a turnCancelled notice does not reopen the pulse", () => {
+    let state = nextStreamingReplyState(awaiting(""), {
+      eventType: "chat.message",
+      data: {
+        id: "msg_1",
+        parts: [
+          {
+            kind: "text",
+            text: "This turn was cancelled.",
+            turnCancelled: true,
+          },
+        ],
+      },
+    });
+    state = nextStreamingReplyState(
+      state,
+      agentEvent({ type: "reactor.start", seq: 0, data: {} }),
+    );
+    expect(isPendingReply(state)).toBe(false);
+    expect(isAwaitingReply(state)).toBe(false);
+  });
+});
+
+describe("isAwaitingReply (CL-7201: Stop stays up while tokens stream)", () => {
+  test("is true for the whole awaiting phase, including streamed text", () => {
+    expect(isAwaitingReply(awaiting(""))).toBe(true);
+    expect(isAwaitingReply(awaiting("Hello"))).toBe(true);
+  });
+
+  test("is false when idle or already replied", () => {
+    expect(isAwaitingReply(null)).toBe(false);
+    expect(isAwaitingReply({ phase: "replied" })).toBe(false);
+  });
+
+  test("isPendingReply is only the tokenless pulse — not the Stop predicate", () => {
+    expect(isPendingReply(awaiting("Hello"))).toBe(false);
+    expect(isAwaitingReply(awaiting("Hello"))).toBe(true);
+  });
+});
+
 describe("nextStreamingReplyState (CL-false-no-reply: rendered content, not a lifecycle event, ends the turn)", () => {
   test("a chat.message from the awaiting turn's agent moves straight to replied — the reply already rendered, connector.reply or not", () => {
     const state = awaiting("Full answer.");
diff --git a/packages/chat-ui/src/streaming-reply.ts b/packages/chat-ui/src/streaming-reply.ts
index 8a3ec6284..70e6b2cce 100644
--- a/packages/chat-ui/src/streaming-reply.ts
+++ b/packages/chat-ui/src/streaming-reply.ts
@@ -53,6 +53,13 @@ export function isPendingReply(state: StreamingReplyState): boolean {
   return state !== null && state.phase === "awaiting" && state.text === "";
 }
 
+/** Whether a turn is still in flight — Stop stays up for the whole
+ * `"awaiting"` phase, including after tokens have started streaming.
+ * Distinct from `isPendingReply`, which is only the empty typing pulse. */
+export function isAwaitingReply(state: StreamingReplyState): boolean {
+  return state !== null && state.phase === "awaiting";
+}
+
 type InferenceDeltaEvent = {
   readonly type: "inference.text.delta";
   readonly data: { readonly partial: { readonly text: string } };
@@ -103,6 +110,34 @@ function hasTurnFailedPart(data: unknown): boolean {
   );
 }
 
+/** Whether a `chat.message` payload carries `postCancelledNotice`'s
+ * `turnCancelled` part (see `packages/chat/src/workbench-service.ts`,
+ * CL-7201) — the cancellation counterpart to `hasTurnFailedPart` above,
+ * kept as its own flag rather than reusing `turnFailed` because a user
+ * stopping a turn is not a failure. Same reasoning applies here: a
+ * cancelled turn's dispatch can close with no `chat.agent` events of its
+ * own (still waiting on `waitUntilFree`, say), so this notice is the
+ * only signal that clears the pulse for that case. */
+function hasTurnCancelledPart(data: unknown): boolean {
+  if (typeof data !== "object" || data === null) return false;
+  const parts = (data as Record<string, unknown>).parts;
+  if (!Array.isArray(parts)) return false;
+  return parts.some(
+    (part) =>
+      typeof part === "object" &&
+      part !== null &&
+      (part as Record<string, unknown>).turnCancelled === true,
+  );
+}
+
+/** Either of the two turn-ended notice flags — the one thing
+ * `isRenderedAgentReply` and `nextStreamingReplyState` actually care
+ * about ("is this a system notice about how the turn ended, or the
+ * agent's own reply"), never which specific outcome it was. */
+function hasTurnEndedNoticePart(data: unknown): boolean {
+  return hasTurnFailedPart(data) || hasTurnCancelledPart(data);
+}
+
 /** Whether a `chat.message` payload is the awaiting turn's own reply
  * actually rendering on screen — the one observable fact this module can
  * trust over any `chat.agent` lifecycle event. `postReply`
@@ -113,10 +148,11 @@ function hasTurnFailedPart(data: unknown): boolean {
  * backstop armed once the reply the reader is looking at has already
  * posted. Requires an agent sender (never the reader's own echoed
  * message) and at least one part; `postUndeliveredNotice` also posts from
- * the agent's own address with a real text part, so `hasTurnFailedPart`
- * rules that one out explicitly rather than by accident. */
+ * the agent's own address with a real text part, so
+ * `hasTurnEndedNoticePart` rules that one (and its cancelled
+ * counterpart) out explicitly rather than by accident. */
 function isRenderedAgentReply(data: unknown): boolean {
-  if (hasTurnFailedPart(data)) return false;
+  if (hasTurnEndedNoticePart(data)) return false;
   if (typeof data !== "object" || data === null) return false;
   const sender = (data as Record<string, unknown>).sender;
   if (typeof sender !== "object" || sender === null) return false;
@@ -148,15 +184,21 @@ function isRenderedAgentReply(data: unknown): boolean {
  * inert rather than re-opening the pulse. The hard-terminal events —
  * `reactor.done`/`reactor.error`, `message.run.ended`, `inference.error`,
  * and a `chat.message` carrying `postUndeliveredNotice`'s `turnFailed`
- * part (see `hasTurnFailedPart`, the one failure path with no `chat.agent`
- * events of its own) — return to idle from any phase. Every other event
- * type (tool calls, thinking, usage) leaves the current state untouched.
+ * or `postCancelledNotice`'s `turnCancelled` part (see
+ * `hasTurnEndedNoticePart`, the failure/cancellation paths with no
+ * `chat.agent` events of their own) — return to idle from any phase.
+ * A `turnCancelled` notice is the exception: it settles `"replied"` so a
+ * late `inference.start` / `reactor.start` / text delta from the still-
+ * running occurrence (CL-7230's ceiling) cannot reopen the pulse.
+ * Every other event type (tool calls, thinking, usage) leaves the
+ * current state untouched.
  */
 export function nextStreamingReplyState(
   current: StreamingReplyState,
   event: { readonly eventType: string; readonly data: unknown },
 ): StreamingReplyState {
   if (event.eventType === "chat.message") {
+    if (hasTurnCancelledPart(event.data)) return REPLIED;
     if (hasTurnFailedPart(event.data)) return null;
     if (
       current !== null &&
diff --git a/packages/chat-ui/src/strings.ts b/packages/chat-ui/src/strings.ts
index 0c1fe979a..0bbf02a78 100644
--- a/packages/chat-ui/src/strings.ts
+++ b/packages/chat-ui/src/strings.ts
@@ -38,6 +38,7 @@ export const CHAT_STRINGS = {
   composerPlaceholderChat: (name: string) => `Message ${name}…`,
   composerSend: "Send",
   composerSending: "Sending…",
+  composerStop: "Stop",
   composerKeyboardHint: "Enter to send",
   composerAttach: "Attach files",
   composerAttachmentsLabel: "Selected attachments",
@@ -159,6 +160,7 @@ export const CHAT_STRINGS = {
   unpinMessageAction: "Unpin message",
   pinMessageError: "Couldn't pin that message — try again.",
   unpinMessageError: "Couldn't unpin that message — try again.",
+  turnCancelError: "Couldn't stop that turn — try again.",
   pinnedStripLabel: "Pinned messages",
   pinnedStripEmptyPreview: "Pinned message",
   pinnedStripJumpAction: (preview: string) => `Jump to: ${preview}`,
@@ -317,6 +319,7 @@ export const CHAT_STRINGS = {
     `Couldn't resume the running reply — try again. (ref ${refId})`,
   resumeFailedRetryAction: "Retry",
   turnFailedTitle: (sender: string) => `${sender} didn't reply`,
+  turnCancelledTitle: (sender: string) => `You stopped ${sender}'s turn`,
   turnFailedSub: "No reply arrived — the agent may be unavailable.",
   noUsableModelBannerText:
     "No model is connected yet, so a reply here won't come through.",
diff --git a/packages/chat-ui/src/styles.css b/packages/chat-ui/src/styles.css
index e41f12cd6..14f493d54 100644
--- a/packages/chat-ui/src/styles.css
+++ b/packages/chat-ui/src/styles.css
@@ -3985,3 +3985,17 @@
   font-size: 0.75rem;
   color: var(--muted-foreground);
 }
+
+/* CL-7201's cancelled-turn row: the same quiet inline layout as
+   .chat-turn-failed, but neutral rather than danger-tinted — the user
+   asked for this outcome, so it reads as a plain fact, not a warning,
+   and carries no Retry (the person can just send again). */
+.chat-turn-cancelled {
+  display: flex;
+  align-items: center;
+  gap: 0.5rem;
+  margin: 0.15rem 0 0.35rem 2.9rem;
+  max-width: 100%;
+  font-size: 0.8125rem;
+  color: var(--muted-foreground);
+}
diff --git a/packages/chat-ui/src/timeline.tsx b/packages/chat-ui/src/timeline.tsx
index 85cbf6c3e..acbecc654 100644
--- a/packages/chat-ui/src/timeline.tsx
+++ b/packages/chat-ui/src/timeline.tsx
@@ -812,6 +812,32 @@ function FailedTurnStrip({
   );
 }
 
+/**
+ * The cancelled-turn counterpart to `FailedTurnStrip` (CL-7201) — same
+ * quiet inline placement, deliberately simpler: no Retry (the user
+ * chose to stop this; resending is just typing again, not recovering
+ * from an error) and no disclosure, since `postCancelledNotice`'s own
+ * text ("This turn was cancelled.") is the whole story — there is no
+ * hidden diagnosis to expand into, unlike a failure's cause.
+ */
+function CancelledTurnStrip({
+  item,
+  participants,
+  currentUser,
+}: {
+  readonly item: TimelineMessageItem;
+  readonly participants: readonly ParticipantRecord[];
+  readonly currentUser: CurrentUser | undefined;
+}) {
+  const display = senderDisplay(item.sender, participants, currentUser);
+  const sender = display?.label ?? CHAT_STRINGS.senderFallbackMember;
+  return (
+    <div className="chat-turn-cancelled" role="status">
+      <span>{CHAT_STRINGS.turnCancelledTitle(sender)}</span>
+    </div>
+  );
+}
+
 /**
  * The nearest message before a failed-turn notice sent by someone other
  * than the unreachable agent itself — the request that notice answered.
@@ -960,6 +986,7 @@ export function offersMessageSocialChrome(item: MessageItem): boolean {
   return !item.parts.every((part) => {
     if (part.kind === "event") return true;
     if (part.kind === "text" && part.turnFailed === true) return true;
+    if (part.kind === "text" && part.turnCancelled === true) return true;
     if (part.kind === "text" && isClassifiedInferenceFailureText(part.text)) {
       return true;
     }
@@ -1617,6 +1644,16 @@ function MessagePartsInner({
                 />
               );
             }
+            if (part.kind === "text" && part.turnCancelled === true) {
+              return (
+                <CancelledTurnStrip
+                  key={key}
+                  item={item}
+                  participants={participants}
+                  currentUser={currentUser}
+                />
+              );
+            }
             if (part.kind === "text") {
               return (
                 <TextBubble
diff --git a/packages/chat-ui/test/composer.test.tsx b/packages/chat-ui/test/composer.test.tsx
index 082a9dc2c..0cbbdc192 100644
--- a/packages/chat-ui/test/composer.test.tsx
+++ b/packages/chat-ui/test/composer.test.tsx
@@ -680,3 +680,127 @@ describe("ComposerHandle.setText", () => {
     expect(sent).toEqual([{ text: "copied prompt", attachments: [] }]);
   });
 });
+
+// CL-7201: the composer's Stop affordance. `handleStop` guards against a
+// double-click and re-enables itself once the host reports the turn is
+// no longer running -- but a REJECTED stop request must also re-enable
+// it, or a genuinely failed cancel (not a slow one) leaves the person
+// with a permanently disabled button and no way to retry for the rest
+// of that turn's life (Critique finding, CL-7201).
+function stopButton(): HTMLButtonElement {
+  const button = container?.querySelector<HTMLButtonElement>(
+    '[aria-label="Stop"]',
+  );
+  if (button === null || button === undefined) {
+    throw new Error("stop button not found");
+  }
+  return button;
+}
+
+function mountStoppable(
+  running: boolean,
+  onStop: () => void | Promise<unknown>,
+) {
+  container = document.createElement("div");
+  document.body.appendChild(container);
+  root = createRoot(container);
+  act(() => {
+    root?.render(
+      createElement(Composer, {
+        agents: [],
+        onSend: () => Promise.resolve(true),
+        onInviteAgent: () => undefined,
+        onOpenAgentsSettings: () => undefined,
+        onCreateRoutineInSpace: () => undefined,
+        running,
+        onStop,
+      }),
+    );
+  });
+  return {
+    container,
+    rerender: (nextRunning: boolean) => {
+      act(() => {
+        root?.render(
+          createElement(Composer, {
+            agents: [],
+            onSend: () => Promise.resolve(true),
+            onInviteAgent: () => undefined,
+            onOpenAgentsSettings: () => undefined,
+            onCreateRoutineInSpace: () => undefined,
+            running: nextRunning,
+            onStop,
+          }),
+        );
+      });
+    },
+  };
+}
+
+describe("Composer stop affordance (CL-7201)", () => {
+  test("renders no Stop button when no turn is running", () => {
+    mountStoppable(false, () => undefined);
+    expect(container?.querySelector('[aria-label="Stop"]')).toBeNull();
+  });
+
+  test("clicking Stop calls onStop and disables the button against a double-click", async () => {
+    let calls = 0;
+    mountStoppable(true, () => {
+      calls += 1;
+    });
+
+    expect(stopButton().hasAttribute("disabled")).toBe(false);
+    act(() => {
+      stopButton().click();
+    });
+    await settle();
+
+    expect(calls).toBe(1);
+    expect(stopButton().hasAttribute("disabled")).toBe(true);
+
+    act(() => {
+      stopButton().click();
+    });
+    await settle();
+    expect(calls).toBe(1);
+  });
+
+  test("the button re-enables once the host reports the turn is no longer running", async () => {
+    const { rerender } = mountStoppable(true, () => undefined);
+    act(() => {
+      stopButton().click();
+    });
+    await settle();
+    expect(stopButton().hasAttribute("disabled")).toBe(true);
+
+    rerender(false);
+    expect(container?.querySelector('[aria-label="Stop"]')).toBeNull();
+  });
+
+  test("a stop request that REJECTS re-enables the button instead of leaving it stuck", async () => {
+    let reject: (err: unknown) => void = () => undefined;
+    mountStoppable(
+      true,
+      () =>
+        new Promise((_resolve, rej) => {
+          reject = rej;
+        }),
+    );
+
+    act(() => {
+      stopButton().click();
+    });
+    await settle();
+    expect(stopButton().hasAttribute("disabled")).toBe(true);
+
+    await act(async () => {
+      reject(new Error("network error"));
+      await Promise.resolve();
+      await Promise.resolve();
+    });
+
+    // The turn is still running (the cancel request itself failed, not
+    // the turn) -- the button must come back so the user can try again.
+    expect(stopButton().hasAttribute("disabled")).toBe(false);
+  });
+});
diff --git a/packages/chat/src/agent-turns.test.ts b/packages/chat/src/agent-turns.test.ts
index 34044fd2c..7fb0bdc4d 100644
--- a/packages/chat/src/agent-turns.test.ts
+++ b/packages/chat/src/agent-turns.test.ts
@@ -286,6 +286,94 @@ describe("createInMemoryAgentTurnStore", () => {
       expect(stored?.status).toBe("failed");
       expect(stored?.replyMessageId).toBeNull();
     });
+
+    // CL-7201: a turn cancelled by the user must never be resurrected by
+    // a real reply that lands after the fact -- exactly the same
+    // guarantee CL-7193 already gives a timed-out turn against a late
+    // reply, now exercised for the cancel outcome specifically, since
+    // cancellation is a NEW way to close a turn out from under work
+    // that is still in flight (a `message_response` gate answer, an
+    // ordinary reply) and has no code of its own to fall back on if
+    // this compare-and-set ever regressed.
+    test("a turn cancelled while a real reply is in flight cannot be reopened by that reply landing late", async () => {
+      const store = createInMemoryAgentTurnStore();
+      const opened = await store.startTurn(BASE);
+
+      const cancelled = await store.finishTurn({
+        tenantId: BASE.tenantId,
+        turnId: opened.id,
+        status: "cancelled",
+        error: "Cancelled by user",
+      });
+      expect(cancelled?.status).toBe("cancelled");
+
+      // The agent (or a message_response gate answer correlating to
+      // this turn) finishes its work anyway -- CL-7230's known ceiling
+      // is that nothing here can stop it -- and tries to close the same
+      // turn as a normal completed reply.
+      const lateReply = await store.finishTurn({
+        tenantId: BASE.tenantId,
+        turnId: opened.id,
+        status: "completed",
+        replyMessageId: "msg_late_reply",
+      });
+      expect(lateReply).toBeUndefined();
+
+      const stored = await store.getTurn({
+        tenantId: BASE.tenantId,
+        turnId: opened.id,
+      });
+      expect(stored?.status).toBe("cancelled");
+      expect(stored?.replyMessageId).toBeNull();
+    });
+  });
+
+  // CL-7201: the cancel endpoint's fallback sweep -- settling a turn
+  // whose dispatch has already moved off the caller's own call stack
+  // (its `sendMail` resolved, an abort signal has nothing left to
+  // reach) -- must see every currently-running turn for a workbench,
+  // not just the newest one. `listTurns` alone is the wrong primitive
+  // for that sweep: it has no status filter and pages to
+  // `AGENT_TURNS_PAGE_SIZE`, so a busy workbench could silently leave
+  // older running turns unsettled.
+  describe("findRunningTurns (CL-7201)", () => {
+    test("returns every running turn for a workbench, across agents, excluding settled ones", async () => {
+      const store = createInMemoryAgentTurnStore();
+      const first = await store.startTurn(BASE);
+      const second = await store.startTurn({
+        ...BASE,
+        agentAddress: "ins_echo2@acme.example",
+      });
+      const settled = await store.startTurn({
+        ...BASE,
+        agentAddress: "ins_echo3@acme.example",
+      });
+      await store.finishTurn({
+        tenantId: BASE.tenantId,
+        turnId: settled.id,
+        status: "completed",
+        replyMessageId: "msg_done",
+      });
+      await store.startTurn({ ...BASE, workbenchId: "wb_other" });
+
+      const running = await store.findRunningTurns({
+        tenantId: BASE.tenantId,
+        workbenchId: BASE.workbenchId,
+      });
+
+      expect(new Set(running.map((turn) => turn.id))).toEqual(
+        new Set([first.id, second.id]),
+      );
+    });
+
+    test("returns nothing for a workbench with no running turns", async () => {
+      const store = createInMemoryAgentTurnStore();
+      const running = await store.findRunningTurns({
+        tenantId: BASE.tenantId,
+        workbenchId: BASE.workbenchId,
+      });
+      expect(running).toEqual([]);
+    });
   });
 });
 
diff --git a/packages/chat/src/agent-turns.ts b/packages/chat/src/agent-turns.ts
index a5080384b..ec3880acf 100644
--- a/packages/chat/src/agent-turns.ts
+++ b/packages/chat/src/agent-turns.ts
@@ -21,7 +21,7 @@ import { agentTurns } from "./schema";
 import type { ChatDb } from "./store";
 import { CHAT_TURN_TIMEOUT_MS } from "./turn-claims";
 
-export type AgentTurnStatus = "running" | "completed" | "failed";
+export type AgentTurnStatus = "running" | "completed" | "failed" | "cancelled";
 
 export interface AgentTurn {
   readonly id: string;
@@ -100,6 +100,20 @@ export interface AgentTurnStore {
     readonly workbenchId: string;
     readonly agentAddress: string;
   }): Promise<AgentTurn | undefined>;
+  /**
+   * Every `running` turn for a workbench, across every agent — the
+   * cancel endpoint's own read (CL-7201): a workbench can have more than
+   * one agent turn in flight at once (`dispatchTurnBatch` fans out
+   * concurrently), and settling "the" in-flight turn means settling all
+   * of them. Deliberately not built on `listTurns`: that method has no
+   * status filter and pages to `AGENT_TURNS_PAGE_SIZE`, so a busy
+   * workbench could silently leave an older running turn off the page
+   * and therefore unsettled.
+   */
+  findRunningTurns(input: {
+    readonly tenantId: string;
+    readonly workbenchId: string;
+  }): Promise<readonly AgentTurn[]>;
   /**
    * Resolves once (workbench, agent) has no `running` turn — immediately
    * if none is running right now, otherwise when the current one closes
@@ -348,6 +362,16 @@ export function createInMemoryAgentTurnStore(
       return runningTurn(input);
     },
 
+    async findRunningTurns(input) {
+      expireStaleTurns();
+      return [...rows.values()].filter(
+        (turn) =>
+          turn.tenantId === input.tenantId &&
+          turn.workbenchId === input.workbenchId &&
+          turn.status === "running",
+      );
+    },
+
     async waitUntilFree(input, signal) {
       for (;;) {
         if (signal?.aborted) throw signal.reason;
@@ -403,7 +427,9 @@ function toAgentTurn(row: AgentTurnRow): AgentTurn {
       )
     : [];
   const status: AgentTurnStatus =
-    row.status === "completed" || row.status === "failed"
+    row.status === "completed" ||
+    row.status === "failed" ||
+    row.status === "cancelled"
       ? row.status
       : "running";
   return {
@@ -551,6 +577,21 @@ export function createDrizzleAgentTurnStore<
       return resolveRunningTurn(input);
     },
 
+    async findRunningTurns(input) {
+      await expireStaleTurns(input);
+      const rows = await db
+        .select()
+        .from(agentTurns)
+        .where(
+          and(
+            eq(agentTurns.tenantId, input.tenantId),
+            eq(agentTurns.workbenchId, input.workbenchId),
+            eq(agentTurns.status, "running"),
+          ),
+        );
+      return rows.map((row) => toAgentTurn(row as AgentTurnRow));
+    },
+
     async waitUntilFree(input, signal) {
       for (;;) {
         if (signal?.aborted) throw signal.reason;
diff --git a/packages/chat/src/chat-orchestrator.ts b/packages/chat/src/chat-orchestrator.ts
index 3c866956a..57396ada4 100644
--- a/packages/chat/src/chat-orchestrator.ts
+++ b/packages/chat/src/chat-orchestrator.ts
@@ -94,7 +94,10 @@ export type ChatOrchestratorDeps = {
    * address and nothing finer. Omitted, replies carry no run id at all
    * rather than a guessed one; there is no second way to name a run.
    */
-  agentTurns?: Pick<AgentTurnStore, "findRunningTurn" | "finishTurn">;
+  agentTurns?: Pick<
+    AgentTurnStore,
+    "findRunningTurn" | "finishTurn" | "listTurns"
+  >;
   /**
    * Resolves a gate-blocked event's `correlationId` to the approval row the
    * hub's IPC register co-write already wrote — the same read the "needs
@@ -546,6 +549,17 @@ function correlateOriginatingWorkbench(
   return undefined;
 }
 
+async function latestTurnForAgent(
+  agentTurns: Pick<AgentTurnStore, "listTurns"> | undefined,
+  tenantId: string,
+  workbenchId: string,
+  agentAddress: string,
+) {
+  if (agentTurns === undefined) return undefined;
+  const turns = await agentTurns.listTurns({ tenantId, workbenchId });
+  return turns.find((turn) => turn.agentAddress === agentAddress);
+}
+
 async function postReply(
   deps: ChatOrchestratorDeps,
   pendingDelegationThreads: ExpiringMap<string, PendingDelegationThread>,
@@ -574,7 +588,7 @@ async function postReply(
     .filter((member) => member.turnId !== undefined)
     .map((member) => member.workbenchId);
   const correlated = correlateOriginatingWorkbench(event, members);
-  const targetIds =
+  const resolvedTargets =
     correlated !== undefined
       ? [correlated]
       : runningIds.length === 1
@@ -582,6 +596,26 @@ async function postReply(
         : runningIds.length === 0 && resolved.workbenchIds.length === 1
           ? resolved.workbenchIds
           : [];
+  // A cancelled 1:1 turn still has exactly one membership and no running
+  // row, so the fallback above would otherwise post the late reply as an
+  // unattached message. Drop those; a membership that never opened a
+  // turn still uses the fallback.
+  const targetIds: string[] = [];
+  for (const workbenchId of resolvedTargets) {
+    const member = members.find((entry) => entry.workbenchId === workbenchId);
+    if (member?.turnId !== undefined) {
+      targetIds.push(workbenchId);
+      continue;
+    }
+    const latest = await latestTurnForAgent(
+      deps.agentTurns,
+      resolved.tenantId,
+      workbenchId,
+      resolved.roomAddress,
+    );
+    if (latest?.status === "cancelled") continue;
+    targetIds.push(workbenchId);
+  }
 
   if (targetIds.length === 0) {
     reportError(
diff --git a/packages/chat/src/index.ts b/packages/chat/src/index.ts
index d97b7c446..7bc393aeb 100644
--- a/packages/chat/src/index.ts
+++ b/packages/chat/src/index.ts
@@ -141,6 +141,11 @@ export type {
   WorkbenchTurnQueue,
   WorkbenchTurnQueueDeps,
 } from "./turn-queue";
+export {
+  createTurnCancelRegistry,
+  TurnCancelledError,
+} from "./turn-cancellation";
+export type { TurnCancelRegistry } from "./turn-cancellation";
 export type {
   WorkbenchEvents,
   WorkbenchLauncher,
@@ -239,6 +244,7 @@ export {
   sendWorkbenchMessage,
   startWorkflowCommand,
   provisionSpaceWorkbench,
+  cancelWorkbenchTurn,
 } from "./workbench-service";
 export type {
   LaunchAndJoinAgentDeps,
@@ -253,6 +259,7 @@ export type {
   SendWorkbenchMessageDeps,
   SendWorkbenchMessageInput,
   SendWorkbenchMessageResult,
+  CancelWorkbenchTurnResult,
   StartWorkflowCommandDeps,
   StartWorkflowCommandInput,
   StartWorkflowCommandResult,
diff --git a/packages/chat/src/parts.ts b/packages/chat/src/parts.ts
index 6a6a79165..0c428784b 100644
--- a/packages/chat/src/parts.ts
+++ b/packages/chat/src/parts.ts
@@ -14,6 +14,13 @@ export const TextPart = type({
    * (`PrFailedTurnStrip`) instead of a plain bubble. Absent on every
    * other text part. */
   "turnFailed?": "boolean",
+  /** Set only on the cancelled-turn notice `postCancelledNotice`
+   * (`./workbench-service.ts`) posts in the cancelled agent's own voice
+   * (CL-7201) — distinct from `turnFailed`: a user cancelling a turn is
+   * not a failure, and the frontend renders it with its own honest copy
+   * rather than `FailedTurnStrip`'s "didn't reply" framing. Absent on
+   * every other text part. */
+  "turnCancelled?": "boolean",
 });
 export type TextPart = typeof TextPart.infer;
 
diff --git a/packages/chat/src/routes.ts b/packages/chat/src/routes.ts
index 4d3f348d3..b67c15d17 100644
--- a/packages/chat/src/routes.ts
+++ b/packages/chat/src/routes.ts
@@ -76,6 +76,7 @@ import {
   findExistingAgentChat,
   removeWorkbenchParticipant,
   sendWorkbenchMessage,
+  cancelWorkbenchTurn,
 } from "./workbench-service";
 import {
   bridgeWorkbenchStream,
@@ -92,6 +93,10 @@ import {
   createWorkbenchTurnQueue,
   type WorkbenchTurnQueue,
 } from "./turn-queue";
+import {
+  createTurnCancelRegistry,
+  type TurnCancelRegistry,
+} from "./turn-cancellation";
 import type { ChatPlatform } from "./platform-port";
 import type { ChatStore } from "./store";
 import {
@@ -296,6 +301,15 @@ export type CreateChatRoutesDeps = {
    * consumer of turn-claim state to share it with.
    */
   turnQueue?: WorkbenchTurnQueue;
+  /**
+   * The live abort seam a running turn is reachable through (CL-7201) —
+   * see `./turn-cancellation.ts` and `SendWorkbenchMessageDeps`'s field
+   * of the same name in `./workbench-service.ts`. Defaults to a fresh,
+   * router-scoped registry when omitted, the same "construct one
+   * instance, share it everywhere" pattern `turnQueue` follows — it is
+   * process-local, in-memory state with no cost to always have.
+   */
+  turnCancellation?: TurnCancelRegistry;
   /**
    * Slack-Connect-style workbench projection (CL-5882) — see
    * `./workbench-share.ts`. Omitted entirely, every `/workbenches/:id/shares*`
@@ -921,6 +935,7 @@ export function createChatRoutes(deps: CreateChatRoutesDeps): Hono<TenantEnv> {
       claims: createInMemoryTurnClaimStore({ ttlMs: deps.turnTimeoutMs }),
       publish,
     });
+  const turnCancellation = deps.turnCancellation ?? createTurnCancelRegistry();
 
   app.post(
     "/workbenches",
@@ -2103,6 +2118,7 @@ export function createChatRoutes(deps: CreateChatRoutesDeps): Hono<TenantEnv> {
           roomMessages: deps.roomMessages,
           publish,
           turnQueue,
+          turnCancellation,
           ...(deps.agentTurns !== undefined
             ? { agentTurns: deps.agentTurns }
             : {}),
@@ -2297,6 +2313,7 @@ export function createChatRoutes(deps: CreateChatRoutesDeps): Hono<TenantEnv> {
                 roomMessages: deps.roomMessages,
                 publish,
                 turnQueue,
+                turnCancellation,
                 ...(deps.agentTurns !== undefined
                   ? { agentTurns: deps.agentTurns }
                   : {}),
@@ -3700,6 +3717,42 @@ export function createChatRoutes(deps: CreateChatRoutesDeps): Hono<TenantEnv> {
     },
   );
 
+  // CL-7201: the escape hatch for a wedged or wrongly-guessed turn — the
+  // only bound before this route existed was the dispatch/wait-until-free
+  // timeouts, measured in minutes. Write, not read: cancelling changes
+  // the workbench's state, exactly like posting a message does.
+  app.post(
+    "/workbenches/:id/turns/cancel",
+    deps.requireGrant(idResource("room", "id"), "write"),
+    async (c) => {
+      const tenant = c.get("tenant");
+      const principal = c.get("principal");
+      const workbenchId = c.req.param("id");
+      const access = await resolveWorkbenchAccess(
+        deps,
+        tenant.id,
+        workbenchId,
+        principal.id,
+        principal.refId,
+      );
+      if (access === undefined) {
+        return c.json(ErrorEnvelope("not_found", "workbench not found"), 404);
+      }
+      const result = await cancelWorkbenchTurn(
+        {
+          turnCancellation,
+          roomMessages: deps.roomMessages,
+          publish,
+          ...(deps.agentTurns !== undefined
+            ? { agentTurns: deps.agentTurns }
+            : {}),
+        },
+        { tenantId: access.ownerTenantId, workbenchId },
+      );
+      return c.json(result);
+    },
+  );
+
   app.get(
     "/workbenches/:id/turns/:turnId",
     deps.requireGrant(idResource("room", "id"), "read"),
diff --git a/packages/chat/src/turn-cancellation.test.ts b/packages/chat/src/turn-cancellation.test.ts
new file mode 100644
index 000000000..61feba776
--- /dev/null
+++ b/packages/chat/src/turn-cancellation.test.ts
@@ -0,0 +1,67 @@
+import { describe, expect, test } from "bun:test";
+
+import {
+  createTurnCancelRegistry,
+  TurnCancelledError,
+} from "./turn-cancellation";
+
+describe("createTurnCancelRegistry (CL-7201)", () => {
+  test("cancel aborts every controller registered for that workbench", () => {
+    const registry = createTurnCancelRegistry();
+    const a = registry.register("wb_1");
+    const b = registry.register("wb_1");
+
+    const cancelled = registry.cancel("wb_1");
+
+    expect(cancelled).toBe(true);
+    expect(a.signal.aborted).toBe(true);
+    expect(b.signal.aborted).toBe(true);
+    expect(a.signal.reason).toBeInstanceOf(TurnCancelledError);
+  });
+
+  test("cancel never touches a controller registered for a different workbench", () => {
+    const registry = createTurnCancelRegistry();
+    const other = registry.register("wb_2");
+
+    registry.cancel("wb_1");
+
+    expect(other.signal.aborted).toBe(false);
+  });
+
+  test("cancel on a workbench with nothing registered is a harmless no-op", () => {
+    const registry = createTurnCancelRegistry();
+    expect(registry.cancel("wb_never_ran")).toBe(false);
+  });
+
+  test("unregister removes a controller so a later cancel no longer reaches it", () => {
+    const registry = createTurnCancelRegistry();
+    const controller = registry.register("wb_1");
+    registry.unregister("wb_1", controller);
+
+    const cancelled = registry.cancel("wb_1");
+
+    expect(cancelled).toBe(false);
+    expect(controller.signal.aborted).toBe(false);
+  });
+
+  test("unregistering one of several controllers leaves the rest cancellable", () => {
+    const registry = createTurnCancelRegistry();
+    const a = registry.register("wb_1");
+    const b = registry.register("wb_1");
+    registry.unregister("wb_1", a);
+
+    registry.cancel("wb_1");
+
+    expect(a.signal.aborted).toBe(false);
+    expect(b.signal.aborted).toBe(true);
+  });
+
+  test("a second cancel call is a harmless no-op once nothing is left registered", () => {
+    const registry = createTurnCancelRegistry();
+    const controller = registry.register("wb_1");
+    registry.cancel("wb_1");
+    registry.unregister("wb_1", controller);
+
+    expect(registry.cancel("wb_1")).toBe(false);
+  });
+});
diff --git a/packages/chat/src/turn-cancellation.ts b/packages/chat/src/turn-cancellation.ts
new file mode 100644
index 000000000..75f32820d
--- /dev/null
+++ b/packages/chat/src/turn-cancellation.ts
@@ -0,0 +1,79 @@
+// CL-7201: the live abort seam a running turn is reachable through while
+// it is still on our own call stack — the `waitUntilFree` wait, the
+// `dispatchTurn` call around `sendMail` — as opposed to `agent-turns.ts`'s
+// projection, which records what a turn's outcome WAS after the fact.
+// This registry is what lets a cancel request reach the actual in-flight
+// work instead of only closing its row once whatever it was doing
+// eventually finishes on its own.
+//
+// Deliberately process-local and workbench-keyed, mirroring
+// `createTurnFreedSignal` (`./agent-turns.ts`): a workbench can have more
+// than one agent turn running at once (`dispatchTurnBatch` fans out
+// concurrently), so cancelling "the" in-flight turn for a workbench means
+// aborting every controller registered for it, not just one.
+
+/** The abort reason `TurnCancelRegistry.cancel` gives every controller it
+ * aborts — the one thing `dispatchTurn`'s own abort-close handler checks
+ * to tell a user's deliberate cancellation apart from a dispatch deadline
+ * timing out, so it can settle the turn row `cancelled` rather than
+ * `failed`. */
+export class TurnCancelledError extends Error {
+  constructor(message = "Cancelled by user") {
+    super(message);
+    this.name = "TurnCancelledError";
+  }
+}
+
+export interface TurnCancelRegistry {
+  /** Registers a fresh controller for `workbenchId`'s in-flight work.
+   * The caller owns unregistering it (typically in a `finally`) once
+   * that work settles on its own, win or lose. */
+  register(workbenchId: string): AbortController;
+  /** Removes a controller this workbench no longer needs cancelled —
+   * its own work already settled, so a later `cancel` must not abort a
+   * controller nothing is listening on any more. */
+  unregister(workbenchId: string, controller: AbortController): void;
+  /**
+   * Aborts every controller currently registered for `workbenchId` with
+   * a `TurnCancelledError`, and returns whether anything was actually
+   * reachable this way. `false` does not mean nothing was running — a
+   * turn whose `sendMail` has already resolved and moved off our call
+   * stack entirely has nothing left registered here at all; settling
+   * that turn's row is `cancelWorkbenchTurn`'s (`./workbench-service.ts`)
+   * separate sweep, not this registry's job.
+   */
+  cancel(workbenchId: string): boolean;
+}
+
+export function createTurnCancelRegistry(): TurnCancelRegistry {
+  const controllersByWorkbench = new Map<string, Set<AbortController>>();
+
+  return {
+    register(workbenchId) {
+      const controller = new AbortController();
+      const controllers =
+        controllersByWorkbench.get(workbenchId) ?? new Set<AbortController>();
+      controllers.add(controller);
+      controllersByWorkbench.set(workbenchId, controllers);
+      return controller;
+    },
+
+    unregister(workbenchId, controller) {
+      const controllers = controllersByWorkbench.get(workbenchId);
+      if (controllers === undefined) return;
+      controllers.delete(controller);
+      if (controllers.size === 0) {
+        controllersByWorkbench.delete(workbenchId);
+      }
+    },
+
+    cancel(workbenchId) {
+      const controllers = controllersByWorkbench.get(workbenchId);
+      if (controllers === undefined || controllers.size === 0) return false;
+      for (const controller of controllers) {
+        controller.abort(new TurnCancelledError());
+      }
+      return true;
+    },
+  };
+}
diff --git a/packages/chat/src/with-timeout.test.ts b/packages/chat/src/with-timeout.test.ts
index d2fd66017..f9e9de4b7 100644
--- a/packages/chat/src/with-timeout.test.ts
+++ b/packages/chat/src/with-timeout.test.ts
@@ -1,3 +1,5 @@
+import { getEventListeners } from "node:events";
+
 import { describe, expect, test } from "bun:test";
 
 import { withTimeout } from "./with-timeout";
@@ -72,4 +74,103 @@ describe("withTimeout", () => {
     await Bun.sleep(60);
     expect(sawAbort).toBe(false);
   });
+
+  // CL-7201: a caller with its own reason to give up (a user cancelling a
+  // turn) must be able to cut `work` short exactly like a timeout does —
+  // without waiting for the timeout's own clock, and without work having
+  // to guess which of two signals it was handed.
+  describe("an external signal (CL-7201)", () => {
+    test("aborts work's signal immediately when the external signal fires, well before the deadline", async () => {
+      const external = new AbortController();
+      let reason: unknown;
+
+      const promise = withTimeout(
+        (signal) =>
+          new Promise<never>((_resolve, reject) => {
+            signal.addEventListener("abort", () => {
+              reason = signal.reason;
+              reject(signal.reason);
+            });
+          }),
+        10_000,
+        "did not settle within 10000ms",
+        external.signal,
+      );
+
+      const cancelReason = new Error("cancelled by user");
+      external.abort(cancelReason);
+
+      await expect(promise).rejects.toThrow("cancelled by user");
+      expect(reason).toBe(cancelReason);
+    });
+
+    test("an external signal that is already aborted aborts work immediately", async () => {
+      const external = new AbortController();
+      external.abort(new Error("already gone"));
+      let aborted = false;
+
+      await expect(
+        withTimeout(
+          (signal) =>
+            new Promise<never>((_resolve, reject) => {
+              if (signal.aborted) {
+                aborted = true;
+                reject(signal.reason);
+                return;
+              }
+              signal.addEventListener("abort", () => reject(signal.reason));
+            }),
+          10_000,
+          "did not settle within 10000ms",
+          external.signal,
+        ),
+      ).rejects.toThrow("already gone");
+      expect(aborted).toBe(true);
+    });
+
+    test("the timeout still wins when the external signal never fires", async () => {
+      const external = new AbortController();
+      await expect(
+        withTimeout(
+          () => new Promise<never>(() => {}),
+          10,
+          "did not settle within 10ms",
+          external.signal,
+        ),
+      ).rejects.toThrow("did not settle within 10ms");
+    });
+
+    test("work settling on its own is unaffected by an external signal that never fires", async () => {
+      const external = new AbortController();
+      const result = await withTimeout(
+        async () => "ok",
+        50,
+        "timed out",
+        external.signal,
+      );
+      expect(result).toBe("ok");
+    });
+
+    // CL-7201 (Critique finding): the timeout-fired branch never removed
+    // its own listener from `externalSignal` — only the two `work`-
+    // settles-first branches did. Within one `dispatchTurnBatch`
+    // recipient the same cancellation controller's signal is reused
+    // across two sequential `withTimeout` calls (`waitUntilFree`, then
+    // `dispatchTurn`); a `waitUntilFree` timeout leaving a dangling
+    // listener behind means the `dispatchTurn` call's own listener
+    // stacks on top of it instead of starting clean.
+    test("a timeout win still removes this call's own listener from the external signal", async () => {
+      const external = new AbortController();
+      await expect(
+        withTimeout(
+          () => new Promise<never>(() => {}),
+          10,
+          "did not settle within 10ms",
+          external.signal,
+        ),
+      ).rejects.toThrow("did not settle within 10ms");
+
+      expect(getEventListeners(external.signal, "abort")).toHaveLength(0);
+    });
+  });
 });
diff --git a/packages/chat/src/with-timeout.ts b/packages/chat/src/with-timeout.ts
index a162b3469..6a3e6c0b3 100644
--- a/packages/chat/src/with-timeout.ts
+++ b/packages/chat/src/with-timeout.ts
@@ -12,24 +12,57 @@
 // poll loop, close a row it opened) can react instead of running to
 // completion unobserved. A `work` that ignores the signal keeps
 // today's abandon-on-timeout behavior.
+//
+// CL-7201: a caller can also hand in its own `externalSignal` — a user
+// cancelling the turn this `work` belongs to, say — that cuts `work`
+// short exactly like the timeout does, without waiting for the timeout's
+// own clock. `work` only ever sees ONE signal regardless of which of the
+// two fired, so it never has to reason about "which deadline was this."
+// The rejection carries the external signal's own `reason` rather than
+// this module's timeout `Error`, so a caller downstream (`dispatchTurn`)
+// can tell a real cancellation apart from a genuine timeout.
 export function withTimeout<T>(
   work: (signal: AbortSignal) => Promise<T>,
   ms: number,
   message: string,
+  externalSignal?: AbortSignal,
 ): Promise<T> {
   const controller = new AbortController();
   return new Promise((resolve, reject) => {
     const timer = setTimeout(() => {
       controller.abort(new Error(message));
+      // CL-7201 (Critique finding): the two `work`-settles-first
+      // branches below already remove this listener; the timeout
+      // winning is a third way this call can end and needs the same
+      // cleanup, or `externalSignal` — reused across more than one
+      // `withTimeout` call in `dispatchTurnBatch` — keeps a dangling
+      // listener from every timed-out call forever.
+      externalSignal?.removeEventListener("abort", onExternalAbort);
       reject(new Error(message));
     }, ms);
+
+    const onExternalAbort = () => {
+      clearTimeout(timer);
+      controller.abort(externalSignal?.reason);
+      reject(externalSignal?.reason);
+    };
+    if (externalSignal?.aborted === true) {
+      onExternalAbort();
+    } else {
+      externalSignal?.addEventListener("abort", onExternalAbort, {
+        once: true,
+      });
+    }
+
     work(controller.signal).then(
       (value) => {
         clearTimeout(timer);
+        externalSignal?.removeEventListener("abort", onExternalAbort);
         resolve(value);
       },
       (cause: unknown) => {
         clearTimeout(timer);
+        externalSignal?.removeEventListener("abort", onExternalAbort);
         reject(cause);
       },
     );
diff --git a/packages/chat/src/workbench-service.ts b/packages/chat/src/workbench-service.ts
index 4904eb723..7d47c236d 100644
--- a/packages/chat/src/workbench-service.ts
+++ b/packages/chat/src/workbench-service.ts
@@ -23,6 +23,10 @@ import {
 } from "./turn-context";
 import type { AgentTurnStore } from "./agent-turns";
 import type { ThreadStore } from "./threads";
+import {
+  TurnCancelledError,
+  type TurnCancelRegistry,
+} from "./turn-cancellation";
 import {
   addParticipant,
   handleFromName,
@@ -1234,6 +1238,18 @@ export type SendWorkbenchMessageDeps = {
    * that claim releases. See `./turn-queue.ts`.
    */
   readonly turnQueue: WorkbenchTurnQueue;
+  /**
+   * The live abort seam a running turn is reachable through while still
+   * on our own call stack (CL-7201) — see `./turn-cancellation.ts`.
+   * `dispatchTurnBatch` registers one controller per recipient it
+   * dispatches and composes it into each `withTimeout` call so a
+   * cancellation lands exactly like a timeout does, distinguished only
+   * by its `TurnCancelledError` reason. Required, not optional: it is
+   * process-local, in-memory state with no cost to always have — every
+   * composition gets real cancellation propagation, not just the ones
+   * that remember to wire it up.
+   */
+  readonly turnCancellation: TurnCancelRegistry;
   /**
    * The turn projection (CL-6329). `dispatchTurn` opens a row before it
    * touches the execution plane, so an in-flight turn is visible from
@@ -1645,6 +1661,7 @@ async function dispatchTurnBatch(
     | "turnDispatchTimeoutMs"
     | "waitUntilFreeTimeoutMs"
     | "agentTurns"
+    | "turnCancellation"
   >,
   tenantId: string,
   workbenchId: string,
@@ -1692,6 +1709,16 @@ async function dispatchTurnBatch(
   // delay every agent mentioned after it.
   await Promise.all(
     recipients.map(async (agentAddress) => {
+      // CL-7201: one controller for this recipient's whole attempt —
+      // spanning both the `waitUntilFree` wait below and the
+      // `dispatchTurn` call after it — so a cancel request lands
+      // wherever this recipient actually is, not just one of the two
+      // phases. Registered before either `withTimeout` call and always
+      // unregistered once this recipient's own attempt settles, win or
+      // lose, so a cancel arriving after the fact never reaches (or
+      // leaks a reference to) a controller nothing is listening on any
+      // more.
+      const cancelController = deps.turnCancellation.register(workbenchId);
       try {
         // CL-6670: wait under its own deadline, separate from the
         // per-hop deadline below. An agent that already has a turn
@@ -1724,6 +1751,7 @@ async function dispatchTurnBatch(
               ),
             waitUntilFreeTimeoutMs,
             waitUntilFreeTimeoutMessage(agentAddress, waitUntilFreeTimeoutMs),
+            cancelController.signal,
           );
         }
         // CL-6644: one deadline around the whole turn, not another
@@ -1764,8 +1792,24 @@ async function dispatchTurnBatch(
             ),
           turnDispatchTimeoutMs,
           turnDispatchTimeoutMessage(agentAddress, turnDispatchTimeoutMs),
+          cancelController.signal,
         );
       } catch (err) {
+        // CL-7201: a deliberate cancellation is not a failure — the
+        // user asked for exactly this. `dispatchTurn`'s own abort-close
+        // handler (if this recipient was still inside its `sendMail`
+        // call) or `cancelWorkbenchTurn`'s sweep (if it wasn't) already
+        // settled the turn row and posted the one honest notice this
+        // gets; reporting it here too would double-post and misfile a
+        // user action as an operational error.
+        if (err instanceof TurnCancelledError) {
+          fanoutLog.info(
+            "Turn dispatch for {agentAddress} on workbench {workbenchId} " +
+              "was cancelled by the user for message(s) {messageIds}",
+            { agentAddress, workbenchId, messageIds },
+          );
+          return;
+        }
         const refId = reportError(err, {
           operation: "chat.dispatchTurn",
           tenantId,
@@ -1792,6 +1836,8 @@ async function dispatchTurnBatch(
           cause: err,
           refId,
         });
+      } finally {
+        deps.turnCancellation.unregister(workbenchId, cancelController);
       }
     }),
   );
@@ -1838,9 +1884,25 @@ export type DispatchTurnInput = {
  * row to attach to — `finishTurn`'s compare-and-set means whichever of
  * the abort close and the late reply's own close reaches the row first
  * is the only one that applies.
+ *
+ * CL-7201: the same abort can also be a deliberate cancellation rather
+ * than a timeout (`signal.reason instanceof TurnCancelledError`) — this
+ * closes the row `cancelled` instead of `failed` in that case, and, only
+ * if this close actually wins `finishTurn`'s compare-and-set (this
+ * recipient's controller was still reachable when the user cancelled),
+ * posts the one cancelled notice the timeline gets for it. Losing that
+ * race means `cancelWorkbenchTurn`'s own sweep already settled the row
+ * and posted the notice instead — exactly one of the two ever does. A
+ * signal already aborted BEFORE this is ever called returns immediately
+ * after closing the row, never calling `sendMail` at all — that is not
+ * CL-7230's ceiling (a send already in flight, which cannot be
+ * stopped), just a send that hasn't started yet and has no reason to.
  */
 export async function dispatchTurn(
-  deps: Pick<SendWorkbenchMessageDeps, "platform" | "agentTurns">,
+  deps: Pick<
+    SendWorkbenchMessageDeps,
+    "platform" | "agentTurns" | "roomMessages" | "publish"
+  >,
   input: DispatchTurnInput,
   signal?: AbortSignal,
 ): Promise<void> {
@@ -1853,16 +1915,25 @@ export async function dispatchTurn(
 
   const closeAsTimedOut = () => {
     if (turn === undefined) return;
+    const cancelled = signal?.reason instanceof TurnCancelledError;
     deps.agentTurns
       ?.finishTurn({
         tenantId: input.tenantId,
         turnId: turn.id,
-        status: "failed",
+        status: cancelled ? "cancelled" : "failed",
         error:
           signal?.reason instanceof Error
             ? signal.reason.message
             : "turn dispatch timed out",
       })
+      .then((finished) => {
+        if (finished === undefined || !cancelled) return;
+        return postCancelledNotice(deps, {
+          tenantId: input.tenantId,
+          workbenchId: input.workbenchId,
+          agentAddress: input.agentAddress,
+        });
+      })
       .catch((err: unknown) => {
         reportError(err, {
           operation: "chat.dispatchTurn.closeAsTimedOut",
@@ -1873,10 +1944,17 @@ export async function dispatchTurn(
       });
   };
   if (signal?.aborted) {
+    // CL-7201 (Critique finding): already aborted before `sendMail` was
+    // ever asked to run at all — not CL-7230's "aborts while sendMail
+    // is already in flight" ceiling, which genuinely cannot be
+    // stopped. Firing a brand-new mail send for a turn already known
+    // (and closed) as cancelled would orphan a reply nothing could ever
+    // attach to a running row again, so this returns instead of falling
+    // through to it.
     closeAsTimedOut();
-  } else {
-    signal?.addEventListener("abort", closeAsTimedOut, { once: true });
+    return;
   }
+  signal?.addEventListener("abort", closeAsTimedOut, { once: true });
 
   try {
     await deps.platform.sendMail({
@@ -1988,3 +2066,149 @@ async function postUndeliveredNotice(
     );
   }
 }
+
+const CANCELLED_NOTICE = "This turn was cancelled.";
+
+/**
+ * The timeline's own record of a cancellation (CL-7201) — deliberately
+ * distinct from `postUndeliveredNotice`: a user stopping a turn is not a
+ * failure, and reusing `turnFailed`'s "didn't reply" framing (with its
+ * Retry action) would misrepresent something the user asked for as
+ * something that went wrong on its own. Posted in the cancelled agent's
+ * own voice for the same reason `postUndeliveredNotice` is: the person
+ * reading the room sees who stopped replying and why, without a system
+ * message breaking the conversation's voice. Swallows its own failure
+ * exactly like `postUndeliveredNotice` — if the timeline is unreachable
+ * there is nowhere left to say so.
+ */
+async function postCancelledNotice(
+  deps: Pick<SendWorkbenchMessageDeps, "roomMessages" | "publish">,
+  input: {
+    readonly tenantId: string;
+    readonly workbenchId: string;
+    readonly agentAddress: string;
+  },
+): Promise<void> {
+  try {
+    await postRoomMessage(deps, {
+      tenantId: input.tenantId,
+      workbenchId: input.workbenchId,
+      sender: { name: null, address: input.agentAddress },
+      runId: localPartOf(input.agentAddress),
+      parts: [
+        {
+          kind: "text",
+          text: CANCELLED_NOTICE,
+          turnCancelled: true,
+        },
+      ],
+    });
+  } catch (err) {
+    // report-error-ignore: mirrors postUndeliveredNotice just above —
+    // the timeline being unreachable here is the same pre-existing,
+    // already-tracked class of failure with nowhere left to report to.
+    fanoutLog.error(
+      "Could not post the cancelled-turn notice for {agentAddress} onto " +
+        "workbench {workbenchId}'s timeline: {err}",
+      { agentAddress: input.agentAddress, workbenchId: input.workbenchId, err },
+    );
+  }
+}
+
+export type CancelWorkbenchTurnResult = {
+  /** How many turns were running for this workbench the moment cancel
+   * was asked for, and are now settled `cancelled` — the honest answer
+   * to "what did cancelling stop," per CL-7230's ceiling. Counted by
+   * outcome, not by which of the two mechanisms below actually
+   * performed the write: a turn `dispatchTurn`'s own abort-close
+   * settled a moment before this call's sweep reached it still counts
+   * here as cancelled. A workbench with nothing running returns 0. */
+  readonly cancelledCount: number;
+};
+
+/**
+ * Stops a workbench's in-flight turn(s) (CL-7201) — the cancel route's
+ * own logic, kept here rather than in `routes.ts` so it is testable
+ * without an HTTP round trip.
+ *
+ * Two independent mechanisms, run together, because a turn can be in
+ * either of two places when the user asks to stop it:
+ *
+ * 1. Still reachable on our own call stack — `dispatchTurnBatch`'s
+ *    per-recipient controller (`./turn-cancellation.ts`) is aborted,
+ *    which cuts the `waitUntilFree` wait or the `dispatchTurn` call
+ *    short exactly like a timeout does, synchronously, the moment
+ *    `cancel` below fires. That recipient's own abort-close handler
+ *    settles its row and posts the notice — frequently winning the
+ *    race against this function's own sweep, below, for any turn that
+ *    was still reachable this way.
+ * 2. Already off our call stack entirely — `sendMail` already resolved,
+ *    the agent is generating (or parked on a `message_response` gate
+ *    somewhere in the execution plane this package cannot see into).
+ *    Nothing is registered to abort any more, so the row is found via
+ *    `findRunningTurns` (snapshotted BEFORE `cancel` below, so a row
+ *    path 1 already claimed is still counted) and settled directly.
+ *
+ * Both paths call the same `finishTurn` compare-and-set, so whichever
+ * reaches a given row first is the only one that ever settles or
+ * notifies for it — never both, never neither; the loser's own
+ * `finishTurn` call harmlessly returns `undefined`. CL-7230's known
+ * ceiling applies to path 2 specifically: settling the row is not the
+ * same as stopping the underlying agent process, which this cannot
+ * reach.
+ */
+export async function cancelWorkbenchTurn(
+  deps: Pick<
+    SendWorkbenchMessageDeps,
+    "agentTurns" | "turnCancellation" | "roomMessages" | "publish"
+  >,
+  input: { readonly tenantId: string; readonly workbenchId: string },
+): Promise<CancelWorkbenchTurnResult> {
+  if (deps.agentTurns === undefined) {
+    deps.turnCancellation.cancel(input.workbenchId);
+    return { cancelledCount: 0 };
+  }
+  const agentTurns = deps.agentTurns;
+
+  // Snapshotted before `cancel` fires: path 1's abort-close can (and
+  // often does) win a row's compare-and-set synchronously inside
+  // `cancel` itself, before this sweep's own `finishTurn` call ever
+  // runs — this list is what lets the sweep still count, and settle,
+  // whatever it didn't personally win.
+  const running = await agentTurns.findRunningTurns({
+    tenantId: input.tenantId,
+    workbenchId: input.workbenchId,
+  });
+
+  deps.turnCancellation.cancel(input.workbenchId);
+
+  await Promise.all(
+    running.map(async (turn) => {
+      const finished = await agentTurns.finishTurn({
+        tenantId: input.tenantId,
+        turnId: turn.id,
+        status: "cancelled",
+        error: "Cancelled by user",
+      });
+      // `undefined` means path 1's abort-close already won this row —
+      // it already posted its own notice, so posting a second one here
+      // would double it up.
+      if (finished === undefined) return;
+      await postCancelledNotice(deps, {
+        tenantId: input.tenantId,
+        workbenchId: input.workbenchId,
+        agentAddress: finished.agentAddress,
+      });
+    }),
+  );
+
+  const settled = await Promise.all(
+    running.map((turn) =>
+      agentTurns.getTurn({ tenantId: input.tenantId, turnId: turn.id }),
+    ),
+  );
+  return {
+    cancelledCount: settled.filter((turn) => turn?.status === "cancelled")
+      .length,
+  };
+}
diff --git a/packages/chat/src/workflow-participant-routes.ts b/packages/chat/src/workflow-participant-routes.ts
index 9d2a1f7f2..998eebb08 100644
--- a/packages/chat/src/workflow-participant-routes.ts
+++ b/packages/chat/src/workflow-participant-routes.ts
@@ -126,6 +126,10 @@ export type CreateWorkflowParticipantRoutesDeps = {
    * workflow-child message and a person's own message for the same
    * workbench serialize against each other too. */
   readonly turnQueue: SendWorkbenchMessageDeps["turnQueue"];
+  /** The same cancellation registry `createChatRoutes` is given
+   * (CL-7201) — shared, never a second instance, so a cancel request
+   * reaches a controller registered from either entry point. */
+  readonly turnCancellation: SendWorkbenchMessageDeps["turnCancellation"];
   readonly authenticator: WorkflowRunAuthenticator;
   readonly tenancy: Pick<
     WorkbenchTenancyStore,
@@ -405,6 +409,7 @@ export function createWorkflowParticipantRoutes(
         roomMessages: deps.roomMessages,
         publish: deps.publish,
         turnQueue: deps.turnQueue,
+        turnCancellation: deps.turnCancellation,
       },
       {
         tenantId: scope.tenantId,
diff --git a/packages/chat/test/chat-orchestrator.test.ts b/packages/chat/test/chat-orchestrator.test.ts
index 9d531f35a..fa40d7178 100644
--- a/packages/chat/test/chat-orchestrator.test.ts
+++ b/packages/chat/test/chat-orchestrator.test.ts
@@ -457,6 +457,52 @@ describe("createChatOrchestrator", () => {
     orchestrator.dispose();
   });
 
+  test("a connector.reply after a cancelled 1:1 turn is dropped, not posted unattached", async () => {
+    const room = fakeRoom();
+    const agentTurns = createInMemoryAgentTurnStore();
+    const agentAddress = "ins_echo1@ten1.workbench.test";
+    const turn = await agentTurns.startTurn({
+      tenantId: "ten_1",
+      workbenchId: "ins_workbench1",
+      agentAddress,
+      requestMessageIds: ["msg_1"],
+    });
+    await agentTurns.finishTurn({
+      tenantId: "ten_1",
+      turnId: turn.id,
+      status: "cancelled",
+      error: "Cancelled by user",
+    });
+    const events = createSidecarEmitter();
+    const orchestrator = createChatOrchestrator({
+      db: createFakeDb({ id: "ins_echo1", tenantId: "ten_1" }) as never,
+      store: {
+        listWorkbenchSettings: async () => [
+          workbenchRow("ins_workbench1", [agentAddress]),
+        ],
+      },
+      roomMessages: room.roomMessages,
+      publish: room.publish,
+      platform: fakeMail().platform,
+      events,
+      agentTurns,
+      claims: fakeClaims(),
+      approvals: { findByCorrelationId: async () => null },
+    });
+
+    events.emit("agent.event", {
+      agentAddress,
+      sessionId: "ses_1",
+      event: { type: "connector.reply", data: { content: "late after stop" } },
+    });
+
+    await new Promise((resolve) => setTimeout(resolve, 0));
+
+    expect(room.posted).toEqual([]);
+
+    orchestrator.dispose();
+  });
+
   test("a connector.reply correlated to room B does not finish room A's running turn", async () => {
     const room = fakeRoom();
     const agentTurns = createInMemoryAgentTurnStore();
diff --git a/packages/chat/test/dispatch-turn-abort.test.ts b/packages/chat/test/dispatch-turn-abort.test.ts
new file mode 100644
index 000000000..07b8171bc
--- /dev/null
+++ b/packages/chat/test/dispatch-turn-abort.test.ts
@@ -0,0 +1,58 @@
+// CL-7201 (Critique finding): `dispatchTurn` must never call `sendMail`
+// for a turn whose signal was ALREADY aborted before the call — as
+// opposed to CL-7230's disclosed ceiling (a signal that aborts WHILE
+// `sendMail` is already in flight, which genuinely cannot be stopped).
+// An already-aborted signal at entry means the caller knew, before ever
+// asking this to do anything, that the turn was cancelled; dispatching
+// a brand-new mail send at that point orphans a reply nothing will ever
+// attach to a running row again.
+import { describe, expect, test } from "bun:test";
+
+import { createInMemoryAgentTurnStore } from "../src/agent-turns";
+import { createInMemoryRoomMessageStore } from "../src/room-messages";
+import { TurnCancelledError } from "../src/turn-cancellation";
+import { dispatchTurn } from "../src/workbench-service";
+import { fakePlatform, TENANT } from "./test-support";
+
+describe("dispatchTurn with an already-aborted signal (CL-7201)", () => {
+  test("never calls sendMail, and settles the row cancelled", async () => {
+    const platform = fakePlatform();
+    const agentTurns = createInMemoryAgentTurnStore();
+    const roomMessages = createInMemoryRoomMessageStore();
+    const controller = new AbortController();
+    controller.abort(new TurnCancelledError());
+
+    await dispatchTurn(
+      { platform, agentTurns, roomMessages, publish: () => undefined },
+      {
+        tenantId: TENANT.id,
+        workbenchId: "wb_1",
+        principalId: "prn_1",
+        agentAddress: "ins_echo1@acme.example",
+        parts: [{ kind: "text", text: "hello" }],
+        requestMessageIds: ["msg_1"],
+      },
+      controller.signal,
+    );
+
+    expect(platform.sentMail).toHaveLength(0);
+
+    const turns = await agentTurns.listTurns({
+      tenantId: TENANT.id,
+      workbenchId: "wb_1",
+    });
+    expect(turns).toHaveLength(1);
+    expect(turns[0]?.status).toBe("cancelled");
+
+    const messages = await roomMessages.listMessages({
+      tenantId: TENANT.id,
+      workbenchId: "wb_1",
+    });
+    const notice = messages.items.find((message) =>
+      message.parts.some(
+        (part) => part.kind === "text" && part.turnCancelled === true,
+      ),
+    );
+    expect(notice).toBeDefined();
+  });
+});
diff --git a/packages/chat/test/turn-cancel-route.test.ts b/packages/chat/test/turn-cancel-route.test.ts
new file mode 100644
index 000000000..5d5f4a67f
--- /dev/null
+++ b/packages/chat/test/turn-cancel-route.test.ts
@@ -0,0 +1,76 @@
+// CL-7201: the HTTP surface for cancelling a workbench's in-flight
+// turn(s). `turn-cancellation-dispatch.test.ts` exercises
+// `cancelWorkbenchTurn`'s own logic directly; this file proves the route
+// wires it up correctly — grant enforcement, 404 on an unknown
+// workbench, and the shape of the response.
+import { describe, expect, test } from "bun:test";
+
+import { createInMemoryAgentTurnStore } from "../src/agent-turns";
+import { createChatRoutes } from "../src/routes";
+import {
+  buildDeps,
+  createWorkbench,
+  fakePlatform,
+  mountAs,
+} from "./test-support";
+
+describe("POST /workbenches/:id/turns/cancel (CL-7201)", () => {
+  test("cancels a stuck turn and clears it via the response body", async () => {
+    const platform = fakePlatform({
+      invitable: [{ id: "wfd_echo", name: "echo" }],
+    });
+    platform.sendMail = () => new Promise<never>(() => {});
+    const agentTurns = createInMemoryAgentTurnStore();
+    const deps = buildDeps({
+      platform,
+      agentTurns,
+      turnDispatchTimeoutMs: 60_000,
+    });
+    const app = mountAs(createChatRoutes(deps), "prn_alice");
+    const { body: workbench } = await createWorkbench(app, {
+      kind: "chat",
+      definitionId: "wfd_echo",
+    });
+
+    void app.request(`/workbenches/${workbench.id}/messages`, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ parts: [{ kind: "text", text: "hello" }] }),
+    });
+    await Bun.sleep(5);
+
+    const response = await app.request(
+      `/workbenches/${workbench.id}/turns/cancel`,
+      { method: "POST" },
+    );
+    expect(response.status).toBe(200);
+    const body = await response.json();
+    expect(body).toEqual({ cancelledCount: 1 });
+  });
+
+  test("404s for a workbench that doesn't exist", async () => {
+    const deps = buildDeps();
+    const app = mountAs(createChatRoutes(deps), "prn_alice");
+
+    const response = await app.request(
+      "/workbenches/run_does_not_exist/turns/cancel",
+      { method: "POST" },
+    );
+
+    expect(response.status).toBe(404);
+  });
+
+  test("denies the request when the write grant is refused", async () => {
+    const deps = buildDeps({
+      requireGrant: () => async (c) =>
+        c.json({ error: { code: "forbidden" } }, 403),
+    });
+    const app = mountAs(createChatRoutes(deps), "prn_alice");
+
+    const response = await app.request("/workbenches/run_1/turns/cancel", {
+      method: "POST",
+    });
+
+    expect(response.status).toBe(403);
+  });
+});
diff --git a/packages/chat/test/turn-cancellation-dispatch.test.ts b/packages/chat/test/turn-cancellation-dispatch.test.ts
new file mode 100644
index 000000000..eebd67c98
--- /dev/null
+++ b/packages/chat/test/turn-cancellation-dispatch.test.ts
@@ -0,0 +1,308 @@
+// CL-7201: cancellation has two independent ways to reach a running
+// turn, and both must settle the row honestly (never claim `failed`
+// for something the user asked for) with exactly one notice on the
+// timeline:
+//
+// 1. The turn is still reachable on our own call stack (`waitUntilFree`
+//    still waiting, or `dispatchTurn`'s `sendMail` still in flight) --
+//    the cancellation registry's `AbortSignal` cuts it short directly.
+// 2. The turn's dispatch has already resolved and moved off our call
+//    stack entirely (the agent is generating, or parked on a
+//    `message_response` gate somewhere in the execution plane this
+//    package has no visibility into) -- `cancelWorkbenchTurn`'s sweep
+//    is the only thing left that can settle the row, per CL-7230's
+//    ceiling: it can record the outcome, not stop the underlying work.
+import { describe, expect, test } from "bun:test";
+
+import { createInMemoryAgentTurnStore } from "../src/agent-turns";
+import { createChatRoutes } from "../src/routes";
+import { createTurnCancelRegistry } from "../src/turn-cancellation";
+import { createWorkbenchSubscriberRegistry } from "../src/workbench-events";
+import { cancelWorkbenchTurn } from "../src/workbench-service";
+import {
+  buildDeps,
+  createWorkbench,
+  fakePlatform,
+  mountAs,
+  settleFanout,
+  TENANT,
+  timelineOf,
+} from "./test-support";
+
+async function postHello(app: ReturnType<typeof mountAs>, workbenchId: string) {
+  return app.request(`/workbenches/${workbenchId}/messages`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ parts: [{ kind: "text", text: "hello" }] }),
+  });
+}
+
+describe("cancelWorkbenchTurn (CL-7201)", () => {
+  test("cancelling a turn stuck inside dispatchTurn's sendMail settles it cancelled, not failed, with one honest notice", async () => {
+    const platform = fakePlatform({
+      invitable: [{ id: "wfd_echo", name: "echo" }],
+    });
+    platform.sendMail = () => new Promise<never>(() => {});
+    const agentTurns = createInMemoryAgentTurnStore();
+    const turnCancellation = createTurnCancelRegistry();
+    const workbenchSubscribers = createWorkbenchSubscriberRegistry();
+
+    // Generous on purpose: proves cancellation beats the deadline rather
+    // than racing it.
+    const deps = buildDeps({
+      platform,
+      agentTurns,
+      turnCancellation,
+      workbenchSubscribers,
+      turnDispatchTimeoutMs: 60_000,
+    });
+    const app = mountAs(createChatRoutes(deps), "prn_alice");
+    const { body: workbench } = await createWorkbench(app, {
+      kind: "chat",
+      definitionId: "wfd_echo",
+    });
+
+    void postHello(app, workbench.id);
+    // Let dispatchTurn actually start (startTurn + the stuck sendMail
+    // call) before cancelling -- otherwise there is nothing in flight
+    // yet to cancel.
+    await Bun.sleep(5);
+
+    const result = await cancelWorkbenchTurn(
+      {
+        agentTurns,
+        turnCancellation,
+        roomMessages: deps.roomMessages,
+        publish: workbenchSubscribers.publish,
+      },
+      { tenantId: TENANT.id, workbenchId: workbench.id },
+    );
+    await settleFanout();
+
+    expect(result.cancelledCount).toBe(1);
+
+    const turns = await agentTurns.listTurns({
+      tenantId: TENANT.id,
+      workbenchId: workbench.id,
+    });
+    expect(turns).toHaveLength(1);
+    expect(turns[0]?.status).toBe("cancelled");
+
+    const timeline = await timelineOf(deps, workbench.id);
+    const cancelledNotices = timeline.filter((message) =>
+      message.parts.some(
+        (part) => part.kind === "text" && part.turnCancelled === true,
+      ),
+    );
+    expect(cancelledNotices).toHaveLength(1);
+
+    const undeliveredNotices = timeline.filter((message) =>
+      message.parts.some(
+        (part) => part.kind === "text" && part.turnFailed === true,
+      ),
+    );
+    expect(undeliveredNotices).toHaveLength(0);
+  });
+
+  test("cancelling a turn whose dispatch already resolved off our call stack still settles it via the sweep", async () => {
+    const platform = fakePlatform({
+      invitable: [{ id: "wfd_echo", name: "echo" }],
+    });
+    const agentTurns = createInMemoryAgentTurnStore();
+    const turnCancellation = createTurnCancelRegistry();
+    const workbenchSubscribers = createWorkbenchSubscriberRegistry();
+    const deps = buildDeps({
+      platform,
+      agentTurns,
+      turnCancellation,
+      workbenchSubscribers,
+    });
+    const app = mountAs(createChatRoutes(deps), "prn_alice");
+    const { body: workbench } = await createWorkbench(app, {
+      kind: "chat",
+      definitionId: "wfd_echo",
+    });
+
+    await postHello(app, workbench.id);
+    await settleFanout();
+
+    // Sanity: nothing in this harness closes the row on its own --
+    // proves the later "cancelled" status came from the sweep, not from
+    // some other path already having settled it.
+    const beforeCancel = await agentTurns.listTurns({
+      tenantId: TENANT.id,
+      workbenchId: workbench.id,
+    });
+    expect(beforeCancel[0]?.status).toBe("running");
+
+    const result = await cancelWorkbenchTurn(
+      {
+        agentTurns,
+        turnCancellation,
+        roomMessages: deps.roomMessages,
+        publish: workbenchSubscribers.publish,
+      },
+      { tenantId: TENANT.id, workbenchId: workbench.id },
+    );
+
+    expect(result.cancelledCount).toBe(1);
+    const after = await agentTurns.listTurns({
+      tenantId: TENANT.id,
+      workbenchId: workbench.id,
+    });
+    expect(after[0]?.status).toBe("cancelled");
+
+    const timeline = await timelineOf(deps, workbench.id);
+    const cancelledNotices = timeline.filter((message) =>
+      message.parts.some(
+        (part) => part.kind === "text" && part.turnCancelled === true,
+      ),
+    );
+    expect(cancelledNotices).toHaveLength(1);
+  });
+
+  test("a late reply landing after cancellation cannot reopen the turn", async () => {
+    const platform = fakePlatform({
+      invitable: [{ id: "wfd_echo", name: "echo" }],
+    });
+    const agentTurns = createInMemoryAgentTurnStore();
+    const turnCancellation = createTurnCancelRegistry();
+    const workbenchSubscribers = createWorkbenchSubscriberRegistry();
+    const deps = buildDeps({
+      platform,
+      agentTurns,
+      turnCancellation,
+      workbenchSubscribers,
+    });
+    const app = mountAs(createChatRoutes(deps), "prn_alice");
+    const { body: workbench } = await createWorkbench(app, {
+      kind: "chat",
+      definitionId: "wfd_echo",
+    });
+
+    await postHello(app, workbench.id);
+    await settleFanout();
+
+    await cancelWorkbenchTurn(
+      {
+        agentTurns,
+        turnCancellation,
+        roomMessages: deps.roomMessages,
+        publish: workbenchSubscribers.publish,
+      },
+      { tenantId: TENANT.id, workbenchId: workbench.id },
+    );
+
+    const [turn] = await agentTurns.listTurns({
+      tenantId: TENANT.id,
+      workbenchId: workbench.id,
+    });
+    if (turn === undefined) throw new Error("expected a turn to be running");
+    const lateReply = await agentTurns.finishTurn({
+      tenantId: TENANT.id,
+      turnId: turn.id,
+      status: "completed",
+      replyMessageId: "msg_late",
+    });
+    expect(lateReply).toBeUndefined();
+
+    const stored = await agentTurns.getTurn({
+      tenantId: TENANT.id,
+      turnId: turn.id,
+    });
+    expect(stored?.status).toBe("cancelled");
+  });
+
+  test("cancelling a workbench with nothing running is a harmless no-op", async () => {
+    const agentTurns = createInMemoryAgentTurnStore();
+    const turnCancellation = createTurnCancelRegistry();
+    const workbenchSubscribers = createWorkbenchSubscriberRegistry();
+    const deps = buildDeps({
+      agentTurns,
+      turnCancellation,
+      workbenchSubscribers,
+    });
+
+    const result = await cancelWorkbenchTurn(
+      {
+        agentTurns,
+        turnCancellation,
+        roomMessages: deps.roomMessages,
+        publish: workbenchSubscribers.publish,
+      },
+      { tenantId: TENANT.id, workbenchId: "wb_never_ran" },
+    );
+
+    expect(result.cancelledCount).toBe(0);
+  });
+
+  test("cancelling without an agentTurns store configured never throws", async () => {
+    const turnCancellation = createTurnCancelRegistry();
+    const workbenchSubscribers = createWorkbenchSubscriberRegistry();
+    const deps = buildDeps({ turnCancellation, workbenchSubscribers });
+
+    const result = await cancelWorkbenchTurn(
+      {
+        turnCancellation,
+        roomMessages: deps.roomMessages,
+        publish: workbenchSubscribers.publish,
+      },
+      { tenantId: TENANT.id, workbenchId: "wb_1" },
+    );
+
+    expect(result.cancelledCount).toBe(0);
+  });
+
+  test("timeout and cancel during in-flight sendMail produce exactly one notice", async () => {
+    const platform = fakePlatform({
+      invitable: [{ id: "wfd_echo", name: "echo" }],
+    });
+    platform.sendMail = () => new Promise<never>(() => {});
+    const agentTurns = createInMemoryAgentTurnStore();
+    const turnCancellation = createTurnCancelRegistry();
+    const workbenchSubscribers = createWorkbenchSubscriberRegistry();
+    const deps = buildDeps({
+      platform,
+      agentTurns,
+      turnCancellation,
+      workbenchSubscribers,
+      turnDispatchTimeoutMs: 20,
+    });
+    const app = mountAs(createChatRoutes(deps), "prn_alice");
+    const { body: workbench } = await createWorkbench(app, {
+      kind: "chat",
+      definitionId: "wfd_echo",
+    });
+
+    void postHello(app, workbench.id);
+    await Bun.sleep(5);
+
+    const result = await cancelWorkbenchTurn(
+      {
+        agentTurns,
+        turnCancellation,
+        roomMessages: deps.roomMessages,
+        publish: workbenchSubscribers.publish,
+      },
+      { tenantId: TENANT.id, workbenchId: workbench.id },
+    );
+    await settleFanout();
+
+    expect(result.cancelledCount).toBe(1);
+
+    const timeline = await timelineOf(deps, workbench.id);
+    const notices = timeline.filter((message) =>
+      message.parts.some(
+        (part) =>
+          part.kind === "text" &&
+          (part.turnCancelled === true || part.turnFailed === true),
+      ),
+    );
+    expect(notices).toHaveLength(1);
+    expect(
+      notices[0]?.parts.some(
+        (part) => part.kind === "text" && part.turnCancelled === true,
+      ),
+    ).toBe(true);
+  });
+});
diff --git a/packages/chat/test/workflow-participant-routes.test.ts b/packages/chat/test/workflow-participant-routes.test.ts
index 6b43fb30e..1127a2787 100644
--- a/packages/chat/test/workflow-participant-routes.test.ts
+++ b/packages/chat/test/workflow-participant-routes.test.ts
@@ -18,6 +18,7 @@ import {
 } from "../src/workflow-participant-routes";
 import { createInMemoryTurnClaimStore } from "../src/turn-claims";
 import { createWorkbenchTurnQueue } from "../src/turn-queue";
+import { createTurnCancelRegistry } from "../src/turn-cancellation";
 import { createInMemoryWorkbenchTenancyStore } from "../src/workbench-tenancy";
 import { fakePlatform, TENANT } from "./test-support";
 
@@ -54,6 +55,7 @@ function buildApp(
         claims: createInMemoryTurnClaimStore({ ttlMs: 60_000 }),
         publish,
       }),
+    turnCancellation: overrides.turnCancellation ?? createTurnCancelRegistry(),
     authenticator: overrides.authenticator ?? authenticateAsRun,
     tenancy: overrides.tenancy ?? createInMemoryWorkbenchTenancyStore(),
     sessionFor: overrides.sessionFor ?? (async () => ["session=test"]),
diff --git a/packages/icons/src/index.tsx b/packages/icons/src/index.tsx
index 9a692c4e0..eb2b4b05d 100644
--- a/packages/icons/src/index.tsx
+++ b/packages/icons/src/index.tsx
@@ -75,6 +75,7 @@ export {
   Smiley,
   Stack,
   Star,
+  Stop,
   SquaresFour,
   User,
   UserCircle,