diff --git a/app/api/jobs.py b/app/api/jobs.py
index c27775fd..ef852a66 100644
--- a/app/api/jobs.py
+++ b/app/api/jobs.py
@@ -419,6 +419,133 @@ def _write_vocal_split_error(stems_dir: Path, cause: str, tail: list[str]) -> No
         logger.warning("could not write vocal_split_error.txt in %s", stems_dir, exc_info=True)
 
 
+class ResplitBody(BaseModel):
+    """Which stems the new run should mix down to. Same shape the importer
+    takes, and bounded the same way: unknown names are dropped rather than
+    trusted, and an empty result falls back to every stem."""
+
+    stems: list[str] = Field(default_factory=list, max_length=len(STEM_NAMES))
+
+
+def _retained_source(job_id: str) -> Path | None:
+    """The upload kept beside a finished job, if there is one.
+
+    Only uploads have this. A link's source is deleted once its stems exist,
+    because it can be fetched again; an upload's cannot, so the runner keeps
+    it (see cleanup_source). Jobs finished before that change kept nothing,
+    which is why absence is an ordinary answer here rather than an error.
+    """
+    job_dir = (JOBS_DIR / job_id).resolve()
+    if not job_dir.is_dir() or not job_dir.is_relative_to(JOBS_DIR.resolve()):
+        return None
+    for candidate in sorted(job_dir.glob("source.*")):
+        resolved = candidate.resolve()
+        if (
+            resolved.is_file()
+            and resolved.suffix.lower() in _ALLOWED_EXTS
+            and resolved.is_relative_to(JOBS_DIR.resolve())
+        ):
+            return resolved
+    return None
+
+
+def _resplit_source_url(source_url: str | None, new_id: str) -> str:
+    """A source that names the same file without colliding with it.
+
+    The library replaces any existing track that shares a sourceUrl -- that is
+    how re-importing a link supersedes its old entry -- so a re-split reusing
+    the original's source deleted the very track it came from. Worse than
+    losing the row: the job directory stayed on disk with nothing referencing
+    it, and syncWithServer re-adopted it on the next launch as a duplicate.
+
+    Reusing the row is not an option either. Two jobs that share a source are
+    collapsed again on every launch, so the pair has to differ on disk, not
+    just in this session.
+
+    The marker goes before the extension, never after: deriveQuality reads the
+    suffix to tell a lossless WAV from a compressed MP3.
+    """
+    base = source_url or "local:track"
+    head, dot, ext = base.rpartition(".")
+    marker = new_id[:6]
+    return f"{head} ({marker}){dot}{ext}" if dot else f"{base} ({marker})"
+
+
+def _link_or_copy(src: Path, dest: Path) -> None:
+    """Hard-link the source into the new job, copying only if that fails.
+
+    A re-split of a 300 MB upload should not cost another 300 MB. Both paths
+    are inside JOBS_DIR so a link is normally available; os.link raises
+    EXDEV across filesystems and EPERM on some mounts, and a copy is correct
+    in every case, just larger.
+    """
+    try:
+        os.link(src, dest)
+    except OSError:
+        shutil.copy2(src, dest)
+
+
+@router.post("/{job_id}/resplit")
+async def resplit_job(job_id: str, body: ResplitBody) -> dict:
+    """Separate a finished upload again, from the source kept beside it.
+
+    A link-sourced track has never needed this: re-importing its URL does the
+    same thing. An upload had no equivalent -- the file was handed over once,
+    and the composer has nothing to submit for it -- so changing which stems
+    you wanted meant finding the original file and uploading it a second time
+    (#635).
+
+    Produces a new job rather than mutating this one, which is exactly what
+    re-importing a link already does. The old track keeps its stems, its
+    sections and its beat grid until the person who asked for this decides
+    otherwise.
+    """
+    if not JOB_ID_RE.match(job_id):
+        raise HTTPException(status_code=404, detail="job not found")
+    job = registry_get(job_id)
+    if job is None or job.status != "done":
+        raise HTTPException(status_code=404, detail="job not found")
+
+    source = _retained_source(job_id)
+    if source is None:
+        # Not a failure of this request: the track simply has nothing to
+        # re-separate from. The UI offers re-import for anything with a URL.
+        raise HTTPException(status_code=409, detail="no source kept for this track")
+
+    selected = [s for s in body.stems if s in STEM_NAMES] or list(STEM_NAMES)
+
+    new_id = uuid.uuid4().hex[:12]
+    new_dir = JOBS_DIR / new_id
+    new_dir.mkdir(parents=True, exist_ok=True)
+    try:
+        await asyncio.to_thread(_link_or_copy, source, new_dir / f"source{source.suffix}")
+    except OSError:
+        shutil.rmtree(new_dir, ignore_errors=True)
+        logger.exception("[%s] resplit could not stage the source", job_id)
+        raise HTTPException(status_code=500, detail="could not start re-split") from None
+
+    new_job = Job(
+        id=new_id,
+        selected_stems=selected,
+        title=job.title,
+        duration_sec=job.duration_sec,
+        # Still a local: source, so this job keeps its own copy and can be
+        # re-split in turn -- but distinct, so the library shows it beside the
+        # track it came from instead of replacing it.
+        source_url=_resplit_source_url(job.source_url, new_id),
+        auto_sections=get_auto_sections(),
+    )
+    if not registry_register_if_capacity(new_job, MAX_PENDING_UPLOAD_JOBS):
+        shutil.rmtree(new_dir, ignore_errors=True)
+        raise HTTPException(status_code=503, detail=_UPLOAD_QUEUE_FULL_DETAIL)
+    jobqueue.enqueue(new_job.id)
+    registry_persist(JOBS_DIR)
+    # source_url comes back because the client cannot derive it: it is
+    # deliberately not the one it asked with, and the library keys its
+    # dedup on exactly this string.
+    return {"job_id": new_job.id, "source_url": new_job.source_url}
+
+
 @router.post("/{job_id}/vocal-split")
 async def start_vocal_split(job_id: str) -> Response:
     """Trigger the on-demand lead/backing vocal split (#275) for a completed
diff --git a/app/pipeline/collect.py b/app/pipeline/collect.py
index 8cd251bd..0b6fd1f1 100644
--- a/app/pipeline/collect.py
+++ b/app/pipeline/collect.py
@@ -74,8 +74,9 @@ def _run_ffmpeg(job: Job, cmd: list[str]) -> bool:
 def collect(job: Job, stems_root: Path, job_dir: Path) -> list[str]:
     """Move Demucs-emitted stems into the job's stems/ dir and clean up
     the demucs intermediate dir. Does NOT delete the source download --
-    cleanup_source() is called by the runner after any post-processing
-    that needs to re-encode the source (e.g. building original.wav)."""
+    cleanup_source() is called by the runner, for the jobs whose source
+    can be fetched again, after any post-processing that needs to
+    re-encode it (e.g. building original.wav)."""
     target_dir = job_dir / "stems"
     target_dir.mkdir(exist_ok=True)
     found: list[str] = []
@@ -94,7 +95,11 @@ def cleanup_source(job_dir: Path) -> None:
     """Delete the source audio file. Called after collect AND after any
     post-processing that re-encodes the source (make_original_track).
     The source is 100-300 MB, so getting rid of it is the bulk of disk
-    reclaim per job; only the stems remain."""
+    reclaim per job; only the stems remain.
+
+    Not called for uploads. The runner decides: a link can be fetched
+    again, an upload cannot, and deleting an upload's source destroys
+    the only copy StemDeck has of it."""
     for f in job_dir.glob("source.*"):
         f.unlink(missing_ok=True)
 
diff --git a/app/pipeline/runner.py b/app/pipeline/runner.py
index f4b3c6a0..d9832d3d 100644
--- a/app/pipeline/runner.py
+++ b/app/pipeline/runner.py
@@ -13,8 +13,8 @@
 from app.core.config import DEMUCS_MODEL, TIMEOUT_FFMPEG
 from app.core.models import Job, JobCancelled, _set
 from app.core.redact import redact
+from app.core.registry import is_upload, set_proc
 from app.core.registry import persist as persist_registry
-from app.core.registry import set_proc
 from app.pipeline.analyze import analyze
 from app.pipeline.beatgrid import compute_beat_grid
 from app.pipeline.collect import (
@@ -197,10 +197,16 @@ def _run_common(job: Job, source: Path, job_dir: Path) -> None:
     mark = _lap(job, "separate", mark)
     found = collect(job, stems_root, job_dir)
     stems_dir = job_dir / "stems"
-    # Source (100-300 MB or the local upload) is no longer needed after
-    # collect; delete it before the ffmpeg amix steps in case scratch space
-    # is tight.
-    cleanup_source(job_dir)
+    # Deleting the source is the bulk of disk reclaim per job, and it happens
+    # before the ffmpeg amix steps below in case scratch space is tight. But
+    # only a job that can fetch its source again is allowed to give it up.
+    #
+    # An upload is the one copy StemDeck will ever have. Throwing it away means
+    # the track can never be separated again -- not with a different model, not
+    # at all -- and the person who imported it may no longer have the file
+    # either. A link costs a re-download; an upload costs the recording.
+    if not is_upload(job):
+        cleanup_source(job_dir)
     job.stems = [{"name": name, "url": f"/api/jobs/{job.id}/stems/{name}.wav"} for name in found]
     _check_cancel(job)
     _set(job, stage="Mixing tracks...")
diff --git a/static/css/daw.css b/static/css/daw.css
index efb50bd5..5c491e68 100644
--- a/static/css/daw.css
+++ b/static/css/daw.css
@@ -163,6 +163,15 @@ input, textarea { font-family: inherit; }
   overflow: hidden;
 }
 .file-pill.hidden { display: none !important; }
+/* The loaded-track pill reports state rather than staging input, so it reads a
+   step quieter than the file pill it borrows its shape from. */
+.track-pill { opacity: 0.82; }
+/* A staged file is what the button will act on next, so it speaks for itself
+   and the loaded track stands down. Keyed off the same has-file class the file
+   pill uses, so clearing the file brings this back without any JS agreeing to
+   it. */
+.url-wrap.has-file .track-pill { display: none !important; }
+.track-pill .file-name { max-width: 220px; }
 .file-name { overflow: hidden; text-overflow: ellipsis; max-width: 140px; }
 .file-size { color: var(--muted); flex-shrink: 0; }
 .file-clear {
diff --git a/static/index.html b/static/index.html
index 2ea9c7a5..d5d25858 100644
--- a/static/index.html
+++ b/static/index.html
@@ -64,6 +64,18 @@
               <span class="file-size" id="fileSize"></span>
               <button class="file-clear" id="fileClear" type="button" aria-label="Remove file" data-i18n-aria-label="topbar.removeFile">×</button>
             </div>
+            <!-- The open track, when it is one the button acts on directly.
+                 A YouTube track shows its URL in the box because that URL is
+                 what gets submitted. An upload has nothing submittable to put
+                 there, but it still needs to say which audio the button will
+                 split, so it says it here instead of in the input. No clear
+                 button: this reports what is loaded, it does not stage it. -->
+            <div class="file-pill track-pill hidden" id="trackPill">
+              <svg viewBox="0 0 24 24" width="13" height="13" fill="none" stroke="currentColor" stroke-width="2" aria-hidden="true">
+                <path d="M9 18V5l12-2v13"/><circle cx="6" cy="18" r="3"/><circle cx="18" cy="16" r="3"/>
+              </svg>
+              <span class="file-name" id="trackPillName"></span>
+            </div>
             <button class="daw-upload-btn" type="button" title="Upload audio file" id="uploadFileBtn" aria-label="Upload audio file" data-i18n-title="topbar.uploadFile" data-i18n-aria-label="topbar.uploadFile">
               <svg width="13" height="13" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8" aria-hidden="true">
                 <path d="M12 3v12 M7 8l5-5 5 5 M5 21h14"/>
diff --git a/static/js/catalog.js b/static/js/catalog.js
index 889643b6..fb95f666 100644
--- a/static/js/catalog.js
+++ b/static/js/catalog.js
@@ -9,7 +9,7 @@ import {
   queueCount, queueRowStates, reorderQueuedJob, runningLabel, startQueue,
   startQueueStream,
 } from "./queue.js";
-import { fmtTime, storeGet, storeSet } from "./utils.js";
+import { fmtTime, isReimportableSource, storeGet, storeSet } from "./utils.js";
 import { notifyFailure, setReleasePending, dismissFailuresByJobId, dismissFailuresByKind } from "./notifications.js";
 // Aliased (not the bare "t") -- this file already uses "t"/"tr" as local
 // variable names for track objects and table rows in several scopes.
@@ -696,7 +696,7 @@ function applyStoredStemSelection(track) {
 // only path back is a fresh re-upload.
 function reimportUnavailableTrack(trackId, track) {
   updateTrackStatus(trackId, "unavailable");
-  if (track.sourceUrl && !track.sourceUrl.startsWith("local:")) {
+  if (isReimportableSource(track.sourceUrl)) {
     importFromUrl(track.sourceUrl, { title: track.title, stems: track.selectedStems });
     return;
   }
@@ -759,18 +759,73 @@ async function loadTrackIntoStudio(trackId) {
   applyStoredStemSelection(track);
   setCurrentTrack(trackId);
 
+  // The composer is an input the Split stems button submits, not a caption for
+  // the open track, so it may only ever hold something that can actually be
+  // imported. A `local:` source is a file that was uploaded once and is not
+  // reachable again; putting its bare filename here armed the button with a
+  // string that can never resolve, and pressing it POSTed "my song.mp3" as
+  // though it were a link (#635). Non-empty is also what let it through the
+  // browser's own required check.
+  //
+  // Cleared rather than left alone: whatever the previously opened track put
+  // there is still a live URL, and re-importing *that* on a click meant for
+  // this track is worse than doing nothing.
+  const importable = isReimportableSource(track.sourceUrl);
+  // A link-sourced track needs nothing new: its URL goes in the box and the
+  // button imports it again, which is what re-splitting one has always meant.
+  // An upload has no URL, so the button acts on the track itself and the
+  // server separates the source it kept beside it.
+  const resplittable = !importable && track.status === "done";
   const urlInput = document.getElementById("url");
-  if (urlInput && track.sourceUrl) {
-    urlInput.value = track.sourceUrl.startsWith("local:")
-      ? track.sourceUrl.slice(6)
-      : track.sourceUrl;
+  if (urlInput) {
+    urlInput.value = importable ? track.sourceUrl : "";
+    // `required` is the guard for "the button has nothing to act on", and it
+    // is a blunt one: the browser refuses the submit before any handler runs,
+    // so it must not be set while the button has a track to re-split. Setting
+    // it there made pressing Split stems on an upload answer "please fill out
+    // this field" instead of separating it.
+    if (importable || resplittable) urlInput.removeAttribute("required");
+    else urlInput.setAttribute("required", "");
   }
+  setResplitTarget(resplittable ? track : null);
 
   applyTrackInfoToPanel(track);
   wireUpAudio(trackId, track.audioStems, track.duration || 0, track.thumb, track.mixUrl ?? null, track.title || "", peaksPromise, track.hasVideo ?? false, track.videoStatus ?? null);
   initSections(trackId, track.sections, track.duration || 0);
 }
 
+/**
+ * Aim the Split stems button at a track rather than at the composer.
+ *
+ * Carried on the button itself rather than in a module variable so job.js can
+ * read it at submit time without the two files having to agree on an import
+ * order. Cleared with null whenever the open track is one the composer can
+ * handle on its own.
+ *
+ * The button's label does not change. What it does is the same thing it has
+ * always done -- split this track into stems -- and only where it reads the
+ * track from differs.
+ */
+export function setResplitTarget(track) {
+  const submitBtn = document.getElementById("submit");
+  if (!submitBtn) return;
+  submitBtn.dataset.resplitJob = track?.id ?? "";
+  submitBtn.dataset.resplitTitle = track?.title ?? "";
+  submitBtn.dataset.resplitSource = track?.sourceUrl ?? "";
+
+  // Say which audio the button will split. A link-sourced track answers that
+  // with the URL in the box; an upload has nothing submittable to put there,
+  // so without this the composer sat empty and there was no way to tell what
+  // pressing the button would act on.
+  const pill = document.getElementById("trackPill");
+  const pillName = document.getElementById("trackPillName");
+  if (pill && pillName) {
+    pillName.textContent = track?.title ?? "";
+    pillName.title = track?.title ?? "";
+    pill.classList.toggle("hidden", !track);
+  }
+}
+
 export function setCurrentTrack(trackId) {
   _currentTrackId = trackId;
   for (const el of document.querySelectorAll(".cat-item.active")) el.classList.remove("active");
diff --git a/static/js/job.js b/static/js/job.js
index 8ec73301..348b7231 100644
--- a/static/js/job.js
+++ b/static/js/job.js
@@ -107,7 +107,13 @@ function setSubmitProcessing(processing) {
   submitBtn.classList.toggle("loading", processing);
   document.querySelector(".strip-sq-process")?.classList.toggle("loading", processing);
   const label = submitBtn.querySelector("span");
-  if (label) label.textContent = processing ? t("job.processing") : t("job.process");
+  // Back to the label the markup ships, not a second one that only exists
+  // here. This restored t("job.process") -- "Process" -- while index.html
+  // starts the button as t("process.splitStems") -- "Split stems" -- so the
+  // first submit of a session renamed the button for good, on success as much
+  // as on failure, and nothing put it back short of a reload or a language
+  // switch (#635).
+  if (label) label.textContent = processing ? t("job.processing") : t("process.splitStems");
 }
 
 /** True when audio is loaded in the studio. Either engine counts: the Web Audio
@@ -756,9 +762,22 @@ export function wireJobForm() {
       return;
     }
 
+    // Re-splitting a finished upload. The composer is empty for one by
+    // design -- there is no URL to put in it -- so the button acts on the open
+    // track and the server separates the source it kept beside it. A staged
+    // file or a typed URL is a new import and wins, which is what lets the
+    // composer still be used while such a track is open.
+    const resplitJob = !file && !urlInput.value.trim() ? submitBtn.dataset.resplitJob : "";
+
     const sanitized = file ? sanitizeFilename(file.name) : null;
-    const sourceUrl = file ? `local:${sanitized}` : urlInput.value;
-    const displayTitle = sanitized ?? (urlInput.value || t("job.processingTrackTitle"));
+    const sourceUrl = resplitJob
+      ? submitBtn.dataset.resplitSource
+      : file
+        ? `local:${sanitized}`
+        : urlInput.value;
+    const displayTitle = resplitJob
+      ? submitBtn.dataset.resplitTitle || t("job.processingTrackTitle")
+      : (sanitized ?? (urlInput.value || t("job.processingTrackTitle")));
 
     const postUrlText = document.getElementById("post-url-text");
     if (postUrlText) postUrlText.textContent = displayTitle;
@@ -774,8 +793,16 @@ export function wireJobForm() {
       }
     }
 
+    let endpoint = "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/api/jobs";
     let fetchInit;
-    if (file) {
+    if (resplitJob) {
+      endpoint = `/api/jobs/${encodeURIComponent(resplitJob)}/resplit`;
+      fetchInit = {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ stems: [...selectedStems] }),
+      };
+    } else if (file) {
       const fd = new FormData();
       fd.append("file", file);
       fd.append("stems", JSON.stringify([...selectedStems]));
@@ -794,11 +821,17 @@ export function wireJobForm() {
     }
 
     let jobId;
+    // A re-split's source is deliberately not the one it was asked with: the
+    // library replaces any existing track sharing a sourceUrl, so reusing it
+    // would delete the track this was made from. The server decides the new
+    // one and says so here, because nothing on this side can derive it.
+    let newSourceUrl = sourceUrl;
     try {
-      const res = await fetch("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/api/jobs", fetchInit);
+      const res = await fetch(endpoint, fetchInit);
       const data = await res.json();
       if (!res.ok) throw new Error(data.detail || res.statusText);
       jobId = data.job_id;
+      if (data.source_url) newSourceUrl = data.source_url;
     } catch (err) {
       if (file) jobBox.classList.add("hidden");
       showError(t("job.startFailed", { message: err.message }));
@@ -812,7 +845,7 @@ export function wireJobForm() {
     // The server has the upload; disarm the picker so the next click cannot
     // silently import the same file a second time.
     if (file) fileInput._clear?.();
-    jobSources.set(jobId, sourceUrl);
+    jobSources.set(jobId, newSourceUrl);
     jobVocalSplitModes.set(jobId, selectedStems.has("vocals") ? vocalSplitMode : "all");
     addTrackToLibrary({
       id: jobId,
@@ -829,7 +862,7 @@ export function wireJobForm() {
       keyConfidence: null,
       lufs: null,
       peakDb: null,
-      sourceUrl,
+      sourceUrl: newSourceUrl,
     });
 
     if (background) {
diff --git a/static/js/utils.js b/static/js/utils.js
index 4562462c..166b2cad 100644
--- a/static/js/utils.js
+++ b/static/js/utils.js
@@ -132,4 +132,19 @@ export function parseTimecode(str) {
   return null;
 }
 
+// Can this track be fetched again from where it came from?
+//
+// "local:" is the scheme the importer gives an uploaded file: a name for
+// something that was handed over once and is not reachable a second time.
+// Everything else is a link the importer can act on.
+//
+// One predicate rather than three spellings of it. The composer arming the
+// Split stems button and the re-import of an unavailable track are asking the
+// same question, and the answer stopped agreeing between them: the composer
+// showed an uploaded file's bare filename as though it were a link, and the
+// button then submitted it (#635).
+export function isReimportableSource(sourceUrl) {
+  return !!sourceUrl && !sourceUrl.startsWith("local:");
+}
+
 export const $ = (id) => document.getElementById(id);
\ No newline at end of file
diff --git a/tests/e2e/composer-arming.spec.mjs b/tests/e2e/composer-arming.spec.mjs
new file mode 100644
index 00000000..af77004a
--- /dev/null
+++ b/tests/e2e/composer-arming.spec.mjs
@@ -0,0 +1,156 @@
+// What the Split stems button is allowed to be pointed at (#635).
+//
+// The composer is an input the button submits, not a caption for whatever
+// track is open. Opening a track writes its source back into it, and for an
+// uploaded file that source is the synthetic "local:my song.mp3". Stripping
+// the prefix and showing the bare filename armed the button with a string that
+// can never resolve: pressing it POSTed "my song.mp3" as though it were a
+// link, the server refused it, and the reporter got an error for pressing a
+// button that looked like it should re-split the song in front of them.
+//
+// Being non-empty is what made it reachable at all -- an empty box is stopped
+// by the browser's own required check before any of our code runs.
+//
+// The other half of the rule -- a real link still lands in the box, ready to
+// re-import -- is tests/js/source-arming.test.mjs. Asserting it here meant
+// rewriting syncWithServer's own payload to fight the fixture's local source,
+// which tests the stub more than it tests the app.
+import { expect, test } from "@playwright/test";
+import { openStudio, JOB_ID, TRACK_TITLE } from "./helpers.mjs";
+
+const YOUTUBE_URL = "https://www.youtube.com/watch?v=dQw4w9WgXcQ";
+
+test.describe("composer arming", () => {
+  test("an uploaded track puts no filename in the box, and aims the button at itself", async ({
+    page,
+  }) => {
+    // seed.py's fixture is sourceUrl "local:e2e-fixture.wav", which is exactly
+    // the case that broke.
+    await openStudio(page);
+
+    const url = page.locator("#url");
+    await expect(url).toHaveValue("");
+    // The button acts on the track instead, so the box must NOT be required:
+    // the browser refuses a required-and-empty submit before any handler runs,
+    // which would make re-splitting an upload impossible.
+    await expect(url).not.toHaveAttribute("required", "");
+    await expect(page.locator("#submit")).toHaveAttribute("data-resplit-job", JOB_ID);
+    // And it says so: an empty box with no other signal left no way to tell
+    // what pressing the button would act on.
+    await expect(page.locator("#trackPill")).toBeVisible();
+    await expect(page.locator("#trackPillName")).toHaveText(TRACK_TITLE);
+  });
+
+  test("an unfinished upload has nothing to act on at all", async ({ page }) => {
+    // Neither a URL to import nor stems to re-separate from. This is the one
+    // case where the empty box should stop the submit itself.
+    await openStudio(page);
+    await page.evaluate(() => {
+      document.getElementById("submit").dataset.resplitJob = "";
+      document.getElementById("url").setAttribute("required", "");
+    });
+
+    await page.locator("#submit").click();
+    // Still on the page, nothing queued: the browser refused it.
+    await expect(page.locator("#url")).toHaveValue("");
+  });
+
+  test("pressing the button re-splits the open upload", async ({ page }) => {
+    // The end-to-end wiring, and the one that catches a guard placed wrongly.
+    // `required` on an empty box is refused by the browser before any handler
+    // runs, so setting it here made the button answer "please fill out this
+    // field" instead of separating the track -- invisible to every assertion
+    // that only looks at attributes.
+    await openStudio(page);
+
+    const sent = [];
+    await page.route("**/api/jobs/*/resplit", async (route) => {
+      sent.push({ url: route.request().url(), body: route.request().postDataJSON() });
+      await route.fulfill({
+        status: 200,
+        contentType: "application/json",
+        body: JSON.stringify({ job_id: "cafebabe0001" }),
+      });
+    });
+
+    await page.locator("#submit").click();
+
+    await expect.poll(() => sent.length, { timeout: 10000 }).toBe(1);
+    expect(sent[0].url).toContain(`/api/jobs/${JOB_ID}/resplit`);
+    expect(Array.isArray(sent[0].body.stems)).toBe(true);
+  });
+
+  test("re-splitting does not swallow the track it came from", async ({ page }) => {
+    // addTrackToLibrary replaces any existing track that shares a sourceUrl,
+    // which is how re-importing a link supersedes its old entry. A re-split
+    // reuses the source of the track it came from, so it would trip the same
+    // branch -- and that branch drops the catalog entry without deleting the
+    // job, leaving a directory with no reference for syncWithServer to
+    // re-adopt on the next launch.
+    await openStudio(page);
+
+    await page.route("**/api/jobs/*/resplit", (route) =>
+      route.fulfill({
+        status: 200,
+        contentType: "application/json",
+        // The server hands back the source it chose, which is deliberately
+        // not the one this job was made from.
+        body: JSON.stringify({
+          job_id: "cafebabe0003",
+          source_url: "local:E2E Fixture Track (cafeba).wav",
+        }),
+      }),
+    );
+    await page.locator("#submit").click();
+
+    // A row renders in both Recent and the folder tree, so count is not the
+    // question -- presence is.
+    await expect(page.locator(`.cat-item[data-id="cafebabe0003"]`).first()).toBeVisible({
+      timeout: 10000,
+    });
+    await expect(
+      page.locator(`.cat-item[data-id="${JOB_ID}"]`).first(),
+      "the track that was re-split must still be in the library",
+    ).toBeVisible();
+  });
+
+  test("a typed URL still wins over the open upload", async ({ page }) => {
+    // The composer is not disabled while such a track is open: putting a link
+    // in it is a new import, not a re-split of what happens to be loaded.
+    await openStudio(page);
+
+    const hits = [];
+    await page.route("**/api/jobs**", async (route) => {
+      if (route.request().method() !== "POST") return route.fallback();
+      hits.push(route.request().url());
+      await route.fulfill({
+        status: 200,
+        contentType: "application/json",
+        body: JSON.stringify({ job_id: "cafebabe0002" }),
+      });
+    });
+
+    await page.locator("#url").fill(YOUTUBE_URL);
+    await page.locator("#submit").click();
+
+    await expect.poll(() => hits.length, { timeout: 10000 }).toBe(1);
+    expect(hits[0]).not.toContain("resplit");
+  });
+
+  test("the button keeps its name after a submit", async ({ page }) => {
+    // setSubmitProcessing restored a label the markup never used, so the first
+    // submit of a session renamed the button to "Process" for good -- on a
+    // successful import as much as on a failed one.
+    await openStudio(page);
+    const label = page.locator("#submit span");
+    const before = await label.textContent();
+
+    await page.route("**/api/jobs", (route) =>
+      route.fulfill({ status: 503, contentType: "application/json", body: JSON.stringify({ detail: "nope" }) }),
+    );
+    await page.locator("#url").fill(YOUTUBE_URL);
+    await page.locator("#submit").click();
+
+    await expect(label).toHaveText(before.trim(), { timeout: 10000 });
+  });
+});
diff --git a/tests/js/source-arming.test.mjs b/tests/js/source-arming.test.mjs
new file mode 100644
index 00000000..e0958e72
--- /dev/null
+++ b/tests/js/source-arming.test.mjs
@@ -0,0 +1,49 @@
+// Which track sources the Split stems button may be pointed at (#635).
+//
+// The composer is an input that button submits, not a caption for the open
+// track. An uploaded file's source is the synthetic "local:my song.mp3", and
+// showing its bare filename armed the button with a string that can never
+// resolve: pressing it POSTed "my song.mp3" as though it were a link.
+//
+// Run:  node tests/js/source-arming.test.mjs
+import { isReimportableSource } from "../../static/js/utils.js";
+
+let pass = 0,
+  fail = 0;
+const check = (name, cond) => {
+  if (cond) pass++;
+  else {
+    fail++;
+    console.log(`FAIL  ${name}`);
+  }
+};
+
+// Links the importer can act on.
+for (const url of [
+  "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
+  "https://soundcloud.com/artist/track",
+  "http://example.com/a.mp3",
+]) {
+  check(`reimportable: ${url}`, isReimportableSource(url) === true);
+}
+
+// Uploaded files. Not reachable a second time, whatever the name looks like.
+for (const source of [
+  "local:my song.mp3",
+  "local:e2e-fixture.wav",
+  // A filename that happens to read like a URL is still a filename.
+  "local:https___youtube.com.mp3",
+]) {
+  check(`not reimportable: ${source}`, isReimportableSource(source) === false);
+}
+
+// Absent is not reimportable, and must not throw on the way to saying so.
+for (const empty of [undefined, null, ""]) {
+  check(`absent: ${JSON.stringify(empty)}`, isReimportableSource(empty) === false);
+}
+
+// The prefix is a scheme, so it only counts at the start.
+check("local: mid-string is a URL", isReimportableSource("https://x.com/local:a") === true);
+
+console.log(fail ? `\n${fail} FAILED` : `\n${pass}/${pass} checks passed`);
+process.exit(fail ? 1 : 0);
diff --git a/tests/test_jobs_api.py b/tests/test_jobs_api.py
index 3a48d042..85d2b0c2 100644
--- a/tests/test_jobs_api.py
+++ b/tests/test_jobs_api.py
@@ -7,7 +7,7 @@
 import pytest
 from fastapi.testclient import TestClient
 
-from app.core.config import MAX_PENDING_UPLOAD_JOBS, MAX_PENDING_URL_JOBS
+from app.core.config import MAX_PENDING_UPLOAD_JOBS, MAX_PENDING_URL_JOBS, STEM_NAMES
 from app.core.models import Job
 from app.core.registry import _jobs
 
@@ -821,3 +821,142 @@ def test_submit_captures_the_song_structure_setting_on_the_job(client, monkeypat
     r = client.post("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/api/jobs", json={"url": "https://youtu.be/oHg5SJYRHA0"})
     assert r.status_code == 200
     assert registry.get(r.json()["job_id"]).auto_sections is False
+
+
+# --- POST /api/jobs/{id}/resplit (#635) -------------------------------------
+#
+# Re-separating a finished upload from the source kept beside it. A
+# link-sourced track never needed this -- re-importing its URL does the same
+# thing -- but an upload had no equivalent: the file was handed over once, and
+# the composer has nothing to submit for it.
+
+
+@pytest.fixture
+def resplit_client(tmp_path, monkeypatch):
+    import app.api.jobs as jobs_mod
+
+    monkeypatch.setattr(jobs_mod, "JOBS_DIR", tmp_path)
+    with patch("app.api.jobs.jobqueue.enqueue", lambda job_id: None):
+        from app.main import app
+
+        with TestClient(app) as c:
+            yield c
+
+
+def _finished_upload(tmp_path, job_id="aaaaaaaaaaaa", *, source="source.mp3"):
+    """A done upload with its source still beside it, as the runner now leaves it."""
+    job = Job(id=job_id, status="done", title="Demo", duration_sec=60.0)
+    job.source_url = "local:Demo.mp3"
+    _jobs[job.id] = job
+    job_dir = tmp_path / job.id
+    (job_dir / "stems").mkdir(parents=True)
+    if source:
+        (job_dir / source).write_bytes(b"ID3")
+    return job
+
+
+def test_resplit_starts_a_new_job_from_the_retained_source(resplit_client, tmp_path):
+    job = _finished_upload(tmp_path)
+
+    r = resplit_client.post(f"/api/jobs/{job.id}/resplit", json={"stems": ["vocals", "drums"]})
+
+    assert r.status_code == 200
+    new_id = r.json()["job_id"]
+    assert new_id != job.id, "re-split produces a new job, the way re-importing a link does"
+    assert _jobs[new_id].selected_stems == ["vocals", "drums"]
+    # Still a local: source, so its own copy is kept and it can be re-split in
+    # turn -- but distinct, or the library would replace the track it came from
+    # and leave that job on disk with nothing referencing it.
+    assert _jobs[new_id].source_url != job.source_url
+    assert _jobs[new_id].source_url.startswith("local:")
+    assert _jobs[new_id].source_url.endswith(".mp3"), "deriveQuality reads the suffix"
+    assert (tmp_path / new_id / "source.mp3").is_file()
+    # The original is untouched: its stems, sections and beat grid survive.
+    assert (tmp_path / job.id / "source.mp3").is_file()
+    assert (tmp_path / job.id / "stems").is_dir()
+
+
+@pytest.mark.parametrize(
+    ("source_url", "expected"),
+    [
+        ("local:My Song.mp3", "local:My Song (abc123).mp3"),
+        ("local:no extension", "local:no extension (abc123)"),
+        ("local:dotted.name.wav", "local:dotted.name (abc123).wav"),
+        (None, "local:track (abc123)"),
+    ],
+)
+def test_resplit_source_names_the_same_file_without_colliding(source_url, expected):
+    """The marker goes before the extension: deriveQuality reads the suffix to
+    tell a lossless WAV from a compressed MP3, so appending after it would
+    relabel the track."""
+    import app.api.jobs as jobs_mod
+
+    assert jobs_mod._resplit_source_url(source_url, "abc123def456") == expected
+
+
+def test_resplit_falls_back_to_every_stem_when_the_list_is_unusable(resplit_client, tmp_path):
+    """Unknown names are dropped rather than trusted, matching the importer."""
+    job = _finished_upload(tmp_path)
+
+    r = resplit_client.post(f"/api/jobs/{job.id}/resplit", json={"stems": ["../etc", "nope"]})
+
+    assert r.status_code == 200
+    assert _jobs[r.json()["job_id"]].selected_stems == list(STEM_NAMES)
+
+
+def test_resplit_rejects_an_over_long_stem_list(resplit_client, tmp_path):
+    job = _finished_upload(tmp_path)
+
+    r = resplit_client.post(f"/api/jobs/{job.id}/resplit", json={"stems": ["vocals"] * 50})
+
+    assert r.status_code == 422
+
+
+def test_resplit_404s_for_an_unknown_job(resplit_client):
+    r = resplit_client.post("/api/jobs/bbbbbbbbbbbb/resplit", json={"stems": []})
+    assert r.status_code == 404
+
+
+def test_resplit_409s_when_no_source_was_kept(resplit_client, tmp_path):
+    """Every job finished before the source was retained is in this state, as
+    is any link-sourced track. It is an ordinary answer, not a failure."""
+    job = _finished_upload(tmp_path, source=None)
+
+    r = resplit_client.post(f"/api/jobs/{job.id}/resplit", json={"stems": []})
+
+    assert r.status_code == 409
+    assert "source" in r.json()["detail"]
+
+
+def test_resplit_ignores_a_source_with_an_extension_we_never_accept(resplit_client, tmp_path):
+    """source.* is a glob, and the job directory is not a trusted input just
+    because we created it. Only the extensions the importer accepts may be fed
+    back into the pipeline."""
+    job = _finished_upload(tmp_path, source="source.sh")
+
+    r = resplit_client.post(f"/api/jobs/{job.id}/resplit", json={"stems": []})
+
+    assert r.status_code == 409
+
+
+@pytest.mark.parametrize(
+    "job_id",
+    [
+        "../../etc/passwd",  # normalised away by the client, never routed here
+        "..%2F..%2Fetc",  # escaped, so it arrives as a job id and must be refused
+        "aaaa..aaaaaa",  # right length, wrong alphabet
+        "aaaa/../aaaa",
+        "a" * 200,
+    ],
+)
+def test_resplit_never_lets_a_crafted_id_reach_the_filesystem(resplit_client, job_id):
+    """JOB_ID_RE is the gate, and it runs before any I/O.
+
+    The first case never reaches the handler at all -- the client collapses it
+    and nothing answers POST at that path -- which is why this asserts on a
+    refusal rather than on one status. The rest do arrive, and must be turned
+    away as a missing job rather than a 500 from something touching a path.
+    """
+    r = resplit_client.post(f"/api/jobs/{job_id}/resplit", json={"stems": []})
+    assert r.status_code in (404, 405, 422), r.status_code
+    assert r.status_code != 500
diff --git a/tests/test_pipeline_runner.py b/tests/test_pipeline_runner.py
index 013d06cc..45e086ff 100644
--- a/tests/test_pipeline_runner.py
+++ b/tests/test_pipeline_runner.py
@@ -450,6 +450,50 @@ def _common_stage_patches(job_dir: Path, sections):
     )
 
 
+@pytest.mark.parametrize(
+    ("source_url", "kept"),
+    [
+        ("local:my song.mp3", True),
+        ("https://www.youtube.com/watch?v=dQw4w9WgXcQ", False),
+        # No source recorded at all is not an upload, so it is reclaimed as
+        # before. Nothing depends on holding it.
+        (None, False),
+    ],
+)
+def test_only_a_source_that_can_be_fetched_again_is_deleted(
+    tmp_path: Path, source_url: str | None, kept: bool
+):
+    """An upload's source is the only copy StemDeck will ever have.
+
+    Deleting it is the bulk of disk reclaim per job, which is why it happens
+    at all, but a link can be downloaded again and an upload cannot. Throwing
+    an upload's source away means the track can never be separated again, with
+    any model, and the person who imported it may no longer have the file.
+    """
+    job = Job(id="abcdefabc120", duration_sec=60.0, source_url=source_url)
+    job_dir = tmp_path / job.id
+    (job_dir / "stems").mkdir(parents=True)
+    source = job_dir / "source.mp3"
+    source.write_bytes(b"ID3")
+
+    patches = _common_stage_patches(job_dir, [])
+    # Index 3 is the cleanup_source patch; let the real one run so this
+    # asserts on the file rather than on a call count.
+    with (
+        patches[0],
+        patches[1],
+        patches[2],
+        patches[4],
+        patches[5],
+        patches[6],
+        patches[7],
+        patches[8],
+    ):
+        _run_common(job, source, job_dir)
+
+    assert source.exists() is kept
+
+
 def test_common_pipeline_stores_automatic_section_suggestions(tmp_path: Path):
     job = Job(id="abcdefabc111", duration_sec=60.0, auto_sections=True)
     job_dir = tmp_path / job.id