fix(webapp): stop session durations climbing forever when no run is live

Sessions kept an ever-growing wall-clock duration because the cell ticked for
any open session, even when its run had finished long ago. The duration now
ticks only while a run is genuinely executing; otherwise it freezes at the last
run's completion (or shows a dash if it never ran). Session status stays the
existing filterable ACTIVE/CLOSED/EXPIRED set, so there is nothing new to
filter. This drops the earlier display-only IDLE status, which was not
filterable.

Author: D-K-P

.server-changes/sessions-idle-status.md

@@ -3,4 +3,4 @@ area: webapp
 type: fix
 ---
 
-The Sessions list no longer shows an abandoned session as Active with a duration that climbs forever. A session whose run has finished now shows as Idle with a duration frozen at when it stopped, and only sessions with a run still executing show as Active.
+The Sessions list no longer shows an ever-growing duration for a session whose run finished long ago. The duration now stops at the last run's activity, and only sessions with a run still executing keep counting up.

apps/webapp/app/components/sessions/v1/SessionStatus.tsx

@@ -1,34 +1,26 @@
 import { CheckCircleIcon, ClockIcon } from "@heroicons/react/20/solid";
 import assertNever from "assert-never";
-import {
-  type SessionDisplayStatus,
-  type SessionStatus,
-} from "~/services/sessionsRepository/sessionsRepository.server";
+import { type SessionStatus } from "~/services/sessionsRepository/sessionsRepository.server";
 import { cn } from "~/utils/cn";
 
-// Filterable statuses only — `IDLE` is display-only and derived from run
-// liveness, so it never appears in the filter surface.
 export const allSessionStatuses = ["ACTIVE", "CLOSED", "EXPIRED"] as const satisfies Readonly<
   Array<SessionStatus>
 >;
 
-const descriptions: Record<SessionDisplayStatus, string> = {
+const descriptions: Record<SessionStatus, string> = {
   ACTIVE: "The session is open and can receive input or schedule new runs.",
-  IDLE: "The session is open but has no run currently executing.",
   CLOSED: "The session was closed; no further input or runs can be triggered against it.",
   EXPIRED: "The session passed its expiry time without being closed explicitly.",
 };
 
-export function descriptionForSessionStatus(status: SessionDisplayStatus): string {
+export function descriptionForSessionStatus(status: SessionStatus): string {
   return descriptions[status];
 }
 
-export function sessionStatusTitle(status: SessionDisplayStatus): string {
+export function sessionStatusTitle(status: SessionStatus): string {
   switch (status) {
     case "ACTIVE":
       return "Active";
-    case "IDLE":
-      return "Idle";
     case "CLOSED":
       return "Closed";
     case "EXPIRED":
@@ -38,12 +30,10 @@ export function sessionStatusTitle(status: SessionDisplayStatus): string {
   }
 }
 
-export function sessionStatusColor(status: SessionDisplayStatus): string {
+export function sessionStatusColor(status: SessionStatus): string {
   switch (status) {
     case "ACTIVE":
       return "text-pending";
-    case "IDLE":
-      return "text-text-dimmed";
     case "CLOSED":
       return "text-success";
     case "EXPIRED":
@@ -58,7 +48,7 @@ export function SessionStatusIcon({
   className,
   pulse = true,
 }: {
-  status: SessionDisplayStatus;
+  status: SessionStatus;
   className: string;
   pulse?: boolean;
 }) {
@@ -74,14 +64,6 @@ export function SessionStatusIcon({
           </span>
         </span>
       );
-    case "IDLE":
-      // Open but not live: a static, dimmed dot (no pulse) — distinct from
-      // ACTIVE's pulsing dot and EXPIRED's clock.
-      return (
-        <span className={cn("inline-flex items-center justify-center", className)}>
-          <span className="size-2 rounded-full bg-text-dimmed" />
-        </span>
-      );
     case "CLOSED":
       return <CheckCircleIcon className={cn(sessionStatusColor(status), className)} />;
     case "EXPIRED":
@@ -91,7 +73,7 @@ export function SessionStatusIcon({
   }
 }
 
-export function SessionStatusLabel({ status }: { status: SessionDisplayStatus }) {
+export function SessionStatusLabel({ status }: { status: SessionStatus }) {
   // system-mono-label: System themes uncolor the label (see tailwind.css)
   return (
     <span className={cn("system-mono-label", sessionStatusColor(status))}>
@@ -106,7 +88,7 @@ export function SessionStatusCombo({
   iconClassName,
   pulse = true,
 }: {
-  status: SessionDisplayStatus;
+  status: SessionStatus;
   className?: string;
   iconClassName?: string;
   pulse?: boolean;

apps/webapp/app/components/sessions/v1/SessionsTable.tsx

@@ -195,28 +195,37 @@ export function SessionsTable({
 }
 
 function SessionDuration({ session }: { session: SessionListItem }) {
-  // Only a genuinely live session ticks. Everything else freezes at the moment
-  // it stopped being live: closedAt for explicit closes, expiresAt when the TTL
-  // ran out, or the current run's completedAt for an idle (open, not-running)
-  // session — so an abandoned session doesn't count up forever.
-  if (session.status === "ACTIVE") {
-    return <LiveTimer startTime={new Date(session.createdAt)} />;
-  }
-
-  const endedAt =
+  // Closed and expired sessions freeze at the moment they ended.
+  const terminalEnd =
     session.status === "CLOSED"
       ? session.closedAt
       : session.status === "EXPIRED"
         ? session.expiresAt
-        : session.currentRunCompletedAt;
+        : undefined;
+
+  if (terminalEnd) {
+    return (
+      <>{formatDuration(new Date(session.createdAt), new Date(terminalEnd), { style: "short" })}</>
+    );
+  }
+
+  // An open session ticks only while a run is genuinely executing; otherwise it
+  // freezes at the last run's completion so the duration doesn't climb forever.
+  if (session.hasLiveRun) {
+    return <LiveTimer startTime={new Date(session.createdAt)} />;
+  }
 
-  if (endedAt) {
+  if (session.currentRunCompletedAt) {
     return (
-      <>{formatDuration(new Date(session.createdAt), new Date(endedAt), { style: "short" })}</>
+      <>
+        {formatDuration(new Date(session.createdAt), new Date(session.currentRunCompletedAt), {
+          style: "short",
+        })}
+      </>
     );
   }
 
-  // Idle session that never ran — nothing to measure.
+  // Open session that never ran — nothing to measure.
   return <span className="text-text-dimmed">–</span>;
 }
 

apps/webapp/app/presenters/v3/SessionListPresenter.server.ts

@@ -14,7 +14,7 @@ import {
   LEGACY_PLAYGROUND_TAG,
 } from "~/services/sessionsRepository/sessionsRepository.server";
 import { ServiceValidationError } from "~/v3/services/baseService.server";
-import { deriveSessionStatus } from "./deriveSessionStatus";
+import { isSessionLive } from "./isSessionLive";
 import { findCurrentWorkerFromEnvironment } from "~/v3/models/workerDeployment.server";
 import { runStore } from "~/v3/runStore.server";
 import { startActiveSpan } from "~/v3/tracer.server";
@@ -212,15 +212,18 @@ export class SessionListPresenter {
       sessions: sessions.map((session) => {
         const currentRun = session.currentRunId ? runById.get(session.currentRunId) : undefined;
 
-        // A session is only ACTIVE while its current run is genuinely live.
-        // Open sessions whose run has terminated (or that have no run) read
-        // IDLE rather than ticking ACTIVE forever.
-        const status = deriveSessionStatus({
-          closedAt: session.closedAt,
-          expiresAt: session.expiresAt,
+        const status: SessionStatus =
+          session.closedAt != null
+            ? "CLOSED"
+            : session.expiresAt != null && session.expiresAt.getTime() < now
+              ? "EXPIRED"
+              : "ACTIVE";
+
+        // Whether a run is genuinely executing right now. Drives the duration
+        // cell (tick vs freeze); it does NOT affect the filterable status.
+        const hasLiveRun = isSessionLive({
           hasCurrentRun: session.currentRunId != null,
           currentRunStatus: currentRun?.status,
-          now,
         });
 
         return {
@@ -244,8 +247,9 @@ export class SessionListPresenter {
           updatedAt: session.updatedAt.toISOString(),
           environment: displayableEnvironment,
           currentRunFriendlyId: currentRun?.friendlyId,
-          // Freeze point for an IDLE session's duration — when its current run
-          // finished. Undefined when the session never ran (renders as a dash).
+          hasLiveRun,
+          // Freeze point for the duration when the session isn't live: when its
+          // current run finished. Undefined when it never ran (renders a dash).
           currentRunCompletedAt: currentRun?.completedAt
             ? currentRun.completedAt.toISOString()
             : undefined,

apps/webapp/app/presenters/v3/SpanPresenter.server.ts

@@ -36,7 +36,6 @@ import { runStore } from "~/v3/runStore.server";
 import { getTaskEventStoreTableForRun, type TaskEventStoreTable } from "~/v3/taskEventStore.server";
 import { isFailedRunStatus, isFinalRunStatus } from "~/v3/taskStatus";
 import { BasePresenter } from "./basePresenter.server";
-import { deriveSessionStatus } from "./deriveSessionStatus";
 import { WaitpointPresenter } from "./WaitpointPresenter.server";
 import {
   controlPlaneResolver,
@@ -359,41 +358,25 @@ export class SpanPresenter extends BasePresenter {
                 taskIdentifier: true,
                 closedAt: true,
                 expiresAt: true,
-                currentRunId: true,
               },
             },
           },
         })
       : null;
 
-    // Resolve the session's current run so the badge reflects run liveness
-    // (the same IDLE-vs-ACTIVE distinction as the sessions list/detail), not
-    // just closedAt/expiresAt. Env-scoped, matching the run reads here.
-    const sessionCurrentRun =
-      sessionRun && sessionRun.session.currentRunId
-        ? await runStore.findRun(
-            {
-              id: sessionRun.session.currentRunId,
-              runtimeEnvironmentId: run.runtimeEnvironmentId,
-            },
-            { select: { status: true } },
-            this._replica
-          )
-        : null;
-
     const session = sessionRun
       ? {
           friendlyId: sessionRun.session.friendlyId,
           externalId: sessionRun.session.externalId,
           type: sessionRun.session.type,
           taskIdentifier: sessionRun.session.taskIdentifier,
-          status: deriveSessionStatus({
-            closedAt: sessionRun.session.closedAt,
-            expiresAt: sessionRun.session.expiresAt,
-            hasCurrentRun: sessionRun.session.currentRunId != null,
-            currentRunStatus: sessionCurrentRun?.status,
-            now: Date.now(),
-          }),
+          status:
+            sessionRun.session.closedAt != null
+              ? ("CLOSED" as const)
+              : sessionRun.session.expiresAt != null &&
+                  sessionRun.session.expiresAt.getTime() < Date.now()
+                ? ("EXPIRED" as const)
+                : ("ACTIVE" as const),
           reason: sessionRun.reason,
           triggeredAt: sessionRun.triggeredAt,
         }