Keep interrupted runs stable in issue chat

ui/src/lib/optimistic-issue-runs.test.ts

@@ -0,0 +1,114 @@
+import { describe, expect, it } from "vitest";
+import type { RunForIssue } from "../api/activity";
+import type { ActiveRunForIssue, LiveRunForIssue } from "../api/heartbeats";
+import { removeLiveRunById, upsertInterruptedRun } from "./optimistic-issue-runs";
+
+function createLiveRun(overrides: Partial<LiveRunForIssue> = {}): LiveRunForIssue {
+  return {
+    id: "run-1",
+    status: "running",
+    invocationSource: "manual",
+    triggerDetail: null,
+    startedAt: "2026-04-08T21:00:00.000Z",
+    finishedAt: null,
+    createdAt: "2026-04-08T21:00:00.000Z",
+    agentId: "agent-1",
+    agentName: "CodexCoder",
+    adapterType: "codex_local",
+    ...overrides,
+  };
+}
+
+function createActiveRun(overrides: Partial<ActiveRunForIssue> = {}): ActiveRunForIssue {
+  return {
+    id: "run-1",
+    companyId: "company-1",
+    agentId: "agent-1",
+    agentName: "CodexCoder",
+    adapterType: "codex_local",
+    invocationSource: "on_demand",
+    triggerDetail: null,
+    status: "running",
+    startedAt: new Date("2026-04-08T21:00:00.000Z"),
+    finishedAt: null,
+    error: null,
+    wakeupRequestId: null,
+    exitCode: null,
+    signal: null,
+    usageJson: { inputTokens: 1 },
+    resultJson: { summary: "partial" },
+    sessionIdBefore: null,
+    sessionIdAfter: null,
+    logStore: null,
+    logRef: null,
+    logBytes: null,
+    logSha256: null,
+    logCompressed: false,
+    stdoutExcerpt: null,
+    stderrExcerpt: null,
+    errorCode: null,
+    externalRunId: null,
+    processPid: null,
+    processStartedAt: null,
+    retryOfRunId: null,
+    processLossRetryCount: 0,
+    contextSnapshot: null,
+    createdAt: new Date("2026-04-08T21:00:00.000Z"),
+    updatedAt: new Date("2026-04-08T21:00:00.000Z"),
+    ...overrides,
+  };
+}
+
+describe("upsertInterruptedRun", () => {
+  it("adds a synthetic cancelled historical run when the live run has not reached linkedRuns yet", () => {
+    const runs = upsertInterruptedRun(undefined, createLiveRun(), "2026-04-08T21:00:10.000Z");
+    expect(runs).toEqual([{
+      runId: "run-1",
+      status: "cancelled",
+      agentId: "agent-1",
+      startedAt: "2026-04-08T21:00:00.000Z",
+      finishedAt: "2026-04-08T21:00:10.000Z",
+      createdAt: "2026-04-08T21:00:00.000Z",
+      invocationSource: "manual",
+      usageJson: null,
+      resultJson: null,
+    }]);
+  });
+
+  it("updates an existing linked run in place when the interrupted run is already present", () => {
+    const existing: RunForIssue[] = [{
+      runId: "run-1",
+      status: "running",
+      agentId: "agent-1",
+      startedAt: "2026-04-08T21:00:00.000Z",
+      finishedAt: null,
+      createdAt: "2026-04-08T21:00:00.000Z",
+      invocationSource: "manual",
+      usageJson: { inputTokens: 2 },
+      resultJson: { summary: "partial" },
+    }];
+
+    const runs = upsertInterruptedRun(existing, createActiveRun(), "2026-04-08T21:00:11.000Z");
+    expect(runs).toEqual([{
+      runId: "run-1",
+      status: "cancelled",
+      agentId: "agent-1",
+      startedAt: "2026-04-08T21:00:00.000Z",
+      finishedAt: "2026-04-08T21:00:11.000Z",
+      createdAt: "2026-04-08T21:00:00.000Z",
+      invocationSource: "on_demand",
+      usageJson: { inputTokens: 2 },
+      resultJson: { summary: "partial" },
+    }]);
+  });
+});
+
+describe("removeLiveRunById", () => {
+  it("removes an interrupted live run from the live list", () => {
+    const runs = removeLiveRunById([
+      createLiveRun(),
+      createLiveRun({ id: "run-2" }),
+    ], "run-1");
+    expect(runs?.map((run) => run.id)).toEqual(["run-2"]);
+  });
+});

ui/src/lib/optimistic-issue-runs.ts

@@ -0,0 +1,68 @@
+import type { RunForIssue } from "../api/activity";
+import type { ActiveRunForIssue, LiveRunForIssue } from "../api/heartbeats";
+
+export interface InterruptRunSource {
+  id: string;
+  agentId: string;
+  startedAt: Date | string | null;
+  createdAt: Date | string;
+  invocationSource: string;
+  usageJson?: Record<string, unknown> | null;
+  resultJson?: Record<string, unknown> | null;
+}
+
+function toTimestamp(value: Date | string | null | undefined) {
+  if (!value) return 0;
+  return new Date(value).getTime();
+}
+
+function toIsoString(value: Date | string | null | undefined) {
+  if (!value) return null;
+  return value instanceof Date ? value.toISOString() : value;
+}
+
+export function upsertInterruptedRun(
+  runs: RunForIssue[] | undefined,
+  run: InterruptRunSource,
+  finishedAt: string,
+): RunForIssue[] {
+  const nextRun: RunForIssue = {
+    runId: run.id,
+    status: "cancelled",
+    agentId: run.agentId,
+    startedAt: toIsoString(run.startedAt),
+    finishedAt,
+    createdAt: toIsoString(run.createdAt) ?? finishedAt,
+    invocationSource: run.invocationSource,
+    usageJson: run.usageJson ?? null,
+    resultJson: run.resultJson ?? null,
+  };
+
+  const current = runs ?? [];
+  const existingIndex = current.findIndex((entry) => entry.runId === run.id);
+  if (existingIndex === -1) {
+    return [...current, nextRun].sort((a, b) => {
+      const diff = toTimestamp(a.startedAt ?? a.createdAt) - toTimestamp(b.startedAt ?? b.createdAt);
+      if (diff !== 0) return diff;
+      return a.runId.localeCompare(b.runId);
+    });
+  }
+
+  const updated = [...current];
+  updated[existingIndex] = {
+    ...updated[existingIndex],
+    ...nextRun,
+    usageJson: updated[existingIndex]?.usageJson ?? nextRun.usageJson,
+    resultJson: updated[existingIndex]?.resultJson ?? nextRun.resultJson,
+  };
+  return updated;
+}
+
+export function removeLiveRunById(
+  runs: LiveRunForIssue[] | undefined,
+  runId: string,
+) {
+  if (!runs) return runs;
+  const nextRuns = runs.filter((run) => run.id !== runId);
+  return nextRuns.length === runs.length ? runs : nextRuns;
+}