@@ -918,7 +918,14 @@ Four properties are load-bearing:
 - **The detail is carried, not re-derived.**  `LeaseAttempt.detail` (already
   truncated to 200 chars by `_response_detail`, so a proxy's HTML error page
   cannot become a 5 KB Event message) is the single value both the `lease.denied`
-  log line and the Event render.
+  log line and the Event render.  The Event's own half of the message states the
+  whole ask — GPU count, class, **and the requested lease duration**, rendered
+  compactly by `k8s_client.format_duration_compact` (`3h10m`) and taken from the
+  preflight-built `OnDemandAdmissionCandidate.duration_seconds` (minimum runtime
+  + `ONDEMAND_LEASE_BUFFER_MINUTES`) rather than re-derived, so the pod reports
+  the duration the app actually refused.  The length is often *why* it was
+  refused, and without it the owner of a long job cannot tell a capacity shortage
+  from a length they could shorten.
 - **Throttled by content first, clock second.**  A *changed* reason is new
   information and emits immediately; an *unchanged* one waits out
   `ONDEMAND_DENIAL_EVENT_REPEAT_MINUTES` (default 30).  The retry cadence is
 
@@ -187,7 +187,10 @@ reservation rather than creating a duplicate.
   ceiling: 4)` — that reason is also mirrored onto the pod as a `Warning`
   Kubernetes Event (`reason=OnDemandLeaseDenied`), so the pod's **owner** can see
   why their job is still Pending with `kubectl describe pod` rather than needing
-  the controller's logs.  An unchanged reason is restated at most once per
+  the controller's logs.  The Event names the whole ask — GPU count, class, and
+  the requested lease duration (`minimum duration 4h10m`: the pod's
+  `galends/minimum-runtime-seconds` plus `ONDEMAND_LEASE_BUFFER_MINUTES`), which
+  is frequently what made it infeasible.  An unchanged reason is restated at most once per
   `ONDEMAND_DENIAL_EVENT_REPEAT_MINUTES` (a changed one is reported at once), and
   only the app's own denial is surfaced this way — a network failure or a
   controller misconfiguration is an operator's problem and stays in the log.
 
@@ -291,6 +291,29 @@ def local_display(dt: datetime) -> str:
     return format_local(dt, _display_tz)
 
 
+def format_duration_compact(seconds: int) -> str:
+    """Render a duration as a compact ``3h10m``, for prose a person reads.
+
+    Only non-zero components appear, largest first, so a lease sized in whole
+    minutes reads ``3h10m`` rather than ``3h10m00s`` — the fixed-width
+    ``{h}h{mm}m{ss}s`` form the guarantee and overstay messages use is right for
+    comparing two elapsed times against each other, and needlessly noisy for a
+    single requested length.  A sub-minute (or zero) duration still renders its
+    seconds, so the value is never blank.
+    """
+    total = max(0, int(seconds))
+    hours, rest = divmod(total, 3600)
+    minutes, secs = divmod(rest, 60)
+    parts = []
+    if hours:
+        parts.append(f"{hours}h")
+    if minutes:
+        parts.append(f"{minutes}m")
+    if secs or not parts:
+        parts.append(f"{secs}s")
+    return "".join(parts)
+
+
 # Annotation keys describing the reservation an admitted pod is running under,
 # stamped alongside the runtime guarantee (see annotate_runtime_guarantee).
 # ``galends/guaranteed-until`` is the end of the guarantee *chain*, which says
@@ -1215,6 +1238,7 @@ async def emit_lease_denied_event(
     *,
     gpu_class: str,
     gpu_count: int,
+    duration_seconds: int,
 ) -> None:
     """Create a ``Warning`` Event linked to a pod whose JIT lease was refused.
 
@@ -1231,6 +1255,14 @@ async def emit_lease_denied_event(
     until something changes — which also matches how kube-scheduler reports the
     neighbouring condition, ``FailedScheduling``.  Informational only: the
     controller keeps retrying on its own cadence either way.
+
+    The message states the *whole* ask, not just its GPU half: *duration_seconds*
+    is the lease length the controller requested (the pod's
+    ``galends/minimum-runtime-seconds`` plus ``ONDEMAND_LEASE_BUFFER_MINUTES``),
+    and it is frequently why an ask was refused — the same GPUs are free now but
+    booked before the run would end.  Without it the owner of a long job reads
+    "1 x xtra was denied" and has no way to tell a capacity shortage from a
+    length they could shorten.
     """
     await _emit_pod_event(
         pod_uid,
@@ -1241,7 +1273,8 @@ async def emit_lease_denied_event(
         action="RequestOnDemandLease",
         event_type="Warning",
         message=(
-            f"On-demand GPU lease for {gpu_count} x {gpu_class} was denied by the "
+            f"On-demand GPU lease for {gpu_count} x {gpu_class}, minimum duration "
+            f"{format_duration_compact(duration_seconds)} was denied by the "
             f"reservation service: {detail}. The pod stays Pending; the controller "
             f"will keep retrying."
         ),
 
@@ -1113,6 +1113,7 @@ async def _emit_lease_denial_event(
     candidate: OnDemandCandidate,
     detail: Optional[str],
     now: datetime,
+    duration_seconds: int,
 ) -> None:
     """Tell the pod's owner why its JIT lease was refused, via a Kubernetes Event.
 
@@ -1130,6 +1131,14 @@ async def _emit_lease_denial_event(
     a pod still waiting must restate its reason or ``kubectl describe`` goes
     blank on a pod that is still blocked.  ``0`` disables the throttle entirely.
 
+    *duration_seconds* is the lease length the ask carried (the pod's minimum
+    runtime plus the configured buffer), taken from the preflight-built ask
+    rather than re-derived here, so the Event states the same duration the app
+    refused.  It is fixed for a candidate's life -- ``min_runtime_seconds`` is
+    read once, when the candidate is created -- so the throttle above stays
+    keyed on *detail* alone: the duration half of the message cannot change
+    between two denials of the same candidate.
+
     Best-effort throughout, like every other emitter here: a failure to emit is
     logged and never disturbs the retry cadence, which is the thing that
     actually gets the pod running.
@@ -1151,6 +1160,7 @@ async def _emit_lease_denial_event(
             detail,
             gpu_class=candidate.gpu_class_label,
             gpu_count=candidate.gpu_requested,
+            duration_seconds=duration_seconds,
         )
     except Exception as exc:  # noqa: BLE001
         log.warning("%s", kv(
@@ -1210,7 +1220,9 @@ async def _grant_and_admit(
                 # Surface the app's reason on the pod itself: the retry cadence
                 # below is invisible to its owner, who otherwise sees only a pod
                 # that stays Pending with nothing saying why.
-                await _emit_lease_denial_event(config, uid, candidate, attempt.detail, now)
+                await _emit_lease_denial_event(
+                    config, uid, candidate, attempt.detail, now, ask.duration_seconds,
+                )
         else:
             # A fault waiting will not fix — a read-only service key, a schema
             # mismatch after an app upgrade, an unknown group name.  WARNING so
 
@@ -319,11 +319,18 @@ Events:
   Type     Reason                Age    From                          Message
   ----     ------                ----   ----                          -------
   Warning  FailedScheduling      5m12s  default-scheduler             0/41 nodes are available: ...
-  Warning  OnDemandLeaseDenied   4m58s  gpu-reservation-controller    On-demand GPU lease for 2 x a100 was denied by the reservation service: Only 1 GPU(s) available for this group at 2026-08-21 14:00 (group ceiling: 4). The pod stays Pending; the controller will keep retrying.
+  Warning  OnDemandLeaseDenied   4m58s  gpu-reservation-controller    On-demand GPU lease for 2 x a100, minimum duration 4h10m was denied by the reservation service: Only 1 GPU(s) available for this group at 2026-08-21 14:00 (group ceiling: 4). The pod stays Pending; the controller will keep retrying.
 ```
 
-Three things worth knowing about it:
+Four things worth knowing about it:
 
+- **It states the whole ask, duration included.** `minimum duration 4h10m` is
+  the lease the controller requested on the pod's behalf: its
+  `galends/minimum-runtime-seconds` (§3) plus the deployment's lease buffer
+  (`ONDEMAND_LEASE_BUFFER_MINUTES`, 10 minutes by default). The length is often
+  *why* an ask was refused — the GPUs are free now but booked before the run
+  would end — so a job that declares a shorter minimum runtime may get in where
+  this one did not.
 - **It is not a terminal state.** The controller keeps retrying on its own
   cadence (2–5 minutes); the Event is a report, not a rejection. A pod denied
   for capacity usually gets in once someone else's job ends.
 
@@ -26,7 +26,7 @@
 
 from app import k8s_client
 from app.controller import ControllerState, OnDemandCandidate
-from app.k8s_client import emit_lease_denied_event
+from app.k8s_client import emit_lease_denied_event, format_duration_compact
 from app.reservation_client import LeaseAttempt, ReservationClient
 from app.schemas import OnDemandAdmissionCandidate, OnDemandReservationRequest
 
@@ -40,6 +40,9 @@
 )
 
 NOW = datetime(2024, 1, 15, 9, 0, tzinfo=timezone.utc)
+# The ask the app refused: a 3 h pod minimum runtime plus the default 10 min
+# lease buffer, which is what the Event reports.
+LEASE_SECONDS = 3 * 3600 + 10 * 60
 DETAIL = "Only 2 GPU(s) available for this group at 2024-01-15 09:00 (group ceiling: 4)"
 
 
@@ -174,12 +177,13 @@ def create_namespaced_event(self, namespace, body):
         return SimpleNamespace()
 
 
-def _emit(core, monkeypatch, *, detail=DETAIL):
+def _emit(core, monkeypatch, *, detail=DETAIL, duration_seconds=LEASE_SECONDS):
     monkeypatch.setattr(k8s_client, "_core_v1", core)
     asyncio.run(
         emit_lease_denied_event(
             "uid-1", "pod-1", USERNAME, detail,
             gpu_class=GPU_CLASS_LABEL, gpu_count=2,
+            duration_seconds=duration_seconds,
         )
     )
 
@@ -213,6 +217,25 @@ def test_message_carries_the_apps_reason_verbatim(self, monkeypatch):
         assert DETAIL in event.message
         assert "2 x " + GPU_CLASS_LABEL in event.message
 
+    def test_message_states_the_requested_duration(self, monkeypatch):
+        # The duration is half the ask and is frequently why it was refused:
+        # without it the owner of a long job cannot tell a capacity shortage
+        # from a length they could shorten.
+        core = _CapturingCore()
+        _emit(core, monkeypatch)
+        _ns, event = core.events[0]
+        assert (
+            f"On-demand GPU lease for 2 x {GPU_CLASS_LABEL}, minimum duration 3h10m "
+            f"was denied by the reservation service: {DETAIL}."
+        ) in event.message
+
+    def test_sub_minute_duration_still_renders(self, monkeypatch):
+        # A duration must never render blank, whatever its magnitude.
+        core = _CapturingCore()
+        _emit(core, monkeypatch, duration_seconds=45)
+        _ns, event = core.events[0]
+        assert "minimum duration 45s was denied" in event.message
+
     def test_generate_name_so_repeats_never_409(self, monkeypatch):
         core = _CapturingCore()
         _emit(core, monkeypatch)
@@ -244,6 +267,25 @@ def test_normal_emitters_still_emit_normal(self, monkeypatch):
         assert event.involved_object.uid == "uid-1"
 
 
+class TestFormatDurationCompact:
+    @pytest.mark.parametrize(
+        "seconds,expected",
+        [
+            (3 * 3600 + 10 * 60, "3h10m"),   # the common ask: 3 h + 10 min buffer
+            (3600, "1h"),                     # zero components are dropped
+            (3660, "1h1m"),
+            (3601, "1h1s"),                   # ...including the middle one
+            (600, "10m"),
+            (90, "1m30s"),
+            (45, "45s"),
+            (0, "0s"),                        # never blank
+            (-5, "0s"),                       # nor negative
+        ],
+    )
+    def test_renders_non_zero_components_only(self, seconds, expected):
+        assert format_duration_compact(seconds) == expected
+
+
 # ---------------------------------------------------------------------------
 # main._emit_lease_denial_event — the throttle
 # ---------------------------------------------------------------------------
@@ -254,16 +296,24 @@ def __init__(self, raises=None):
         self.calls: list = []
         self._raises = raises
 
-    async def __call__(self, uid, name, namespace, detail, *, gpu_class, gpu_count):
+    async def __call__(
+        self, uid, name, namespace, detail, *, gpu_class, gpu_count, duration_seconds
+    ):
         if self._raises is not None:
             raise self._raises
-        self.calls.append((uid, name, namespace, detail, gpu_class, gpu_count))
+        self.calls.append(
+            (uid, name, namespace, detail, gpu_class, gpu_count, duration_seconds)
+        )
 
 
 def _run(m, monkeypatch, config, candidate, detail, now, recorder=None):
     recorder = recorder or _Recorder()
     monkeypatch.setattr(m, "emit_lease_denied_event", recorder)
-    asyncio.run(m._emit_lease_denial_event(config, "uid-1", candidate, detail, now))
+    asyncio.run(
+        m._emit_lease_denial_event(
+            config, "uid-1", candidate, detail, now, LEASE_SECONDS
+        )
+    )
     return recorder
 
 
@@ -386,7 +436,7 @@ def _grant_and_admit(m, monkeypatch, status, detail, config=None):
         group_name=GROUP_NAME,
         gpu_class_id=GPU_CLASS_ID,
         gpu_count=2,
-        duration_seconds=1200,
+        duration_seconds=LEASE_SECONDS,
     )
     done = asyncio.run(
         m._grant_and_admit(
@@ -405,6 +455,14 @@ def test_409_reaches_the_pod(self, monkeypatch):
         assert len(rec.calls) == 1
         assert rec.calls[0][3] == DETAIL
 
+    def test_the_reported_duration_is_the_one_that_was_asked_for(self, monkeypatch):
+        # Taken from the preflight-built ask (minimum runtime + buffer), not
+        # re-derived at the Event, so the pod states the duration the app
+        # actually refused.
+        m = _main_module(monkeypatch)
+        rec, _candidate_out = _grant_and_admit(m, monkeypatch, 409, DETAIL)
+        assert rec.calls[0][6] == LEASE_SECONDS
+
     def test_409_detail_is_logged_alongside(self, monkeypatch, caplog):
         m = _main_module(monkeypatch)
         monkeypatch.setattr(m, "emit_lease_denied_event", _Recorder())