diff --git a/server/src/__tests__/activity-service.test.ts b/server/src/__tests__/activity-service.test.ts index 35f58a138c2..2ac88be6d82 100644 --- a/server/src/__tests__/activity-service.test.ts +++ b/server/src/__tests__/activity-service.test.ts @@ -129,6 +129,59 @@ describeEmbeddedPostgres("activity service", () => { await db.delete(authUsers).where(eq(authUsers.id, userId)); }); + // Recorded in chat-eval cohort 13 (runs-adapters.inspect-failed-run): the + // agent told the person "Paperclip retried automatically" about a run the + // board started with Retry, because the run read gave only raw invocation + // fields (on_demand, manual) and an owner id. + it("says who started each retry run: a named person's Retry or automatic recovery", async () => { + const companyId = randomUUID(), agentId = randomUUID(), issueId = randomUUID(), userId = `member-${companyId}`; + const failedRunId = randomUUID(), boardRetryId = randomUUID(), memberRetryId = randomUUID(), autoRetryId = randomUUID(), unknownRetryId = randomUUID(); + await db.insert(companies).values({ id: companyId, name: "Retries", issuePrefix: `R${companyId.slice(0, 6)}` }); + await db.insert(agents).values({ id: agentId, companyId, name: "Morgan", adapterType: "process" }); + await db.insert(authUsers).values({ id: userId, name: "Sam Rivera", email: `${userId}@example.test`, createdAt: new Date(), updatedAt: new Date() }); + await db.insert(issues).values({ id: issueId, companyId, title: "Website", assigneeAgentId: agentId }); + const wake = async (reason: string, requestedByActorType: string | null, requestedByActorId: string | null, source = "on_demand") => { + const [row] = await db.insert(agentWakeupRequests).values({ companyId, agentId, source, triggerDetail: source === "automation" ? "system" : "manual", + reason, requestedByActorType, requestedByActorId, status: "completed", payload: { issueId } }).returning(); + return row!.id; + }; + const base = { companyId, agentId, issueId, scopeKind: "issue", contextSnapshot: { issueId } } as const; + const memberTaskRetryId = await wake("task_retry", "user", userId), inheritedRetryId = randomUUID(); + const at = (seconds: number) => new Date(Date.UTC(2026, 10, 13, 18, 0, seconds)); + await db.insert(heartbeatRuns).values([ + { ...base, id: failedRunId, status: "failed", errorCode: "native_provider_model_rejected", invocationSource: "assignment", createdAt: at(0) }, + { ...base, id: boardRetryId, status: "succeeded", invocationSource: "on_demand", triggerDetail: "manual", responsibleUserId: "local-board", + retryOfRunId: failedRunId, wakeupRequestId: await wake("retry_failed_run", "user", "local-board"), createdAt: at(1) }, + // Task Retry, as the queue saves it: the person's request is linked from + // the run context with the source run as previousRunId, and retryOfRunId stays empty. + { ...base, id: memberRetryId, status: "succeeded", invocationSource: "on_demand", triggerDetail: "manual", + wakeupRequestId: await wake("issue_assigned", "user", userId), + contextSnapshot: { issueId, previousRunId: failedRunId, forceFreshSession: true, taskRetryRequestId: memberTaskRetryId }, createdAt: at(2) }, + // Automatic recovery keeps the original responsible user; that is not who started it. + { ...base, id: autoRetryId, status: "succeeded", invocationSource: "automation", triggerDetail: "system", responsibleUserId: "local-board", + retryOfRunId: failedRunId, wakeupRequestId: await wake("transient_failure_retry", null, null, "automation"), createdAt: at(3) }, + // Automatic recovery after that Task Retry inherits the person's request in its context. + { ...base, id: inheritedRetryId, status: "succeeded", invocationSource: "automation", triggerDetail: "system", retryOfRunId: memberRetryId, + wakeupRequestId: await wake("transient_failure_retry", null, null, "automation"), + contextSnapshot: { issueId, previousRunId: failedRunId, taskRetryRequestId: memberTaskRetryId }, createdAt: at(5) }, + { ...base, id: unknownRetryId, status: "succeeded", invocationSource: "on_demand", triggerDetail: "manual", retryOfRunId: failedRunId, createdAt: at(4) }, + ]); + + const rows = await activityService(db).runsForIssue(companyId, issueId); + const byId = new Map(rows.map(row => [row.runId, row.retriedBy])); + expect(byId.get(failedRunId)).toBeNull(); + expect(byId.get(boardRetryId)).toEqual({ kind: "person", personName: "Board", + summary: "Board pressed Retry on the failed run. Paperclip did not retry it automatically." }); + expect(byId.get(memberRetryId)).toEqual({ kind: "person", personName: "Sam Rivera", + summary: "Sam Rivera pressed Retry on the failed run. Paperclip did not retry it automatically." }); + expect(byId.get(autoRetryId)).toEqual({ kind: "automatic", + summary: "Paperclip retried the failed run automatically; no person pressed Retry." }); + expect(byId.get(inheritedRetryId)).toMatchObject({ kind: "automatic" }); + expect(byId.get(unknownRetryId)).toBeNull(); + expect(JSON.stringify([...byId.values()])).not.toMatch(/local-board|member-/); + await db.delete(authUsers).where(eq(authUsers.id, userId)); + }); + it("limits company activity lists", async () => { const companyId = randomUUID(); diff --git a/server/src/routes/openapi.ts b/server/src/routes/openapi.ts index 754c7ab8649..3803834b536 100644 --- a/server/src/routes/openapi.ts +++ b/server/src/routes/openapi.ts @@ -6487,6 +6487,7 @@ registry.registerPath({ path: "/api/issues/{id}/runs", tags: ["activity"], summary: "List runs for an issue", + description: "A retry run's retriedBy says in plain words who started it: a person who pressed Retry (named), or Paperclip's automatic recovery. It is null for a run that is not a retry. Use it rather than inferring the starter from invocationSource or triggerDetail.", request: { params: z.object({ id: z.string() }), query: z.object({ view: z.literal("recent").optional().describe("At most two recent run summaries."), runIds: z.string().optional().describe("Comma-separated list of 1 to 100 run UUIDs. Returns only those runs linked to this accessible issue.") }) }, responses: { 200: r.ok(), 400: r.badRequest, 401: r.unauthorized, 403: r.forbidden, 404: r.notFound }, }); diff --git a/server/src/services/activity.ts b/server/src/services/activity.ts index 69922166e5d..c44b130dd26 100644 --- a/server/src/services/activity.ts +++ b/server/src/services/activity.ts @@ -6,6 +6,7 @@ import { and, asc, desc, eq, inArray, isNull, or, sql, type SQL } from "drizzle- import type { Db } from "@paperclipai/db"; import { activityLog, + agentWakeupRequests, agents, authUsers, documentRevisions, @@ -61,6 +62,37 @@ export function activityActorFallbackName(actorType: string, actorId: string) { return "Paperclip"; } +/** Wake reasons recorded when a person presses Retry on a failed run or task. */ +const PERSON_RETRY_WAKE_REASONS = new Set(["retry_failed_run", "task_retry"]); + +export type RunRetriedBy = { kind: "person"; personName: string; summary: string } | { kind: "automatic"; summary: string }; + +/** + * Who started a retry run, in plain words. A run's own invocation fields do + * not say this: a person's Retry is an on-demand run whose responsible user + * may also own automatic retries. The run's wake request records whether a + * person pressed Retry; automatic recovery creates an automation run. Returns + * null for a run that is not a retry or whose starter is not recorded, rather + * than guessing. + */ +export function describeRunRetry( + run: { retryOfRunId: string | null; taskRetryRequestId?: string | null; invocationSource: string | null }, + wake: { reason: string | null; requestedByActorType: string | null } | null, + personName: string | null, +): RunRetriedBy | null { + if (!run.retryOfRunId && !run.taskRetryRequestId) return null; + // The run's own start decides first: automatic recovery after a person's + // Task Retry inherits that Retry's request, but the person did not start it. + if (run.invocationSource === "automation") { + return { kind: "automatic", summary: "Paperclip retried the failed run automatically; no person pressed Retry." }; + } + if (wake?.requestedByActorType === "user" && wake.reason && PERSON_RETRY_WAKE_REASONS.has(wake.reason)) { + const name = personName?.trim() || "A board member"; + return { kind: "person", personName: name, summary: `${name} pressed Retry on the failed run. Paperclip did not retry it automatically.` }; + } + return null; +} + export function activityService(db: Db) { const scheduledLivenessBackfills = new Set(); // Issues whose last backfill pass left no missing liveness, keyed like @@ -521,6 +553,8 @@ export function activityService(db: Db) { wakeCommentId: sql`${heartbeatRuns.contextSnapshot} ->> 'wakeCommentId'`, contextCommentId: sql`${heartbeatRuns.contextSnapshot} ->> 'commentId'`, contextIssueId: sql`${heartbeatRuns.contextSnapshot} ->> 'issueId'`, + // A person's Task Retry links its saved request here instead of retryOfRunId. + taskRetryRequestId: sql`${heartbeatRuns.contextSnapshot} ->> 'taskRetryRequestId'`, }) .from(heartbeatRuns) .innerJoin( @@ -554,9 +588,9 @@ export function activityService(db: Db) { .orderBy(desc(heartbeatRuns.createdAt), desc(heartbeatRuns.id)); const runs = await (limit === undefined ? runsQuery : runsQuery.limit(limit)); - if (runs.length === 0) return runs; + if (runs.length === 0) return []; const runIds = runs.map((run) => run.runId); - if (runIds.length === 0) return runs; + if (runIds.length === 0) return []; const exhaustionRowsQuery = db .select({ @@ -602,12 +636,39 @@ export function activityService(db: Db) { .where(and(eq(issueDocuments.companyId, companyId), eq(issueDocuments.issueId, issueId), eq(issueDocuments.key, "plan"))) .limit(1) : Promise.resolve([]); - const [exhaustionRows, leaseRows, executionByRunId, [savedPlan]] = await Promise.all([ + const retryWakeId = (run: (typeof runs)[number]) => run.taskRetryRequestId && UUID_PATTERN.test(run.taskRetryRequestId) + ? run.taskRetryRequestId : run.retryOfRunId ? run.wakeupRequestId : null; + const retryWakeIds = [...new Set(runs.flatMap(run => { const id = retryWakeId(run); return id ? [id] : []; }))]; + const retryWakesQuery = retryWakeIds.length + ? db.select({ + id: agentWakeupRequests.id, + reason: agentWakeupRequests.reason, + requestedByActorType: agentWakeupRequests.requestedByActorType, + requestedByActorId: agentWakeupRequests.requestedByActorId, + }).from(agentWakeupRequests) + .where(and(eq(agentWakeupRequests.companyId, companyId), inArray(agentWakeupRequests.id, retryWakeIds))) + : Promise.resolve([]); + const [exhaustionRows, leaseRows, executionByRunId, [savedPlan], retryWakes] = await Promise.all([ exhaustionRowsQuery, leaseRowsQuery, executionProjectionsForRuns(db, companyId, runIds, new Date(), { retryDatabaseReads: true }), savedPlanQuery, + retryWakesQuery, ]); + const retryWakeById = new Map(retryWakes.map(wake => [wake.id, wake])); + const retryPersonIds = [...new Set(retryWakes.flatMap(wake => + wake.requestedByActorType === "user" && wake.requestedByActorId && wake.requestedByActorId !== "local-board" ? [wake.requestedByActorId] : []))]; + const retryPersonNames = new Map((retryPersonIds.length + ? await db.select({ id: authUsers.id, name: authUsers.name }).from(authUsers).where(inArray(authUsers.id, retryPersonIds)) + : []).filter(row => row.name?.trim()).map(row => [row.id, row.name!.trim()])); + const retriedBy = (run: (typeof runs)[number]) => { + const wakeId = retryWakeId(run); + const wake = wakeId ? retryWakeById.get(wakeId) ?? null : null; + const actorId = wake?.requestedByActorId ?? null; + const personName = wake?.requestedByActorType === "user" && actorId + ? retryPersonNames.get(actorId) ?? activityActorFallbackName("user", actorId) : null; + return describeRunRetry(run, wake, personName); + }; const retryExhaustedReasonByRunId = new Map(); for (const row of exhaustionRows) { if (!row.message || retryExhaustedReasonByRunId.has(row.runId)) continue; @@ -666,6 +727,7 @@ export function activityService(db: Db) { } : null, retryExhaustedReason: retryExhaustedReasonByRunId.get(run.runId) ?? null, + retriedBy: retriedBy(run), }; }); }, diff --git a/server/src/services/agent-conversations.ts b/server/src/services/agent-conversations.ts index 104b927a01f..fd4bfe05869 100644 --- a/server/src/services/agent-conversations.ts +++ b/server/src/services/agent-conversations.ts @@ -122,7 +122,7 @@ When the person says an existing task must not start until another task is done For review or follow-up tasks, include the existing source materials the assignee needs, not just task identifiers or a rubric. Read the source task's saved documents and comments, then copy the relevant existing content into the handoff or attach resources the recipient can actually read. A new task's tools may only expose its own documents and history. Supplying existing source material is coordination, not creating the assigned deliverable. -For task links, use the company-prefixed relative path //issues/. The company prefix is the part of a task identifier before its final hyphen and number: for task RUN-1 the prefix is RUN. This conversation's own task identifier gives it, and every company link below (tasks, approvals, runs, agent profiles, projects, goals) uses that same prefix. Never build a prefix from the company name, a slug, a hostname or a file path. Write every company link as a Markdown link, such as [Review the approval](//approvals/): a bare path or a path in inline code is not clickable in this conversation. Start each link target with exactly one slash: a target beginning with //, such as ///issues/, points to a different website. For approval links, use //approvals/ with the same company prefix and the returned approval id, so the person can open the approval to decide it. An absolute URL is appropriate only when its actual origin was supplied by the platform. Never invent a hostname for a Paperclip link. For an execution run, link //agents//runs/ using the run's returned agentId. Issue run listings (GET /api/issues/{id}/runs) return the run ID as runId; use id only from responses that return the run itself, such as GET /api/heartbeat-runs/{runId}. Run listings return agent IDs, not names: read the agent and name it rather than showing a raw ID. For a project, link //projects/. For a goal, link //goals/. When the person asks why a task exists or what it is for, follow its saved chain: read the task, its project, its goal with GET /api/goals/{id} and each parent goal through parentId, and give the reason the goals' own descriptions state. Link the task, its project and every goal in the chain. When the task has no goal, say so instead of supplying a reason. When a tool result gives a record's href, such as a project or a workspace, link that href; a workspace without an href has no page on this instance, so name it instead of linking it. +For task links, use the company-prefixed relative path //issues/. The company prefix is the part of a task identifier before its final hyphen and number: for task RUN-1 the prefix is RUN. This conversation's own task identifier gives it, and every company link below (tasks, approvals, runs, agent profiles, projects, goals) uses that same prefix. Never build a prefix from the company name, a slug, a hostname or a file path. Write every company link as a Markdown link, such as [Review the approval](//approvals/): a bare path or a path in inline code is not clickable in this conversation. Start each link target with exactly one slash: a target beginning with //, such as ///issues/, points to a different website. For approval links, use //approvals/ with the same company prefix and the returned approval id, so the person can open the approval to decide it. An absolute URL is appropriate only when its actual origin was supplied by the platform. Never invent a hostname for a Paperclip link. For an execution run, link //agents//runs/ using the run's returned agentId. Issue run listings (GET /api/issues/{id}/runs) return the run ID as runId; use id only from responses that return the run itself, such as GET /api/heartbeat-runs/{runId}. A retry run's retriedBy says who started it: a named person who pressed Retry, or Paperclip's automatic recovery. Say that, and do not call a retry automatic unless retriedBy says so. Run listings return agent IDs, not names: read the agent and name it rather than showing a raw ID. For a project, link //projects/. For a goal, link //goals/. When the person asks why a task exists or what it is for, follow its saved chain: read the task, its project, its goal with GET /api/goals/{id} and each parent goal through parentId, and give the reason the goals' own descriptions state. Link the task, its project and every goal in the chain. When the task has no goal, say so instead of supplying a reason. When a tool result gives a record's href, such as a project or a workspace, link that href; a workspace without an href has no page on this instance, so name it instead of linking it. When a reply concerns a specific agent, such as one you paused, resumed, configured, or reported on, link its profile at //agents/ using the agent's returned urlKey or id. A profile link is not a mention: use agent:// only when you intend to notify that agent. When you send a person to a control on an agent's profile, link the page that holds it instead of the bare profile: //agents//api-keys for API keys, /identity for identity and instructions, /runtime for harness settings, /secrets for secrets and variables, /permissions for permissions. When you cannot hire an agent yourself, send the person to the hire form at //agents/new, where they can hire it directly, and to your own /permissions page, where they can turn on hiring for you. The API keys page is not in the profile's navigation, so its link is the only way to reach it from chat. diff --git a/ui/src/api/activity.ts b/ui/src/api/activity.ts index 01f5ff6f3de..f2011f7eabd 100644 --- a/ui/src/api/activity.ts +++ b/ui/src/api/activity.ts @@ -30,6 +30,8 @@ export interface RunForIssue { scheduledRetryAttempt?: number; scheduledRetryReason?: string | null; retryExhaustedReason?: string | null; + /** Who started a retry run: a named person who pressed Retry, or automatic recovery. */ + retriedBy?: { kind: "person"; personName: string; summary: string } | { kind: "automatic"; summary: string } | null; livenessState?: RunLivenessState | null; livenessReason?: string | null; continuationAttempt?: number;