@@ -614,9 +614,10 @@ Effects and music are read from stems. At `--quality best` the
 recording is separated into vocals, drums, bass, guitar, piano and other by
 HeyGen's `/v3/audio/stems`, with your HeyGen credential (see
 [audio services](#audio-services)): it is uploaded as 192 kb/s MP3 through the
-same origin's direct-upload endpoints, `POST` starts a job, and `GET <url>/<id>`
-is polled until the stems are ready (`HYPERFRAMES_AUDIO_STEMS_TIMEOUT_MS`, 30
-minutes by default). Effects are read
+same origin's direct-upload endpoints. The separation request waits for the
+stems; an in-progress response or dropped connection retries the same request
+with the same idempotency key (`HYPERFRAMES_AUDIO_STEMS_TIMEOUT_MS`, 30 minutes
+by default). Effects are read
 from the drums stem and the music from the other four. Without stems, effects are
 read from the mix outside speech and the music is not read; with neither stems nor
 a transcript, voice and effects are not read either, because the mix alone does
 
@@ -47,9 +47,9 @@ const bed = (t: number) =>
 let server: Server;
 let stalledPath: string | null = null;
 let onStalled = () => {};
-let polls = 0;
 let stemCalls = 0;
 let stemRequest: unknown = null;
+const stemKeys: unknown[] = [];
 const stemFiles: Record<string, string> = {};
 
 async function body(req: IncomingMessage) {
@@ -74,10 +74,9 @@ const routes = new Map<string, (reply: Reply, req: IncomingMessage, bytes: Buffe
       expect(req.headers["x-api-key"]).toBe("test-key");
       stemCalls++;
       stemRequest = JSON.parse(bytes.toString());
-      reply(202, { data: { id: "job-1", status: "processing" } });
-    },
-    "GET /v3/audio/stems/job-1": (reply) => {
-      polls++;
+      stemKeys.push(req.headers["idempotency-key"]);
+      if (stemCalls === 1)
+        return reply(409, { error: { code: "request_in_progress", message: "Retry shortly." } });
       reply(200, {
         data: {
           id: "job-1",
@@ -179,7 +178,8 @@ describe.skipIf(!ffmpeg)("readAudio", () => {
       quality: "best",
     });
     expect(stemRequest).toEqual({ version: 1, audio: { type: "asset_id", asset_id: "episode" } });
-    expect(polls).toBe(1);
+    expect(stemKeys).toHaveLength(2);
+    expect(stemKeys[1]).toBe(stemKeys[0]);
     expect(analysis).toMatchObject({
       separation: "stems",
       stems: ["bass", "drums", "guitar", "other", "piano", "vocals"],
@@ -195,7 +195,7 @@ describe.skipIf(!ffmpeg)("readAudio", () => {
     expect(readFileSync(textPath, "utf8")).toContain("effect  boom (S1): low");
     expect(existsSync(join(cacheDir, "stems"))).toBe(true);
     await readAudio(path, "episode.wav", { cacheDir, quality: "best" });
-    expect(stemCalls).toBe(1);
+    expect(stemCalls).toBe(2);
   });
 
   it("falls back on partial stems and retries instead of caching unmeasured layers as silence", async () => {
 
@@ -16,29 +16,24 @@ import {
 } from "../analysis/providers/shared.js";
 
 /**
- * The stem separation service contract.
- *
- * Request: `POST /v3/audio/stems` on the HeyGen API with the CLI's HeyGen credential, or `POST
- * <HYPERFRAMES_AUDIO_STEMS_URL>` with `x-api-key: <HYPERFRAMES_AUDIO_API_KEY>`; a new `Idempotency-Key`, and
- * `{ version: 1, audio: { type: "asset_id", asset_id } }`. The recording is uploaded
- * first as 192 kb/s stereo MP3 through the same origin's asset direct-upload routes.
- *
- * Response: `{ data: StemsJob }`, or a bare `StemsJob`. While `status` is `pending` or `processing`,
- * `GET <that url>/<id>` returns the job again. A `completed` job lists one URL per stem;
- * the names are vocals, drums, bass, guitar, piano and other.
+ * Upload 192 kb/s stereo MP3 through the service origin's direct-upload routes, then POST
+ * `{ version: 1, audio: { type: "asset_id", asset_id } }` with one Idempotency-Key.
+ * A completed response wraps StemsJob in `data`. Retry 409 `request_in_progress` or a dropped
+ * connection with the same key and body; other HTTP errors carry `{ error: { code, message } }`.
+ * A complete separation contains vocals, drums, bass, guitar, piano and other.
  */
 interface StemsJob {
   id: string;
-  status: "pending" | "processing" | "completed" | "failed";
+  status: "pending" | "completed" | "failed";
   stems?: { name: string; url: string }[];
-  error?: { message?: string };
+  failure_message?: string;
 }
 
 const URL_ENV = "HYPERFRAMES_AUDIO_STEMS_URL";
 const KEY_ENV = "HYPERFRAMES_AUDIO_API_KEY";
 const TIMEOUT_ENV = "HYPERFRAMES_AUDIO_STEMS_TIMEOUT_MS";
 const DEFAULT_TIMEOUT_MS = 30 * 60_000;
-const POLL_MS = 5000;
+const RETRY_MS = 5000;
 const DONE = "stems.json";
 const STEM_NAMES = ["vocals", "drums", "bass", "guitar", "piano", "other"] as const;
 
@@ -63,7 +58,25 @@ export function cachedStems(dir: string): Record<string, string> | null {
   return Object.values(paths).every((p) => existsSync(p)) ? paths : null;
 }
 
+class StillRunning extends Error {}
+
+const DROPPED = new Set(["UND_ERR_HEADERS_TIMEOUT", "UND_ERR_SOCKET"]);
+
+const dropped = (error: unknown) =>
+  error instanceof TypeError &&
+  DROPPED.has((error.cause as { code?: string } | undefined)?.code ?? "");
+
+async function stillRunning(response: Response): Promise<boolean> {
+  if (response.status !== 409) return false;
+  const body = (await response
+    .clone()
+    .json()
+    .catch(() => null)) as { error?: { code?: string } } | null;
+  return body?.error?.code === "request_in_progress";
+}
+
 async function job(response: Response): Promise<StemsJob> {
+  if (await stillRunning(response)) throw new StillRunning();
   if (!response.ok) throw await serviceFailure(response, "the stems service");
   const body = (await response.json()) as { data?: StemsJob } | StemsJob | null;
   const value = (body && "data" in body ? body.data : body) as StemsJob | undefined;
@@ -83,6 +96,21 @@ async function encoded(path: string, dir: string, signal: AbortSignal): Promise<
   return out;
 }
 
+async function separated(
+  url: string,
+  request: RequestInit,
+  signal: AbortSignal,
+): Promise<StemsJob> {
+  for (;;) {
+    try {
+      return await job(await fetch(url, { ...request, signal }));
+    } catch (error) {
+      if (!(error instanceof StillRunning || dropped(error))) throw error;
+      await sleep(RETRY_MS, undefined, { signal });
+    }
+  }
+}
+
 /** Separate the recording through the configured service and save each stem into `dir`. */
 export async function fetchStems(
   path: string,
@@ -107,32 +135,23 @@ export async function fetchStems(
       idempotencyKey: randomUUID(),
       signal,
     });
-    let current = await job(
-      await fetch(url, {
+    const current = await separated(
+      url,
+      {
         method: "POST",
-        signal,
         redirect: "error",
         headers: {
           ...headers,
           "idempotency-key": randomUUID(),
           "content-type": "application/json",
         },
         body: JSON.stringify({ version: 1, audio: { type: "asset_id", asset_id: asset.asset_id } }),
-      }),
+      },
+      signal,
     );
-    while (current.status === "pending" || current.status === "processing") {
-      await sleep(POLL_MS, undefined, { signal });
-      current = await job(
-        await fetch(`${url.replace(/\/$/, "")}/${encodeURIComponent(current.id)}`, {
-          redirect: "error",
-          headers,
-          signal,
-        }),
-      );
-    }
     if (current.status !== "completed")
       throw new Error(
-        `stem separation failed${current.error?.message ? `: ${current.error.message}` : ""}`,
+        `stem separation failed${current.failure_message ? `: ${current.failure_message}` : ""}`,
       );
     const stems = current.stems ?? [];
     const missing = STEM_NAMES.filter((name) => !stems.some((stem) => stem.name === name));