Skip to content

The open-source app everyone uses to manage agents at work

Add issue controls and retry-now recovery (#5426)

Dotta772fc92619ed
diff --git a/docs/assets/pr-5426/scheduled-retry-story-desktop.png b/docs/assets/pr-5426/scheduled-retry-story-desktop.png
new file mode 100644
index 0000000000..3f0c875df1
Binary files /dev/null and b/docs/assets/pr-5426/scheduled-retry-story-desktop.png differ
diff --git a/docs/assets/pr-5426/scheduled-retry-story-mobile.png b/docs/assets/pr-5426/scheduled-retry-story-mobile.png
new file mode 100644
index 0000000000..97b02b7d63
Binary files /dev/null and b/docs/assets/pr-5426/scheduled-retry-story-mobile.png differ
diff --git a/packages/shared/src/index.ts b/packages/shared/src/index.ts
index 4c06b7362d..7872de735c 100644
--- a/packages/shared/src/index.ts
+++ b/packages/shared/src/index.ts
@@ -371,6 +371,10 @@ export type {
IssueProductivityReviewTrigger,
SuccessfulRunHandoffState,
SuccessfulRunHandoffStateKind,
+ IssueScheduledRetry,
+ IssueScheduledRetryStatus,
+ IssueRetryNowOutcome,
+ IssueRetryNowResponse,
IssueReferenceSource,
IssueRelatedWorkItem,
IssueRelatedWorkSummary,
diff --git a/packages/shared/src/types/index.ts b/packages/shared/src/types/index.ts
index c0c0f1f44f..ddc8162d27 100644
--- a/packages/shared/src/types/index.ts
+++ b/packages/shared/src/types/index.ts
@@ -153,6 +153,10 @@ export type {
IssueProductivityReviewTrigger,
SuccessfulRunHandoffState,
SuccessfulRunHandoffStateKind,
+ IssueScheduledRetry,
+ IssueScheduledRetryStatus,
+ IssueRetryNowOutcome,
+ IssueRetryNowResponse,
IssueReferenceSource,
IssueRelatedWorkItem,
IssueRelatedWorkSummary,
diff --git a/packages/shared/src/types/issue.ts b/packages/shared/src/types/issue.ts
index 2f09515af5..827c259f02 100644
--- a/packages/shared/src/types/issue.ts
+++ b/packages/shared/src/types/issue.ts
@@ -181,6 +181,34 @@ export interface SuccessfulRunHandoffState {
createdAt: Date | string | null;
}
+export type IssueScheduledRetryStatus = "scheduled_retry" | "queued" | "running" | "cancelled";
+
+export interface IssueScheduledRetry {
+ runId: string;
+ status: IssueScheduledRetryStatus;
+ agentId: string;
+ agentName: string | null;
+ retryOfRunId: string | null;
+ scheduledRetryAt: Date | string | null;
+ scheduledRetryAttempt: number;
+ scheduledRetryReason: string | null;
+ retryExhaustedReason?: string | null;
+ error?: string | null;
+ errorCode?: string | null;
+}
+
+export type IssueRetryNowOutcome =
+ | "promoted"
+ | "already_promoted"
+ | "no_scheduled_retry"
+ | "gate_suppressed";
+
+export interface IssueRetryNowResponse {
+ outcome: IssueRetryNowOutcome;
+ message: string;
+ scheduledRetry: IssueScheduledRetry | null;
+}
+
export interface IssueRelation {
id: string;
companyId: string;
@@ -345,6 +373,7 @@ export interface Issue {
blockerAttention?: IssueBlockerAttention;
productivityReview?: IssueProductivityReview | null;
successfulRunHandoff?: SuccessfulRunHandoffState | null;
+ scheduledRetry?: IssueScheduledRetry | null;
relatedWork?: IssueRelatedWorkSummary;
referencedIssueIdentifiers?: string[];
planDocument?: IssueDocument | null;
diff --git a/server/src/__tests__/issue-scheduled-retry-routes.test.ts b/server/src/__tests__/issue-scheduled-retry-routes.test.ts
new file mode 100644
index 0000000000..527500af9f
--- /dev/null
+++ b/server/src/__tests__/issue-scheduled-retry-routes.test.ts
@@ -0,0 +1,518 @@
+import { randomUUID } from "node:crypto";
+import express from "express";
+import request from "supertest";
+import { and, eq } from "drizzle-orm";
+import { afterAll, afterEach, beforeAll, describe, expect, it } from "vitest";
+import {
+ activityLog,
+ agents,
+ agentWakeupRequests,
+ companies,
+ createDb,
+ heartbeatRunEvents,
+ heartbeatRuns,
+ issueComments,
+ issueRelations,
+ issueTreeHolds,
+ issues,
+} from "@paperclipai/db";
+import {
+ getEmbeddedPostgresTestSupport,
+ startEmbeddedPostgresTestDatabase,
+} from "./helpers/embedded-postgres.js";
+import { errorHandler } from "../middleware/index.js";
+import { issueRoutes } from "../routes/issues.js";
+
+const embeddedPostgresSupport = await getEmbeddedPostgresTestSupport();
+const describeEmbeddedPostgres = embeddedPostgresSupport.supported ? describe : describe.skip;
+
+if (!embeddedPostgresSupport.supported) {
+ console.warn(
+ `Skipping embedded Postgres scheduled retry route tests on this host: ${
+ embeddedPostgresSupport.reason ?? "unsupported environment"
+ }`,
+ );
+}
+
+describeEmbeddedPostgres("issue scheduled retry routes", () => {
+ let db!: ReturnType<typeof createDb>;
+ let tempDb: Awaited<ReturnType<typeof startEmbeddedPostgresTestDatabase>> | null = null;
+
+ beforeAll(async () => {
+ tempDb = await startEmbeddedPostgresTestDatabase("paperclip-issue-scheduled-retry-routes-");
+ db = createDb(tempDb.connectionString);
+ }, 20_000);
+
+ afterEach(async () => {
+ await db.delete(issueComments);
+ await db.delete(issueRelations);
+ await db.delete(issueTreeHolds);
+ await db.delete(activityLog);
+ await db.delete(issues);
+ await db.delete(heartbeatRunEvents);
+ await db.delete(heartbeatRuns);
+ await db.delete(agentWakeupRequests);
+ await db.delete(agents);
+ await db.delete(companies);
+ });
+
+ afterAll(async () => {
+ await tempDb?.cleanup();
+ });
+
+ function createApp(actor: Express.Request["actor"]) {
+ const app = express();
+ app.use(express.json());
+ app.use((req, _res, next) => {
+ req.actor = actor;
+ next();
+ });
+ app.use("/api", issueRoutes(db, {} as any));
+ app.use(errorHandler);
+ return app;
+ }
+
+ function boardActor(companyId: string): Express.Request["actor"] {
+ return {
+ type: "board",
+ userId: "board-user",
+ companyIds: [companyId],
+ memberships: [{ companyId, membershipRole: "admin", status: "active" }],
+ isInstanceAdmin: false,
+ source: "session",
+ };
+ }
+
+ function agentActor(companyId: string, agentId: string): Express.Request["actor"] {
+ return {
+ type: "agent",
+ agentId,
+ companyId,
+ runId: randomUUID(),
+ source: "agent_jwt",
+ };
+ }
+
+ async function seedIssueWithRetry(input: {
+ agentStatus?: "active" | "paused";
+ retryStatus?: "scheduled_retry" | "queued" | "running";
+ issueStatus?: "in_progress" | "todo" | "done" | "cancelled";
+ } = {}) {
+ const companyId = randomUUID();
+ const agentId = randomUUID();
+ const issueId = randomUUID();
+ const sourceRunId = randomUUID();
+ const retryRunId = randomUUID();
+ const wakeupRequestId = randomUUID();
+ const issuePrefix = `T${companyId.replace(/-/g, "").slice(0, 6).toUpperCase()}`;
+ const now = new Date("2026-05-06T18:00:00.000Z");
+ const scheduledRetryAt = new Date("2026-05-06T19:00:00.000Z");
+
+ await db.insert(companies).values({
+ id: companyId,
+ name: "Paperclip",
+ issuePrefix,
+ requireBoardApprovalForNewAgents: false,
+ });
+ await db.insert(agents).values({
+ id: agentId,
+ companyId,
+ name: "CodexCoder",
+ role: "engineer",
+ status: input.agentStatus ?? "active",
+ adapterType: "codex_local",
+ adapterConfig: {},
+ runtimeConfig: {
+ heartbeat: {
+ wakeOnDemand: true,
+ maxConcurrentRuns: 1,
+ },
+ },
+ permissions: {},
+ });
+ await db.insert(heartbeatRuns).values({
+ id: sourceRunId,
+ companyId,
+ agentId,
+ invocationSource: "assignment",
+ triggerDetail: "system",
+ status: "failed",
+ error: "transient upstream error",
+ errorCode: "adapter_failed",
+ finishedAt: now,
+ contextSnapshot: {
+ issueId,
+ wakeReason: "issue_assigned",
+ },
+ updatedAt: now,
+ createdAt: now,
+ });
+ await db.insert(agentWakeupRequests).values({
+ id: wakeupRequestId,
+ companyId,
+ agentId,
+ source: "automation",
+ triggerDetail: "system",
+ reason: "bounded_transient_heartbeat_retry",
+ payload: {
+ issueId,
+ retryOfRunId: sourceRunId,
+ scheduledRetryAt: scheduledRetryAt.toISOString(),
+ },
+ status: "queued",
+ });
+ await db.insert(heartbeatRuns).values({
+ id: retryRunId,
+ companyId,
+ agentId,
+ invocationSource: "automation",
+ triggerDetail: "system",
+ status: input.retryStatus ?? "scheduled_retry",
+ wakeupRequestId,
+ retryOfRunId: sourceRunId,
+ scheduledRetryAt,
+ scheduledRetryAttempt: 2,
+ scheduledRetryReason: "transient_failure",
+ contextSnapshot: {
+ issueId,
+ wakeReason: "bounded_transient_heartbeat_retry",
+ retryOfRunId: sourceRunId,
+ scheduledRetryAt: scheduledRetryAt.toISOString(),
+ scheduledRetryAttempt: 2,
+ retryReason: "transient_failure",
+ },
+ updatedAt: now,
+ createdAt: now,
+ });
+ await db
+ .update(agentWakeupRequests)
+ .set({ runId: retryRunId })
+ .where(eq(agentWakeupRequests.id, wakeupRequestId));
+ await db.insert(issues).values({
+ id: issueId,
+ companyId,
+ title: "Retryable issue",
+ status: input.issueStatus ?? "in_progress",
+ priority: "medium",
+ assigneeAgentId: agentId,
+ executionRunId: retryRunId,
+ executionAgentNameKey: "codexcoder",
+ executionLockedAt: now,
+ issueNumber: 1,
+ identifier: `${issuePrefix}-1`,
+ });
+
+ return { companyId, agentId, issueId, sourceRunId, retryRunId, scheduledRetryAt };
+ }
+
+ it("surfaces the current scheduled retry in the issue read model", async () => {
+ const { companyId, issueId, agentId, sourceRunId, retryRunId, scheduledRetryAt } = await seedIssueWithRetry();
+
+ const res = await request(createApp(boardActor(companyId))).get(`/api/issues/${issueId}`);
+
+ expect(res.status, JSON.stringify(res.body)).toBe(200);
+ expect(res.body.scheduledRetry).toMatchObject({
+ runId: retryRunId,
+ status: "scheduled_retry",
+ agentId,
+ agentName: "CodexCoder",
+ retryOfRunId: sourceRunId,
+ scheduledRetryAttempt: 2,
+ scheduledRetryReason: "transient_failure",
+ });
+ expect(res.body.scheduledRetry.scheduledRetryAt).toBe(scheduledRetryAt.toISOString());
+ });
+
+ it("promotes the existing scheduled retry and treats duplicate clicks as idempotent", async () => {
+ const { companyId, issueId, retryRunId } = await seedIssueWithRetry();
+ const app = createApp(boardActor(companyId));
+
+ const first = await request(app).post(`/api/issues/${issueId}/scheduled-retry/retry-now`).send({});
+
+ expect(first.status, JSON.stringify(first.body)).toBe(200);
+ expect(first.body).toMatchObject({
+ outcome: "promoted",
+ scheduledRetry: {
+ runId: retryRunId,
+ status: "queued",
+ },
+ });
+
+ const second = await request(app).post(`/api/issues/${issueId}/scheduled-retry/retry-now`).send({});
+
+ expect(second.status, JSON.stringify(second.body)).toBe(200);
+ expect(second.body).toMatchObject({
+ outcome: "already_promoted",
+ scheduledRetry: {
+ runId: retryRunId,
+ status: "queued",
+ },
+ });
+
+ const retryRuns = await db
+ .select({ id: heartbeatRuns.id, status: heartbeatRuns.status })
+ .from(heartbeatRuns)
+ .where(and(eq(heartbeatRuns.retryOfRunId, first.body.scheduledRetry.retryOfRunId), eq(heartbeatRuns.companyId, companyId)));
+ expect(retryRuns).toHaveLength(1);
+ expect(retryRuns[0]).toMatchObject({ id: retryRunId, status: "queued" });
+ });
+
+ it("returns a clear no-op response when there is no scheduled retry", async () => {
+ const companyId = randomUUID();
+ const issueId = randomUUID();
+ await db.insert(companies).values({
+ id: companyId,
+ name: "Paperclip",
+ issuePrefix: "NONE",
+ requireBoardApprovalForNewAgents: false,
+ });
+ await db.insert(issues).values({
+ id: issueId,
+ companyId,
+ title: "No retry",
+ status: "todo",
+ priority: "medium",
+ issueNumber: 1,
+ identifier: "NONE-1",
+ });
+
+ const res = await request(createApp(boardActor(companyId)))
+ .post(`/api/issues/${issueId}/scheduled-retry/retry-now`)
+ .send({});
+
+ expect(res.status, JSON.stringify(res.body)).toBe(200);
+ expect(res.body).toMatchObject({
+ outcome: "no_scheduled_retry",
+ scheduledRetry: null,
+ });
+ });
+
+ it("reports already-promoted retries without creating another run", async () => {
+ const { companyId, issueId, retryRunId } = await seedIssueWithRetry({ retryStatus: "queued" });
+
+ const res = await request(createApp(boardActor(companyId)))
+ .post(`/api/issues/${issueId}/scheduled-retry/retry-now`)
+ .send({});
+
+ expect(res.status, JSON.stringify(res.body)).toBe(200);
+ expect(res.body).toMatchObject({
+ outcome: "already_promoted",
+ scheduledRetry: {
+ runId: retryRunId,
+ status: "queued",
+ },
+ });
+ });
+
+ it("uses normal promotion gates and records gate-suppressed retries", async () => {
+ const { companyId, issueId, retryRunId } = await seedIssueWithRetry({ agentStatus: "paused" });
+
+ const res = await request(createApp(boardActor(companyId)))
+ .post(`/api/issues/${issueId}/scheduled-retry/retry-now`)
+ .send({});
+
+ expect(res.status, JSON.stringify(res.body)).toBe(200);
+ expect(res.body).toMatchObject({
+ outcome: "gate_suppressed",
+ scheduledRetry: {
+ runId: retryRunId,
+ status: "cancelled",
+ errorCode: "agent_not_invokable",
+ },
+ });
+
+ const [run] = await db
+ .select({ status: heartbeatRuns.status, errorCode: heartbeatRuns.errorCode })
+ .from(heartbeatRuns)
+ .where(eq(heartbeatRuns.id, retryRunId));
+ expect(run).toEqual({ status: "cancelled", errorCode: "agent_not_invokable" });
+
+ const [activity] = await db
+ .select({ action: activityLog.action, entityId: activityLog.entityId, runId: activityLog.runId })
+ .from(activityLog)
+ .where(eq(activityLog.entityId, issueId));
+ expect(activity).toEqual({
+ action: "issue.scheduled_retry_retry_now",
+ entityId: issueId,
+ runId: retryRunId,
+ });
+ });
+
+ it("requires board access for retry-now", async () => {
+ const { companyId, agentId, issueId } = await seedIssueWithRetry();
+
+ const res = await request(createApp(agentActor(companyId, agentId)))
+ .post(`/api/issues/${issueId}/scheduled-retry/retry-now`)
+ .send({});
+
+ expect(res.status).toBe(403);
+ });
+
+ it("enforces company scoping for retry-now", async () => {
+ const { issueId } = await seedIssueWithRetry();
+
+ const res = await request(createApp(boardActor(randomUUID())))
+ .post(`/api/issues/${issueId}/scheduled-retry/retry-now`)
+ .send({});
+
+ expect(res.status).toBe(403);
+ });
+
+ it("suppresses retry-now when the issue is under a budget hard-stop", async () => {
+ const { companyId, agentId, issueId, retryRunId } = await seedIssueWithRetry();
+ await db
+ .update(agents)
+ .set({ status: "paused", pauseReason: "budget" })
+ .where(eq(agents.id, agentId));
+
+ const res = await request(createApp(boardActor(companyId)))
+ .post(`/api/issues/${issueId}/scheduled-retry/retry-now`)
+ .send({});
+
+ expect(res.status, JSON.stringify(res.body)).toBe(200);
+ expect(res.body).toMatchObject({
+ outcome: "gate_suppressed",
+ scheduledRetry: {
+ runId: retryRunId,
+ status: "cancelled",
+ errorCode: "budget_blocked",
+ },
+ });
+ });
+
+ it("suppresses retry-now when the issue is waiting on another review participant", async () => {
+ const { companyId, agentId, issueId, retryRunId } = await seedIssueWithRetry({ issueStatus: "in_progress" });
+ const reviewerAgentId = randomUUID();
+ await db.insert(agents).values({
+ id: reviewerAgentId,
+ companyId,
+ name: "ReviewerAgent",
+ role: "qa",
+ status: "active",
+ adapterType: "codex_local",
+ adapterConfig: {},
+ runtimeConfig: {
+ heartbeat: {
+ wakeOnDemand: true,
+ maxConcurrentRuns: 1,
+ },
+ },
+ permissions: {},
+ });
+ await db
+ .update(issues)
+ .set({
+ status: "in_review",
+ executionState: {
+ status: "pending",
+ currentStageId: randomUUID(),
+ currentStageIndex: 0,
+ currentStageType: "review",
+ currentParticipant: { type: "agent", agentId: reviewerAgentId, userId: null },
+ returnAssignee: { type: "agent", agentId, userId: null },
+ reviewRequest: null,
+ completedStageIds: [],
+ lastDecisionId: null,
+ lastDecisionOutcome: null,
+ },
+ })
+ .where(eq(issues.id, issueId));
+
+ const res = await request(createApp(boardActor(companyId)))
+ .post(`/api/issues/${issueId}/scheduled-retry/retry-now`)
+ .send({});
+
+ expect(res.status, JSON.stringify(res.body)).toBe(200);
+ expect(res.body).toMatchObject({
+ outcome: "gate_suppressed",
+ scheduledRetry: {
+ runId: retryRunId,
+ status: "cancelled",
+ errorCode: "issue_review_participant_changed",
+ },
+ });
+ });
+
+ it("suppresses retry-now when the issue is under an active subtree pause hold", async () => {
+ const { companyId, issueId, retryRunId } = await seedIssueWithRetry();
+ await db.insert(issueTreeHolds).values({
+ companyId,
+ rootIssueId: issueId,
+ mode: "pause",
+ status: "active",
+ reason: "manual pause for review",
+ releasePolicy: { strategy: "manual" },
+ });
+
+ const res = await request(createApp(boardActor(companyId)))
+ .post(`/api/issues/${issueId}/scheduled-retry/retry-now`)
+ .send({});
+
+ expect(res.status, JSON.stringify(res.body)).toBe(200);
+ expect(res.body).toMatchObject({
+ outcome: "gate_suppressed",
+ scheduledRetry: {
+ runId: retryRunId,
+ status: "cancelled",
+ errorCode: "issue_paused",
+ },
+ });
+ });
+
+ it("suppresses retry-now when unresolved blockers remain", async () => {
+ const { companyId, issueId, retryRunId } = await seedIssueWithRetry();
+ const blockerId = randomUUID();
+ await db.insert(issues).values({
+ id: blockerId,
+ companyId,
+ title: "Blocking task",
+ status: "todo",
+ priority: "medium",
+ issueNumber: 2,
+ identifier: "BLOCK-2",
+ });
+ await db.insert(issueRelations).values({
+ id: randomUUID(),
+ companyId,
+ issueId: blockerId,
+ relatedIssueId: issueId,
+ type: "blocks",
+ });
+ await db
+ .update(issues)
+ .set({ status: "blocked" })
+ .where(eq(issues.id, issueId));
+
+ const res = await request(createApp(boardActor(companyId)))
+ .post(`/api/issues/${issueId}/scheduled-retry/retry-now`)
+ .send({});
+
+ expect(res.status, JSON.stringify(res.body)).toBe(200);
+ expect(res.body).toMatchObject({
+ outcome: "gate_suppressed",
+ scheduledRetry: {
+ runId: retryRunId,
+ status: "cancelled",
+ errorCode: "issue_dependencies_blocked",
+ },
+ });
+ });
+
+ it("suppresses retry-now when the issue already reached a terminal status", async () => {
+ const { companyId, issueId, retryRunId } = await seedIssueWithRetry({ issueStatus: "done" });
+
+ const res = await request(createApp(boardActor(companyId)))
+ .post(`/api/issues/${issueId}/scheduled-retry/retry-now`)
+ .send({});
+
+ expect(res.status, JSON.stringify(res.body)).toBe(200);
+ expect(res.body).toMatchObject({
+ outcome: "gate_suppressed",
+ scheduledRetry: {
+ runId: retryRunId,
+ status: "cancelled",
+ errorCode: "issue_terminal_status",
+ },
+ });
+ });
+});
diff --git a/server/src/__tests__/issues-goal-context-routes.test.ts b/server/src/__tests__/issues-goal-context-routes.test.ts
index 4e90e0ad44..504714ab55 100644
--- a/server/src/__tests__/issues-goal-context-routes.test.ts
+++ b/server/src/__tests__/issues-goal-context-routes.test.ts
@@ -13,6 +13,7 @@ const mockIssueService = vi.hoisted(() => ({
getComment: vi.fn(),
listBlockerAttention: vi.fn(),
listProductivityReviews: vi.fn(),
+ getCurrentScheduledRetry: vi.fn(),
listAttachments: vi.fn(),
}));
@@ -188,6 +189,7 @@ describe.sequential("issue goal context routes", () => {
mockIssueService.getComment.mockResolvedValue(null);
mockIssueService.listBlockerAttention.mockResolvedValue(new Map());
mockIssueService.listProductivityReviews.mockResolvedValue(new Map());
+ mockIssueService.getCurrentScheduledRetry.mockResolvedValue(null);
mockIssueService.listAttachments.mockResolvedValue([]);
mockDocumentsService.getIssueDocumentPayload.mockResolvedValue({});
mockDocumentsService.getIssueDocumentByKey.mockResolvedValue(null);
diff --git a/server/src/routes/issues.ts b/server/src/routes/issues.ts
index 4e568c1581..69aada8fcc 100644
--- a/server/src/routes/issues.ts
+++ b/server/src/routes/issues.ts
@@ -1498,6 +1498,7 @@ export function issueRoutes(
relations,
blockerAttention,
productivityReview,
+ scheduledRetry,
attachments,
continuationSummary,
currentExecutionWorkspace,
@@ -1510,6 +1511,7 @@ export function issueRoutes(
svc.getRelationSummaries(issue.id),
svc.listBlockerAttention(issue.companyId, [issue]).then((map) => map.get(issue.id) ?? null),
svc.listProductivityReviews(issue.companyId, [issue.id]).then((map) => map.get(issue.id) ?? null),
+ svc.getCurrentScheduledRetry(issue.id),
svc.listAttachments(issue.id),
documentsSvc.getIssueDocumentByKey(issue.id, ISSUE_CONTINUATION_SUMMARY_DOCUMENT_KEY),
currentExecutionWorkspacePromise,
@@ -1525,6 +1527,7 @@ export function issueRoutes(
workMode: issue.workMode,
...(blockerAttention ? { blockerAttention } : {}),
productivityReview,
+ scheduledRetry,
priority: issue.priority,
projectId: issue.projectId,
goalId: goal?.id ?? issue.goalId,
@@ -1606,6 +1609,7 @@ export function issueRoutes(
productivityReview,
referenceSummary,
successfulRunHandoffStates,
+ scheduledRetry,
] = await Promise.all([
resolveIssueProjectAndGoal(issue),
svc.getAncestors(issue.id),
@@ -1616,6 +1620,7 @@ export function issueRoutes(
svc.listProductivityReviews(issue.companyId, [issue.id]).then((map) => map.get(issue.id) ?? null),
issueReferencesSvc.listIssueReferenceSummary(issue.id),
listSuccessfulRunHandoffStates(db, issue.companyId, [issue.id]),
+ svc.getCurrentScheduledRetry(issue.id),
]);
const mentionedProjects = mentionedProjectIds.length > 0
? await projectsSvc.listByIds(issue.companyId, mentionedProjectIds)
@@ -1631,6 +1636,7 @@ export function issueRoutes(
...(blockerAttention ? { blockerAttention } : {}),
productivityReview,
successfulRunHandoff: successfulRunHandoffStates.get(issue.id) ?? null,
+ scheduledRetry,
blockedBy: relations.blockedBy,
blocks: relations.blocks,
relatedWork: referenceSummary,
@@ -2438,6 +2444,44 @@ export function issueRoutes(
res.json({ ok: true });
});
+ router.post("/issues/:id/scheduled-retry/retry-now", async (req, res) => {
+ assertBoard(req);
+ const id = req.params.id as string;
+ const issue = await svc.getById(id);
+ if (!issue) {
+ res.status(404).json({ error: "Issue not found" });
+ return;
+ }
+ assertCompanyAccess(req, issue.companyId);
+
+ const actor = getActorInfo(req);
+ const result = await heartbeat.retryScheduledRetryNow({
+ issueId: issue.id,
+ actor: {
+ actorType: actor.actorType,
+ actorId: actor.actorId,
+ },
+ });
+
+ await logActivity(db, {
+ companyId: issue.companyId,
+ actorType: actor.actorType,
+ actorId: actor.actorId,
+ action: "issue.scheduled_retry_retry_now",
+ entityType: "issue",
+ entityId: issue.id,
+ agentId: result.scheduledRetry?.agentId ?? issue.assigneeAgentId ?? null,
+ runId: result.scheduledRetry?.runId ?? null,
+ details: {
+ outcome: result.outcome,
+ message: result.message,
+ scheduledRetry: result.scheduledRetry,
+ },
+ });
+
+ res.json(result);
+ });
+
router.patch("/issues/:id", validate(updateIssueRouteSchema), async (req, res) => {
const id = req.params.id as string;
const existing = await svc.getById(id);
diff --git a/server/src/services/heartbeat.ts b/server/src/services/heartbeat.ts
index 427f91cd29..dc719cb69f 100644
--- a/server/src/services/heartbeat.ts
+++ b/server/src/services/heartbeat.ts
@@ -4712,6 +4712,7 @@ export function heartbeatService(db: Db, options: HeartbeatServiceOptions = {})
issueId: string | null;
details: Record<string, unknown>;
};
+ type BlockedScheduledRetryGate = Extract<ScheduledRetryGate, { allowed: false }>;
async function evaluateScheduledRetryGate(input: {
run: typeof heartbeatRuns.$inferSelect;
@@ -4960,6 +4961,111 @@ export function heartbeatService(db: Db, options: HeartbeatServiceOptions = {})
return cancelled;
}
+ async function promoteScheduledRetryRun(
+ dueRun: typeof heartbeatRuns.$inferSelect,
+ now: Date,
+ ): Promise<
+ | { outcome: "promoted"; run: typeof heartbeatRuns.$inferSelect }
+ | {
+ outcome: "gate_suppressed";
+ run: typeof heartbeatRuns.$inferSelect;
+ reason: string;
+ errorCode: BlockedScheduledRetryGate["errorCode"];
+ }
+ | { outcome: "not_promoted"; run: typeof heartbeatRuns.$inferSelect | null }
+ > {
+ const agent = await getAgent(dueRun.agentId);
+ if (!agent) {
+ const gate = {
+ allowed: false as const,
+ reason: "Scheduled retry suppressed because the agent no longer exists",
+ errorCode: "agent_not_invokable" as const,
+ issueId: readNonEmptyString(parseObject(dueRun.contextSnapshot).issueId),
+ details: { agentId: dueRun.agentId },
+ };
+ const cancelled = await cancelScheduledRetryForGate(dueRun, gate, now);
+ return cancelled
+ ? {
+ outcome: "gate_suppressed",
+ run: cancelled,
+ reason: gate.reason,
+ errorCode: gate.errorCode,
+ }
+ : { outcome: "not_promoted", run: null };
+ }
+
+ const contextSnapshot = parseObject(dueRun.contextSnapshot);
+ const gate = await evaluateScheduledRetryGate({
+ run: dueRun,
+ agent,
+ contextSnapshot,
+ retryReason: dueRun.scheduledRetryReason,
+ enforceIssueExecutionLock: dueRun.scheduledRetryReason === MAX_TURN_CONTINUATION_RETRY_REASON,
+ });
+ if (!gate.allowed) {
+ if (
+ gate.errorCode === "issue_not_found" &&
+ dueRun.scheduledRetryReason !== MAX_TURN_CONTINUATION_RETRY_REASON
+ ) {
+ // Preserve legacy transient retry behavior for runs that only carry a
+ // loose task context rather than a persisted issue row.
+ } else {
+ const cancelled = await cancelScheduledRetryForGate(dueRun, gate, now);
+ return cancelled
+ ? {
+ outcome: "gate_suppressed",
+ run: cancelled,
+ reason: gate.reason,
+ errorCode: gate.errorCode,
+ }
+ : { outcome: "not_promoted", run: null };
+ }
+ }
+
+ const promoted = await db
+ .update(heartbeatRuns)
+ .set({
+ status: "queued",
+ updatedAt: now,
+ })
+ .where(
+ and(
+ eq(heartbeatRuns.id, dueRun.id),
+ eq(heartbeatRuns.status, "scheduled_retry"),
+ lte(heartbeatRuns.scheduledRetryAt, now),
+ ),
+ )
+ .returning()
+ .then((rows) => rows[0] ?? null);
+ if (!promoted) return { outcome: "not_promoted", run: null };
+
+ await appendRunEvent(promoted, await nextRunEventSeq(promoted.id), {
+ eventType: "lifecycle",
+ stream: "system",
+ level: "info",
+ message: "Scheduled retry became due and was promoted to the queued run pool",
+ payload: {
+ scheduledRetryAttempt: promoted.scheduledRetryAttempt,
+ scheduledRetryAt: promoted.scheduledRetryAt ? new Date(promoted.scheduledRetryAt).toISOString() : null,
+ scheduledRetryReason: promoted.scheduledRetryReason,
+ },
+ });
+
+ publishLiveEvent({
+ companyId: promoted.companyId,
+ type: "heartbeat.run.queued",
+ payload: {
+ runId: promoted.id,
+ agentId: promoted.agentId,
+ invocationSource: promoted.invocationSource,
+ triggerDetail: promoted.triggerDetail,
+ wakeupRequestId: promoted.wakeupRequestId,
+ },
+ });
+
+ return { outcome: "promoted", run: promoted };
+ }
+
async function scheduleBoundedRetryForRun(
run: typeof heartbeatRuns.$inferSelect,
agent: typeof agents.$inferSelect,
@@ -5384,86 +5490,191 @@ export function heartbeatService(db: Db, options: HeartbeatServiceOptions = {})
const promotedRunIds: string[] = [];
for (const dueRun of dueRuns) {
- const agent = await getAgent(dueRun.agentId);
- if (!agent) {
- await cancelScheduledRetryForGate(dueRun, {
- allowed: false,
- reason: "Scheduled retry suppressed because the agent no longer exists",
- errorCode: "agent_not_invokable",
- issueId: readNonEmptyString(parseObject(dueRun.contextSnapshot).issueId),
- details: { agentId: dueRun.agentId },
- }, now);
- continue;
+ const result = await promoteScheduledRetryRun(dueRun, now);
+ if (result.outcome === "promoted") {
+ promotedRunIds.push(result.run.id);
}
+ }
- const contextSnapshot = parseObject(dueRun.contextSnapshot);
- const gate = await evaluateScheduledRetryGate({
- run: dueRun,
- agent,
- contextSnapshot,
- retryReason: dueRun.scheduledRetryReason,
- enforceIssueExecutionLock: dueRun.scheduledRetryReason === MAX_TURN_CONTINUATION_RETRY_REASON,
- });
- if (!gate.allowed) {
- if (
- gate.errorCode === "issue_not_found" &&
- dueRun.scheduledRetryReason !== MAX_TURN_CONTINUATION_RETRY_REASON
- ) {
- // Preserve legacy transient retry behavior for runs that only carry a
- // loose task context rather than a persisted issue row.
- } else {
- await cancelScheduledRetryForGate(dueRun, gate, now);
- continue;
- }
+ return {
+ promoted: promotedRunIds.length,
+ runIds: promotedRunIds,
+ };
+ }
+
+ async function getIssueRetryRun(
+ companyId: string,
+ issueId: string,
+ statuses: Array<"scheduled_retry" | "queued" | "running" | "cancelled">,
+ ) {
+ if (statuses.length === 0) return null;
+ return db
+ .select({
+ run: heartbeatRuns,
+ agentName: agents.name,
+ })
+ .from(heartbeatRuns)
+ .innerJoin(agents, eq(heartbeatRuns.agentId, agents.id))
+ .where(
+ and(
+ eq(heartbeatRuns.companyId, companyId),
+ inArray(heartbeatRuns.status, statuses),
+ sql`${heartbeatRuns.contextSnapshot} ->> 'issueId' = ${issueId}`,
+ sql`${heartbeatRuns.retryOfRunId} is not null`,
+ ),
+ )
+ .orderBy(desc(heartbeatRuns.updatedAt), desc(heartbeatRuns.createdAt), desc(heartbeatRuns.id))
+ .limit(1)
+ .then((rows) => rows[0] ?? null);
+ }
+
+ function summarizeIssueScheduledRetryRun(
+ row: { run: typeof heartbeatRuns.$inferSelect; agentName: string | null },
+ ) {
+ return {
+ runId: row.run.id,
+ status: row.run.status as "scheduled_retry" | "queued" | "running" | "cancelled",
+ agentId: row.run.agentId,
+ agentName: row.agentName,
+ retryOfRunId: row.run.retryOfRunId,
+ scheduledRetryAt: row.run.scheduledRetryAt,
+ scheduledRetryAttempt: row.run.scheduledRetryAttempt,
+ scheduledRetryReason: row.run.scheduledRetryReason,
+ error: row.run.error,
+ errorCode: row.run.errorCode,
+ };
+ }
+
+ async function retryScheduledRetryNow(input: {
+ issueId: string;
+ actor?: { actorType?: "user" | "agent" | "system"; actorId?: string | null };
+ now?: Date;
+ }) {
+ const now = input.now ?? new Date();
+ const issue = await db
+ .select({ id: issues.id, companyId: issues.companyId })
+ .from(issues)
+ .where(eq(issues.id, input.issueId))
+ .then((rows) => rows[0] ?? null);
+ if (!issue) throw notFound("Issue not found");
+
+ const scheduled = await getIssueRetryRun(issue.companyId, issue.id, ["scheduled_retry"]);
+ if (!scheduled) {
+ const alreadyPromoted = await getIssueRetryRun(issue.companyId, issue.id, ["queued", "running"]);
+ if (alreadyPromoted) {
+ return {
+ outcome: "already_promoted" as const,
+ message: "Scheduled retry was already promoted",
+ scheduledRetry: summarizeIssueScheduledRetryRun(alreadyPromoted),
+ };
}
+ return {
+ outcome: "no_scheduled_retry" as const,
+ message: "No live scheduled retry exists for this issue",
+ scheduledRetry: null,
+ };
+ }
- const promoted = await db
+ const contextSnapshot = {
+ ...parseObject(scheduled.run.contextSnapshot),
+ scheduledRetryAt: now.toISOString(),
+ retryNowRequestedAt: now.toISOString(),
+ retryNowRequestedByActorType: input.actor?.actorType ?? null,
+ retryNowRequestedByActorId: input.actor?.actorId ?? null,
+ };
+
+ const updated = await db.transaction(async (tx) => {
+ const row = await tx
.update(heartbeatRuns)
.set({
- status: "queued",
+ scheduledRetryAt: now,
+ contextSnapshot,
updatedAt: now,
})
- .where(
- and(
- eq(heartbeatRuns.id, dueRun.id),
- eq(heartbeatRuns.status, "scheduled_retry"),
- lte(heartbeatRuns.scheduledRetryAt, now),
- ),
- )
+ .where(and(eq(heartbeatRuns.id, scheduled.run.id), eq(heartbeatRuns.status, "scheduled_retry")))
.returning()
.then((rows) => rows[0] ?? null);
- if (!promoted) continue;
+ if (!row) return null;
- promotedRunIds.push(promoted.id);
+ if (row.wakeupRequestId) {
+ const wakeupPayload = {
+ ...(parseObject(
+ await tx
+ .select({ payload: agentWakeupRequests.payload })
+ .from(agentWakeupRequests)
+ .where(eq(agentWakeupRequests.id, row.wakeupRequestId))
+ .then((rows) => rows[0]?.payload ?? null),
+ )),
+ scheduledRetryAt: now.toISOString(),
+ retryNowRequestedAt: now.toISOString(),
+ };
+ await tx
+ .update(agentWakeupRequests)
+ .set({
+ payload: wakeupPayload,
+ updatedAt: now,
+ })
+ .where(eq(agentWakeupRequests.id, row.wakeupRequestId));
+ }
- await appendRunEvent(promoted, await nextRunEventSeq(promoted.id), {
- eventType: "lifecycle",
- stream: "system",
- level: "info",
- message: "Scheduled retry became due and was promoted to the queued run pool",
- payload: {
- scheduledRetryAttempt: promoted.scheduledRetryAttempt,
- scheduledRetryAt: promoted.scheduledRetryAt ? new Date(promoted.scheduledRetryAt).toISOString() : null,
- scheduledRetryReason: promoted.scheduledRetryReason,
- },
- });
+ return row;
+ });
- publishLiveEvent({
- companyId: promoted.companyId,
- type: "heartbeat.run.queued",
- payload: {
- runId: promoted.id,
- agentId: promoted.agentId,
- invocationSource: promoted.invocationSource,
- triggerDetail: promoted.triggerDetail,
- wakeupRequestId: promoted.wakeupRequestId,
- },
- });
+ if (!updated) {
+ const alreadyPromoted = await getIssueRetryRun(issue.companyId, issue.id, ["queued", "running"]);
+ if (alreadyPromoted) {
+ return {
+ outcome: "already_promoted" as const,
+ message: "Scheduled retry was already promoted",
+ scheduledRetry: summarizeIssueScheduledRetryRun(alreadyPromoted),
+ };
+ }
+ return {
+ outcome: "no_scheduled_retry" as const,
+ message: "No live scheduled retry exists for this issue",
+ scheduledRetry: null,
+ };
}
+ await appendRunEvent(updated, await nextRunEventSeq(updated.id), {
+ eventType: "lifecycle",
+ stream: "system",
+ level: "info",
+ message: "Scheduled retry was requested to run now",
+ payload: {
+ issueId: issue.id,
+ scheduledRetryAttempt: updated.scheduledRetryAttempt,
+ scheduledRetryAt: updated.scheduledRetryAt ? new Date(updated.scheduledRetryAt).toISOString() : null,
+ scheduledRetryReason: updated.scheduledRetryReason,
+ requestedByActorType: input.actor?.actorType ?? null,
+ requestedByActorId: input.actor?.actorId ?? null,
+ },
+ });
+
+ const promotion = await promoteScheduledRetryRun(updated, now);
+ const promotedRow = await getIssueRetryRun(issue.companyId, issue.id, ["queued", "running", "cancelled"]);
+ const scheduledRetry = promotedRow
+ ? summarizeIssueScheduledRetryRun(promotedRow)
+ : summarizeIssueScheduledRetryRun({ run: promotion.run ?? updated, agentName: scheduled.agentName });
+
+ if (promotion.outcome === "promoted") {
+ return {
+ outcome: "promoted" as const,
+ message: "Scheduled retry was promoted to the queued run pool",
+ scheduledRetry,
+ };
+ }
+ if (promotion.outcome === "gate_suppressed") {
+ return {
+ outcome: "gate_suppressed" as const,
+ message: promotion.reason,
+ scheduledRetry,
+ };
+ }
return {
- promoted: promotedRunIds.length,
- runIds: promotedRunIds,
+ outcome: "already_promoted" as const,
+ message: "Scheduled retry was already promoted",
+ scheduledRetry,
};
}
@@ -9383,6 +9594,7 @@ export function heartbeatService(db: Db, options: HeartbeatServiceOptions = {})
reapOrphanedRuns,
promoteDueScheduledRetries,
+ retryScheduledRetryNow,
resumeQueuedRuns,
diff --git a/server/src/services/issues.ts b/server/src/services/issues.ts
index 332fe92451..8229b1d64c 100644
--- a/server/src/services/issues.ts
+++ b/server/src/services/issues.ts
@@ -156,6 +156,19 @@ type IssueActiveRunRow = {
finishedAt: Date | null;
createdAt: Date;
};
+type IssueScheduledRetryRow = {
+ runId: string;
+ status: "scheduled_retry" | "queued" | "running" | "cancelled";
+ agentId: string;
+ agentName: string | null;
+ retryOfRunId: string | null;
+ scheduledRetryAt: Date | null;
+ scheduledRetryAttempt: number;
+ scheduledRetryReason: string | null;
+ retryExhaustedReason?: string | null;
+ error?: string | null;
+ errorCode?: string | null;
+};
type IssueWithLabels = IssueRow & { labels: IssueLabelRow[]; labelIds: string[] };
type IssueWithLabelsAndRun = IssueWithLabels & { activeRun: IssueActiveRunRow | null };
type IssueUserCommentStats = {
@@ -1686,6 +1699,36 @@ export function issueService(db: Db) {
return enriched;
}
+ async function getCurrentScheduledRetryForIssue(issueId: string, companyId: string): Promise<IssueScheduledRetryRow | null> {
+ const row = await db
+ .select({
+ runId: heartbeatRuns.id,
+ status: heartbeatRuns.status,
+ agentId: heartbeatRuns.agentId,
+ agentName: agents.name,
+ retryOfRunId: heartbeatRuns.retryOfRunId,
+ scheduledRetryAt: heartbeatRuns.scheduledRetryAt,
+ scheduledRetryAttempt: heartbeatRuns.scheduledRetryAttempt,
+ scheduledRetryReason: heartbeatRuns.scheduledRetryReason,
+ error: heartbeatRuns.error,
+ errorCode: heartbeatRuns.errorCode,
+ })
+ .from(heartbeatRuns)
+ .innerJoin(agents, eq(heartbeatRuns.agentId, agents.id))
+ .where(
+ and(
+ eq(heartbeatRuns.companyId, companyId),
+ eq(heartbeatRuns.status, "scheduled_retry"),
+ sql`${heartbeatRuns.contextSnapshot} ->> 'issueId' = ${issueId}`,
+ ),
+ )
+ .orderBy(asc(heartbeatRuns.scheduledRetryAt), asc(heartbeatRuns.createdAt), asc(heartbeatRuns.id))
+ .limit(1)
+ .then((rows) => rows[0] ?? null);
+
+ return row ? { ...row, status: "scheduled_retry" } : null;
+ }
+
function deriveIssueCommentAuthorType(comment: {
authorType?: string | null;
authorAgentId?: string | null;
@@ -2502,6 +2545,16 @@ export function issueService(db: Db) {
return getIssueByIdentifier(identifier);
},
+ getCurrentScheduledRetry: async (issueId: string) => {
+ const issue = await db
+ .select({ id: issues.id, companyId: issues.companyId })
+ .from(issues)
+ .where(eq(issues.id, issueId))
+ .then((rows) => rows[0] ?? null);
+ if (!issue) throw notFound("Issue not found");
+ return getCurrentScheduledRetryForIssue(issue.id, issue.companyId);
+ },
+
getRelationSummaries: async (issueId: string) => {
const issue = await db
.select({ id: issues.id, companyId: issues.companyId })
diff --git a/ui/src/api/issues.ts b/ui/src/api/issues.ts
index 3ed54a888e..10427c50eb 100644
--- a/ui/src/api/issues.ts
+++ b/ui/src/api/issues.ts
@@ -12,6 +12,7 @@ import type {
IssueComment,
IssueDocument,
IssueLabel,
+ IssueRetryNowResponse,
IssueThreadInteraction,
IssueTreeControlPreview,
IssueTreeHold,
@@ -129,6 +130,8 @@ export const issuesApi = {
releaseTreeHold: (id: string, holdId: string, data: ReleaseIssueTreeHold) =>
api.post<IssueTreeHold>(`/issues/${id}/tree-holds/${holdId}/release`, data),
checkMonitorNow: (id: string) => api.post<{ ok: true }>(`/issues/${id}/monitor/check-now`, {}),
+ retryScheduledRetryNow: (id: string) =>
+ api.post<IssueRetryNowResponse>(`/issues/${id}/scheduled-retry/retry-now`, {}),
remove: (id: string) => api.delete<Issue>(`/issues/${id}`),
checkout: (id: string, agentId: string) =>
api.post<Issue>(`/issues/${id}/checkout`, {
diff --git a/ui/src/components/IssueProperties.test.tsx b/ui/src/components/IssueProperties.test.tsx
index 41f103b224..936c168cd1 100644
--- a/ui/src/components/IssueProperties.test.tsx
+++ b/ui/src/components/IssueProperties.test.tsx
@@ -18,6 +18,8 @@ import { IssueProperties } from "./IssueProperties";
const mockAgentsApi = vi.hoisted(() => ({
list: vi.fn(),
+ adapterModels: vi.fn(),
+ adapterModelProfiles: vi.fn(),
}));
const mockProjectsApi = vi.hoisted(() => ({
@@ -34,10 +36,6 @@ const mockAuthApi = vi.hoisted(() => ({
getSession: vi.fn(),
}));
-const mockInstanceSettingsApi = vi.hoisted(() => ({
- getExperimental: vi.fn(),
-}));
-
vi.mock("../context/CompanyContext", () => ({
useCompany: () => ({
selectedCompanyId: "company-1",
@@ -60,8 +58,8 @@ vi.mock("../api/auth", () => ({
authApi: mockAuthApi,
}));
-vi.mock("../api/instanceSettings", () => ({
- instanceSettingsApi: mockInstanceSettingsApi,
+vi.mock("../context/ToastContext", () => ({
+ useToastActions: () => ({ pushToast: vi.fn() }),
}));
vi.mock("../hooks/useProjectOrder", () => ({
@@ -353,6 +351,8 @@ describe("IssueProperties", () => {
container = document.createElement("div");
document.body.appendChild(container);
mockAgentsApi.list.mockResolvedValue([]);
+ mockAgentsApi.adapterModels.mockResolvedValue([]);
+ mockAgentsApi.adapterModelProfiles.mockResolvedValue([]);
mockProjectsApi.list.mockResolvedValue([]);
mockIssuesApi.list.mockResolvedValue([]);
mockIssuesApi.listLabels.mockResolvedValue([]);
@@ -362,7 +362,6 @@ describe("IssueProperties", () => {
color: "#6366f1",
}));
mockAuthApi.getSession.mockResolvedValue({ user: { id: "user-1" } });
- mockInstanceSettingsApi.getExperimental.mockResolvedValue({ enableIsolatedWorkspaces: false });
});
afterEach(() => {
@@ -578,9 +577,8 @@ describe("IssueProperties", () => {
act(() => root.unmount());
});
- it("shows a workspace tasks link for non-default workspaces when isolated workspaces are enabled", async () => {
+ it("shows only the workspace detail link for non-default workspaces", async () => {
mockProjectsApi.list.mockResolvedValue([createProject()]);
- mockInstanceSettingsApi.getExperimental.mockResolvedValue({ enableIsolatedWorkspaces: true });
const root = renderProperties(container, {
issue: createIssue({
projectId: "project-1",
@@ -596,14 +594,10 @@ describe("IssueProperties", () => {
await flush();
await flush();
- const tasksLink = Array.from(container.querySelectorAll("a")).find(
- (link) => link.textContent?.includes("View workspace tasks"),
- );
const workspaceLink = Array.from(container.querySelectorAll("a")).find(
(link) => link.textContent?.trim() === "View workspace",
);
- expect(tasksLink).not.toBeUndefined();
- expect(tasksLink?.getAttribute("href")).toBe("/execution-workspaces/workspace-1/issues");
+ expect(container.textContent).not.toContain("View workspace tasks");
expect(workspaceLink).not.toBeUndefined();
expect(workspaceLink?.getAttribute("href")).toBe("/execution-workspaces/workspace-1");
@@ -806,6 +800,132 @@ describe("IssueProperties", () => {
act(() => root.unmount());
});
+ it("hides model options when the issue uses the assignee default", async () => {
+ mockAgentsApi.list.mockResolvedValue([
+ {
+ id: "agent-1",
+ name: "Senior Product Engineer",
+ role: "engineer",
+ title: null,
+ status: "active",
+ adapterType: "codex_local",
+ icon: null,
+ },
+ ]);
+
+ const root = renderProperties(container, {
+ issue: createIssue({
+ assigneeAgentId: "agent-1",
+ assigneeAdapterOverrides: null,
+ }),
+ childIssues: [],
+ onUpdate: vi.fn(),
+ });
+ await flush();
+
+ expect(container.textContent).not.toContain("Model lane");
+ expect(container.textContent).not.toContain("Codex options");
+
+ act(() => root.unmount());
+ });
+
+ it("edits existing custom assignee model options from the properties pane", async () => {
+ const onUpdate = vi.fn();
+ mockAgentsApi.list.mockResolvedValue([
+ {
+ id: "agent-1",
+ name: "Senior Product Engineer",
+ role: "engineer",
+ title: null,
+ status: "active",
+ adapterType: "codex_local",
+ icon: null,
+ },
+ ]);
+ mockAgentsApi.adapterModels.mockResolvedValue([
+ { id: "gpt-5.5", label: "GPT-5.5" },
+ { id: "gpt-5.4", label: "GPT-5.4" },
+ ]);
+
+ const root = renderProperties(container, {
+ issue: createIssue({
+ assigneeAgentId: "agent-1",
+ assigneeAdapterOverrides: {
+ adapterConfig: {
+ model: "gpt-5.4",
+ modelReasoningEffort: "high",
+ },
+ },
+ }),
+ childIssues: [],
+ onUpdate,
+ });
+ await flush();
+ await flush();
+
+ expect(container.textContent).toContain("Custom · gpt-5.4 · high");
+ expect(container.textContent).toContain("Model lane");
+
+ const modelButton = Array.from(container.querySelectorAll("button"))
+ .find((button) => button.textContent?.includes("GPT-5.5"));
+ expect(modelButton).not.toBeUndefined();
+
+ await act(async () => {
+ modelButton!.dispatchEvent(new MouseEvent("click", { bubbles: true }));
+ });
+
+ expect(onUpdate).toHaveBeenCalledWith({
+ assigneeAdapterOverrides: {
+ adapterConfig: {
+ model: "gpt-5.5",
+ modelReasoningEffort: "high",
+ },
+ },
+ });
+
+ act(() => root.unmount());
+ });
+
+ it("clears existing assignee adapter overrides from the properties pane", async () => {
+ const onUpdate = vi.fn();
+ mockAgentsApi.list.mockResolvedValue([
+ {
+ id: "agent-1",
+ name: "Senior Product Engineer",
+ role: "engineer",
+ title: null,
+ status: "active",
+ adapterType: "codex_local",
+ icon: null,
+ },
+ ]);
+
+ const root = renderProperties(container, {
+ issue: createIssue({
+ assigneeAgentId: "agent-1",
+ assigneeAdapterOverrides: {
+ adapterConfig: {
+ model: "gpt-5.4",
+ },
+ },
+ }),
+ childIssues: [],
+ onUpdate,
+ });
+ await flush();
+
+ const clearButton = container.querySelector('button[aria-label="Clear adapter options"]');
+ expect(clearButton).not.toBeNull();
+
+ await act(async () => {
+ clearButton!.dispatchEvent(new MouseEvent("click", { bubbles: true }));
+ });
+
+ expect(onUpdate).toHaveBeenCalledWith({ assigneeAdapterOverrides: null });
+
+ act(() => root.unmount());
+ });
+
it("shows a checkmark on selected labels in the picker", async () => {
mockIssuesApi.listLabels.mockResolvedValue([
createLabel(),
diff --git a/ui/src/components/IssueProperties.tsx b/ui/src/components/IssueProperties.tsx
index 968bbc2bb7..50a64bd814 100644
--- a/ui/src/components/IssueProperties.tsx
+++ b/ui/src/components/IssueProperties.tsx
@@ -3,15 +3,16 @@ import { pickTextColorForPillBg } from "@/lib/color-contrast";
import { Link } from "@/lib/router";
import type { Issue, IssueLabel, Project, WorkspaceRuntimeService } from "@paperclipai/shared";
import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import type { AdapterModel } from "../api/agents";
import { accessApi } from "../api/access";
import { agentsApi } from "../api/agents";
import { authApi } from "../api/auth";
-import { instanceSettingsApi } from "../api/instanceSettings";
import { issuesApi } from "../api/issues";
import { projectsApi } from "../api/projects";
import { useCompany } from "../context/CompanyContext";
import { queryKeys } from "../lib/queryKeys";
import { buildCompanyUserInlineOptions, buildCompanyUserLabelMap } from "../lib/company-members";
+import { ISSUE_OVERRIDE_ADAPTER_TYPES, type IssueModelLane } from "../lib/issue-assignee-overrides";
import { useProjectOrder } from "../hooks/useProjectOrder";
import {
getRecentAssigneeIds,
@@ -25,6 +26,10 @@ import { orderItemsBySelectedAndRecent } from "../lib/recent-selections";
import { formatAssigneeUserLabel } from "../lib/assignees";
import { buildExecutionPolicy, stageParticipantValues } from "../lib/issue-execution-policy";
import { formatMonitorOffset } from "../lib/issue-monitor";
+import { formatRetryReason } from "../lib/runRetryState";
+import { useRetryNowMutation } from "../hooks/useRetryNowMutation";
+import { RetryErrorBand } from "./IssueScheduledRetryCard";
+import { extractProviderIdWithFallback } from "../lib/model-utils";
import { StatusIcon } from "./StatusIcon";
import { PriorityIcon } from "./PriorityIcon";
import { Identity } from "./Identity";
@@ -32,6 +37,7 @@ import { IssueReferencePill } from "./IssueReferencePill";
import { formatDate, formatDateTime, cn, projectUrl } from "../lib/utils";
import { timeAgo } from "../lib/timeAgo";
import { Button } from "@/components/ui/button";
+import { ToggleSwitch } from "@/components/ui/toggle-switch";
import {
Dialog,
DialogClose,
@@ -43,8 +49,9 @@ import {
} from "@/components/ui/dialog";
import { Separator } from "@/components/ui/separator";
import { Popover, PopoverContent, PopoverTrigger } from "@/components/ui/popover";
-import { User, Hexagon, ArrowUpRight, Tag, Plus, GitBranch, FolderOpen, Check, ExternalLink, X, Clock } from "lucide-react";
+import { User, Hexagon, ArrowUpRight, Tag, Plus, GitBranch, FolderOpen, Check, ExternalLink, X, Clock, RotateCcw, Loader2, CheckCircle2 } from "lucide-react";
import { AgentIcon } from "./AgentIconPicker";
+import { InlineEntitySelector, type InlineEntityOption } from "./InlineEntitySelector";
function TruncatedCopyable({ value, icon: Icon }: { value: string; icon: React.ComponentType<{ className?: string }> }) {
const [copied, setCopied] = useState(false);
@@ -122,10 +129,6 @@ function runningRuntimeServiceWithUrl(
return runtimeServices?.find((service) => service.status === "running" && service.url?.trim()) ?? null;
}
-function executionWorkspaceIssuesHref(workspaceId: string) {
- return `/execution-workspaces/${workspaceId}/issues`;
-}
-
function toDateTimeLocalValue(value: string | null | undefined) {
if (!value) return "";
const date = new Date(value);
@@ -151,6 +154,82 @@ function PropertyRow({ label, children }: { label: string; children: React.React
);
}
+const ISSUE_THINKING_EFFORT_OPTIONS = {
+ claude_local: [
+ { value: "", label: "Default" },
+ { value: "low", label: "Low" },
+ { value: "medium", label: "Medium" },
+ { value: "high", label: "High" },
+ ],
+ codex_local: [
+ { value: "", label: "Default" },
+ { value: "minimal", label: "Minimal" },
+ { value: "low", label: "Low" },
+ { value: "medium", label: "Medium" },
+ { value: "high", label: "High" },
+ { value: "xhigh", label: "X-High" },
+ ],
+ opencode_local: [
+ { value: "", label: "Default" },
+ { value: "minimal", label: "Minimal" },
+ { value: "low", label: "Low" },
+ { value: "medium", label: "Medium" },
+ { value: "high", label: "High" },
+ { value: "xhigh", label: "X-High" },
+ { value: "max", label: "Max" },
+ ],
+} as const;
+
+function asRecord(value: unknown): Record<string, unknown> {
+ return typeof value === "object" && value !== null && !Array.isArray(value)
+ ? value as Record<string, unknown>
+ : {};
+}
+
+function compactRecord(record: Record<string, unknown>) {
+ return Object.fromEntries(
+ Object.entries(record).filter(([, value]) => value !== undefined),
+ );
+}
+
+function thinkingEffortOptionsFor(adapterType: string | null | undefined) {
+ if (adapterType === "codex_local") return ISSUE_THINKING_EFFORT_OPTIONS.codex_local;
+ if (adapterType === "opencode_local") return ISSUE_THINKING_EFFORT_OPTIONS.opencode_local;
+ return ISSUE_THINKING_EFFORT_OPTIONS.claude_local;
+}
+
+function thinkingEffortKeyFor(adapterType: string | null | undefined) {
+ if (adapterType === "codex_local") return "modelReasoningEffort";
+ if (adapterType === "opencode_local") return "variant";
+ return "effort";
+}
+
+function thinkingEffortValueFor(adapterType: string | null | undefined, adapterConfig: Record<string, unknown>) {
+ if (adapterType === "codex_local") {
+ return String(adapterConfig.modelReasoningEffort ?? adapterConfig.reasoningEffort ?? adapterConfig.effort ?? "");
+ }
+ if (adapterType === "opencode_local") {
+ return String(adapterConfig.variant ?? "");
+ }
+ return String(adapterConfig.effort ?? "");
+}
+
+function overrideLane(overrides: Issue["assigneeAdapterOverrides"]): IssueModelLane {
+ if (overrides?.modelProfile === "cheap") return "cheap";
+ if (overrides?.adapterConfig) return "custom";
+ return "primary";
+}
+
+function sortAdapterModels(models: AdapterModel[]) {
+ return [...models].sort((a, b) => {
+ const providerA = extractProviderIdWithFallback(a.id);
+ const providerB = extractProviderIdWithFallback(b.id);
+ const byProvider = providerA.localeCompare(providerB);
+ if (byProvider !== 0) return byProvider;
+ return a.id.localeCompare(b.id);
+ });
+}
+
function RemovableIssueReferencePill({
issue,
onRemove,
@@ -317,7 +396,9 @@ export function IssueProperties({
const [approversOpen, setApproversOpen] = useState(false);
const [approverSearch, setApproverSearch] = useState("");
const [monitorOpen, setMonitorOpen] = useState(false);
+ const [scheduledRetryOpen, setScheduledRetryOpen] = useState(false);
const [labelsOpen, setLabelsOpen] = useState(false);
+ const [assigneeOptionsOpen, setAssigneeOptionsOpen] = useState(false);
const [labelSearch, setLabelSearch] = useState("");
const [newLabelName, setNewLabelName] = useState("");
const [newLabelColor, setNewLabelColor] = useState("#6366f1");
@@ -341,12 +422,6 @@ export function IssueProperties({
queryFn: () => accessApi.listUserDirectory(companyId!),
enabled: !!companyId,
});
- const { data: experimentalSettings } = useQuery({
- queryKey: queryKeys.instance.experimentalSettings,
- queryFn: () => instanceSettingsApi.getExperimental(),
- retry: false,
- });
-
const { data: projects } = useQuery({
queryKey: queryKeys.projects.list(companyId!),
queryFn: () => projectsApi.list(companyId!),
@@ -414,16 +489,10 @@ export function IssueProperties({
? orderedProjects.find((project) => project.id === issue.projectId) ?? null
: null;
const issueProject = issue.project ?? currentProject;
- const isolatedWorkspacesEnabled = experimentalSettings?.enableIsolatedWorkspaces === true;
const issueUsesMainWorkspace = useMemo(
() => isMainIssueWorkspace({ issue, project: issueProject }),
[issue, issueProject],
);
- const workspaceTasksExecutionWorkspaceId = useMemo(() => {
- if (!isolatedWorkspacesEnabled) return null;
- if (issueUsesMainWorkspace) return null;
- return issue.executionWorkspaceId ?? issue.currentExecutionWorkspace?.id ?? null;
- }, [isolatedWorkspacesEnabled, issue, issueUsesMainWorkspace]);
const showWorkspaceDetailLink = Boolean(issue.executionWorkspaceId) && !issueUsesMainWorkspace;
const liveWorkspaceService = useMemo(() => {
if (issueUsesMainWorkspace) return null;
@@ -482,6 +551,219 @@ export function IssueProperties({
const assignee = issue.assigneeAgentId
? agents?.find((a) => a.id === issue.assigneeAgentId)
: null;
+ const assigneeAdapterType = assignee?.adapterType ?? null;
+ const assigneeAdapterOverrides = issue.assigneeAdapterOverrides ?? null;
+ const showAssigneeAdapterOptions = assigneeAdapterOverrides !== null;
+ const supportsAssigneeOverrides = Boolean(
+ assigneeAdapterType && ISSUE_OVERRIDE_ADAPTER_TYPES.has(assigneeAdapterType),
+ );
+ const assigneeSupportsCheapLane = Boolean(
+ supportsAssigneeOverrides
+ && (assigneeAdapterType === "claude_local"
+ || assigneeAdapterType === "codex_local"
+ || assigneeAdapterType === "opencode_local"),
+ );
+ const assigneeOverrideLane = overrideLane(assigneeAdapterOverrides);
+ const assigneeOverrideAdapterConfig = asRecord(assigneeAdapterOverrides?.adapterConfig);
+ const assigneeOverrideModel =
+ typeof assigneeOverrideAdapterConfig.model === "string" ? assigneeOverrideAdapterConfig.model : "";
+ const assigneeOverrideThinkingEffort = thinkingEffortValueFor(
+ assigneeAdapterType,
+ assigneeOverrideAdapterConfig,
+ );
+ const assigneeOverrideChrome = assigneeAdapterType === "claude_local"
+ && assigneeOverrideAdapterConfig.chrome === true;
+ const { data: assigneeAdapterModels } = useQuery({
+ queryKey:
+ companyId && assigneeAdapterType
+ ? queryKeys.agents.adapterModels(companyId, assigneeAdapterType)
+ : ["agents", "none", "adapter-models", assigneeAdapterType ?? "none"],
+ queryFn: () => agentsApi.adapterModels(companyId!, assigneeAdapterType!),
+ enabled: Boolean(companyId) && showAssigneeAdapterOptions && supportsAssigneeOverrides,
+ });
+ const { data: assigneeCheapProfiles } = useQuery({
+ queryKey: companyId && assigneeAdapterType
+ ? queryKeys.agents.adapterModelProfiles(companyId, assigneeAdapterType)
+ : ["agents", "none", "adapter-model-profiles", assigneeAdapterType ?? "none"],
+ queryFn: () => agentsApi.adapterModelProfiles(companyId!, assigneeAdapterType!),
+ enabled: Boolean(companyId) && showAssigneeAdapterOptions && assigneeSupportsCheapLane,
+ });
+ const assigneeCheapProfile = useMemo(
+ () => (assigneeCheapProfiles ?? []).find((profile) => profile.key === "cheap") ?? null,
+ [assigneeCheapProfiles],
+ );
+ const modelOverrideOptions = useMemo<InlineEntityOption[]>(() => {
+ const models = sortAdapterModels(assigneeAdapterModels ?? []);
+ const options = models.map((model) => ({
+ id: model.id,
+ label: model.label,
+ searchText: `${model.id} ${extractProviderIdWithFallback(model.id)}`,
+ }));
+ if (assigneeOverrideModel && !options.some((option) => option.id === assigneeOverrideModel)) {
+ options.unshift({
+ id: assigneeOverrideModel,
+ label: assigneeOverrideModel,
+ searchText: assigneeOverrideModel,
+ });
+ }
+ return options;
+ }, [assigneeAdapterModels, assigneeOverrideModel]);
+ const updateAssigneeAdapterOverrides = (next: Issue["assigneeAdapterOverrides"]) => {
+ onUpdate({ assigneeAdapterOverrides: next });
+ };
+ const buildAssigneeOverrideWithConfig = (adapterConfig: Record<string, unknown>) => {
+ const nextConfig = compactRecord(adapterConfig);
+ const next = compactRecord({
+ useProjectWorkspace: assigneeAdapterOverrides?.useProjectWorkspace,
+ ...(Object.keys(nextConfig).length > 0 ? { adapterConfig: nextConfig } : {}),
+ });
+ return Object.keys(next).length > 0 ? next : null;
+ };
+ const updateAssigneeOverrideConfig = (patch: Record<string, unknown>) => {
+ updateAssigneeAdapterOverrides(
+ buildAssigneeOverrideWithConfig({
+ ...assigneeOverrideAdapterConfig,
+ ...patch,
+ }),
+ );
+ };
+ const updateAssigneeOverrideThinkingEffort = (nextValue: string) => {
+ const nextConfig = { ...assigneeOverrideAdapterConfig };
+ delete nextConfig.modelReasoningEffort;
+ delete nextConfig.reasoningEffort;
+ delete nextConfig.effort;
+ delete nextConfig.variant;
+ if (nextValue) {
+ nextConfig[thinkingEffortKeyFor(assigneeAdapterType)] = nextValue;
+ }
+ updateAssigneeAdapterOverrides(buildAssigneeOverrideWithConfig(nextConfig));
+ };
+ const setAssigneeOverrideLane = (lane: IssueModelLane) => {
+ if (lane === "primary") {
+ updateAssigneeAdapterOverrides(null);
+ return;
+ }
+ if (lane === "cheap") {
+ updateAssigneeAdapterOverrides(
+ compactRecord({
+ useProjectWorkspace: assigneeAdapterOverrides?.useProjectWorkspace,
+ modelProfile: "cheap",
+ }),
+ );
+ return;
+ }
+ updateAssigneeAdapterOverrides(buildAssigneeOverrideWithConfig(assigneeOverrideAdapterConfig) ?? { adapterConfig: {} });
+ };
+ const assigneeOptionsTrigger = (() => {
+ if (assigneeOverrideLane === "cheap") {
+ return <span className="text-sm">Cheap model</span>;
+ }
+ if (assigneeOverrideLane === "custom") {
+ const details = [
+ assigneeOverrideModel,
+ assigneeOverrideThinkingEffort,
+ assigneeOverrideChrome ? "Chrome" : "",
+ ].filter(Boolean);
+ return (
+ <span className="min-w-0 text-sm break-words">
+ Custom{details.length > 0 ? ` · ${details.join(" · ")}` : " adapter options"}
+ </span>
+ );
+ }
+ return <span className="text-sm text-muted-foreground">Primary model</span>;
+ })();
+ const assigneeOptionsContent = supportsAssigneeOverrides ? (
+ <div className="w-full space-y-3 p-2">
+ <div className="space-y-1.5">
+ <div className="text-xs text-muted-foreground">Model lane</div>
+ <div className="flex w-full overflow-hidden rounded-md border border-border" role="radiogroup" aria-label="Model lane">
+ {(["primary", ...(assigneeSupportsCheapLane ? (["cheap"] as const) : ([] as const)), "custom"] as const).map((lane) => (
+ <button
+ key={lane}
+ type="button"
+ role="radio"
+ aria-checked={assigneeOverrideLane === lane}
+ className={cn(
+ "flex-1 px-2 py-1 text-xs capitalize transition-colors hover:bg-accent/40",
+ assigneeOverrideLane === lane && "bg-accent text-foreground",
+ )}
+ onClick={() => setAssigneeOverrideLane(lane)}
+ >
+ {lane === "primary" ? "Primary" : lane === "cheap" ? "Cheap" : "Custom"}
+ </button>
+ ))}
+ </div>
+ {assigneeOverrideLane === "cheap" ? (
+ <p className="text-[11px] text-muted-foreground">
+ Sends <code>modelProfile: "cheap"</code>{" "}
+ {assigneeCheapProfile?.adapterConfig && typeof (assigneeCheapProfile.adapterConfig as Record<string, unknown>).model === "string"
+ ? <>· adapter default <code>{String((assigneeCheapProfile.adapterConfig as Record<string, unknown>).model)}</code></>
+ : assigneeCheapProfile
+ ? <>· uses the agent&apos;s configured cheap profile</>
+ : <>· falls back to the primary model if no cheap profile is configured</>}
+ </p>
+ ) : null}
+ </div>
+ {assigneeOverrideLane === "custom" ? (
+ <>
+ <div className="space-y-1.5">
+ <div className="text-xs text-muted-foreground">Model</div>
+ <InlineEntitySelector
+ value={assigneeOverrideModel}
+ options={modelOverrideOptions}
+ placeholder="Default model"
+ disablePortal
+ noneLabel="Default model"
+ searchPlaceholder="Search models..."
+ emptyMessage="No models found."
+ onChange={(model) => updateAssigneeOverrideConfig({ model: model || undefined })}
+ />
+ </div>
+ <div className="space-y-1.5">
+ <div className="text-xs text-muted-foreground">Thinking effort</div>
+ <div className="flex items-center gap-1.5 flex-wrap">
+ {thinkingEffortOptionsFor(assigneeAdapterType).map((option) => (
+ <button
+ key={option.value || "default"}
+ className={cn(
+ "px-2 py-1 rounded-md text-xs border border-border hover:bg-accent/50 transition-colors",
+ assigneeOverrideThinkingEffort === option.value && "bg-accent",
+ )}
+ onClick={() => updateAssigneeOverrideThinkingEffort(option.value)}
+ >
+ {option.label}
+ </button>
+ ))}
+ </div>
+ </div>
+ {assigneeAdapterType === "claude_local" ? (
+ <div className="flex items-center justify-between rounded-md border border-border px-2 py-1.5">
+ <div className="text-xs text-muted-foreground">Enable Chrome (--chrome)</div>
+ <ToggleSwitch
+ checked={assigneeOverrideChrome}
+ onCheckedChange={(next) => updateAssigneeOverrideConfig({ chrome: next ? true : undefined })}
+ />
+ </div>
+ ) : null}
+ </>
+ ) : null}
+ </div>
+ ) : (
+ <div className="w-full space-y-2 p-2">
+ <p className="text-xs text-muted-foreground">
+ {assignee
+ ? "This assignee's adapter does not expose editable issue overrides."
+ : "Select a compatible agent assignee to edit these overrides."}
+ </p>
+ <button
+ type="button"
+ className="inline-flex items-center rounded-full border border-border px-2 py-0.5 text-xs text-muted-foreground transition-colors hover:bg-accent/50 hover:text-foreground"
+ onClick={() => updateAssigneeAdapterOverrides(null)}
+ >
+ Clear adapter options
+ </button>
+ </div>
+ );
const reviewerValues = stageParticipantValues(issue.executionPolicy, "review");
const approverValues = stageParticipantValues(issue.executionPolicy, "approval");
const userLabel = (userId: string | null | undefined) => formatAssigneeUserLabel(userId, currentUserId, userLabelMap);
@@ -651,6 +933,169 @@ export function IssueProperties({
Attempt {issue.monitorAttemptCount}
</span>
) : null;
+
+ const scheduledRetry = issue.scheduledRetry ?? null;
+ const retryNow = useRetryNowMutation(issue.id);
+ const showScheduledRetryRow = scheduledRetry && scheduledRetry.status === "scheduled_retry";
+ const scheduledRetryDueAtIso = scheduledRetry?.scheduledRetryAt
+ ? new Date(scheduledRetry.scheduledRetryAt).toISOString()
+ : null;
+ const scheduledRetryRelative = scheduledRetryDueAtIso
+ ? formatMonitorOffset(scheduledRetryDueAtIso)
+ : null;
+ const scheduledRetryAbsolute = scheduledRetry?.scheduledRetryAt
+ ? formatDateTime(scheduledRetry.scheduledRetryAt)
+ : null;
+ const scheduledRetryShortDate = scheduledRetry?.scheduledRetryAt
+ ? formatDate(new Date(scheduledRetry.scheduledRetryAt))
+ : null;
+ const scheduledRetryReasonLabel = formatRetryReason(scheduledRetry?.scheduledRetryReason);
+ const scheduledRetryAttempt =
+ typeof scheduledRetry?.scheduledRetryAttempt === "number"
+ && Number.isFinite(scheduledRetry.scheduledRetryAttempt)
+ && scheduledRetry.scheduledRetryAttempt > 0
+ ? scheduledRetry.scheduledRetryAttempt
+ : null;
+ const scheduledRetryIsContinuation =
+ scheduledRetry?.scheduledRetryReason === "max_turns_continuation";
+ const scheduledRetryRelativeLabel = (() => {
+ if (!scheduledRetryRelative) return "Pending schedule";
+ const action = scheduledRetryIsContinuation ? "Continuation" : "Retry";
+ if (scheduledRetryRelative === "now") return `${action} due now`;
+ return `${action} ${scheduledRetryRelative}`;
+ })();
+ const scheduledRetryRetryNowSuccess = retryNow.isSuccess
+ && (retryNow.data?.outcome === "promoted" || retryNow.data?.outcome === "already_promoted");
+ const scheduledRetryAttemptBadge = scheduledRetryAttempt !== null ? (
+ <span className="text-xs text-muted-foreground">Attempt {scheduledRetryAttempt}</span>
+ ) : null;
+ const scheduledRetryTrigger = (
+ <span className="inline-flex min-w-0 flex-wrap items-center gap-x-1.5 gap-y-0.5">
+ <Clock className="mt-0.5 h-3.5 w-3.5 shrink-0 text-cyan-600 dark:text-cyan-400" aria-hidden="true" />
+ <span
+ className="min-w-0 text-sm break-words text-foreground"
+ title={scheduledRetryAbsolute ?? undefined}
+ >
+ {scheduledRetryRelativeLabel}
+ </span>
+ {scheduledRetryShortDate ? (
+ <span className="text-xs text-muted-foreground" title={scheduledRetryAbsolute ?? undefined}>
+ {scheduledRetryShortDate}
+ </span>
+ ) : null}
+ </span>
+ );
+ const scheduledRetryContent = scheduledRetry ? (
+ <div className="flex w-full flex-col gap-2 p-2 text-xs">
+ <div className="flex items-center justify-between">
+ <span className="text-sm font-medium text-foreground">
+ {scheduledRetryIsContinuation ? "Scheduled continuation" : "Scheduled retry"}
+ </span>
+ {scheduledRetryAttempt !== null ? (
+ <span className="rounded-full border border-border bg-muted/30 px-2 py-0.5 text-xs text-muted-foreground">
+ Attempt {scheduledRetryAttempt}
+ </span>
+ ) : null}
+ </div>
+ <dl className="grid grid-cols-[6rem_1fr] gap-y-1">
+ {scheduledRetryReasonLabel ? (
+ <>
+ <dt className="text-muted-foreground">Reason</dt>
+ <dd className="text-foreground">{scheduledRetryReasonLabel}</dd>
+ </>
+ ) : null}
+ {scheduledRetryAbsolute ? (
+ <>
+ <dt className="text-muted-foreground">Next attempt</dt>
+ <dd className="text-foreground">
+ {scheduledRetryAbsolute}
+ {scheduledRetryRelative ? (
+ <span className="ml-1 text-muted-foreground">· {scheduledRetryRelative}</span>
+ ) : null}
+ </dd>
+ </>
+ ) : null}
+ {scheduledRetry.retryOfRunId ? (
+ <>
+ <dt className="text-muted-foreground">Replaces run</dt>
+ <dd className="text-foreground">
+ <Link
+ to={`/agents/${scheduledRetry.agentId}/runs/${scheduledRetry.retryOfRunId}`}
+ className="font-mono text-foreground hover:underline"
+ >
+ {scheduledRetry.retryOfRunId.slice(0, 8)}
+ </Link>
+ </dd>
+ </>
+ ) : null}
+ {scheduledRetry.agentName ? (
+ <>
+ <dt className="text-muted-foreground">Agent</dt>
+ <dd className="text-foreground">
+ <Link
+ to={`/agents/${scheduledRetry.agentId}`}
+ className="text-foreground hover:underline"
+ >
+ {scheduledRetry.agentName}
+ </Link>
+ </dd>
+ </>
+ ) : null}
+ {scheduledRetry.error ? (
+ <>
+ <dt className="text-muted-foreground">Last error</dt>
+ <dd className="text-foreground break-words">{scheduledRetry.error}</dd>
+ </>
+ ) : null}
+ </dl>
+ <RetryErrorBand
+ error={retryNow.lastError}
+ onRetry={() => {
+ retryNow.reset();
+ retryNow.mutate();
+ }}
+ />
+ <Separator className="my-1" />
+ <div className="flex items-center justify-between gap-2">
+ <Button
+ type="button"
+ size="sm"
+ variant="default"
+ onClick={() => retryNow.mutate()}
+ disabled={retryNow.isPending || scheduledRetryRetryNowSuccess}
+ data-testid="issue-scheduled-retry-properties-retry-now"
+ >
+ {retryNow.isPending ? (
+ <span className="inline-flex items-center gap-1.5">
+ <Loader2 className="h-3.5 w-3.5 animate-spin" aria-hidden="true" />
+ Retrying…
+ </span>
+ ) : scheduledRetryRetryNowSuccess ? (
+ <span className="inline-flex items-center gap-1.5">
+ <CheckCircle2 className="h-3.5 w-3.5" aria-hidden="true" />
+ {retryNow.data?.outcome === "already_promoted" ? "Already promoted" : "Promoted"}
+ </span>
+ ) : (
+ <span className="inline-flex items-center gap-1.5">
+ <RotateCcw className="h-3.5 w-3.5" aria-hidden="true" />
+ Retry now
+ </span>
+ )}
+ </Button>
+ <span className="text-right text-xs text-muted-foreground">
+ {retryNow.isPending
+ ? "Promoting scheduled retry"
+ : scheduledRetryRetryNowSuccess
+ ? retryNow.data?.outcome === "already_promoted"
+ ? "Already promoted — run starting"
+ : "Promoted — run starting"
+ : scheduledRetryIsContinuation
+ ? "Pulls continuation forward immediately"
+ : "Pulls retry forward immediately"}
+ </span>
+ </div>
+ </div>
+ ) : null;
const monitorContent = (
<div className="flex w-full flex-col gap-2">
<div className="flex flex-col gap-2 md:flex-row">
@@ -1334,6 +1779,31 @@ export function IssueProperties({
{assigneeContent}
</PropertyPicker>
+ {showAssigneeAdapterOptions ? (
+ <PropertyPicker
+ inline={inline}
+ label="Model"
+ open={assigneeOptionsOpen}
+ onOpenChange={setAssigneeOptionsOpen}
+ triggerContent={assigneeOptionsTrigger}
+ triggerClassName="min-w-0 max-w-full"
+ popoverClassName={cn("max-w-full", inline ? "w-full" : "w-72")}
+ extra={
+ <button
+ type="button"
+ className="inline-flex items-center justify-center h-5 w-5 rounded hover:bg-accent/50 transition-colors text-muted-foreground hover:text-foreground"
+ onClick={() => updateAssigneeAdapterOverrides(null)}
+ aria-label="Clear adapter options"
+ title="Clear adapter options"
+ >
+ <X className="h-3 w-3" />
+ </button>
+ }
+ >
+ {assigneeOptionsContent}
+ </PropertyPicker>
+ ) : null}
+
<PropertyPicker
inline={inline}
label="Project"
@@ -1491,6 +1961,21 @@ export function IssueProperties({
</PropertyRow>
)}
+ {showScheduledRetryRow && scheduledRetryContent ? (
+ <PropertyPicker
+ inline={inline}
+ label="Scheduled retry"
+ open={scheduledRetryOpen}
+ onOpenChange={setScheduledRetryOpen}
+ triggerContent={scheduledRetryTrigger}
+ triggerClassName="min-w-0 max-w-full"
+ popoverClassName={cn("max-w-full", inline ? "w-full" : "w-80 sm:w-[32rem]")}
+ extra={scheduledRetryAttemptBadge}
+ >
+ {scheduledRetryContent}
+ </PropertyPicker>
+ ) : null}
+
<PropertyPicker
inline={inline}
label="Monitor"
@@ -1539,17 +2024,6 @@ export function IssueProperties({
</Link>
</PropertyRow>
)}
- {workspaceTasksExecutionWorkspaceId && (
- <PropertyRow label="Tasks">
- <Link
- to={executionWorkspaceIssuesHref(workspaceTasksExecutionWorkspaceId)}
- className="text-sm text-primary hover:underline inline-flex items-center gap-1"
- >
- View workspace tasks
- <ExternalLink className="h-3 w-3" />
- </Link>
- </PropertyRow>
- )}
{issue.currentExecutionWorkspace?.branchName && (
<PropertyRow label="Branch">
<TruncatedCopyable
diff --git a/ui/src/components/IssueScheduledRetryCard.test.tsx b/ui/src/components/IssueScheduledRetryCard.test.tsx
new file mode 100644
index 0000000000..cd1078b2e8
--- /dev/null
+++ b/ui/src/components/IssueScheduledRetryCard.test.tsx
@@ -0,0 +1,226 @@
+// @vitest-environment jsdom
+
+import { act } from "react";
+import type { ComponentProps, ReactNode } from "react";
+import { createRoot, type Root } from "react-dom/client";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
+import type { IssueRetryNowOutcome, IssueScheduledRetry } from "@paperclipai/shared";
+import { IssueScheduledRetryCard } from "./IssueScheduledRetryCard";
+import { ToastProvider } from "../context/ToastContext";
+
+const retryNowMock = vi.hoisted(() => vi.fn());
+
+vi.mock("@/lib/router", () => ({
+ Link: ({ children, to, ...props }: { children: ReactNode; to: string } & ComponentProps<"a">) => (
+ <a href={to} {...props}>{children}</a>
+ ),
+}));
+
+vi.mock("../api/issues", () => ({
+ issuesApi: {
+ retryScheduledRetryNow: retryNowMock,
+ },
+}));
+
+(globalThis as unknown as { IS_REACT_ACT_ENVIRONMENT: boolean }).IS_REACT_ACT_ENVIRONMENT = true;
+
+let container: HTMLDivElement;
+let root: Root;
+let dateNowSpy: ReturnType<typeof vi.spyOn> | null = null;
+
+const SYSTEM_NOW = new Date("2026-04-18T20:00:00.000Z").getTime();
+
+const baseRetry: IssueScheduledRetry = {
+ runId: "run-00000000",
+ status: "scheduled_retry",
+ agentId: "agent-1",
+ agentName: "ClaudeCoder",
+ retryOfRunId: "run-prev-1234567",
+ scheduledRetryAt: "2026-04-18T20:15:00.000Z",
+ scheduledRetryAttempt: 4,
+ scheduledRetryReason: "transient_failure",
+ retryExhaustedReason: null,
+ error: "Upstream provider rate limited",
+ errorCode: "rate_limited",
+};
+
+function buildRetryResponse(outcome: IssueRetryNowOutcome) {
+ return {
+ outcome,
+ message:
+ outcome === "promoted"
+ ? "Promoted scheduled retry"
+ : outcome === "already_promoted"
+ ? "Scheduled retry already promoted"
+ : outcome === "no_scheduled_retry"
+ ? "No scheduled retry"
+ : "Promotion suppressed by gate",
+ scheduledRetry:
+ outcome === "promoted" || outcome === "already_promoted"
+ ? { ...baseRetry, status: "queued" as const }
+ : null,
+ };
+}
+
+async function flushAll() {
+ for (let i = 0; i < 4; i += 1) {
+ // eslint-disable-next-line no-await-in-loop
+ await act(async () => {
+ await Promise.resolve();
+ });
+ }
+}
+
+function renderWithProviders(ui: ReactNode) {
+ const queryClient = new QueryClient({
+ defaultOptions: { queries: { retry: false }, mutations: { retry: false } },
+ });
+ act(() => {
+ root.render(
+ <QueryClientProvider client={queryClient}>
+ <ToastProvider>{ui}</ToastProvider>
+ </QueryClientProvider>,
+ );
+ });
+}
+
+beforeEach(() => {
+ dateNowSpy = vi.spyOn(Date, "now").mockReturnValue(SYSTEM_NOW);
+ retryNowMock.mockReset();
+ container = document.createElement("div");
+ document.body.appendChild(container);
+ root = createRoot(container);
+});
+
+afterEach(() => {
+ act(() => root.unmount());
+ container.remove();
+ dateNowSpy?.mockRestore();
+});
+
+function getCard() {
+ return container.querySelector('[data-testid="issue-scheduled-retry-card"]');
+}
+
+function getRetryNowButton() {
+ return container.querySelector<HTMLButtonElement>(
+ '[data-testid="issue-scheduled-retry-card-retry-now"]',
+ );
+}
+
+describe("IssueScheduledRetryCard", () => {
+ it("renders nothing when there is no scheduled retry", () => {
+ renderWithProviders(<IssueScheduledRetryCard issueId="issue-1" scheduledRetry={null} />);
+ expect(getCard()).toBeNull();
+ });
+
+ it("renders nothing when status is not scheduled_retry", () => {
+ renderWithProviders(
+ <IssueScheduledRetryCard
+ issueId="issue-1"
+ scheduledRetry={{ ...baseRetry, status: "queued" }}
+ />,
+ );
+ expect(getCard()).toBeNull();
+ });
+
+ it("shows attempt count, reason, absolute and relative timestamps", () => {
+ renderWithProviders(
+ <IssueScheduledRetryCard issueId="issue-1" scheduledRetry={baseRetry} />,
+ );
+ const card = getCard();
+ expect(card).not.toBeNull();
+ const text = card!.textContent ?? "";
+ expect(text).toContain("Retry scheduled");
+ expect(text).toContain("Attempt 4");
+ expect(text).toContain("Transient failure");
+ expect(text).toContain("Automatic retry in 15m");
+ expect(text).toContain("run-prev");
+ });
+
+ it("uses continuation copy for max-turn continuations", () => {
+ renderWithProviders(
+ <IssueScheduledRetryCard
+ issueId="issue-1"
+ scheduledRetry={{ ...baseRetry, scheduledRetryReason: "max_turns_continuation" }}
+ />,
+ );
+ const text = getCard()?.textContent ?? "";
+ expect(text).toContain("Continuation scheduled");
+ expect(text).toContain("Automatic continuation");
+ expect(text).toContain("Pulls continuation forward immediately");
+ });
+
+ it("uses 'due now' label when scheduledRetryAt is at the current time", () => {
+ renderWithProviders(
+ <IssueScheduledRetryCard
+ issueId="issue-1"
+ scheduledRetry={{ ...baseRetry, scheduledRetryAt: "2026-04-18T20:00:10.000Z" }}
+ />,
+ );
+ const text = getCard()?.textContent ?? "";
+ expect(text).toContain("Automatic retry due now");
+ });
+
+ it("invokes retry-now and shows promoted state on success", async () => {
+ retryNowMock.mockResolvedValue(buildRetryResponse("promoted"));
+ renderWithProviders(
+ <IssueScheduledRetryCard issueId="issue-1" scheduledRetry={baseRetry} />,
+ );
+ const button = getRetryNowButton();
+ expect(button).not.toBeNull();
+
+ act(() => {
+ button!.click();
+ });
+ await flushAll();
+ expect(retryNowMock).toHaveBeenCalledWith("issue-1");
+ const finalButton = getRetryNowButton();
+ expect(finalButton!.textContent ?? "").toContain("Promoted");
+ expect(finalButton!.disabled).toBe(true);
+ });
+
+ it("shows already promoted state when backend reports duplicate click", async () => {
+ retryNowMock.mockResolvedValue(buildRetryResponse("already_promoted"));
+ renderWithProviders(
+ <IssueScheduledRetryCard issueId="issue-1" scheduledRetry={baseRetry} />,
+ );
+ act(() => {
+ getRetryNowButton()!.click();
+ });
+ await flushAll();
+ expect(getRetryNowButton()!.textContent ?? "").toContain("Already promoted");
+ expect(container.querySelector('[data-testid="issue-scheduled-retry-error-band"]')).toBeNull();
+ });
+
+ it("renders an inline error band on backend failure", async () => {
+ retryNowMock.mockRejectedValue(new Error("Server error"));
+ renderWithProviders(
+ <IssueScheduledRetryCard issueId="issue-1" scheduledRetry={baseRetry} />,
+ );
+ act(() => {
+ getRetryNowButton()!.click();
+ });
+ await flushAll();
+ const band = container.querySelector('[data-testid="issue-scheduled-retry-error-band"]');
+ expect(band).not.toBeNull();
+ expect((band?.textContent ?? "")).toContain("Server error");
+ expect(getRetryNowButton()!.disabled).toBe(false);
+ });
+
+ it("surfaces gate-suppressed outcome via the inline error band", async () => {
+ retryNowMock.mockResolvedValue(buildRetryResponse("gate_suppressed"));
+ renderWithProviders(
+ <IssueScheduledRetryCard issueId="issue-1" scheduledRetry={baseRetry} />,
+ );
+ act(() => {
+ getRetryNowButton()!.click();
+ });
+ await flushAll();
+ const band = container.querySelector('[data-testid="issue-scheduled-retry-error-band"]');
+ expect(band).not.toBeNull();
+ expect((band?.textContent ?? "")).toContain("Promotion suppressed");
+ expect(getRetryNowButton()!.disabled).toBe(false);
+ });
+});
diff --git a/ui/src/components/IssueScheduledRetryCard.tsx b/ui/src/components/IssueScheduledRetryCard.tsx
new file mode 100644
index 0000000000..bd6eef0c3e
--- /dev/null
+++ b/ui/src/components/IssueScheduledRetryCard.tsx
@@ -0,0 +1,194 @@
+import { Clock, RotateCcw, AlertCircle, Loader2, CheckCircle2 } from "lucide-react";
+import { Link } from "@/lib/router";
+import { Button } from "@/components/ui/button";
+import { cn, formatDateTime } from "@/lib/utils";
+import { formatMonitorOffset } from "@/lib/issue-monitor";
+import { formatRetryReason } from "@/lib/runRetryState";
+import type { IssueScheduledRetry } from "@paperclipai/shared";
+import { useRetryNowMutation, type RetryNowError } from "../hooks/useRetryNowMutation";
+
+const MAX_TURN_CONTINUATION = "max_turns_continuation";
+
+function isContinuationReason(reason: string | null | undefined) {
+ return reason === MAX_TURN_CONTINUATION;
+}
+
+function shortRunId(runId: string | null | undefined) {
+ return typeof runId === "string" && runId.length >= 8 ? runId.slice(0, 8) : runId ?? "";
+}
+
+interface IssueScheduledRetryCardProps {
+ issueId: string | null | undefined;
+ scheduledRetry: IssueScheduledRetry | null | undefined;
+}
+
+export function IssueScheduledRetryCard({
+ issueId,
+ scheduledRetry,
+}: IssueScheduledRetryCardProps) {
+ const retryNow = useRetryNowMutation(issueId);
+
+ if (!scheduledRetry || !issueId) return null;
+ if (scheduledRetry.status !== "scheduled_retry") return null;
+
+ const continuation = isContinuationReason(scheduledRetry.scheduledRetryReason);
+ const dueAtIso = scheduledRetry.scheduledRetryAt
+ ? new Date(scheduledRetry.scheduledRetryAt).toISOString()
+ : null;
+ const relative = dueAtIso ? formatMonitorOffset(dueAtIso) : null;
+ const absolute = scheduledRetry.scheduledRetryAt
+ ? formatDateTime(scheduledRetry.scheduledRetryAt)
+ : null;
+ const reason = formatRetryReason(scheduledRetry.scheduledRetryReason);
+ const attempt =
+ typeof scheduledRetry.scheduledRetryAttempt === "number"
+ && Number.isFinite(scheduledRetry.scheduledRetryAttempt)
+ && scheduledRetry.scheduledRetryAttempt > 0
+ ? scheduledRetry.scheduledRetryAttempt
+ : null;
+
+ const badgeLabel = continuation ? "Continuation scheduled" : "Retry scheduled";
+ const titleAction = continuation ? "Automatic continuation" : "Automatic retry";
+ let titleSuffix: string;
+ if (relative === "now") {
+ titleSuffix = "due now";
+ } else if (relative) {
+ titleSuffix = relative;
+ } else {
+ titleSuffix = "pending schedule";
+ }
+ const title = `${titleAction} ${titleSuffix}`;
+
+ const helperIdle = continuation
+ ? "Pulls continuation forward immediately"
+ : "Pulls retry forward immediately";
+ const isError = retryNow.isError || retryNow.lastError !== null;
+ const isSuccessTransient = retryNow.isSuccess
+ && (retryNow.data?.outcome === "promoted" || retryNow.data?.outcome === "already_promoted");
+
+ return (
+ <div
+ data-testid="issue-scheduled-retry-card"
+ className="mb-3 rounded-lg border border-cyan-500/30 bg-cyan-500/5 px-3 py-3"
+ >
+ <div className="flex flex-col gap-2 sm:flex-row sm:items-start sm:justify-between">
+ <div className="min-w-0 flex-1">
+ <div className="flex flex-wrap items-center gap-2 text-xs">
+ <span className="inline-flex items-center gap-1 rounded-full border border-cyan-500/30 bg-cyan-500/10 px-2 py-0.5 font-medium text-cyan-700 dark:text-cyan-300">
+ <Clock className="h-3 w-3" aria-hidden="true" />
+ {badgeLabel}
+ </span>
+ {attempt !== null ? (
+ <span className="text-muted-foreground">Attempt {attempt}</span>
+ ) : null}
+ {reason ? (
+ <span className="text-muted-foreground">{reason}</span>
+ ) : null}
+ </div>
+ <div className="mt-1 text-sm font-medium text-foreground">{title}</div>
+ {(absolute || scheduledRetry.retryOfRunId) ? (
+ <div className="mt-0.5 text-xs text-muted-foreground">
+ {absolute ? <span>{absolute}</span> : null}
+ {absolute && scheduledRetry.retryOfRunId ? <span>{" · "}</span> : null}
+ {scheduledRetry.retryOfRunId ? (
+ <span>
+ Replaces run{" "}
+ <Link
+ to={`/agents/${scheduledRetry.agentId}/runs/${scheduledRetry.retryOfRunId}`}
+ className="font-mono text-foreground hover:underline"
+ >
+ {shortRunId(scheduledRetry.retryOfRunId)}
+ </Link>
+ </span>
+ ) : null}
+ </div>
+ ) : null}
+ {scheduledRetry.error ? (
+ <div className="mt-1 text-xs text-muted-foreground">
+ Last attempt failed: {scheduledRetry.error}. Paperclip will retry automatically.
+ </div>
+ ) : null}
+ {isError ? (
+ <RetryErrorBand
+ error={retryNow.lastError}
+ onRetry={() => {
+ retryNow.reset();
+ retryNow.mutate();
+ }}
+ />
+ ) : null}
+ </div>
+ <div className="flex flex-col items-stretch gap-1 sm:items-end">
+ <Button
+ type="button"
+ variant="outline"
+ size="sm"
+ className="shrink-0 shadow-none"
+ onClick={() => retryNow.mutate()}
+ disabled={retryNow.isPending || isSuccessTransient}
+ data-testid="issue-scheduled-retry-card-retry-now"
+ >
+ {retryNow.isPending ? (
+ <span className="inline-flex items-center gap-1.5">
+ <Loader2 className="h-3.5 w-3.5 animate-spin" aria-hidden="true" />
+ Retrying…
+ </span>
+ ) : isSuccessTransient ? (
+ <span className="inline-flex items-center gap-1.5">
+ <CheckCircle2 className="h-3.5 w-3.5" aria-hidden="true" />
+ {retryNow.data?.outcome === "already_promoted" ? "Already promoted" : "Promoted"}
+ </span>
+ ) : (
+ <span className="inline-flex items-center gap-1.5">
+ <RotateCcw className="h-3.5 w-3.5" aria-hidden="true" />
+ Retry now
+ </span>
+ )}
+ </Button>
+ <span className="text-right text-xs text-muted-foreground sm:max-w-[12rem]">
+ {retryNow.isPending
+ ? "Promoting scheduled retry"
+ : isSuccessTransient
+ ? retryNow.data?.outcome === "already_promoted"
+ ? "Already promoted — run starting"
+ : "Promoted — run starting"
+ : helperIdle}
+ </span>
+ </div>
+ </div>
+ </div>
+ );
+}
+
+interface RetryErrorBandProps {
+ error: RetryNowError | null;
+ onRetry: () => void;
+ className?: string;
+}
+
+export function RetryErrorBand({ error, onRetry, className }: RetryErrorBandProps) {
+ if (!error) return null;
+ return (
+ <div
+ className={cn(
+ "mt-2 flex items-start gap-2 rounded-md border border-rose-500/30 bg-rose-500/5 px-2 py-1.5 text-xs text-rose-700 dark:text-rose-300",
+ className,
+ )}
+ role="alert"
+ data-testid="issue-scheduled-retry-error-band"
+ >
+ <AlertCircle className="mt-0.5 h-3.5 w-3.5 shrink-0" aria-hidden="true" />
+ <div className="min-w-0 flex-1">
+ <div className="font-medium">Couldn't retry now</div>
+ <div className="mt-0.5 text-muted-foreground">{error.message}</div>
+ </div>
+ <button
+ type="button"
+ onClick={onRetry}
+ className="shrink-0 font-medium text-rose-700 hover:underline dark:text-rose-300"
+ >
+ Try again
+ </button>
+ </div>
+ );
+}
diff --git a/ui/src/hooks/useRetryNowMutation.ts b/ui/src/hooks/useRetryNowMutation.ts
new file mode 100644
index 0000000000..6fec474677
--- /dev/null
+++ b/ui/src/hooks/useRetryNowMutation.ts
@@ -0,0 +1,104 @@
+import { useCallback } from "react";
+import { useMutation, useQueryClient, type UseMutationResult } from "@tanstack/react-query";
+import type { IssueRetryNowOutcome, IssueRetryNowResponse } from "@paperclipai/shared";
+import { ApiError } from "../api/client";
+import { issuesApi } from "../api/issues";
+import { useToastActions } from "../context/ToastContext";
+import { queryKeys } from "../lib/queryKeys";
+
+export type RetryNowError = {
+ message: string;
+ outcomeMessage: string | null;
+ status: number | null;
+};
+
+function readErrorMessage(error: unknown): string {
+ if (error instanceof ApiError) {
+ if (typeof error.message === "string" && error.message.trim().length > 0) return error.message;
+ return `Request failed (${error.status})`;
+ }
+ if (error instanceof Error && error.message) return error.message;
+ return "The request failed. Try again in a moment.";
+}
+
+export const RETRY_NOW_OUTCOME_HEADLINE: Record<IssueRetryNowOutcome, string> = {
+ promoted: "Retry promoted",
+ already_promoted: "Retry already running",
+ no_scheduled_retry: "No scheduled retry",
+ gate_suppressed: "Couldn't retry now",
+};
+
+export function useRetryNowMutation(
+ issueId: string | null | undefined,
+): UseMutationResult<IssueRetryNowResponse, unknown, void, unknown> & {
+ lastError: RetryNowError | null;
+} {
+ const queryClient = useQueryClient();
+ const { pushToast } = useToastActions();
+
+ const mutation = useMutation({
+ mutationFn: () => {
+ if (!issueId) throw new Error("Missing issue id");
+ return issuesApi.retryScheduledRetryNow(issueId);
+ },
+ onSuccess: (response) => {
+ if (issueId) {
+ queryClient.invalidateQueries({ queryKey: queryKeys.issues.detail(issueId) });
+ queryClient.invalidateQueries({ queryKey: queryKeys.issues.activity(issueId) });
+ queryClient.invalidateQueries({ queryKey: queryKeys.issues.runs(issueId) });
+ queryClient.invalidateQueries({ queryKey: queryKeys.issues.liveRuns(issueId) });
+ queryClient.invalidateQueries({ queryKey: queryKeys.issues.activeRun(issueId) });
+ }
+ if (response.outcome === "promoted") {
+ pushToast({
+ title: RETRY_NOW_OUTCOME_HEADLINE.promoted,
+ body: response.message,
+ tone: "success",
+ });
+ } else if (response.outcome === "gate_suppressed") {
+ pushToast({
+ title: RETRY_NOW_OUTCOME_HEADLINE.gate_suppressed,
+ body: response.message,
+ tone: "error",
+ });
+ }
+ },
+ onError: (error) => {
+ pushToast({
+ title: "Couldn't retry now",
+ body: readErrorMessage(error),
+ tone: "error",
+ });
+ },
+ });
+
+ const reset = mutation.reset;
+ const wrappedReset = useCallback(() => reset(), [reset]);
+
+ const lastError: RetryNowError | null = (() => {
+ if (mutation.error) {
+ const apiError = mutation.error instanceof ApiError ? mutation.error : null;
+ return {
+ message: readErrorMessage(mutation.error),
+ outcomeMessage: null,
+ status: apiError?.status ?? null,
+ };
+ }
+ if (mutation.data && mutation.data.outcome === "gate_suppressed") {
+ return {
+ message: mutation.data.message,
+ outcomeMessage: mutation.data.message,
+ status: null,
+ };
+ }
+ return null;
+ })();
+
+ return {
+ ...mutation,
+ reset: wrappedReset,
+ lastError,
+ } as UseMutationResult<IssueRetryNowResponse, unknown, void, unknown> & {
+ lastError: RetryNowError | null;
+ };
+}
diff --git a/ui/src/pages/IssueDetail.tsx b/ui/src/pages/IssueDetail.tsx
index 3ae3202e6a..6d356161cc 100644
--- a/ui/src/pages/IssueDetail.tsx
+++ b/ui/src/pages/IssueDetail.tsx
@@ -71,6 +71,7 @@ import { AgentIcon } from "../components/AgentIconPicker";
import { IssueReferenceActivitySummary } from "../components/IssueReferenceActivitySummary";
import { IssueRelatedWorkPanel } from "../components/IssueRelatedWorkPanel";
import { IssueMonitorActivityCard } from "../components/IssueMonitorActivityCard";
+import { IssueScheduledRetryCard } from "../components/IssueScheduledRetryCard";
import { IssueProperties } from "../components/IssueProperties";
import { IssueRunLedger } from "../components/IssueRunLedger";
import { IssueWorkspaceCard } from "../components/IssueWorkspaceCard";
@@ -1159,6 +1160,7 @@ function IssueDetailActivityTab({
</div>
)}
<IssueContinuationHandoff document={continuationHandoff} focusSignal={handoffFocusSignal} />
+ <IssueScheduledRetryCard issueId={issue.id} scheduledRetry={issue.scheduledRetry ?? null} />
<IssueMonitorActivityCard
issue={issue}
onCheckNow={onCheckMonitorNow}
diff --git a/ui/storybook/stories/scheduled-retry.stories.tsx b/ui/storybook/stories/scheduled-retry.stories.tsx
new file mode 100644
index 0000000000..a18e72c06d
--- /dev/null
+++ b/ui/storybook/stories/scheduled-retry.stories.tsx
@@ -0,0 +1,163 @@
+import type { Meta, StoryObj } from "@storybook/react-vite";
+import type { Issue, IssueScheduledRetry } from "@paperclipai/shared";
+import { IssueScheduledRetryCard } from "@/components/IssueScheduledRetryCard";
+import { IssueProperties } from "@/components/IssueProperties";
+import {
+ storybookExecutionWorkspaces,
+ storybookIssueDocuments,
+ storybookIssues,
+} from "../fixtures/paperclipData";
+
+const issueDocumentSummaries = storybookIssueDocuments.map(({ body: _body, ...summary }) => summary);
+
+const baseIssue: Issue = {
+ ...storybookIssues[0]!,
+ planDocument: storybookIssueDocuments.find((document) => document.key === "plan") ?? null,
+ documentSummaries: issueDocumentSummaries,
+ currentExecutionWorkspace: storybookExecutionWorkspaces[0]!,
+};
+
+const inFifteenMinutes = () => new Date(Date.now() + 15 * 60_000).toISOString();
+const justNow = () => new Date(Date.now() + 5_000).toISOString();
+const inTwoDays = () => new Date(Date.now() + 2 * 24 * 60 * 60_000).toISOString();
+
+const transientRetry: IssueScheduledRetry = {
+ runId: "run-aaaaaaaa-1111-1111-1111-111111111111",
+ status: "scheduled_retry",
+ agentId: baseIssue.assigneeAgentId ?? "agent-1",
+ agentName: "ClaudeCoder",
+ retryOfRunId: "run-prev-2222-2222-2222-222222222222",
+ scheduledRetryAt: inFifteenMinutes(),
+ scheduledRetryAttempt: 4,
+ scheduledRetryReason: "transient_failure",
+ retryExhaustedReason: null,
+ error: "Upstream provider returned 502",
+ errorCode: "upstream_502",
+};
+
+const continuationRetry: IssueScheduledRetry = {
+ ...transientRetry,
+ runId: "run-bbbbbbbb-3333-3333-3333-333333333333",
+ retryOfRunId: "run-prev-4444-4444-4444-444444444444",
+ scheduledRetryAt: inTwoDays(),
+ scheduledRetryAttempt: 1,
+ scheduledRetryReason: "max_turns_continuation",
+ error: null,
+};
+
+const dueNowRetry: IssueScheduledRetry = {
+ ...transientRetry,
+ runId: "run-cccccccc-5555-5555-5555-555555555555",
+ scheduledRetryAt: justNow(),
+};
+
+const issueWithRetry = (retry: IssueScheduledRetry): Issue => ({
+ ...baseIssue,
+ scheduledRetry: retry,
+});
+
+function ScheduledRetrySurfaceStories() {
+ return (
+ <div className="space-y-8 p-6">
+ <section className="space-y-2">
+ <div className="text-xs uppercase tracking-wide text-muted-foreground">
+ IssueScheduledRetryCard - transient failure, in 15m
+ </div>
+ <IssueScheduledRetryCard issueId={baseIssue.id} scheduledRetry={transientRetry} />
+ </section>
+
+ <section className="space-y-2">
+ <div className="text-xs uppercase tracking-wide text-muted-foreground">
+ IssueScheduledRetryCard - max-turn continuation, in 2d
+ </div>
+ <IssueScheduledRetryCard issueId={baseIssue.id} scheduledRetry={continuationRetry} />
+ </section>
+
+ <section className="space-y-2">
+ <div className="text-xs uppercase tracking-wide text-muted-foreground">
+ IssueScheduledRetryCard - due now (overdue)
+ </div>
+ <IssueScheduledRetryCard issueId={baseIssue.id} scheduledRetry={dueNowRetry} />
+ </section>
+
+ <section className="space-y-2">
+ <div className="text-xs uppercase tracking-wide text-muted-foreground">
+ IssueScheduledRetryCard - returns null with no live scheduled retry
+ </div>
+ <div className="rounded-lg border border-dashed border-border px-3 py-2 text-xs text-muted-foreground">
+ (intentionally renders nothing for issues without a live scheduled retry)
+ </div>
+ <IssueScheduledRetryCard issueId={baseIssue.id} scheduledRetry={null} />
+ </section>
+
+ <div className="grid gap-6 lg:grid-cols-2">
+ <section className="space-y-2">
+ <div className="text-xs uppercase tracking-wide text-muted-foreground">
+ IssueProperties Scheduled retry row - hidden when no live retry
+ </div>
+ <div className="rounded-lg border border-border bg-background/70 p-4">
+ <IssueProperties issue={baseIssue} onUpdate={() => undefined} inline />
+ </div>
+ </section>
+
+ <section className="space-y-2">
+ <div className="text-xs uppercase tracking-wide text-muted-foreground">
+ IssueProperties Scheduled retry row - transient failure, in 15m
+ </div>
+ <div className="rounded-lg border border-border bg-background/70 p-4">
+ <IssueProperties
+ issue={issueWithRetry(transientRetry)}
+ onUpdate={() => undefined}
+ inline
+ />
+ </div>
+ </section>
+
+ <section className="space-y-2">
+ <div className="text-xs uppercase tracking-wide text-muted-foreground">
+ IssueProperties Scheduled retry row - continuation, in 2d
+ </div>
+ <div className="rounded-lg border border-border bg-background/70 p-4">
+ <IssueProperties
+ issue={issueWithRetry(continuationRetry)}
+ onUpdate={() => undefined}
+ inline
+ />
+ </div>
+ </section>
+
+ <section className="space-y-2">
+ <div className="text-xs uppercase tracking-wide text-muted-foreground">
+ IssueProperties Scheduled retry row - due now
+ </div>
+ <div className="rounded-lg border border-border bg-background/70 p-4">
+ <IssueProperties
+ issue={issueWithRetry(dueNowRetry)}
+ onUpdate={() => undefined}
+ inline
+ />
+ </div>
+ </section>
+ </div>
+ </div>
+ );
+}
+
+const meta = {
+ title: "Product/Issue Scheduled retry surfaces",
+ component: ScheduledRetrySurfaceStories,
+ parameters: {
+ docs: {
+ description: {
+ component:
+ "Surfaces the IssueScheduledRetryCard and IssueProperties Scheduled retry row in transient/continuation/due-now variants for UX review. The card mounts above IssueMonitorActivityCard and the property row sits sibling-to (and above) Monitor.",
+ },
+ },
+ },
+} satisfies Meta<typeof ScheduledRetrySurfaceStories>;
+
+export default meta;
+
+type Story = StoryObj<typeof meta>;
+
+export const ScheduledRetrySurfaces: Story = {};