@@ -110,7 +110,7 @@ one to open.
 | A different result | `dw/server/routes/jobs.py`, `dw_mcp/tools_jobs.py`: `rerun_job` | `rerun` with `new_seed` draws a fresh seed into the workflow's seed variable. | `tests/test_rerun_new_seed.py::test_a_rerun_with_a_new_seed_draws_one_into_that_variable` |
 | Worker protocol | `dw/worker_protocol.py`: `parse_reply` | Every command and reply is a frozen dataclass that travels as a wire dict. | `tests/test_worker_messages.py::test_from_wire_inverts_to_wire`, `tests/test_worker_messages.py::test_an_unknown_reply_type_is_kept_whole_rather_than_raised` |
 | Persistent worker | `dw/worker.py`, `dw/worker_manager.py`, `dw/serve.py` | Jobs run in spawned workers (one per card) that keep models loaded, so a change to engine code needs a server restart. | — |
-| Worker card pinning | `dw/devices.py`: `worker_environment`, `pinned_environment`, `resolve_serve_devices`, `check_device_present`, `device_label`, `card_of`, `ordinal_of` | A worker named with a CUDA index is spawned with `CUDA_VISIBLE_DEVICES` set to that card and `DW_DEVICE=cuda` (a bare `cuda` pins nothing), so index-0 reads inside it measure its own card; `--devices`/`devices` takes one entry per worker (a card named twice, or a bare `cuda` in a list of several, is refused), a card the box lacks is refused at startup naming the cards present, and a job's `device` is `device_label`'s `"cuda:N <card name>"`, read back only through `card_of` and `ordinal_of`. | `tests/test_worker_manager.py::TestWorkerPinning::test_a_cuda_index_pins_the_worker_through_the_environment`, `tests/test_worker_manager.py::TestWorkerPinning::test_a_bare_cuda_sets_no_pin`, `tests/test_serve_main.py::TestConfigureDevices::test_a_refusal_exits_with_code_2`, `tests/test_serve_main.py::TestResolveServeDevices::test_a_card_the_machine_lacks_is_refused_naming_the_cards_present`, `tests/test_serve_main.py::TestResolveServeDevices::test_two_entries_are_both_kept`, `tests/test_serve_main.py::TestResolveServeDevices::test_a_card_named_twice_is_refused` |
+| Worker card pinning | `dw/devices.py`: `worker_environment`, `pinned_environment`, `resolve_serve_devices`, `check_device_present`, `label_of` | A worker named with a CUDA index is spawned with `CUDA_VISIBLE_DEVICES` set to that card and `DW_DEVICE=cuda` (a bare `cuda` pins nothing), so index-0 reads inside it measure its own card; `--devices`/`devices` takes one entry per worker (a card named twice, or a bare `cuda` in a list of several, is refused), a card the box lacks is refused at startup naming the cards present, and a job stores the card it ran on as `device_ordinal` and `device_card` (#693), job and history alike: rerun affinity reads the ordinal, observed cost buckets by the card, and the `device` label `"cuda:N <card name>"` is only `label_of` joining the two - nothing splits a label back apart. | `tests/test_worker_manager.py::TestWorkerPinning::test_a_cuda_index_pins_the_worker_through_the_environment`, `tests/test_worker_manager.py::TestWorkerPinning::test_a_bare_cuda_sets_no_pin`, `tests/test_serve_main.py::TestConfigureDevices::test_a_refusal_exits_with_code_2`, `tests/test_serve_main.py::TestResolveServeDevices::test_a_card_the_machine_lacks_is_refused_naming_the_cards_present`, `tests/test_serve_main.py::TestResolveServeDevices::test_two_entries_are_both_kept`, `tests/test_serve_main.py::TestResolveServeDevices::test_a_card_named_twice_is_refused` |
 | Failed-run reporting | `dw/worker.py`, `dw/worker_protocol.py`: `Failed`, `Cancelled` | A failed or cancelled run's reply still carries the manifest of the steps that ran. | `tests/test_worker_execute.py::test_failure_carries_the_manifest_of_the_steps_that_ran`, `tests/test_worker_execute.py::test_cancellation_carries_the_manifest_too` |
 | Failure path redaction | `dw/path_redaction.py`: `redact_paths`, called by `dw/worker.py` | A failed run's message and traceback name a file under the job's asset roots or output directory by its `asset:`/`output:` reference, never its absolute server path. | `tests/test_worker_execute.py::test_a_failure_names_an_asset_by_reference_not_by_server_path`, `tests/test_path_redaction.py` |
 | Run-time warnings | `dw/events.py`: `emit_warning` | A warning found at run time is emitted as an event, so it reaches the caller and not just the log. | `tests/test_concat_videos.py::TestWarningsReachTheCaller::test_the_level_spread_warning_is_emitted_as_an_event` |
 
@@ -16,10 +16,13 @@
 the *parent* around `Process.start()` (`pinned_environment`): `dw/__init__.py`
 imports torch, so nothing in the child runs early enough to set them there.
 
-**The server process sees every card**, so it names one by its ordinal -
-`device_label()` gives `"cuda:1 NVIDIA GeForce RTX 3090"`, the string a job
-record's `device` carries and the card observed cost buckets by
-(dw/server/observed_cost.py).
+**The server process sees every card**, so it names one by its ordinal
+(`device_ordinal()`, `"cuda:1"`) and its card (`card_name()`, `"NVIDIA
+GeForce RTX 3090"`). A job record stores the two as separate fields
+(`device_ordinal`, `device_card`, #693): rerun affinity reads the ordinal and
+observed cost buckets by the card (dw/server/observed_cost.py), so neither
+parses a string back apart. `label_of()` joins them into the
+`"cuda:1 NVIDIA GeForce RTX 3090"` a job's `device` shows.
 
 A device with no explicit index (`cuda`, the default on every box that
 names none) is not pinned at all, so an unconfigured server spawns its
@@ -229,28 +232,13 @@ def card_name(device=None):
     return None
 
 
-def device_label(device=None):
-    """`"cuda:1 NVIDIA GeForce RTX 3090"` - the ordinal, then the card's
-    name when there is one. What a job record's `device` holds."""
-    ordinal = device_ordinal(device)
-    name = card_name(ordinal)
-    return f"{ordinal} {name}" if name else ordinal
-
-
-def card_of(label):
-    """The card name in a `device_label` string, or None for a label that
-    carries none (`cpu`) or no label at all."""
-    if not label or " " not in label:
-        return None
-    return label.split(" ", 1)[1]
-
-
-def ordinal_of(label):
-    """The ordinal in a `device_label` string ('cuda:1'), or None for no
-    label at all - `card_of`'s other half."""
-    if not label:
+def label_of(ordinal, card):
+    """The `device` label for a stored ordinal and card: `"cuda:1 NVIDIA
+    GeForce RTX 3090"`, or the bare ordinal (`cpu`) for a card with no name,
+    or None for no ordinal at all."""
+    if not ordinal:
         return None
-    return label.split(" ", 1)[0]
+    return f"{ordinal} {card}" if card else ordinal
 
 
 def is_default_device(device=None):
 
@@ -4,6 +4,12 @@
 the column added and every existing row backfilled to `default`, since
 history that cannot say which workspace a job ran in stops making sense once
 there are two.
+
+The card a job ran on is three columns: `device`, the label every reader
+returns (`"cuda:1 NVIDIA GeForce RTX 3090"`), and `device_ordinal`/
+`device_card`, the same card as the two fields rerun affinity and observed
+cost read (#693). A database that predates the two gets them backfilled from
+`device` in SQL when it is first opened, so no reader parses the label.
 """
 
 import json
@@ -114,6 +120,27 @@ def __init__(self, db_path):
             # card has been swapped
             if "device" not in columns:
                 connection.execute("ALTER TABLE jobs ADD COLUMN device TEXT")
+            # The same card as two fields - its ordinal ("cuda:1") and its
+            # name ("NVIDIA GeForce RTX 3090") - so rerun affinity and
+            # observed cost read them rather than parse `device` (#693).
+            # `device` stays the label every reader returns. Rows before the
+            # columns are backfilled from it once, in SQL: an ordinal never
+            # holds a space, so the label splits at its first one, and a
+            # label with none (`cpu`, `mps`) is all ordinal with no card
+            if "device_ordinal" not in columns:
+                connection.execute("ALTER TABLE jobs ADD COLUMN device_ordinal TEXT")
+            if "device_card" not in columns:
+                connection.execute("ALTER TABLE jobs ADD COLUMN device_card TEXT")
+            if "device_ordinal" not in columns or "device_card" not in columns:
+                connection.execute(
+                    "UPDATE jobs SET"
+                    " device_ordinal = CASE WHEN INSTR(device, ' ') > 0"
+                    " THEN SUBSTR(device, 1, INSTR(device, ' ') - 1)"
+                    " ELSE device END,"
+                    " device_card = CASE WHEN INSTR(device, ' ') > 0"
+                    " THEN SUBSTR(device, INSTR(device, ' ') + 1) END"
+                    " WHERE device IS NOT NULL"
+                )
 
     def _connect(self):
         # WAL mode lets a reader (the web UI polling job status, an MCP
@@ -136,8 +163,9 @@ def record(self, job):
                 " started_at, finished_at, arguments, spec, manifest, warnings,"
                 " error, events, workspace, workflow_name, run_id, run_dir,"
                 " acknowledged, host_memory_peak_rss_mb,"
-                " host_memory_job_peak_rss_mb, run_version, device) VALUES"
-                " (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)",
+                " host_memory_job_peak_rss_mb, run_version, device,"
+                " device_ordinal, device_card) VALUES"
+                " (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)",
                 (
                     job.id,
                     job.workflow_name,
@@ -164,6 +192,8 @@ def record(self, job):
                     getattr(job, "host_memory_job_peak_rss_mb", None),
                     getattr(job, "run_version", None),
                     getattr(job, "device", None),
+                    getattr(job, "device_ordinal", None),
+                    getattr(job, "device_card", None),
                 ),
             )
 
@@ -228,6 +258,15 @@ def get(self, job_id):
             ).fetchone()
         return self._to_detail(row) if row else None
 
+    def device_ordinal(self, job_id):
+        """The ordinal of the card a finished job ran on ('cuda:1'), or None
+        for a job that never ran or that history has never seen."""
+        with self._lock, self._connect() as connection:
+            row = connection.execute(
+                "SELECT device_ordinal FROM jobs WHERE id = ?", (job_id,)
+            ).fetchone()
+        return row[0] if row else None
+
     def watermark(self):
         """How far the table has got - what a derived figure caches against.
 
@@ -272,8 +311,8 @@ def finished_runs(self):
                 "SELECT workflow_name, workspace, started_at, finished_at,"
                 " arguments, manifest, INSTR(COALESCE(events, ''), ?) > 0,"
                 " COALESCE(json_array_length(COALESCE(events, '[]')), 0) >= ?,"
-                " host_memory_peak_rss_mb, host_memory_job_peak_rss_mb, device"
-                " FROM jobs WHERE status = ? AND workflow_name IS NOT NULL"
+                " host_memory_peak_rss_mb, host_memory_job_peak_rss_mb, device,"
+                " device_ordinal, device_card FROM jobs WHERE status = ? AND workflow_name IS NOT NULL"
                 " AND started_at IS NOT NULL AND finished_at IS NOT NULL",
                 (LOADING_MARKER, EVENT_CAP, SUCCEEDED),
             ).fetchall()
@@ -290,6 +329,8 @@ def finished_runs(self):
             peak_rss_mb,
             job_peak_rss_mb,
             device,
+            ordinal,
+            card,
         ) in rows:
             key = (workspace or DEFAULT_WORKSPACE_NAME, name)
             grouped.setdefault(key, []).append(
@@ -304,6 +345,8 @@ def finished_runs(self):
                     "host_memory_peak_rss_mb": peak_rss_mb,
                     "host_memory_job_peak_rss_mb": job_peak_rss_mb,
                     "device": device,
+                    "device_ordinal": ordinal,
+                    "device_card": card,
                 }
             )
         return grouped
 
@@ -10,6 +10,7 @@
 import time
 import uuid
 
+from ..devices import label_of
 from ..download_watch import format_progress
 from ..workspace import DEFAULT_WORKSPACE_NAME
 
@@ -78,10 +79,13 @@ def __init__(self, spec):
         self.run_id = None
         self.run_dir = None
         self.run_version = None
-        # The card the job ran on, as `dw.devices.device_label` names it -
-        # set when it starts running, so None while queued and forever for
-        # a job cancelled before it ran (#462)
-        self.device = None
+        # The card the job ran on - its ordinal ("cuda:1") and its name
+        # ("NVIDIA GeForce RTX 3090", None for a card with none) - set when
+        # it starts running, so None while queued and forever for a job
+        # cancelled before it ran (#462, #693). `device` is the two as one
+        # label
+        self.device_ordinal = None
+        self.device_card = None
         # Which form of cost acknowledgement queued this job (#85)
         self.acknowledged = spec.get("acknowledged") or ACK_NONE
         # The worker's own high-water mark for this run, from its final
@@ -110,6 +114,11 @@ def __init__(self, spec):
         self.denoise_total_steps = None
         self.condition = threading.Condition()
 
+    @property
+    def device(self):
+        """`"cuda:1 NVIDIA GeForce RTX 3090"`, or None before it ran."""
+        return label_of(self.device_ordinal, self.device_card)
+
     def add_event(self, event):
         with self.condition:
             # `at` is seconds since the job started (since it was created,
 
@@ -40,7 +40,7 @@
 import threading
 
 from ..worker_protocol import Execute, workflow_identity
-from ..devices import card_of, device_ordinal, ordinal_of
+from ..devices import device_ordinal
 from ..host_memory import process_rss_mb
 from ..worker_manager import WorkerManager
 from ..workflow_run import SEED_BITS
@@ -549,10 +549,8 @@ def _original_device(self, job_id):
         """The ordinal of the card `job_id` ran on ('cuda:1'), or None."""
         job = self.jobs.get(job_id)
         if job is not None:
-            label = job.device
-        else:
-            label = (self.history.get(job_id) or {}).get("device")
-        return ordinal_of(label)
+            return job.device_ordinal
+        return self.history.device_ordinal(job_id)
 
     def queue_position(self, job_id):
         """Index in the waiting queue, or None when the job is not queued."""
@@ -685,7 +683,7 @@ def _run_loop(self):
                 slot, job = picked
                 job.status = RUNNING
                 job.started_at = time.time()
-                job.device = self._job_device(slot)
+                job.device_ordinal, job.device_card = slot.device_fields()
                 slot.current_job_id = job.id
                 slot.started_at = job.started_at
                 # The worker switches to this identity for the run
@@ -839,12 +837,6 @@ def _rank_for_oom(self, slot):
         highest = max((other.oom_score_adj or 0) for other in others)
         manager.set_oom_score_adj(min(1000, highest + 100))
 
-    def _job_device(self, slot=None):
-        """The card the worker runs on, for the job record. A label that
-        cannot be read leaves the job's `device` null rather than failing
-        the job - the run itself does not depend on it."""
-        return (slot or self.slots[0]).label()
-
     def is_busy(self):
         """True while a job is running on any card or queued - the window in
         which a worker may be reading model files a cache delete would rip
@@ -889,7 +881,7 @@ def workers(self):
             pid = slot.manager.pid() if hasattr(slot.manager, "pid") else None
             entry = {
                 "device": device_ordinal(slot.device),
-                "name": card_of(slot.label()),
+                "name": slot.device_fields()[1],
                 "vram_gb": slot.capacity_gb(),
                 "current_job": job_id,
                 "alive": slot.alive(),
 
@@ -337,12 +337,12 @@ def _on_this_card(self, rows, card=None):
         """The rows that ran on the card this server runs on now, or on
         `card` when one is named (#462).
 
-        A row names its card (`device`, "cuda:1 NVIDIA GeForce RTX 3090")
-        and counts when the card name matches, whichever index it had - a
-        3090 run tells a 3090 estimate, not a 4090 one. A row from before
-        jobs carried a `device` ran on the box's default card, so it counts
-        only for that card."""
-        from ..devices import card_of, is_default_device
+        A row names its card (`device_card`, "NVIDIA GeForce RTX 3090") and
+        counts when the card name matches, whichever index it had - a 3090
+        run tells a 3090 estimate, not a 4090 one. A row from before jobs
+        carried a device (no `device_ordinal`) ran on the box's default
+        card, so it counts only for that card."""
+        from ..devices import is_default_device
 
         if card is not None:
             _, name, default = self.card(card)
@@ -355,11 +355,10 @@ def _on_this_card(self, rows, card=None):
                 default = True
         kept = []
         for row in rows:
-            label = row.get("device")
-            if label is None:
+            if row.get("device_ordinal") is None:
                 if default:
                     kept.append(row)
-            elif card_of(label) == name:
+            elif row.get("device_card") == name:
                 kept.append(row)
         return kept
 
 
@@ -66,6 +66,15 @@ def label(self):
             logger.debug("Could not read the worker's device", exc_info=True)
             return None
 
+    def device_fields(self):
+        """The card as a job record stores it - `("cuda:1", "NVIDIA GeForce
+        RTX 3090")` - or `(None, None)` where it cannot be read."""
+        try:
+            return self.manager.device_fields()
+        except Exception:
+            logger.debug("Could not read the worker's device", exc_info=True)
+            return None, None
+
     def ordinal(self):
         """The card as `cuda:1` - what a `device` argument names it by."""
         return device_ordinal(self.device)
 
@@ -14,7 +14,13 @@
 import time
 from typing import Optional
 from . import device_capacity_gb, get_device
-from .devices import device_label, pinned_environment, worker_environment
+from .devices import (
+    card_name,
+    device_ordinal,
+    label_of,
+    pinned_environment,
+    worker_environment,
+)
 from .worker import worker_main
 from .worker_protocol import Cancel, Shutdown, WorkerCrashed, parse_reply
 
@@ -42,7 +48,7 @@ def __init__(self, device: Optional[str] = None):
                 (dw/devices.py)
         """
         self.device = device
-        self._device_label = None
+        self._device_fields = None
         self._capacity_read = False
         self._capacity_gb = None
         self._ceiling_gb = None
@@ -77,13 +83,19 @@ def ensure_worker(self, log_level: str = "INFO"):
             self.oom_score_adj = None
             logger.info("Worker process started")
 
+    def device_fields(self):
+        """This worker's card as a job record stores it - `("cuda:1",
+        "NVIDIA GeForce RTX 3090")`, the card None where it has no name -
+        read once, in the server process, which sees every card by its
+        ordinal."""
+        if self._device_fields is None:
+            ordinal = device_ordinal(self.device)
+            self._device_fields = (ordinal, card_name(ordinal))
+        return self._device_fields
+
     def device_label(self):
-        """This worker's card as a job record names it -
-        `"cuda:1 NVIDIA GeForce RTX 3090"` - read once, in the server
-        process, which sees every card by its ordinal."""
-        if self._device_label is None:
-            self._device_label = device_label(self.device)
-        return self._device_label
+        """`"cuda:1 NVIDIA GeForce RTX 3090"` - the two fields as one label."""
+        return label_of(*self.device_fields())
 
     def shutdown_worker(self):
         """Gracefully shutdown worker process."""