@@ -271,6 +283,7 @@ export function RunWorkspaceRecoverySurface({ run }: { run: HeartbeatRun }) {
{
expect(container.textContent).toContain("Worked");
});
});
+
+describe("TaskChatThread recovery presentation", () => {
+ const recoveryAction = {
+ id: "recovery-1",
+ companyId: "company-1",
+ sourceIssueId: "issue-1",
+ recoveryIssueId: null,
+ kind: "stranded_assigned_issue",
+ status: "active",
+ ownerType: "agent",
+ ownerAgentId: "cto-agent",
+ ownerUserId: null,
+ previousOwnerAgentId: null,
+ returnOwnerAgentId: null,
+ cause: "stranded_assigned_issue",
+ fingerprint: "fp",
+ evidence: {},
+ nextAction: "Choose what happens next.",
+ wakePolicy: null,
+ monitorPolicy: null,
+ attemptCount: 1,
+ maxAttempts: 3,
+ timeoutAt: null,
+ lastAttemptAt: null,
+ outcome: null,
+ resolutionNote: null,
+ resolvedAt: null,
+ createdAt: "2026-08-11T00:00:00.000Z",
+ updatedAt: "2026-08-11T00:00:00.000Z",
+ // eslint-disable-next-line @typescript-eslint/no-explicit-any
+ } as any;
+
+ const liveOwnerRun = {
+ id: "run-1",
+ status: "running",
+ agentId: "cto-agent",
+ agentName: "CTO",
+ createdAt: "2026-08-11T00:00:00.000Z",
+ startedAt: "2026-08-11T00:00:00.000Z",
+ finishedAt: null,
+ issueId: "issue-1",
+ // eslint-disable-next-line @typescript-eslint/no-explicit-any
+ } as any;
+
+ it("renders a live recovery owner as a recessed, expandable line", () => {
+ render(
+ {}}
+ issueId="issue-1"
+ issueStatus="in_progress"
+ recoveryAction={recoveryAction}
+ liveRuns={[liveOwnerRun]}
+ onResolveRecoveryAction={() => {}}
+ />,
+ );
+
+ const line = container.querySelector('[data-testid="recovery-progress-line"]');
+ expect(line).not.toBeNull();
+ expect(line?.getAttribute("data-recovery-state")).toBe("in_progress");
+ expect(container.textContent).toContain("Recovery in progress · CTO");
+ expect(container.textContent).not.toContain("Recovery needed");
+ // Folded by default — no second, prominent recovery surface.
+ expect(container.querySelector('[data-testid="recovery-progress-line-details"]')).toBeNull();
+
+ const toggle = container.querySelector('[data-testid="recovery-progress-line-toggle"]');
+ flushSync(() => {
+ toggle?.dispatchEvent(new MouseEvent("click", { bubbles: true }));
+ });
+ expect(container.querySelector('[data-testid="recovery-progress-line-details"]')).not.toBeNull();
+ expect(container.querySelectorAll("[data-recovery-state][role='status']").length).toBe(1);
+ });
+
+ it("keeps the prominent card when no owner is live or queued", () => {
+ render(
+ {}}
+ issueId="issue-1"
+ issueStatus="todo"
+ recoveryAction={recoveryAction}
+ onResolveRecoveryAction={() => {}}
+ />,
+ );
+
+ expect(container.querySelector('[data-testid="recovery-progress-line"]')).toBeNull();
+ const card = container.querySelector("[data-recovery-state][role='status']");
+ expect(card?.getAttribute("data-recovery-state")).toBe("needed");
+ expect(container.textContent).toContain("RECOVERY NEEDED");
+ });
+
+ it("renders nothing when there is no recovery action", () => {
+ render( {}} issueId="issue-1" />);
+ expect(container.querySelector('[data-testid="task-chat-recovery-notice"]')).toBeNull();
+ });
+});
diff --git a/ui/src/components/TaskChatThread.tsx b/ui/src/components/TaskChatThread.tsx
index 86ce55de929..72cc1621d42 100644
--- a/ui/src/components/TaskChatThread.tsx
+++ b/ui/src/components/TaskChatThread.tsx
@@ -40,6 +40,9 @@ import { TaskChatThreadView, taskChatContentKey } from "@/components/task-chat/T
import { TaskChatComposer } from "@/components/task-chat/TaskChatComposer";
import { useWindowAutoFollow } from "@/components/task-chat/useWindowAutoFollow";
import { useSidebar } from "@/context/SidebarContext";
+import { IssueRecoveryActionCard } from "@/components/IssueRecoveryActionCard";
+import { RecoveryProgressLine } from "@/components/RecoveryProgressLine";
+import { deriveRecoveryPresentation } from "@/lib/recovery-display";
import { cn } from "@/lib/utils";
import { Button } from "@/components/ui/button";
import { useIssuePlanDocument } from "@/hooks/useIssuePlanDocument";
@@ -126,8 +129,58 @@ export function TaskChatThread(props: TaskChatThreadProps) {
draftKey,
onInterruptQueued,
interruptingQueuedRunId,
+ liveIssueIds,
+ scheduledRetry,
+ successfulRunHandoff,
+ recoveryAction,
+ onResolveRecoveryAction,
+ onReissueIsolatedRecoveryAction,
+ reissueIsolatedRecoveryActionPending,
+ onReconcileForwardRecoveryAction,
+ onBreakGlassOverrideRecoveryAction,
+ onQuarantineRestoreRecoveryAction,
+ quarantineRestoreRecoveryActionPending,
+ canBreakGlassRecoveryAction,
+ reconcileRecoveryActionPending,
+ canFalsePositiveRecoveryAction,
} = props;
+ // Recovery in the chat shell. A live or queued recovery owner renders as the
+ // same recessed one-liner the classic thread uses (in the register of
+ // TaskChatSystemNotice), so the chat never shouts "Recovery needed" over an
+ // owner who is already working. Only an ownerless or escalated action gets the
+ // prominent card.
+ const recoveryDisplay = useMemo(
+ () =>
+ deriveRecoveryPresentation({
+ action: recoveryAction,
+ liveRuns: [
+ ...(liveRuns ?? []).filter((run) => isLiveIssueRun(run, issueStatus)),
+ ...(activeRun && isLiveIssueRun(activeRun, issueStatus)
+ ? [{ agentId: activeRun.agentId, agentName: activeRun.agentName, status: activeRun.status }]
+ : []),
+ ],
+ issueId,
+ liveIssueIds,
+ issueAssigneeAgentId,
+ scheduledRetry,
+ successfulRunHandoff,
+ resolveAgentName: (agentId) => agentMap?.get(agentId)?.name,
+ }),
+ [
+ activeRun,
+ agentMap,
+ issueAssigneeAgentId,
+ issueId,
+ issueStatus,
+ liveIssueIds,
+ liveRuns,
+ recoveryAction,
+ scheduledRetry,
+ successfulRunHandoff,
+ ],
+ );
+
const linkedRunMetaById = useMemo(() => {
const map = new Map[number]>();
for (const run of linkedRuns ?? []) map.set(run.runId, run);
@@ -655,6 +708,45 @@ export function TaskChatThread(props: TaskChatThreadProps) {
"mx-auto flex w-full max-w-(--tc-shell-max-w) flex-col gap-2 bg-background/80 px-4 pb-2 pt-1 backdrop-blur supports-[backdrop-filter]:bg-background/60 md:w-(--pct-80)",
)}
>
+ {recoveryAction && recoveryDisplay ? (
+
+ {recoveryDisplay.state === "in_progress" ||
+ recoveryDisplay.state === "observe_only" ? (
+
+ ) : (
+
+ )}
+
+ ) : null}
{composerAccessory}
= {
stalled: "Blocked chain stalled",
needs_attention: "Needs attention",
recovery_required: "Recovery required",
+ recovery_in_progress: "Recovery in progress",
external_wait: "External wait",
owner_paused: "Owner paused",
};
@@ -70,7 +73,20 @@ const SEVERITY_RANK: Record = {
export type BlockedInboxBadgeTone = "muted" | "amber" | "red";
-export function blockedReasonVariant(reason: IssueBlockedInboxReason): BlockedReasonVariant {
+export function blockedReasonVariant(
+ reason: IssueBlockedInboxReason,
+ options?: {
+ /**
+ * The task's recovery action is already owned by a live/queued runner (or has
+ * been folded to observation). An open recovery issue in that state is
+ * progress, not an operator request, so it drops to the recessed variant.
+ */
+ recoveryRecessed?: boolean;
+ },
+): BlockedReasonVariant {
+ if (reason === "open_recovery_issue" && options?.recoveryRecessed) {
+ return "recovery_in_progress";
+ }
return VARIANT_BY_REASON[reason] ?? "needs_attention";
}
diff --git a/ui/src/lib/recovery-display.test.ts b/ui/src/lib/recovery-display.test.ts
index 63235714bce..c1c36d37d2b 100644
--- a/ui/src/lib/recovery-display.test.ts
+++ b/ui/src/lib/recovery-display.test.ts
@@ -2,9 +2,24 @@ import { describe, expect, it } from "vitest";
import {
deriveActiveRecoveryDisplayState,
deriveRecoveryDisplayState,
+ deriveRecoveryPresentation,
+ isRecessedRecoveryState,
recoveryChipLabel,
+ recoveryLivenessFromIssue,
+ RECOVERY_CHIP_DEFAULT_TONE,
} from "./recovery-display";
+const CTO_ID = "cto-agent-id";
+const CODER_ID = "coder-agent-id";
+
+const base = {
+ status: "active" as const,
+ kind: "missing_disposition" as const,
+ outcome: null,
+ ownerAgentId: CTO_ID,
+ recoveryIssueId: null,
+};
+
describe("recoveryChipLabel", () => {
it("returns the workspace-specific label when kind is workspace_validation and state is needed", () => {
expect(recoveryChipLabel("needed", "workspace_validation")).toBe(
@@ -29,15 +44,52 @@ describe("recoveryChipLabel", () => {
"Observing active run",
);
});
+
+ it("names the live recovery owner on the in-progress line", () => {
+ expect(recoveryChipLabel("in_progress", "missing_disposition", { ownerName: "CTO" })).toBe(
+ "Recovery in progress · CTO",
+ );
+ });
+
+ it("ignores an owner name for states that are not in progress", () => {
+ expect(recoveryChipLabel("needed", "missing_disposition", { ownerName: "CTO" })).toBe(
+ "Recovery needed",
+ );
+ expect(recoveryChipLabel("escalated", "missing_disposition", { ownerName: "CTO" })).toBe(
+ "Recovery escalated",
+ );
+ });
+
+ it("ignores a blank owner name", () => {
+ expect(recoveryChipLabel("in_progress", "missing_disposition", { ownerName: " " })).toBe(
+ "Recovery in progress",
+ );
+ });
+});
+
+describe("recovery tones", () => {
+ it("keeps prominent amber/red only for needed and escalated", () => {
+ expect(RECOVERY_CHIP_DEFAULT_TONE.needed.recessed).toBe(false);
+ expect(RECOVERY_CHIP_DEFAULT_TONE.escalated.recessed).toBe(false);
+ expect(RECOVERY_CHIP_DEFAULT_TONE.in_progress.recessed).toBe(true);
+ expect(RECOVERY_CHIP_DEFAULT_TONE.observe_only.recessed).toBe(true);
+ });
+
+ it("gives the in-progress chip no amber or red treatment", () => {
+ expect(RECOVERY_CHIP_DEFAULT_TONE.in_progress.className).not.toMatch(/amber|red/);
+ expect(RECOVERY_CHIP_DEFAULT_TONE.observe_only.className).not.toMatch(/amber|red/);
+ });
+
+ it("classifies recessed states", () => {
+ expect(isRecessedRecoveryState("in_progress")).toBe(true);
+ expect(isRecessedRecoveryState("observe_only")).toBe(true);
+ expect(isRecessedRecoveryState("resolved")).toBe(true);
+ expect(isRecessedRecoveryState("needed")).toBe(false);
+ expect(isRecessedRecoveryState("escalated")).toBe(false);
+ });
});
describe("deriveRecoveryDisplayState", () => {
- const base = {
- status: "active" as const,
- kind: "missing_disposition" as const,
- outcome: null,
- };
-
it("classifies workspace_validation active as needed", () => {
expect(deriveRecoveryDisplayState({ ...base, kind: "workspace_validation" })).toBe(
"needed",
@@ -46,4 +98,216 @@ describe("deriveRecoveryDisplayState", () => {
deriveActiveRecoveryDisplayState({ ...base, kind: "workspace_validation" }),
).toBe("needed");
});
+
+ it("keeps needed when nothing is live or queued", () => {
+ expect(deriveRecoveryDisplayState(base, {})).toBe("needed");
+ });
+
+ it("prefers the server-projected display state when present", () => {
+ expect(
+ deriveRecoveryDisplayState({ ...base, displayState: "observe_only" } as never, {
+ sourceHasLiveRun: false,
+ }),
+ ).toBe("observe_only");
+ });
+
+ it("ignores an unrecognized server-projected display state", () => {
+ expect(deriveRecoveryDisplayState({ ...base, displayState: "bogus" } as never)).toBe("needed");
+ });
+
+ it("reads a running recovery-owner run as in progress", () => {
+ expect(
+ deriveRecoveryDisplayState(base, {
+ ownerRun: { agentId: CTO_ID, status: "running" },
+ }),
+ ).toBe("in_progress");
+ });
+
+ it("reads a queued recovery-owner run as in progress", () => {
+ expect(
+ deriveRecoveryDisplayState(base, {
+ ownerRun: { agentId: CTO_ID, status: "queued" },
+ }),
+ ).toBe("in_progress");
+ });
+
+ it("does not treat a finished owner run as liveness", () => {
+ expect(
+ deriveRecoveryDisplayState(base, {
+ ownerRun: { agentId: CTO_ID, status: "completed" },
+ }),
+ ).toBe("needed");
+ });
+
+ it("does not credit another agent's live run to the recovery owner", () => {
+ expect(
+ deriveRecoveryDisplayState(base, {
+ ownerRun: { agentId: CODER_ID, status: "running" },
+ }),
+ ).toBe("needed");
+ });
+
+ // PAP-16986: recovery escalated to the CTO while the CTO was already running.
+ it("shows an escalated action with a live owner run as in progress, not escalated", () => {
+ expect(
+ deriveRecoveryDisplayState(
+ { ...base, status: "escalated" },
+ { ownerRun: { agentId: CTO_ID, status: "running" } },
+ ),
+ ).toBe("in_progress");
+ });
+
+ it("keeps escalated prominent when no owner is live", () => {
+ expect(deriveRecoveryDisplayState({ ...base, status: "escalated" }, {})).toBe("escalated");
+ });
+
+ it("reads a live source run owned by the recovery owner as in progress", () => {
+ expect(
+ deriveRecoveryDisplayState(base, {
+ sourceHasLiveRun: true,
+ sourceLiveRunAgentId: CTO_ID,
+ }),
+ ).toBe("in_progress");
+ });
+
+ it("folds the action to observation when a different owner took the task over", () => {
+ expect(
+ deriveRecoveryDisplayState(base, {
+ sourceHasLiveRun: true,
+ sourceLiveRunAgentId: CODER_ID,
+ }),
+ ).toBe("observe_only");
+ });
+
+ it("reads a queued wake as in progress", () => {
+ expect(deriveRecoveryDisplayState(base, { hasQueuedWake: true })).toBe("in_progress");
+ });
+
+ it("reads a delegated outcome or a recovery issue as in progress", () => {
+ expect(deriveRecoveryDisplayState({ ...base, outcome: "delegated" })).toBe("in_progress");
+ expect(deriveRecoveryDisplayState({ ...base, recoveryIssueId: "issue-1" })).toBe(
+ "in_progress",
+ );
+ });
+
+ it("observes rather than warns when the successful-run handoff has a live continuation", () => {
+ expect(deriveRecoveryDisplayState(base, { hasLiveContinuation: true })).toBe("observe_only");
+ });
+
+ it("keeps the watchdog observational", () => {
+ expect(deriveRecoveryDisplayState({ ...base, kind: "active_run_watchdog" })).toBe(
+ "observe_only",
+ );
+ });
+
+ it("still escalates a watchdog that escalated", () => {
+ expect(
+ deriveRecoveryDisplayState({ ...base, kind: "active_run_watchdog", status: "escalated" }),
+ ).toBe("escalated");
+ });
+
+ it("treats resolved and cancelled as resolved regardless of liveness", () => {
+ expect(
+ deriveRecoveryDisplayState(
+ { ...base, status: "resolved" },
+ { ownerRun: { agentId: CTO_ID, status: "running" } },
+ ),
+ ).toBe("resolved");
+ expect(deriveRecoveryDisplayState({ ...base, status: "cancelled" })).toBe("resolved");
+ expect(deriveActiveRecoveryDisplayState({ ...base, status: "resolved" })).toBeNull();
+ });
+});
+
+describe("recoveryLivenessFromIssue", () => {
+ it("reads the execution lock, queued retry, and handoff projection", () => {
+ expect(
+ recoveryLivenessFromIssue({
+ executionRunId: "run-1",
+ assigneeAgentId: CTO_ID,
+ scheduledRetry: { status: "scheduled_retry" },
+ successfulRunHandoff: { hasLiveContinuation: true },
+ }),
+ ).toEqual({
+ sourceHasLiveRun: true,
+ sourceLiveRunAgentId: CTO_ID,
+ hasQueuedWake: true,
+ hasLiveContinuation: true,
+ });
+ });
+
+ it("does not attribute an assignee when no run is live", () => {
+ expect(
+ recoveryLivenessFromIssue({ executionRunId: null, assigneeAgentId: CTO_ID }),
+ ).toMatchObject({ sourceHasLiveRun: false, sourceLiveRunAgentId: null });
+ });
+
+ it("ignores a cancelled scheduled retry", () => {
+ expect(
+ recoveryLivenessFromIssue({ scheduledRetry: { status: "cancelled" } }),
+ ).toMatchObject({ hasQueuedWake: false });
+ });
+
+ it("lets explicit signals override the issue-derived ones", () => {
+ expect(
+ recoveryLivenessFromIssue(
+ { executionRunId: null },
+ { sourceHasLiveRun: true, sourceLiveRunAgentId: CODER_ID },
+ ),
+ ).toMatchObject({ sourceHasLiveRun: true, sourceLiveRunAgentId: CODER_ID });
+ });
+
+ it("tolerates a missing issue", () => {
+ expect(recoveryLivenessFromIssue(null)).toMatchObject({ sourceHasLiveRun: false });
+ });
+});
+
+describe("deriveRecoveryPresentation", () => {
+ it("returns null without an action", () => {
+ expect(deriveRecoveryPresentation({ action: null })).toBeNull();
+ });
+
+ it("names the live recovery owner from the run list", () => {
+ expect(
+ deriveRecoveryPresentation({
+ action: base,
+ liveRuns: [{ agentId: CTO_ID, agentName: "CTO", status: "running" }],
+ }),
+ ).toEqual({ state: "in_progress", ownerName: "CTO", recessed: true });
+ });
+
+ it("falls back to the agent map for the owner name", () => {
+ expect(
+ deriveRecoveryPresentation({
+ action: base,
+ scheduledRetry: { status: "queued" },
+ resolveAgentName: (agentId) => (agentId === CTO_ID ? "CTO" : null),
+ }),
+ ).toEqual({ state: "in_progress", ownerName: "CTO", recessed: true });
+ });
+
+ it("counts a live-issue id as source liveness", () => {
+ expect(
+ deriveRecoveryPresentation({
+ action: base,
+ issueId: "issue-1",
+ liveIssueIds: new Set(["issue-1"]),
+ issueAssigneeAgentId: CODER_ID,
+ }),
+ ).toMatchObject({ state: "observe_only", recessed: true });
+ });
+
+ it("keeps an ownerless action prominent", () => {
+ expect(
+ deriveRecoveryPresentation({ action: { ...base, ownerAgentId: null } }),
+ ).toEqual({ state: "needed", ownerName: null, recessed: false });
+ });
+
+ it("ignores terminal runs in the live list", () => {
+ expect(
+ deriveRecoveryPresentation({
+ action: base,
+ liveRuns: [{ agentId: CTO_ID, agentName: "CTO", status: "completed" }],
+ }),
+ ).toMatchObject({ state: "needed", recessed: false });
+ });
});
diff --git a/ui/src/lib/recovery-display.ts b/ui/src/lib/recovery-display.ts
index b0f3a92a581..67e3c1403c7 100644
--- a/ui/src/lib/recovery-display.ts
+++ b/ui/src/lib/recovery-display.ts
@@ -10,58 +10,251 @@ export type RecoveryDisplayState =
export type ActiveRecoveryDisplayState = Exclude;
+const RECOVERY_DISPLAY_STATES = new Set([
+ "needed",
+ "in_progress",
+ "observe_only",
+ "escalated",
+ "resolved",
+]);
+
export const RECOVERY_CHIP_DEFAULT_TONE: Record<
ActiveRecoveryDisplayState,
- { className: string; icon: typeof TriangleAlert; label: string }
+ { className: string; icon: typeof TriangleAlert; label: string; recessed: boolean }
> = {
needed: {
className:
"border-amber-500/60 bg-amber-500/15 text-amber-700 dark:text-amber-300",
icon: TriangleAlert,
label: "Recovery needed",
+ recessed: false,
},
+ // Recessed on purpose: a recovery owner is already live or queued, so this is
+ // progress reporting, not a call to action. Prominent amber/red is reserved
+ // for `needed` (no owner/path) and `escalated` (a decision is truly required).
in_progress: {
- className:
- "border-sky-500/60 bg-sky-500/15 text-sky-700 dark:text-sky-300",
+ className: "border-border bg-muted text-muted-foreground",
icon: RefreshCw,
label: "Recovery in progress",
+ recessed: true,
},
observe_only: {
className: "border-border bg-muted text-muted-foreground",
icon: Eye,
label: "Observing active run",
+ recessed: true,
},
escalated: {
className: "border-red-500/60 bg-red-500/15 text-red-700 dark:text-red-300",
icon: OctagonAlert,
label: "Recovery escalated",
+ recessed: false,
},
};
+/** States that render as a quiet, foldable line instead of a prominent card. */
+export function isRecessedRecoveryState(state: RecoveryDisplayState): boolean {
+ return state === "in_progress" || state === "observe_only" || state === "resolved";
+}
+
+/**
+ * Liveness a surface knows about the *source* task and the recovery owner.
+ *
+ * Recovery classification is only honest when it accounts for who is actually
+ * running: a recovery action whose owner is mid-run is "in progress", and a
+ * newer durable source-owner path invalidates a stale recovery action. Surfaces
+ * pass whatever they have; every field is optional and absence means "unknown"
+ * (which degrades to the pre-liveness classification).
+ */
+export interface RecoveryLivenessSignals {
+ /**
+ * A run the surface is already rendering (e.g. the run card in the active-agents
+ * panel). Counts as recovery-owner liveness when its agent owns the action.
+ */
+ ownerRun?: { agentId?: string | null; status?: string | null } | null;
+ /** The source task holds a live/queued execution run. */
+ sourceHasLiveRun?: boolean;
+ /** Agent behind the source task's live run, when known. */
+ sourceLiveRunAgentId?: string | null;
+ /** A queued wake (scheduled retry) is pending on the source task. */
+ hasQueuedWake?: boolean;
+ /** The successful-run handoff projection reports a live continuation. */
+ hasLiveContinuation?: boolean;
+}
+
+const LIVE_RUN_STATUSES = new Set(["queued", "running"]);
+const QUEUED_WAKE_STATUSES = new Set(["scheduled_retry", "queued", "running"]);
+
+/** Shape of the fields `recoveryLivenessFromIssue` reads; satisfied by `Issue`/`CompactIssue`. */
+export interface RecoveryLivenessIssueLike {
+ id?: string;
+ status?: string | null;
+ executionRunId?: string | null;
+ assigneeAgentId?: string | null;
+ scheduledRetry?: { status?: string | null } | null;
+ successfulRunHandoff?: { hasLiveContinuation?: boolean } | null;
+}
+
+/**
+ * Derives liveness from an issue payload alone — the execution lock, the queued
+ * retry, and the successful-run handoff projection. Surfaces with richer run
+ * data (a live run list, a rendered run card) should merge it in via `extra`.
+ */
+export function recoveryLivenessFromIssue(
+ issue: RecoveryLivenessIssueLike | null | undefined,
+ extra?: RecoveryLivenessSignals,
+): RecoveryLivenessSignals {
+ const sourceHasLiveRun = Boolean(issue?.executionRunId);
+ const retryStatus = issue?.scheduledRetry?.status ?? null;
+ return {
+ sourceHasLiveRun,
+ sourceLiveRunAgentId: sourceHasLiveRun ? issue?.assigneeAgentId ?? null : null,
+ hasQueuedWake: retryStatus ? QUEUED_WAKE_STATUSES.has(retryStatus) : false,
+ hasLiveContinuation: issue?.successfulRunHandoff?.hasLiveContinuation ?? false,
+ ...extra,
+ };
+}
+
+/**
+ * The server-side recovery projection (`displayState`), read defensively.
+ *
+ * The owner-sticky recovery contract publishes the authoritative state on the
+ * action itself. Until every deployment emits it the field is absent, so the
+ * client derivation below stands in — but whenever the server does project a
+ * state, it wins over anything inferred here.
+ */
+function readProjectedState(action: object): RecoveryDisplayState | null {
+ const projected = (action as { displayState?: unknown }).displayState;
+ return typeof projected === "string" && RECOVERY_DISPLAY_STATES.has(projected)
+ ? (projected as RecoveryDisplayState)
+ : null;
+}
+
+type RecoveryActionForDisplay = Pick &
+ Partial>;
+
+function ownerRunIsLive(
+ action: RecoveryActionForDisplay,
+ signals: RecoveryLivenessSignals | undefined,
+): boolean {
+ const run = signals?.ownerRun;
+ if (!run) return false;
+ if (!run.status || !LIVE_RUN_STATUSES.has(run.status)) return false;
+ // An unattributed run can't be proven to be the recovery owner's.
+ if (!action.ownerAgentId || !run.agentId) return false;
+ return run.agentId === action.ownerAgentId;
+}
+
export function deriveRecoveryDisplayState(
- action: Pick,
+ action: RecoveryActionForDisplay,
+ signals?: RecoveryLivenessSignals,
): RecoveryDisplayState {
+ const projected = readProjectedState(action);
+ if (projected) return projected;
+
if (action.status === "resolved") return "resolved";
- if (action.status === "escalated") return "escalated";
if (action.status === "cancelled") return "resolved";
- if (action.kind === "active_run_watchdog") return "observe_only";
+ // The watchdog never asks for a decision — it exists to observe a live run.
+ if (action.kind === "active_run_watchdog" && action.status !== "escalated") {
+ return "observe_only";
+ }
+ // A proven live/queued run by the recovery owner outranks escalation: the
+ // escalation already found an owner and that owner is working it.
+ if (ownerRunIsLive(action, signals)) return "in_progress";
+ if (action.status === "escalated") return "escalated";
+ if (signals?.sourceHasLiveRun) {
+ const ownerIsRunning =
+ Boolean(action.ownerAgentId) && signals.sourceLiveRunAgentId === action.ownerAgentId;
+ // Someone other than the recovery owner is live on the source task — a newer
+ // durable source-owner path that folds this action down to observation.
+ return ownerIsRunning ? "in_progress" : "observe_only";
+ }
+ if (signals?.hasQueuedWake) return "in_progress";
if (action.outcome === "delegated") return "in_progress";
+ if (action.recoveryIssueId) return "in_progress";
+ if (signals?.hasLiveContinuation) return "observe_only";
return "needed";
}
export function deriveActiveRecoveryDisplayState(
- action: Pick,
+ action: RecoveryActionForDisplay,
+ signals?: RecoveryLivenessSignals,
): ActiveRecoveryDisplayState | null {
- const state = deriveRecoveryDisplayState(action);
+ const state = deriveRecoveryDisplayState(action, signals);
return state === "resolved" ? null : state;
}
+/** Minimal run shape the presentation derivation needs; `LiveRunForIssue` satisfies it. */
+export interface RecoveryLivenessRun {
+ agentId?: string | null;
+ agentName?: string | null;
+ status?: string | null;
+}
+
+export interface RecoveryPresentation {
+ state: RecoveryDisplayState;
+ /** Name of the live/queued recovery owner, when resolvable. */
+ ownerName: string | null;
+ /** True when the surface should render the recessed line instead of the card. */
+ recessed: boolean;
+}
+
+/**
+ * One derivation shared by every task thread: classify the action against the
+ * task's live runs, queued wake, and handoff projection, and resolve the owner's
+ * display name for the "Recovery in progress · CTO" line.
+ */
+export function deriveRecoveryPresentation(input: {
+ action: RecoveryActionForDisplay | null | undefined;
+ liveRuns?: readonly RecoveryLivenessRun[];
+ issueId?: string | null;
+ liveIssueIds?: ReadonlySet | null;
+ issueAssigneeAgentId?: string | null;
+ scheduledRetry?: { status?: string | null } | null;
+ successfulRunHandoff?: { hasLiveContinuation?: boolean } | null;
+ resolveAgentName?: (agentId: string) => string | null | undefined;
+}): RecoveryPresentation | null {
+ const { action } = input;
+ if (!action) return null;
+ const liveRuns = (input.liveRuns ?? []).filter(
+ (run) => run.status === "queued" || run.status === "running",
+ );
+ const ownerRun = action.ownerAgentId
+ ? liveRuns.find((run) => run.agentId === action.ownerAgentId) ?? null
+ : null;
+ const sourceRun = liveRuns[0] ?? null;
+ const state = deriveRecoveryDisplayState(
+ action,
+ recoveryLivenessFromIssue(
+ {
+ scheduledRetry: input.scheduledRetry ?? null,
+ successfulRunHandoff: input.successfulRunHandoff ?? null,
+ },
+ {
+ ownerRun: ownerRun ? { agentId: ownerRun.agentId, status: ownerRun.status } : null,
+ sourceHasLiveRun:
+ liveRuns.length > 0 || Boolean(input.issueId && input.liveIssueIds?.has(input.issueId)),
+ sourceLiveRunAgentId: sourceRun?.agentId ?? input.issueAssigneeAgentId ?? null,
+ },
+ ),
+ );
+ const ownerName =
+ ownerRun?.agentName ??
+ (action.ownerAgentId ? input.resolveAgentName?.(action.ownerAgentId) ?? null : null);
+ return { state, ownerName, recessed: isRecessedRecoveryState(state) };
+}
+
export function recoveryChipLabel(
state: ActiveRecoveryDisplayState,
kind: IssueRecoveryActionKind,
+ options?: { ownerName?: string | null },
): string {
if (kind === "workspace_validation" && state === "needed") {
return "Workspace recovery needed";
}
- return RECOVERY_CHIP_DEFAULT_TONE[state].label;
+ const label = RECOVERY_CHIP_DEFAULT_TONE[state].label;
+ const ownerName = options?.ownerName?.trim();
+ // "Recovery in progress · CTO" — naming the live owner is what makes the
+ // recessed line legible without expanding it.
+ return state === "in_progress" && ownerName ? `${label} · ${ownerName}` : label;
}
diff --git a/ui/storybook/stories/source-issue-recovery.stories.tsx b/ui/storybook/stories/source-issue-recovery.stories.tsx
index de29f1f11e9..55b217ee6d6 100644
--- a/ui/storybook/stories/source-issue-recovery.stories.tsx
+++ b/ui/storybook/stories/source-issue-recovery.stories.tsx
@@ -3,6 +3,7 @@ import type { ReactNode } from "react";
import type { IssueRecoveryAction, IssueRelationIssueSummary } from "@paperclipai/shared";
import { Eye, ExternalLink, OctagonAlert, RefreshCw, TriangleAlert } from "lucide-react";
import { IssueRecoveryActionCard } from "@/components/IssueRecoveryActionCard";
+import { RecoveryProgressLine } from "@/components/RecoveryProgressLine";
import { IssueRow } from "@/components/IssueRow";
import { IssueBlockedNotice } from "@/components/IssueBlockedNotice";
import { storybookAgentMap, storybookAgents, createIssue } from "../fixtures/paperclipData";
@@ -261,7 +262,8 @@ const RUN_CARD_RECOVERY_TONE: Record
),
};
+
+function LivenessAwarePanel() {
+ return (
+
+
+ Recovery owner is live or queued
+
+ The recessed line replaces the prominent card. It names the owner, folds all evidence
+ behind one disclosure, and never claims recovery is “needed” while someone is on it.
+
+
+ undefined}
+ />
+
+
+
+
+ Expanded — evidence stays inspectable
+
+ undefined}
+ />
+
+
+
+
+ A newer owner took the task over
+
+ undefined}
+ />
+
+
+
+
+ No owner, no path — prominence is earned
+ undefined}
+ />
+
+