The open-source app everyone uses to manage agents at work
TypeScript acpxagent-orchestrationagent-skillsagentic-aiai-agentsai-engineeringai-governanceai-toolsautonomous-agentsclaudeclaude-codeclaude-skillscodexhermesllmmcpmulti-agentopenclawproject-managementworkflow-automation
fix(server): bound accepted-interaction continuation recovery (#9656)
Dotta4f9894df4459
diff --git a/doc/execution-semantics.md b/doc/execution-semantics.mdindex ecabd67698..e2ee66faf2 100644--- a/doc/execution-semantics.md+++ b/doc/execution-semantics.md@@ -516,6 +516,8 @@ Recovery rule for a parked-for-review continuation:- if the issue has a real waiting target — open (non-terminal) sub-tasks or existing unresolved blockers — Paperclip converts the deliberate wait into a first-class dependency wait: it sets the issue `blocked` by those issues, keeps the original assignee, and posts a plain-language comment explaining that the task will resume automatically when its dependencies finish. The issue then self-resumes through the normal `issue_blockers_resolved` path; no recovery action or escalation owner is involved- if the issue has no waiting target, the park is indistinguishable from a genuine strand and falls through to the standard §9.2 escalation, preserving stranded detection+An accepted interaction supersedes a continuation park recorded before that acceptance. A queued continuation carrying a parseable `interactionResolvedAt` must not be cancelled solely because an older continuation summary says to wait for review or approval. Interaction-continuation recovery is bounded: after three consecutive continuation wakes are cancelled without a run starting, recovery converts a real dependency wait when one exists or escalates the missing execution path visibly instead of requeueing forever.+This keeps the post-decomposition umbrella (§7) on a real waiting path instead of relying on `parentId` rollup, which §6 does not treat as a dependency.### 9.3 Recovery model-profile lanediff --git a/server/src/__tests__/heartbeat-process-recovery.test.ts b/server/src/__tests__/heartbeat-process-recovery.test.tsindex 015a9c1196..2464f82fbb 100644--- a/server/src/__tests__/heartbeat-process-recovery.test.ts+++ b/server/src/__tests__/heartbeat-process-recovery.test.ts@@ -1,6 +1,6 @@import { randomUUID } from "node:crypto";import { spawn, type ChildProcess } from "node:child_process";-import { and, eq, or, inArray } from "drizzle-orm";+import { and, eq, or, inArray, sql } from "drizzle-orm";import { afterAll, afterEach, beforeAll, describe, expect, it, vi } from "vitest";import {activityLog,@@ -4097,6 +4097,197 @@ describeEmbeddedPostgres("heartbeat orphaned process recovery", () => {});});+ it("escalates accepted interaction continuation recovery after three review-park cancellations", async () => {+ const companyId = randomUUID();+ const agentId = randomUUID();+ const issueId = randomUUID();+ const interactionId = randomUUID();+ const resolvedAt = new Date("2026-03-19T00:05:00.000Z");+ const issuePrefix = `T${companyId.replace(/-/g, "").slice(0, 6).toUpperCase()}`;++ await db.insert(companies).values({+ id: companyId,+ name: "Paperclip",+ issuePrefix,+ defaultResponsibleUserId: "responsible-user",+ requireBoardApprovalForNewAgents: false,+ });+ await db.insert(agents).values({+ id: agentId,+ companyId,+ name: "CodexCoder",+ role: "engineer",+ status: "idle",+ adapterType: "codex_local",+ adapterConfig: {},+ runtimeConfig: { heartbeat: { wakeOnDemand: true, maxConcurrentRuns: 1 } },+ permissions: {},+ });+ await db.insert(issues).values({+ id: issueId,+ companyId,+ title: "Accepted plan cancellation loop",+ status: "in_review",+ priority: "medium",+ assigneeAgentId: agentId,+ responsibleUserId: "responsible-user",+ issueNumber: 1,+ identifier: `${issuePrefix}-1`,+ });+ await db.insert(issueThreadInteractions).values({+ id: interactionId,+ companyId,+ issueId,+ kind: "request_confirmation",+ status: "accepted",+ continuationPolicy: "wake_assignee_on_accept",+ createdByAgentId: agentId,+ resolvedByUserId: "responsible-user",+ resolvedAt,+ updatedAt: resolvedAt,+ payload: { version: 1, prompt: "Approve the plan?" },+ result: { outcome: "accepted" },+ });+ for (let attempt = 1; attempt <= 3; attempt += 1) {+ const finishedAt = new Date(resolvedAt.getTime() + attempt * 60_000);+ await db.insert(heartbeatRuns).values({+ id: randomUUID(),+ companyId,+ agentId,+ invocationSource: "automation",+ triggerDetail: "system",+ status: "cancelled",+ errorCode: "issue_continuation_waiting_on_review",+ error: "Continuation summary still says to wait for review",+ contextSnapshot: {+ issueId,+ taskId: issueId,+ wakeReason: "issue_continuation_needed",+ retryReason: "issue_continuation_needed",+ mutation: "interaction",+ interactionId,+ interactionResolvedAt: resolvedAt.toISOString(),+ },+ createdAt: finishedAt,+ startedAt: finishedAt,+ finishedAt,+ updatedAt: finishedAt,+ });+ }++ const heartbeat = heartbeatService(db);+ const result = await heartbeat.reconcileStrandedAssignedIssues();++ expect(result.continuationRequeued).toBe(0);+ expect(result.waitingOnReviewResolved).toBe(0);+ expect(result.escalated).toBe(1);+ expect(result.issueIds).toContain(issueId);++ const [issue, continuationRuns, comments] = await Promise.all([+ db.select().from(issues).where(eq(issues.id, issueId)).then((rows) => rows[0] ?? null),+ db+ .select({ id: heartbeatRuns.id })+ .from(heartbeatRuns)+ .where(and(+ eq(heartbeatRuns.companyId, companyId),+ eq(heartbeatRuns.agentId, agentId),+ sql`${heartbeatRuns.contextSnapshot} ->> 'issueId' = ${issueId}`,+ sql`${heartbeatRuns.contextSnapshot} ->> 'retryReason' = 'issue_continuation_needed'`,+ )),+ db.select({ body: issueComments.body }).from(issueComments).where(eq(issueComments.issueId, issueId)),+ ]);+ expect(issue?.status).toBe("blocked");+ expect(continuationRuns).toHaveLength(3);+ expect(comments.some((comment) => comment.body.includes(interactionId))).toBe(true);+ });++ it("skips accepted interaction recovery after its continuation succeeds", async () => {+ const companyId = randomUUID();+ const agentId = randomUUID();+ const issueId = randomUUID();+ const interactionId = randomUUID();+ const resolvedAt = new Date("2026-03-19T00:05:00.000Z");+ const succeededAt = new Date("2026-03-19T00:06:00.000Z");+ const issuePrefix = `T${companyId.replace(/-/g, "").slice(0, 6).toUpperCase()}`;++ await db.insert(companies).values({+ id: companyId,+ name: "Paperclip",+ issuePrefix,+ defaultResponsibleUserId: "responsible-user",+ requireBoardApprovalForNewAgents: false,+ });+ await db.insert(agents).values({+ id: agentId,+ companyId,+ name: "CodexCoder",+ role: "engineer",+ status: "idle",+ adapterType: "codex_local",+ adapterConfig: {},+ runtimeConfig: { heartbeat: { wakeOnDemand: true, maxConcurrentRuns: 1 } },+ permissions: {},+ });+ await db.insert(issues).values({+ id: issueId,+ companyId,+ title: "Accepted plan already resumed",+ status: "in_review",+ priority: "medium",+ assigneeAgentId: agentId,+ responsibleUserId: "responsible-user",+ issueNumber: 1,+ identifier: `${issuePrefix}-1`,+ });+ await db.insert(issueThreadInteractions).values({+ id: interactionId,+ companyId,+ issueId,+ kind: "request_confirmation",+ status: "accepted",+ continuationPolicy: "wake_assignee_on_accept",+ createdByAgentId: agentId,+ resolvedByUserId: "responsible-user",+ resolvedAt,+ updatedAt: resolvedAt,+ payload: { version: 1, prompt: "Approve the plan?" },+ result: { outcome: "accepted" },+ });+ await db.insert(heartbeatRuns).values({+ id: randomUUID(),+ companyId,+ agentId,+ invocationSource: "automation",+ triggerDetail: "system",+ status: "succeeded",+ contextSnapshot: {+ issueId,+ taskId: issueId,+ wakeReason: "issue_continuation_needed",+ retryReason: "issue_continuation_needed",+ mutation: "interaction",+ interactionId,+ interactionResolvedAt: resolvedAt.toISOString(),+ },+ createdAt: succeededAt,+ startedAt: succeededAt,+ finishedAt: succeededAt,+ updatedAt: succeededAt,+ });++ const heartbeat = heartbeatService(db);+ const result = await heartbeat.reconcileStrandedAssignedIssues();++ expect(result.continuationRequeued).toBe(0);+ expect(result.escalated).toBe(0);+ expect(result.skipped).toBeGreaterThanOrEqual(1);+ const runs = await db+ .select({ id: heartbeatRuns.id })+ .from(heartbeatRuns)+ .where(eq(heartbeatRuns.agentId, agentId));+ expect(runs).toHaveLength(1);+ });+it("requeues accepted interaction continuations even when a later successful run is unrelated", async () => {const companyId = randomUUID();const agentId = randomUUID();diff --git a/server/src/__tests__/heartbeat-stale-queue-invalidation.test.ts b/server/src/__tests__/heartbeat-stale-queue-invalidation.test.tsindex 32611ab4fa..35f33c9f46 100644--- a/server/src/__tests__/heartbeat-stale-queue-invalidation.test.ts+++ b/server/src/__tests__/heartbeat-stale-queue-invalidation.test.ts@@ -1543,4 +1543,63 @@ describeEmbeddedPostgres("heartbeat stale queued-run invalidation", () => {expect(wakeup?.error).toContain("continuation summary says the executor should wait");expect(countExecuteCallsForRun(runId)).toBe(0);});++ it("runs accepted-interaction continuation recovery despite a pre-acceptance review park", async () => {+ const { companyId, agentId } = await seedCompanyAndAgent();+ const issueId = randomUUID();+ await db.insert(issues).values({+ id: issueId,+ companyId,+ title: "Approved implementation resumes",+ status: "in_progress",+ priority: "medium",+ assigneeAgentId: agentId,+ });+ await seedContinuationSummary({+ companyId,+ issueId,+ agentId,+ body: [+ "# Continuation Summary",+ "",+ "## Next Action",+ "",+ "- Wait for reviewer feedback or approval before continuing executor work.",+ ].join("\n"),+ });++ const { runId } = await seedQueuedRun({+ companyId,+ agentId,+ issueId,+ wakeReason: "issue_continuation_needed",+ invocationSource: "automation",+ contextExtras: {+ retryReason: "issue_continuation_needed",+ mutation: "interaction",+ interactionId: randomUUID(),+ interactionResolvedAt: "2026-03-19T00:05:00.000Z",+ },+ });++ await heartbeat.resumeQueuedRuns();++ await waitForCondition(async () => {+ const run = await db+ .select({ status: heartbeatRuns.status })+ .from(heartbeatRuns)+ .where(eq(heartbeatRuns.id, runId))+ .then((rows) => rows[0] ?? null);+ return run?.status === "succeeded";+ });++ const run = await db+ .select({ status: heartbeatRuns.status, errorCode: heartbeatRuns.errorCode })+ .from(heartbeatRuns)+ .where(eq(heartbeatRuns.id, runId))+ .then((rows) => rows[0] ?? null);+ expect(run?.status).toBe("succeeded");+ expect(run?.errorCode).toBeNull();+ expect(countExecuteCallsForRun(runId)).toBe(1);+ });});diff --git a/server/src/services/heartbeat.ts b/server/src/services/heartbeat.tsindex 58941ca95f..a487f8a914 100644--- a/server/src/services/heartbeat.ts+++ b/server/src/services/heartbeat.ts@@ -10505,10 +10505,13 @@ export function heartbeatService(db: Db, options: HeartbeatServiceOptions = {})const resumeIntent = context.resumeIntent === true || context.followUpRequested === true;const wakeReason = readNonEmptyString(context.wakeReason);const retryReason = readNonEmptyString(context.retryReason) ?? run.scheduledRetryReason ?? null;+ const interactionResolvedAt = readNonEmptyString(context.interactionResolvedAt);+ const hasResolvedInteractionEvidence = interactionResolvedAt !== null && !Number.isNaN(Date.parse(interactionResolvedAt));if (issue.status === "in_progress" &&!wakeCommentId &&+ !hasResolvedInteractionEvidence &&(wakeReason === "issue_continuation_needed" || retryReason === "issue_continuation_needed")) {const queuedWake = parseObject(context.paperclipWake);diff --git a/server/src/services/recovery/service.ts b/server/src/services/recovery/service.tsindex 90b24a6a2f..b6a335ccc2 100644--- a/server/src/services/recovery/service.ts+++ b/server/src/services/recovery/service.ts@@ -289,6 +289,7 @@ const NON_RETRYABLE_CONTINUATION_ERROR_CODES = new Set<string>([// issue has a real waiting target we convert it into a normal dependency wait rather// than escalating it as stranded.const CONTINUATION_WAITING_ON_REVIEW_ERROR_CODE = "issue_continuation_waiting_on_review";+const INTERACTION_CONTINUATION_REQUEUE_MAX_ATTEMPTS = 3;const CONTINUATION_RECOVERY_TRANSIENT_MAX_ATTEMPTS = 3;const CONTINUATION_RECOVERY_DEFAULT_MAX_ATTEMPTS = 1;@@ -635,7 +636,9 @@ export function recoveryService(db: Db, deps: { enqueueWakeup: RecoveryWakeup })async function summarizeRecentContinuationRetries(companyId: string,issueId: string,+ agentId: string,errorCodeToMatch: string | null,+ since: Date | null = null,) {const rows = await db.select({@@ -649,7 +652,9 @@ export function recoveryService(db: Db, deps: { enqueueWakeup: RecoveryWakeup }).where(and(eq(heartbeatRuns.companyId, companyId),+ eq(heartbeatRuns.agentId, agentId),sql`${heartbeatRuns.contextSnapshot} ->> 'issueId' = ${issueId}`,+ ...(since ? [or(gte(heartbeatRuns.createdAt, since), gte(heartbeatRuns.finishedAt, since))] : []),),).orderBy(desc(heartbeatRuns.createdAt), desc(heartbeatRuns.id))@@ -3336,6 +3341,39 @@ export function recoveryService(db: Db, deps: { enqueueWakeup: RecoveryWakeup })agentId,acceptedInteractionResolvedAt,);+ const { consecutive } = await summarizeRecentContinuationRetries(+ issue.companyId,+ issue.id,+ agentId,+ CONTINUATION_WAITING_ON_REVIEW_ERROR_CODE,+ acceptedInteractionResolvedAt,+ );+ if (consecutive >= INTERACTION_CONTINUATION_REQUEUE_MAX_ATTEMPTS && latestPostResolutionRun) {+ const resolved = await resolveContinuationWaitingOnReview(issue);+ if (resolved) {+ result.waitingOnReviewResolved += 1;+ result.issueIds.push(issue.id);+ continue;+ }++ const updated = await escalateStrandedAssignedIssue({+ issue,+ previousStatus: issue.status as StrandedPreviousStatus,+ latestRun: latestPostResolutionRun,+ comment:+ `Paperclip stopped requeueing accepted interaction \`${acceptedContinuationInteraction.id}\` after ` ++ `${consecutive} consecutive continuation wakes were cancelled while waiting on review. ` ++ "Moving the issue to `blocked` so the missing execution path is visible for intervention.",+ });+ if (updated) {+ result.escalated += 1;+ result.issueIds.push(issue.id);+ } else {+ result.skipped += 1;+ }+ continue;+ }+const queued = await enqueueStrandedIssueRecovery({issueId: issue.id,agentId,@@ -3656,6 +3694,7 @@ export function recoveryService(db: Db, deps: { enqueueWakeup: RecoveryWakeup })const { consecutive, latestFinishedAt } = await summarizeRecentContinuationRetries(issue.companyId,issue.id,+ agentId,classification.errorCode,);if (consecutive >= classification.maxAttempts) {