diff --git a/frontend/app/api/launch_kit/route.js b/frontend/app/api/launch_kit/route.js
index 464e1205..eb23ce97 100644
--- a/frontend/app/api/launch_kit/route.js
+++ b/frontend/app/api/launch_kit/route.js
@@ -218,6 +218,7 @@ export async function POST(request) {
         baseUrl: providerBaseUrl,
         modelName: providerModelName,
         allowServerKey: isOwner,
+        signal: request.signal,
       },
     });
 
diff --git a/frontend/app/page.js b/frontend/app/page.js
index b42f9665..846d7c6e 100644
--- a/frontend/app/page.js
+++ b/frontend/app/page.js
@@ -411,6 +411,7 @@ export default function Home() {
     reddit: { subreddit: "", title: "" },
   });
   const fileInputRef = useRef(null);
+  const generationAbortRef = useRef(null);
   const campaignApplication = useMemo(() => createBrowserCampaignApplication({
     getStorage: () => window.localStorage,
     key: LIBRARY_KEY,
@@ -880,7 +881,7 @@ ${extractedText}`);
     }
   }
 
-  async function requestGeneration(requestedChannels) {
+  async function requestGeneration(requestedChannels, signal = null) {
     if (!form.notes.trim() && !form.links.trim() && !form.repo.trim() && documentText.length === 0) {
       throw new Error("Add a brief, link, repository, or extractable text file before generating.");
     }
@@ -898,6 +899,7 @@ ${extractedText}`);
     const response = await fetch("/api/launch_kit", {
       method: "POST",
       headers: authHeaders({ "Content-Type": "application/json" }),
+      signal,
       body: JSON.stringify({
         project_name: form.projectName.trim() || "Untitled campaign",
         notes: form.notes.trim(),
@@ -946,11 +948,29 @@ ${extractedText}`);
     return { accepted, nextGenerationRun, data };
   }
 
+  function beginGenerationRequest() {
+    const controller = new AbortController();
+    generationAbortRef.current = controller;
+    return controller;
+  }
+
+  function finishGenerationRequest(controller) {
+    if (generationAbortRef.current === controller) generationAbortRef.current = null;
+  }
+
+  function cancelGeneration() {
+    const controller = generationAbortRef.current;
+    if (!controller || controller.signal.aborted) return;
+    controller.abort();
+    setMessage({ type: "warning", text: "Cancelling generation. Existing drafts will remain unchanged." });
+  }
+
   async function generateInitialCampaign() {
+    const controller = beginGenerationRequest();
     setBusy(true);
     setMessage(null);
     try {
-      const generation = await requestGeneration(channels);
+      const generation = await requestGeneration(channels, controller.signal);
       if (generation.strategyBlocked) {
         setStrategyReview(generation.data.strategy_review);
         setStage("destinations");
@@ -979,9 +999,14 @@ ${extractedText}`);
           : `Campaign generated with ${data.providerUsed || provider.label}. Review and approve each destination before publishing.`,
       });
     } catch (error) {
+      if (error?.name === "AbortError") {
+        setMessage({ type: "warning", text: "Generation cancelled before completion. No campaign draft was replaced." });
+        return;
+      }
       const recovery = providerRecoveryMessage(error.providerError);
       setMessage({ type: "error", text: [error.message, recovery].filter(Boolean).join(" ") });
     } finally {
+      finishGenerationRequest(controller);
       setBusy(false);
     }
   }
@@ -995,10 +1020,11 @@ ${extractedText}`);
     }
 
     setRegenerationDialogOpen(false);
+    const controller = beginGenerationRequest();
     setBusy(true);
     setMessage(null);
     try {
-      const generation = await requestGeneration(targetChannels);
+      const generation = await requestGeneration(targetChannels, controller.signal);
       if (generation.strategyBlocked) {
         setStrategyReview(generation.data.strategy_review);
         setStage("destinations");
@@ -1035,12 +1061,21 @@ ${extractedText}`);
               : "The previous campaign version was archived and all selected destinations were regenerated.",
       });
     } catch (error) {
+      if (error?.name === "AbortError") {
+        dispatchCampaign({ type: "MARK_CHANNELS_CANCELLED", channels: targetChannels });
+        setMessage({
+          type: "warning",
+          text: "Generation cancelled. Existing drafts and edits were preserved; cancelled destinations can be retried.",
+        });
+        return;
+      }
       const recovery = providerRecoveryMessage(error.providerError);
       setMessage({
         type: "error",
         text: [error.message, recovery, "Existing drafts and edits were not changed."].filter(Boolean).join(" "),
       });
     } finally {
+      finishGenerationRequest(controller);
       setBusy(false);
     }
   }
@@ -2056,12 +2091,14 @@ async function exportZip() {
                     {(channelStates[activeChannel]?.issues || []).length > 0 && (
                       <div
                         className="draft-quality-issues"
-                        role={["needs_review", "failed"].includes(channelStates[activeChannel]?.status) ? "alert" : "status"}
+                        role={["needs_review", "failed", "cancelled"].includes(channelStates[activeChannel]?.status) ? "alert" : "status"}
                       >
                         <strong>
                           {channelStates[activeChannel]?.status === "failed"
                             ? "Generation failed"
-                            : channelStates[activeChannel]?.status === "needs_review"
+                            : channelStates[activeChannel]?.status === "cancelled"
+                              ? "Generation cancelled"
+                              : channelStates[activeChannel]?.status === "needs_review"
                               ? "Unresolved quality issues"
                               : "Generation notes"}
                         </strong>
@@ -2100,7 +2137,7 @@ async function exportZip() {
                         onClick={() => void performRegeneration(REGENERATION_POLICIES.CHANNEL, activeChannel)}
                         disabled={busy || !providerReadiness.ready}
                       >
-                        {channelStates[activeChannel]?.status === "failed" ? "Retry destination" : "Regenerate this channel"}
+                        {["failed", "cancelled"].includes(channelStates[activeChannel]?.status) ? "Retry destination" : "Regenerate this channel"}
                       </button>
                       {channelStates[activeChannel]?.edited && generatedPosts[activeChannel] && (
                         <button
@@ -2271,6 +2308,15 @@ async function exportZip() {
               <span>{provider.label}</span>
             </div>
             <div className="studio-actionbar__actions">
+              {busy && (
+                <button
+                  type="button"
+                  className="button button--outline"
+                  onClick={cancelGeneration}
+                >
+                  Cancel generation
+                </button>
+              )}
               {stage !== "source" && (
                 <button
                   type="button"
diff --git a/frontend/lib/ai/generateStudioPackage.js b/frontend/lib/ai/generateStudioPackage.js
index 3bbcc116..83573cf5 100644
--- a/frontend/lib/ai/generateStudioPackage.js
+++ b/frontend/lib/ai/generateStudioPackage.js
@@ -460,7 +460,15 @@ export async function generateStudioPackage(inputs) {
       provider: generator,
       modelOverride,
       config,
-    }), config.destinationConcurrency);
+    }), config.destinationConcurrency, { signal: config.signal });
+
+    if (config.signal?.aborted) {
+      const cancelled = new Error("Generation request was cancelled.");
+      cancelled.code = "provider_request_cancelled";
+      cancelled.status = 499;
+      throw cancelled;
+    }
+    generatedDestinations = generatedDestinations.filter(Boolean);
 
     const generatedDraftMap = Object.fromEntries(
       generatedDestinations
@@ -482,7 +490,13 @@ export async function generateStudioPackage(inputs) {
         provider: generator,
         modelOverride,
         config,
-      }), config.destinationConcurrency);
+      }), config.destinationConcurrency, { signal: config.signal });
+      if (config.signal?.aborted) {
+        const cancelled = new Error("Generation request was cancelled.");
+        cancelled.code = "provider_request_cancelled";
+        cancelled.status = 499;
+        throw cancelled;
+      }
       const replacements = new Map(revised.filter(Boolean).map((item) => [item.channel, item]));
       generatedDestinations = generatedDestinations.map((item) => replacements.get(item.channel) || item);
     }
diff --git a/frontend/lib/ai/generationConcurrency.mjs b/frontend/lib/ai/generationConcurrency.mjs
index e3734f60..6e9146e1 100644
--- a/frontend/lib/ai/generationConcurrency.mjs
+++ b/frontend/lib/ai/generationConcurrency.mjs
@@ -1,6 +1,6 @@
 export const DEFAULT_DESTINATION_CONCURRENCY = 2;
 
-export async function mapWithConcurrency(items, worker, concurrency = DEFAULT_DESTINATION_CONCURRENCY) {
+export async function mapWithConcurrency(items, worker, concurrency = DEFAULT_DESTINATION_CONCURRENCY, { signal = null } = {}) {
   const values = Array.isArray(items) ? items : [];
   if (!values.length) return [];
   if (typeof worker !== "function") throw new TypeError("mapWithConcurrency requires a worker function.");
@@ -14,6 +14,7 @@ export async function mapWithConcurrency(items, worker, concurrency = DEFAULT_DE
 
   async function runLane() {
     while (cursor < values.length) {
+      if (signal?.aborted) break;
       const index = cursor;
       cursor += 1;
       results[index] = await worker(values[index], index);
diff --git a/frontend/lib/ai/providerErrors.mjs b/frontend/lib/ai/providerErrors.mjs
index 0df4b0d8..edb90f0d 100644
--- a/frontend/lib/ai/providerErrors.mjs
+++ b/frontend/lib/ai/providerErrors.mjs
@@ -6,6 +6,7 @@ const SAFE_CODES = Object.freeze({
   QUOTA_EXCEEDED: "provider_quota_exceeded",
   PAYMENT_REQUIRED: "provider_payment_required",
   TIMEOUT: "provider_timeout",
+  CANCELLED: "provider_request_cancelled",
   UNAVAILABLE: "provider_unavailable",
   MALFORMED_RESPONSE: "provider_malformed_response",
   EMPTY_RESPONSE: "provider_empty_response",
@@ -35,6 +36,9 @@ function classify(error) {
   if (error?.code === "provider_empty_response") {
     return { code: SAFE_CODES.EMPTY_RESPONSE, retryable: true, action: "retry_destination" };
   }
+  if (error?.code === "provider_request_cancelled") {
+    return { code: SAFE_CODES.CANCELLED, retryable: true, action: "retry_destination" };
+  }
   if (error?.name === "AbortError" || /timed?\s*out|timeout/.test(message)) {
     return { code: SAFE_CODES.TIMEOUT, retryable: true, action: "retry_destination" };
   }
@@ -81,6 +85,7 @@ function safeMessage(code, provider) {
     case SAFE_CODES.QUOTA_EXCEEDED: return `${label} reports that the current quota is exhausted.`;
     case SAFE_CODES.PAYMENT_REQUIRED: return `${label} requires billing or credits before generation can continue.`;
     case SAFE_CODES.TIMEOUT: return `${label} did not respond within the request limit.`;
+    case SAFE_CODES.CANCELLED: return "Generation was cancelled before the provider request completed.";
     case SAFE_CODES.UNAVAILABLE: return `${label} is temporarily unavailable.`;
     case SAFE_CODES.MALFORMED_RESPONSE: return `${label} returned a response that could not be validated as the required JSON contract.`;
     case SAFE_CODES.EMPTY_RESPONSE: return `${label} returned no usable model output.`;
diff --git a/frontend/lib/ai/providers/claude.js b/frontend/lib/ai/providers/claude.js
index 983f3f9f..47509348 100644
--- a/frontend/lib/ai/providers/claude.js
+++ b/frontend/lib/ai/providers/claude.js
@@ -1,4 +1,5 @@
 import { PROVIDERS, getProviderApiKey } from "../types";
+import { createLinkedAbort, cancelledProviderRequestError } from "../requestAbort.mjs";
 
 /**
  * Calls Anthropic Claude completions API.
@@ -30,8 +31,7 @@ export async function generateClaude(prompt, modelOverride = null, config = {})
     temperature: 0.2
   };
 
-  const controller = new AbortController();
-  const timeoutId = setTimeout(() => controller.abort(), 50000);
+  const abort = createLinkedAbort({ signal: config.signal, timeoutMs: 50_000 });
 
   let resp;
   try {
@@ -39,15 +39,16 @@ export async function generateClaude(prompt, modelOverride = null, config = {})
       method: "POST",
       headers,
       body: JSON.stringify(body),
-      signal: controller.signal
+      signal: abort.signal
     });
   } catch (err) {
     if (err.name === "AbortError") {
+      if (abort.cancelled()) throw cancelledProviderRequestError();
       throw new Error("Request to Anthropic Claude API timed out after 50 seconds.");
     }
     throw err;
   } finally {
-    clearTimeout(timeoutId);
+    abort.cleanup();
   }
 
   if (!resp.ok) {
diff --git a/frontend/lib/ai/providers/customOpenAI.js b/frontend/lib/ai/providers/customOpenAI.js
index fb219300..98329b66 100644
--- a/frontend/lib/ai/providers/customOpenAI.js
+++ b/frontend/lib/ai/providers/customOpenAI.js
@@ -1,4 +1,5 @@
 import { PROVIDERS, getProviderApiKey } from "../types";
+import { createLinkedAbort, cancelledProviderRequestError } from "../requestAbort.mjs";
 
 /**
  * Calls a custom user-configured OpenAI-compatible completions gateway.
@@ -36,8 +37,7 @@ export async function generateCustomOpenAI(prompt, modelOverride = null, config
     temperature: 0.2
   };
 
-  const controller = new AbortController();
-  const timeoutId = setTimeout(() => controller.abort(), 50000);
+  const abort = createLinkedAbort({ signal: config.signal, timeoutMs: 50_000 });
 
   let resp;
   try {
@@ -45,15 +45,16 @@ export async function generateCustomOpenAI(prompt, modelOverride = null, config
       method: "POST",
       headers,
       body: JSON.stringify(body),
-      signal: controller.signal
+      signal: abort.signal
     });
   } catch (err) {
     if (err.name === "AbortError") {
+      if (abort.cancelled()) throw cancelledProviderRequestError();
       throw new Error("Request to custom OpenAI API timed out after 50 seconds.");
     }
     throw err;
   } finally {
-    clearTimeout(timeoutId);
+    abort.cleanup();
   }
 
   if (!resp.ok) {
diff --git a/frontend/lib/ai/providers/gemini.js b/frontend/lib/ai/providers/gemini.js
index a42746a3..a7c8f61a 100644
--- a/frontend/lib/ai/providers/gemini.js
+++ b/frontend/lib/ai/providers/gemini.js
@@ -1,4 +1,5 @@
 import { PROVIDERS, getProviderApiKey } from "../types";
+import { createLinkedAbort, cancelledProviderRequestError } from "../requestAbort.mjs";
 
 /**
  * Calls Google Gemini REST API.
@@ -13,7 +14,7 @@ export async function generateGemini(prompt, modelOverride = null, config = {})
 
   // Attempt generating JSON response first
   try {
-    return await makeGeminiRequest(prompt, model, apiKey, true, config.maxTokens);
+    return await makeGeminiRequest(prompt, model, apiKey, true, config.maxTokens, config.signal);
   } catch (jsonErr) {
     const errorMsg = jsonErr.message || "";
     // If the error message suggests responseMimeType is not supported, or it is a 400 parameter error, retry in text mode
@@ -25,7 +26,7 @@ export async function generateGemini(prompt, modelOverride = null, config = {})
       errorMsg.includes("400")
     ) {
       try {
-        return await makeGeminiRequest(prompt, model, apiKey, false, config.maxTokens);
+        return await makeGeminiRequest(prompt, model, apiKey, false, config.maxTokens, config.signal);
       } catch (textErr) {
         throw new Error(`Gemini request failed: ${textErr.message}`);
       }
@@ -34,7 +35,7 @@ export async function generateGemini(prompt, modelOverride = null, config = {})
   }
 }
 
-async function makeGeminiRequest(prompt, model, apiKey, useJsonMode, maxTokens) {
+async function makeGeminiRequest(prompt, model, apiKey, useJsonMode, maxTokens, signal = null) {
   const url = `https://generativelanguage.googleapis.com/v1beta/models/${model}:generateContent?key=${apiKey}`;
 
   const body = {
@@ -57,8 +58,7 @@ async function makeGeminiRequest(prompt, model, apiKey, useJsonMode, maxTokens)
     body.generationConfig.responseMimeType = "application/json";
   }
 
-  const controller = new AbortController();
-  const timeoutId = setTimeout(() => controller.abort(), 50000);
+  const abort = createLinkedAbort({ signal, timeoutMs: 50_000 });
 
   let resp;
   try {
@@ -68,15 +68,16 @@ async function makeGeminiRequest(prompt, model, apiKey, useJsonMode, maxTokens)
         "Content-Type": "application/json"
       },
       body: JSON.stringify(body),
-      signal: controller.signal
+      signal: abort.signal
     });
   } catch (err) {
     if (err.name === "AbortError") {
+      if (abort.cancelled()) throw cancelledProviderRequestError();
       throw new Error("Request to Gemini API timed out after 50 seconds.");
     }
     throw err;
   } finally {
-    clearTimeout(timeoutId);
+    abort.cleanup();
   }
 
   if (!resp.ok) {
diff --git a/frontend/lib/ai/providers/groq.js b/frontend/lib/ai/providers/groq.js
index b798c0a1..cac3f76f 100644
--- a/frontend/lib/ai/providers/groq.js
+++ b/frontend/lib/ai/providers/groq.js
@@ -1,4 +1,5 @@
 import { PROVIDERS, getProviderApiKey } from "../types";
+import { createLinkedAbort, cancelledProviderRequestError } from "../requestAbort.mjs";
 
 /**
  * Calls Groq Cloud chat completion endpoint.
@@ -27,8 +28,7 @@ export async function generateGroq(prompt, modelOverride = null, config = {}) {
     temperature: 0.2
   };
 
-  const controller = new AbortController();
-  const timeoutId = setTimeout(() => controller.abort(), 50000);
+  const abort = createLinkedAbort({ signal: config.signal, timeoutMs: 50_000 });
 
   let resp;
   try {
@@ -39,15 +39,16 @@ export async function generateGroq(prompt, modelOverride = null, config = {}) {
         Authorization: `Bearer ${apiKey}`
       },
       body: JSON.stringify(body),
-      signal: controller.signal
+      signal: abort.signal
     });
   } catch (err) {
     if (err.name === "AbortError") {
+      if (abort.cancelled()) throw cancelledProviderRequestError();
       throw new Error("Request to Groq API timed out after 50 seconds.");
     }
     throw err;
   } finally {
-    clearTimeout(timeoutId);
+    abort.cleanup();
   }
 
   if (!resp.ok) {
diff --git a/frontend/lib/ai/providers/lmstudio.js b/frontend/lib/ai/providers/lmstudio.js
index fe124d8b..a7ee1c27 100644
--- a/frontend/lib/ai/providers/lmstudio.js
+++ b/frontend/lib/ai/providers/lmstudio.js
@@ -1,4 +1,5 @@
 import { PROVIDERS } from "../types";
+import { createLinkedAbort, cancelledProviderRequestError } from "../requestAbort.mjs";
 
 /**
  * Calls local LM Studio chat completions endpoint.
@@ -25,8 +26,7 @@ export async function generateLMStudio(prompt, modelOverride = null, config = {}
     temperature: 0.2
   };
 
-  const controller = new AbortController();
-  const timeoutId = setTimeout(() => controller.abort(), 55000);
+  const abort = createLinkedAbort({ signal: config.signal, timeoutMs: 55_000 });
 
   try {
     const resp = await fetch(url, {
@@ -35,7 +35,7 @@ export async function generateLMStudio(prompt, modelOverride = null, config = {}
         "Content-Type": "application/json"
       },
       body: JSON.stringify(body),
-      signal: controller.signal
+      signal: abort.signal
     });
 
     if (!resp.ok) {
@@ -53,10 +53,11 @@ export async function generateLMStudio(prompt, modelOverride = null, config = {}
     return rawText;
   } catch (err) {
     if (err.name === "AbortError") {
+      if (abort.cancelled()) throw cancelledProviderRequestError();
       throw new Error("Local LM Studio generation timed out after 55 seconds.");
     }
     throw err;
   } finally {
-    clearTimeout(timeoutId);
+    abort.cleanup();
   }
 }
diff --git a/frontend/lib/ai/providers/ollama.js b/frontend/lib/ai/providers/ollama.js
index 75c94be6..cbf80f24 100644
--- a/frontend/lib/ai/providers/ollama.js
+++ b/frontend/lib/ai/providers/ollama.js
@@ -1,4 +1,5 @@
 import { PROVIDERS } from "../types";
+import { createLinkedAbort, cancelledProviderRequestError } from "../requestAbort.mjs";
 
 /**
  * Calls local Ollama chat completions endpoint.
@@ -25,8 +26,7 @@ export async function generateOllama(prompt, modelOverride = null, config = {})
     temperature: 0.2
   };
 
-  const controller = new AbortController();
-  const timeoutId = setTimeout(() => controller.abort(), 55000);
+  const abort = createLinkedAbort({ signal: config.signal, timeoutMs: 55_000 });
 
   try {
     const resp = await fetch(url, {
@@ -35,7 +35,7 @@ export async function generateOllama(prompt, modelOverride = null, config = {})
         "Content-Type": "application/json"
       },
       body: JSON.stringify(body),
-      signal: controller.signal
+      signal: abort.signal
     });
 
     if (!resp.ok) {
@@ -53,10 +53,11 @@ export async function generateOllama(prompt, modelOverride = null, config = {})
     return rawText;
   } catch (err) {
     if (err.name === "AbortError") {
+      if (abort.cancelled()) throw cancelledProviderRequestError();
       throw new Error("Local Ollama generation timed out after 55 seconds.");
     }
     throw err;
   } finally {
-    clearTimeout(timeoutId);
+    abort.cleanup();
   }
 }
diff --git a/frontend/lib/ai/providers/openai.js b/frontend/lib/ai/providers/openai.js
index 4c4ed988..12325eb0 100644
--- a/frontend/lib/ai/providers/openai.js
+++ b/frontend/lib/ai/providers/openai.js
@@ -1,4 +1,5 @@
 import { PROVIDERS, getProviderApiKey } from "../types";
+import { createLinkedAbort, cancelledProviderRequestError } from "../requestAbort.mjs";
 
 /**
  * Calls official OpenAI completions API.
@@ -34,8 +35,7 @@ export async function generateOpenAI(prompt, modelOverride = null, config = {})
     body.response_format = { type: "json_object" };
   }
 
-  const controller = new AbortController();
-  const timeoutId = setTimeout(() => controller.abort(), 50000);
+  const abort = createLinkedAbort({ signal: config.signal, timeoutMs: 50_000 });
 
   let resp;
   try {
@@ -43,15 +43,16 @@ export async function generateOpenAI(prompt, modelOverride = null, config = {})
       method: "POST",
       headers,
       body: JSON.stringify(body),
-      signal: controller.signal
+      signal: abort.signal
     });
   } catch (err) {
     if (err.name === "AbortError") {
+      if (abort.cancelled()) throw cancelledProviderRequestError();
       throw new Error("Request to OpenAI API timed out after 50 seconds.");
     }
     throw err;
   } finally {
-    clearTimeout(timeoutId);
+    abort.cleanup();
   }
 
   if (!resp.ok) {
diff --git a/frontend/lib/ai/providers/openrouter.js b/frontend/lib/ai/providers/openrouter.js
index ce2b694c..232c50d6 100644
--- a/frontend/lib/ai/providers/openrouter.js
+++ b/frontend/lib/ai/providers/openrouter.js
@@ -1,4 +1,5 @@
 import { PROVIDERS, getProviderApiKey } from "../types";
+import { createLinkedAbort, cancelledProviderRequestError } from "../requestAbort.mjs";
 
 /**
  * Calls OpenRouter chat completions endpoint.
@@ -27,8 +28,7 @@ export async function generateOpenRouter(prompt, modelOverride = null, config =
     temperature: 0.2
   };
 
-  const controller = new AbortController();
-  const timeoutId = setTimeout(() => controller.abort(), 50000);
+  const abort = createLinkedAbort({ signal: config.signal, timeoutMs: 50_000 });
 
   let resp;
   try {
@@ -41,15 +41,16 @@ export async function generateOpenRouter(prompt, modelOverride = null, config =
         "X-Title": "SignalFlow Studio"
       },
       body: JSON.stringify(body),
-      signal: controller.signal
+      signal: abort.signal
     });
   } catch (err) {
     if (err.name === "AbortError") {
+      if (abort.cancelled()) throw cancelledProviderRequestError();
       throw new Error("Request to OpenRouter API timed out after 50 seconds.");
     }
     throw err;
   } finally {
-    clearTimeout(timeoutId);
+    abort.cleanup();
   }
 
   if (!resp.ok) {
diff --git a/frontend/lib/ai/providers/vercelGateway.js b/frontend/lib/ai/providers/vercelGateway.js
index 00f64d60..cba4b282 100644
--- a/frontend/lib/ai/providers/vercelGateway.js
+++ b/frontend/lib/ai/providers/vercelGateway.js
@@ -1,4 +1,5 @@
 import { PROVIDERS, getProviderApiKey } from "../types.js";
+import { createLinkedAbort, cancelledProviderRequestError } from "../requestAbort.mjs";
 
 const GATEWAY_URL = "https://ai-gateway.vercel.sh/v1/chat/completions";
 
@@ -38,8 +39,7 @@ export async function generateVercelGateway(prompt, modelOverride = null, config
     throw gatewayError("vercel_gateway_fetch_unavailable", "Vercel AI Gateway requires fetch().", 500);
   }
 
-  const controller = new AbortController();
-  const timeoutId = setTimeout(() => controller.abort(), 50_000);
+  const abort = createLinkedAbort({ signal: config.signal, timeoutMs: 50_000 });
   let response;
   try {
     response = await fetchImpl(GATEWAY_URL, {
@@ -58,17 +58,18 @@ export async function generateVercelGateway(prompt, modelOverride = null, config
         temperature: 0.2,
         stream: false,
       }),
-      signal: controller.signal,
+      signal: abort.signal,
       cache: "no-store",
     });
   } catch (error) {
     if (error?.name === "AbortError") {
+      if (abort.cancelled()) throw cancelledProviderRequestError();
       throw gatewayError("vercel_gateway_timeout", "Vercel AI Gateway timed out after 50 seconds.", 504);
     }
     if (error?.code) throw error;
     throw gatewayError("vercel_gateway_request_error", "Vercel AI Gateway request failed before receiving a response.", 502);
   } finally {
-    clearTimeout(timeoutId);
+    abort.cleanup();
   }
 
   if (!response.ok) {
diff --git a/frontend/lib/ai/requestAbort.mjs b/frontend/lib/ai/requestAbort.mjs
new file mode 100644
index 00000000..e6f121d5
--- /dev/null
+++ b/frontend/lib/ai/requestAbort.mjs
@@ -0,0 +1,37 @@
+export function createLinkedAbort({ signal = null, timeoutMs = 50_000 } = {}) {
+  const controller = new AbortController();
+  let timedOut = false;
+
+  const abortFromCaller = () => {
+    if (!controller.signal.aborted) controller.abort();
+  };
+
+  if (signal?.aborted) {
+    abortFromCaller();
+  } else if (signal?.addEventListener) {
+    signal.addEventListener("abort", abortFromCaller, { once: true });
+  }
+
+  const timeoutId = setTimeout(() => {
+    timedOut = true;
+    if (!controller.signal.aborted) controller.abort();
+  }, Math.max(1, Number(timeoutMs) || 50_000));
+
+  return Object.freeze({
+    signal: controller.signal,
+    cancelled: () => Boolean(signal?.aborted && !timedOut),
+    timedOut: () => timedOut,
+    cleanup() {
+      clearTimeout(timeoutId);
+      if (signal?.removeEventListener) signal.removeEventListener("abort", abortFromCaller);
+    },
+  });
+}
+
+export function cancelledProviderRequestError() {
+  const error = new Error("Generation request was cancelled.");
+  error.name = "AbortError";
+  error.code = "provider_request_cancelled";
+  error.status = 499;
+  return error;
+}
diff --git a/frontend/lib/studio/campaignState.mjs b/frontend/lib/studio/campaignState.mjs
index 27625d39..84e21770 100644
--- a/frontend/lib/studio/campaignState.mjs
+++ b/frontend/lib/studio/campaignState.mjs
@@ -215,6 +215,31 @@ export function campaignReducer(state, action) {
       };
     }
 
+    case "MARK_CHANNELS_CANCELLED": {
+      const channels = Array.from(new Set((Array.isArray(action.channels) ? action.channels : [])
+        .map((channel) => String(channel || "").trim())
+        .filter(Boolean)));
+      if (!channels.length) return state;
+      const nextChannelStates = { ...state.channelStates };
+      let changed = false;
+      for (const channel of channels) {
+        const previous = nextChannelStates[channel] || {};
+        nextChannelStates[channel] = {
+          ...previous,
+          status: "cancelled",
+          qualityStatus: "needs_review",
+          approved: false,
+          qualityRiskAccepted: false,
+          issues: Array.from(new Set([...(previous.issues || []), "Generation was cancelled. Existing draft content was preserved."])),
+          issueCodes: Array.from(new Set([...(previous.issueCodes || []), "generation_cancelled"])),
+        };
+        changed = true;
+      }
+      return changed
+        ? { ...state, channelStates: nextChannelStates, revision: state.revision + 1 }
+        : state;
+    }
+
     case "RESTORE_GENERATED": {
       const channel = String(action.channel || "").trim();
       const generated = state.generatedPosts[channel];
diff --git a/frontend/lib/studio/campaignStatus.mjs b/frontend/lib/studio/campaignStatus.mjs
index 52f5133b..2aa0296e 100644
--- a/frontend/lib/studio/campaignStatus.mjs
+++ b/frontend/lib/studio/campaignStatus.mjs
@@ -4,6 +4,7 @@ const CHANNEL_LABELS = Object.freeze({
   edited: "Edited",
   needs_review: "Needs review",
   failed: "Generation failed",
+  cancelled: "Generation cancelled",
   stale: "Source changed",
   approved: "Approved",
   empty: "No draft",
@@ -15,7 +16,8 @@ function text(value) {
 
 export function selectChannelStatus({ channelState = {}, isStale = false, content = "" } = {}) {
   let key = "generated";
-  if (!text(content) && channelState.status === "failed") key = "failed";
+  if (channelState.status === "cancelled") key = "cancelled";
+  else if (!text(content) && channelState.status === "failed") key = "failed";
   else if (!text(content)) key = "empty";
   else if (isStale) key = "stale";
   else if (channelState.status === "failed") key = "failed";
@@ -27,7 +29,7 @@ export function selectChannelStatus({ channelState = {}, isStale = false, conten
   return {
     key,
     label: CHANNEL_LABELS[key],
-    isBlocked: ["failed", "stale", "empty"].includes(key),
+    isBlocked: ["failed", "cancelled", "stale", "empty"].includes(key),
     isApproved: Boolean(channelState.approved),
     isEdited: Boolean(channelState.edited),
   };
@@ -64,7 +66,8 @@ export function selectCampaignStatus({
   const editedCount = channelEntries.filter((item) => item.isEdited).length;
   const approvedCount = channelEntries.filter((item) => item.isApproved).length;
   const failedCount = channelEntries.filter((item) => item.key === "failed").length;
-  const needsReviewCount = channelEntries.filter((item) => !item.isApproved && ["generated", "regenerated", "needs_review", "edited"].includes(item.key)).length;
+  const cancelledCount = channelEntries.filter((item) => item.key === "cancelled").length;
+  const needsReviewCount = channelEntries.filter((item) => !item.isApproved && ["generated", "regenerated", "needs_review", "edited", "cancelled"].includes(item.key)).length;
 
   let campaignKey = "not_generated";
   let campaignLabel = "Not generated";
@@ -93,6 +96,7 @@ export function selectCampaignStatus({
     editedCount,
     approvedCount,
     failedCount,
+    cancelledCount,
     needsReviewCount,
     hasEditedDrafts: editedCount > 0,
     copyBlockedReason: isStale
@@ -117,6 +121,7 @@ export function selectPublishAvailability({
   if (isStale) return { ready: false, reason: "Source inputs changed. Regenerate before publishing." };
   if (!hasContent) return { ready: false, reason: "This destination has no usable draft." };
   if (channelStatus?.key === "failed") return { ready: false, reason: "Generation failed for this destination. Regenerate it before publishing." };
+  if (channelStatus?.key === "cancelled") return { ready: false, reason: "Generation was cancelled for this destination. Retry it before publishing." };
   if (!channelStatus?.isApproved) return { ready: false, reason: "Mark this draft approved before publishing or opening its handoff." };
   if (isOverLimit) return { ready: false, reason: "This draft exceeds the destination character guide." };
   if (!connectorReady && !manualRoute) return { ready: false, reason: "Connect the destination or use an available manual handoff." };
diff --git a/frontend/tests/generationQualityContracts.test.mjs b/frontend/tests/generationQualityContracts.test.mjs
index 06aa1d5f..26ae2d16 100644
--- a/frontend/tests/generationQualityContracts.test.mjs
+++ b/frontend/tests/generationQualityContracts.test.mjs
@@ -15,6 +15,7 @@ import {
   duplicateRevisionTargets,
 } from "../lib/ai/crossChannelQuality.mjs";
 import { mapWithConcurrency } from "../lib/ai/generationConcurrency.mjs";
+import { createLinkedAbort } from "../lib/ai/requestAbort.mjs";
 import {
   PROVIDER_ERROR_CODES,
   malformedProviderResponse,
@@ -193,6 +194,31 @@ test("destination concurrency stays bounded and preserves input ordering", async
   assert.deepEqual(result, [10, 20, 30, 40, 50]);
 });
 
+test("destination queue stops starting new work after cancellation", async () => {
+  const controller = new AbortController();
+  const started = [];
+  await mapWithConcurrency([1, 2, 3, 4, 5, 6], async (value) => {
+    started.push(value);
+    if (value === 1) controller.abort();
+    await new Promise((resolve) => setTimeout(resolve, 5));
+    return value;
+  }, 2, { signal: controller.signal });
+
+  assert.ok(started.length <= 2, `started ${started.length} tasks after cancellation`);
+  assert.ok(started.includes(1));
+});
+
+test("linked provider abort distinguishes caller cancellation from timeout", async () => {
+  const controller = new AbortController();
+  const linked = createLinkedAbort({ signal: controller.signal, timeoutMs: 5_000 });
+  controller.abort();
+  await Promise.resolve();
+  assert.equal(linked.signal.aborted, true);
+  assert.equal(linked.cancelled(), true);
+  assert.equal(linked.timedOut(), false);
+  linked.cleanup();
+});
+
 test("provider failures normalize into safe actionable recovery contracts", () => {
   const cases = [
     [{ status: 401, message: "invalid api key sk-secret" }, PROVIDER_ERROR_CODES.INVALID_CREDENTIALS, false, "replace_key"],
@@ -344,7 +370,7 @@ test("failed destinations expose an isolated retry path without touching success
   const page = await readFile(new URL("../app/page.js", import.meta.url), "utf8");
   assert.match(page, /\? "Generation failed"/);
   assert.match(page, /\? "Retry destination" : "Regenerate this channel"/);
-  assert.match(page, /\["needs_review", "failed"\]\.includes\(channelStates\[activeChannel\]\?\.status\) \? "alert" : "status"/);
+  assert.match(page, /\["needs_review", "failed", "cancelled"\]\.includes\(channelStates\[activeChannel\]\?\.status\) \? "alert" : "status"/);
 
   const targets = regenerationTargets({
     policy: REGENERATION_POLICIES.CHANNEL,
@@ -358,3 +384,64 @@ test("failed destinations expose an isolated retry path without touching success
   });
   assert.deepEqual(targets, ["x"]);
 });
+
+
+test("generation cancellation is propagated through API, providers, UI, and campaign state", async () => {
+  const routeSource = await readFile(new URL("../app/api/launch_kit/route.js", import.meta.url), "utf8");
+  const packageSource = await readFile(new URL("../lib/ai/generateStudioPackage.js", import.meta.url), "utf8");
+  const pageSource = await readFile(new URL("../app/page.js", import.meta.url), "utf8");
+  const providerPaths = [
+    "../lib/ai/providers/openai.js",
+    "../lib/ai/providers/claude.js",
+    "../lib/ai/providers/gemini.js",
+    "../lib/ai/providers/groq.js",
+    "../lib/ai/providers/openrouter.js",
+    "../lib/ai/providers/customOpenAI.js",
+    "../lib/ai/providers/ollama.js",
+    "../lib/ai/providers/lmstudio.js",
+    "../lib/ai/providers/vercelGateway.js",
+  ];
+
+  assert.match(routeSource, /signal: request\.signal/);
+  assert.match(packageSource, /\{ signal: config\.signal \}/);
+  assert.match(pageSource, /Cancel generation/);
+  assert.match(pageSource, /MARK_CHANNELS_CANCELLED/);
+
+  for (const providerPath of providerPaths) {
+    const providerSource = await readFile(new URL(providerPath, import.meta.url), "utf8");
+    assert.match(providerSource, /createLinkedAbort/);
+    assert.match(providerSource, /abort\.cancelled\(\)/);
+  }
+
+  let state = campaignReducer(createInitialCampaignState(), {
+    type: "ACCEPT_GENERATION",
+    payload: {
+      posts: { linkedin: "Existing draft" },
+      requestedChannels: ["linkedin"],
+      result: { generation_status: { linkedin: { status: "generated", qualityStatus: "complete" } } },
+      generationRun: { generationRunId: "run-before-cancel" },
+      activeChannel: "linkedin",
+    },
+  });
+  state = campaignReducer(state, { type: "MARK_CHANNELS_CANCELLED", channels: ["linkedin"] });
+  assert.equal(state.posts.linkedin, "Existing draft");
+  assert.equal(state.channelStates.linkedin.status, "cancelled");
+  assert.equal(state.channelStates.linkedin.qualityStatus, "needs_review");
+  assert.equal(state.channelStates.linkedin.approved, false);
+  assert.ok(state.channelStates.linkedin.issueCodes.includes("generation_cancelled"));
+});
+
+test("provider cancellation keeps a distinct safe error class", () => {
+  const error = new Error("cancelled");
+  error.name = "AbortError";
+  error.code = "provider_request_cancelled";
+  error.status = 499;
+  const normalized = providerErrorPayload(normalizeProviderError(error, {
+    provider: "test-provider",
+    model: "test-model",
+  }));
+  assert.equal(normalized.code, PROVIDER_ERROR_CODES.CANCELLED);
+  assert.equal(normalized.retryable, true);
+  assert.equal(normalized.recoveryAction, "retry_destination");
+  assert.equal(normalized.httpStatus, 499);
+});