Files
PaperClipAI/tests/runner-e2e/chat-catalog-domains/runtime-infrastructure-retry.ts
T
DottaandClaude Opus 5.5 3b4c3265ed fix(recovery): offer Try again on a model-unavailable failure and recheck the model first (#21244)
## Thinking Path

> - Paperclip is the open source app people use to manage AI agents for
work
> - When a native run fails, the task thread shows a failure marker, and
some markers offer Try again
> - A `native_provider_model_rejected` failure blocks the task for the
person and shows "Model unavailable", but it has no Try again control
> - Recovery must just work: after the person fixes the model, they need
one obvious control that continues the task, and that control must not
start a run that is sure to fail
> - This pull request shows Try again on the "Model unavailable" marker
and makes the retry recheck the selected model before it starts a run
> - The benefit is that the person fixes the model, presses Try again,
and the task completes, and a too-early press explains which setting to
change instead of failing again

## Linked Issue or Issue Description

Refs #21210

**What happened?**
Paid run 43321773136, `recovery.retry-exhausted` (OpenCode,
`openrouter/deepseek/deepseek-v4.1-flash-1017`). The run failed with
`native_provider_model_rejected`. The task stayed blocked and the thread
showed "Model unavailable", but no Try again control appeared
(`task-chat-run-failed-try-again` not found in 30 s). Only the "Run
failed" and "Usage limit reached" markers offer Try again.

**Expected behavior**
The "Model unavailable" marker offers Try again. Pressing it checks the
selected model first. If the provider-rejected model is still selected,
no run starts, and the person sees which setting to change with a link
to it. After the person changes the model, Try again starts one retry of
the original run.

**Steps to reproduce**
1. Set an agent's model to an id the provider rejects.
2. Assign it a task. The run fails with
`native_provider_model_rejected`.
3. Open the task. Before this change, the marker has no Try again.

## What Changed

- `server/src/services/native-runtime/model-rejected-retry.ts`:
`rejectedModelRetryRefusal` reads the model the failed run sent
(`runnerProfileJson.nativeExecutionInput.provider.model`) and the model
a new run would use (the task's model override for its assignee, else
the agent's model). If they are the same, it returns a 409 refusal with
code `native_provider_model_still_unavailable`, the setting to change
(`agent_model` or `task_model_override`) and the rejected model.
- `server/src/routes/agents.ts`: the exact failed-run retry (`POST
/agents/:id/wakeup`, `reason: retry_failed_run`) applies this check
before it queues anything.
- `ui/src/components/task-chat/adjacent-errors.ts`,
`TaskChatThreadView.tsx`: one `isRetryableFailureMarker` rule, now
including "Model unavailable".
- `ui/src/lib/model-retry-refusal.ts`, `ui/src/pages/IssueDetail.tsx`: a
refused retry shows "Model still unavailable" with the server's message
and an "Open <agent> model settings" link to `/agents/<agent>/runtime`.
A task override refusal names the override in the message.
- Eval `recovery.retry-exhausted` (oracle `runtime.retry-exhausted.v7`):
the rejected model stays selected after the failure. The person presses
Try again (409, toast names the model, its link opens the agent's model
settings, no run starts in 20 s, task stays blocked), restores the
working model, presses Try again (202), and the one retry of the
original run uses the working model, saves the brief and completes the
task. 3 runs: failed 1, succeeded 2. The budget-hold and two follow-up
chat phases are removed; the case now tests the model recheck.
`recovery.yaml` context and expected outcome updated, recorded in
`chat-full-catalog-testops-manifest.json` `changedFields`, pinned in its
test, descriptors and inventory digest updated.

## Verification

- RED on master: `TaskChatThread.test.tsx` "offers Try again on a
model-unavailable failure and retries that run" fails (no control).
`agent-live-run-routes.test.ts` "refuses a retry while the rejected
model is still selected and starts no run" fails (the route queues the
run).
- GREEN: both pass. `agent-live-run-routes.test.ts` 101/101.
- `server/src/services/native-runtime/model-rejected-retry.test.ts`
(embedded PostgreSQL), 6/6: refuses while the agent still selects the
rejected model (names the agent setting); names the task override;
allows the retry when the agent or the override now selects another
model, or the run failed for another reason; ignores another company's
run.
- `ui/src/lib/model-retry-refusal.test.ts`: names the setting and links
to `/agents/morgan/runtime`; no link for a task override; other errors
fall through to the generic toast.
- Server `tsc --noEmit` clean. UI `tsc` clean apart from the
pre-existing generated storybook catalog. `node
scripts/check-token-gates.mjs`: clean.
- Eval: `npx vitest run --config tests/runner-e2e/vitest.config.ts
tests/runner-e2e/chat-catalog tests/runner-e2e/chat-catalog-domains
tests/runner-e2e/chat-*.test.ts`: 339 files pass. New calibration
rejects an accepted early retry, a run started while the model is
rejected, a refusal without the model, setting link or blocked task, a
retry that used the old model, and duplicate or missing retries. `pnpm
test:e2e:runner:typecheck`: pass. Manifest test 10/10.
`source-sdk-public-inputs --check`: `changed: false`.
- Paid run: Runner Full-Stack E2E 43338695850 on throwaway branch
`chat-eval/qa-mr-paid`. Result to follow in a comment.

## Risks

- The recheck compares the selected model with the model the provider
rejected. It does not call the provider. A model the provider rejected
stays refused until the person selects another one; a different but also
unsupported model starts a run that fails with the same marker again.
- The refusal message is a toast (15 s). The marker detail still says to
choose a supported model.
- No persisted shape changes; runs saved by older builds carry the same
`runnerProfileJson` field.

> For core feature work, check [`ROADMAP.md`](ROADMAP.md) first and
discuss it in `#dev` before opening the PR. Feature PRs that overlap
with planned core work may need to be redirected — check the roadmap
first. See `CONTRIBUTING.md`.

## Model Used

- Claude Opus 5.5 (`claude-opus-5-5`), Anthropic, used through Claude
Code with tool use and code execution.

## Checklist

- [x] I have included a thinking path that traces from project context
to this change
- [x] I have specified the model used (with version and capability
details)
- [x] I have checked ROADMAP.md and confirmed this PR does not duplicate
planned core work
- [x] I have searched GitHub for duplicate or related PRs and linked
them above
- [x] I have either (a) linked existing issues with `Fixes: #` / `Closes
#` / `Refs #` OR (b) described the issue in-PR following the relevant
issue template
- [x] I have not referenced internal/instance-local Paperclip issues or
links (only public GitHub `#NNN` / `github.com/paperclipai/paperclip`
URLs)
- [x] My branch name describes the change (e.g. `docs/...`, `fix/...`)
and contains no internal Paperclip ticket id or instance-derived details
- [x] I have run tests locally and they pass
- [x] I have added or updated tests where applicable
- [x] I have updated relevant documentation to reflect my changes
- [x] I have considered and documented any risks above
- [ ] All Paperclip CI gates are green
- [ ] Greptile is 5/5 with no open P2s, recommendations, or follow-ups
- [x] I will address all Greptile and reviewer comments before
requesting merge

🤖 Generated with [Claude Code](https://claude.com/claude-code)

---------

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-12 21:42:52 -06:00

168 lines
19 KiB
TypeScript

import { chatCatalogNativePhaseDeadline, chatCatalogNativePhaseIsTimely } from "../chat-catalog-contract.js";
import { expect, type Page } from "@playwright/test";
import { writeFile } from "node:fs/promises";
import type { HeartbeatRun } from "../../../packages/shared/src/types/heartbeat.js";
import type { Issue } from "../../../packages/shared/src/types/issue.js";
import { pollUntil } from "../api.js";
import { checks, type Entity } from "./internal-support.js";
import { prepareRuntimeWorkerGate, releasedRetryListener, releaseRuntimeWorker, retriesOriginalRun, type RuntimeBriefGate } from "./runtime-busy-worker.js";
import { controllerReadRecovery, linksSourceTask, sourceRunRecovery, type SourceRecoveryActions } from "./runtime-infrastructure.js";
import { unavailableNativeModelFailure } from "./runtime-native-failure.js";
import type { ChatCatalogContext } from "../chat-catalog-contract.js";
import { runtimeDefinition, runtimeObservation, observeRuntime, type RuntimeAgent } from "./runtime-support.js";
export function humanRetryControl(page: Page) {
return page.getByTestId("task-chat-run-failed-try-again").or(page.getByTestId("task-execution-retry")).last();
}
export function isHumanRetryRequest(request: { method(): string; url(): string }, taskId: string, workerId: string) {
const path = new URL(request.url()).pathname;
return request.method() === "POST" && (path === `/api/agents/${workerId}/wakeup` || path === `/api/issues/${taskId}/retry`);
}
export { releasedRetryListener, retriesOriginalRun };
export const PERSON_OWNED_RETRY_FAILURE_CODE = "native_provider_model_rejected";
export function isPersonOwnedRetryFailure(input: { run?: Pick<HeartbeatRun, "id" | "status" | "errorCode" | "companyId" | "agentId"> & { nativePhase?: string | null }; companyId: string; agentId: string;
taskStatus?: string; freshContinuations: number; successorRuns: number }) {
const run = input.run;
return !!run && run.status === "failed" && run.errorCode === PERSON_OWNED_RETRY_FAILURE_CODE && run.companyId === input.companyId && run.agentId === input.agentId
&& input.taskStatus === "blocked" && input.freshContinuations === 0 && input.successorRuns === 0;
}
export async function personOwnedNativeFailure(ctx: ChatCatalogContext) {
const { worker, gate, company } = await prepareRuntimeWorkerGate(ctx, { taskBound: true });
let task: Entity | undefined;
const failure = await unavailableNativeModelFailure(ctx, worker, async () => {
task = await ctx.input.api.post<Entity>(`${company}/issues`, { title: "Website task", status: "todo", assigneeAgentId: worker.id, allowDuplicate: true,
description: `The website brief is being supplied by the human. Run ${gate.command} once and wait for its real output. Do not invent a brief, replace the script, or mark work complete before it returns. Once the brief arrives, save it as a task document and finish normally.` });
return { issueId: task.id };
});
if (!task || failure.failedIssueId !== task.id) throw new Error("Person-owned failure did not stop the fixture's own Website task");
const workingModel = String(failure.originalConfiguration.adapterConfig?.model ?? "");
const kept = await ctx.input.api.patch<RuntimeAgent>(`/api/agents/${worker.id}`, { adapterConfig: { ...failure.originalConfiguration.adapterConfig, model: failure.failedModel } });
if (kept.adapterConfig?.model !== failure.failedModel || !workingModel) throw new Error("The rejected model is not the agent's selected model before Retry");
const companyId = ctx.input.fixtures.company.id, failedRunId = failure.failedRun.id, websiteId = task.id;
const load = async () => {
const [current, run, recovery, runs] = await Promise.all([ctx.input.api.get<Issue>(`/api/issues/${websiteId}`), ctx.input.api.get<HeartbeatRun>(`/api/heartbeat-runs/${failedRunId}`),
sourceRunRecovery(ctx, websiteId, failedRunId), ctx.allRuns()]);
return { current, run, recovery, freshContinuations: (recovery.actions ?? []).filter(action => !!(action.evidence as Record<string, unknown>).freshContinuation).length,
successorRuns: runs.filter(row => row.agentId === worker.id && row.id !== failedRunId).length };
};
const accepted = (v: Awaited<ReturnType<typeof load>>) => isPersonOwnedRetryFailure({ run: v.run, companyId, agentId: worker.id, taskStatus: v.current.status,
freshContinuations: v.freshContinuations, successorRuns: v.successorRuns });
await pollUntil({ label: "The person-owned failure waits for the person's Retry", deadlineAt: Date.now() + 90_000, load, accept: accepted,
reject: v => v.successorRuns > 0 || v.freshContinuations > 0 ? "A person-owned failure was continued without the person" : undefined });
const settled = await pollUntil({ label: "No automatic continuation follows the person-owned failure", deadlineAt: Date.now() + 60_000, load,
accept: v => accepted(v) && Date.now() - Date.parse(String(v.run.finishedAt)) >= 45_000,
reject: v => accepted(v) ? undefined : "A person-owned failure was continued without the person" });
const before = await ctx.input.api.get<SourceRecoveryActions>(`/api/issues/${websiteId}/recovery-actions`);
await ctx.input.evidence("runtime-person-owned-failure.json", { runId: failedRunId, errorCode: settled.run.errorCode, taskStatus: settled.current.status,
activeRecovery: before.active ? { id: before.active.id, ownerType: before.active.ownerType, cause: before.active.cause, status: before.active.status } : null,
freshContinuations: settled.freshContinuations, successorRuns: settled.successorRuns });
return { worker, gate, task: settled.current, workerRunId: failedRunId, failure: settled.run, recoveryBefore: before.active ?? null,
freshContinuationsBefore: settled.freshContinuations, successorRunsBefore: settled.successorRuns, failureKind: failure.failureKind,
rejectedModel: failure.failedModel, workingModel, originalAdapterConfig: failure.originalConfiguration.adapterConfig };
}
export const MODEL_STILL_UNAVAILABLE_CODE = "native_provider_model_still_unavailable";
const MODEL_SETTINGS_PATH = /\/agents\/[^/]+\/runtime$/;
export function gradeInfrastructureRetry(value: unknown) {
const c = checks(), o = runtimeObservation(value);
c.add("actual-person-owned-failure-retry-and-model-recheck", !!o, "The genuine person-owned native failure, the real human Try again control and the independently observed model recheck are required."); if (!o) return c.result();
const s = o.state;
c.add("actual-person-owned-failure-awaits-retry", isPersonOwnedRetryFailure({ run: s.failure as HeartbeatRun, companyId: o.companyId, agentId: (s.worker as Entity)?.id,
taskStatus: (s.task as Issue)?.status, freshContinuations: Number(s.freshContinuationsBefore), successorRuns: Number(s.successorRunsBefore) }),
"The original task stopped because the provider rejected its selected model, stays blocked for the person, and the system starts no continuation of its own.");
c.add("ordinary-human-retry-guidance", s.queryRecoveryRead === true && s.retryVisible === true && linksSourceTask(o, s.task as Entity),
"The canonical reply comes from a run that read the saved recovery record and links the original task, where the real Try again control is visible on the model failure.");
c.add("retry-rechecks-the-still-rejected-model", Number(s.refusedRetryStatus) === 409 && s.refusalCode === MODEL_STILL_UNAVAILABLE_CODE
&& s.refusalNamedRejectedModel === true && s.refusalLinksModelSetting === true && s.noRunWhileModelUnavailable === true && s.taskBlockedAfterRefusal === true,
"Try again while the rejected model is still selected starts no run, keeps the task blocked and tells the person which setting to change, with a working link to it.");
c.add("one-retry-after-model-fixed-completes", s.modelFixedByHuman === true && Number(s.fixedRetryStatus) === 202 && s.retryRunCount === 1
&& s.retryBoundToOriginal === true && s.retryAdmissionAfterFix === true && s.retryUsedFixedModel === true
&& s.originalFailureRetained === true && s.actualRetryResult === true
&& o.tasks.length === 1 && o.tasks[0]?.id === (s.task as Entity).id && o.tasks[0]?.status === "done"
&& o.runs.length === 3 && o.runs.filter(row => row.status === "failed").length === 1 && o.runs.filter(row => row.status === "succeeded").length === 2,
"After the person selects a working model, one Try again starts exactly one retry of the original run with that model, retains the original failure and saves the real Website result.");
return c.result();
}
export const runtimeInfrastructureRetryCases = [runtimeDefinition("recovery.retry-exhausted", personOwnedNativeFailure, gradeInfrastructureRetry, {
oracleVersion: "paperclip.chat-catalog.runtime.retry-exhausted.v7", authentication: "human-session", expectedHumanMessageCount: 1, expectedRunCount: 3, attemptTimeoutMs: 1_200_000,
setupPolicy: { readiness: "preserve-scenario", invariantCheckIds: ["lead-ready", "person-owned-failure-awaits-retry"] },
async verifySetup(ctx, state) { const c = checks(), lead = await ctx.input.api.get<RuntimeAgent>(`/api/agents/${ctx.input.fixtures.agent.id}`), task = state.task as Issue, worker = state.worker as Entity;
const [current, run, recovery, runs] = await Promise.all([ctx.input.api.get<Issue>(`/api/issues/${task.id}`), ctx.input.api.get<HeartbeatRun>(`/api/heartbeat-runs/${state.workerRunId}`),
sourceRunRecovery(ctx, task.id, String(state.workerRunId)), ctx.allRuns()]);
c.add("lead-ready", lead.lifecycleState === "ready" && ["active", "idle"].includes(lead.status ?? ""), "The actual controller remains independently admitted.");
c.add("person-owned-failure-awaits-retry", isPersonOwnedRetryFailure({ run, companyId: ctx.input.fixtures.company.id, agentId: worker.id, taskStatus: current.status,
freshContinuations: (recovery.actions ?? []).filter(action => !!(action.evidence as Record<string, unknown>).freshContinuation).length,
successorRuns: runs.filter(row => row.agentId === worker.id && row.id !== run.id).length }), "The original task waits for the person's Retry after a failure only the person can resolve."); return c.result(); },
runPolicy: { kind: "terminal-counts", terminalStatusCounts: { failed: 1, succeeded: 2 } },
sourceFiles: ["chat-catalog-domains/runtime-infrastructure-retry.ts", "chat-catalog-domains/runtime-infrastructure.ts", "chat-catalog-domains/api-read-receipts.ts", "chat-catalog-domains/runtime-native-fault.ts", "chat-catalog-domains/runtime-native-failure.ts", "chat-catalog-domains/runtime-busy-worker.ts", "chat-catalog-domains/runtime-support.ts", "../../server/src/services/hot-restart.ts", "../../server/src/vendor/paperclip-runner/index.ts", "chat-scenarios/recovery.yaml"],
async act(ctx, state) {
const task = state.task as Issue, worker = state.worker as RuntimeAgent;
const initial = await pollUntil({ label: "Canonical human Retry guidance after the person-owned failure", deadlineAt: chatCatalogNativePhaseDeadline(ctx, Date.now() + 150_000),
load: async () => { await ctx.refreshIssue(); return { source: ctx.issue(), runs: await ctx.allRuns() }; },
accept: v => chatCatalogNativePhaseIsTimely(ctx) && (v.source?.conversationState === "waiting" && v.runs.length === 2 && v.runs.some(row => row.id === state.workerRunId && row.status === "failed") && v.runs.some(row => row.agentId === ctx.input.fixtures.agent.id && row.status === "succeeded")) });
state.queryReply = (await observeRuntime(ctx, state)).reply; const source = ctx.input.page.url();
state.queryRecoveryRead = await controllerReadRecovery(ctx, initial.runs.find(row => row.agentId === ctx.input.fixtures.agent.id)?.id, task.id, String(state.workerRunId), task.identifier);
const taskURL = `/${ctx.input.fixtures.company.issuePrefix}/issues/${task.identifier ?? task.id}`;
await ctx.input.page.goto(taskURL, { waitUntil: "domcontentloaded" });
const retry = humanRetryControl(ctx.input.page); await expect(retry).toBeVisible(); state.retryVisible = true;
const workerRetryRuns = async () => (await ctx.allRuns()).filter(row => row.agentId === worker.id && row.id !== state.workerRunId).length;
const refused = ctx.input.page.waitForResponse(r => isHumanRetryRequest(r.request(), task.id, worker.id));
await retry.click(); const refusal = await refused; state.refusedRetryStatus = refusal.status();
const refusalBody = await refusal.json().catch(() => null) as { error?: unknown; details?: { code?: unknown; rejectedModel?: unknown } } | null;
state.refusalCode = refusalBody?.details?.code ?? null;
const notice = ctx.input.page.getByRole("listitem").filter({ hasText: "Model still unavailable" }).first();
await expect(notice).toBeVisible({ timeout: 10_000 });
state.refusalNamedRejectedModel = (await notice.textContent() ?? "").includes(String(state.rejectedModel));
const settingsLink = notice.getByRole("link").first();
const linked = await settingsLink.count() === 1;
await ctx.input.capture("model-still-unavailable-refusal", "Try again names the model setting while the rejected model is still selected", "runtime-retry-model-refused.png");
const refusalSamples = [await workerRetryRuns()];
if (linked) {
await settingsLink.click();
await ctx.input.page.waitForURL(url => MODEL_SETTINGS_PATH.test(url.pathname), { timeout: 15_000 }).catch(() => undefined);
}
state.refusalLinksModelSetting = linked && MODEL_SETTINGS_PATH.test(new URL(ctx.input.page.url()).pathname)
&& new URL(ctx.input.page.url()).pathname.includes(`/agents/${worker.urlKey ?? worker.id}/`);
await ctx.input.page.waitForTimeout(20_000);
refusalSamples.push(await workerRetryRuns()); state.refusalRunSamples = refusalSamples;
state.noRunWhileModelUnavailable = refusalSamples.every(count => count === 0);
state.taskBlockedAfterRefusal = (await ctx.input.api.get<Issue>(`/api/issues/${task.id}`)).status === "blocked";
const fixed = await ctx.input.api.patch<RuntimeAgent>(`/api/agents/${worker.id}`, { adapterConfig: { ...(state.originalAdapterConfig as Record<string, unknown>), model: state.workingModel } });
state.modelFixedByHuman = fixed.adapterConfig?.model === state.workingModel && fixed.adapterConfig?.model !== state.rejectedModel;
state.modelFixedAt = Date.now();
await ctx.input.page.goto(taskURL, { waitUntil: "domcontentloaded" });
const again = humanRetryControl(ctx.input.page); await expect(again).toBeVisible();
const accepted = ctx.input.page.waitForResponse(r => isHumanRetryRequest(r.request(), task.id, worker.id));
await again.click(); state.fixedRetryStatus = (await accepted).status();
const gateName = (state.gate as RuntimeBriefGate).gateName!;
const released = await pollUntil({ label: "The Retry after the model fix listens for the brief in its own workspace", deadlineAt: Date.now() + 180_000,
load: async () => {
const retries = (await ctx.allRuns()).filter(row => row.agentId === worker.id && row.id !== state.workerRunId);
const run = retries.length === 1 ? await ctx.input.api.get<HeartbeatRun>(`/api/heartbeat-runs/${retries[0]!.id}`) : null;
return { retries: retries.length, run, listener: run ? await releasedRetryListener(run, { companyId: ctx.input.fixtures.company.id, workerId: worker.id,
taskId: task.id, originalRunId: String(state.workerRunId), gateName }) : null };
},
accept: v => v.retries === 1 && !!v.listener,
reject: v => v.retries > 1 ? "Try again started more than one run" : v.run && ["failed", "cancelled", "timed_out"].includes(v.run.status) ? "The retry after the model fix stopped" : undefined });
state.retryWorkspaceId = released.listener!.workspaceId;
await writeFile(released.listener!.gate, `The authorized human fixed the model. Use the preserved task context and save a non-plan website-delivery document with the exact reference Retry website ${ctx.input.nonce}, a semantic single-page Acorn website outline and an accessible signup action, then complete this original task normally. Do not create more tasks or external effects.`, "utf8");
const completed = await pollUntil({ label: "The one Retry after the model fix completes the original task", deadlineAt: Date.now() + 240_000,
load: async () => ({ task: await ctx.input.api.get<Issue>(`/api/issues/${task.id}`), runs: await ctx.allRuns() }),
accept: v => v.task.status === "done" && v.runs.length === 3 && v.runs.filter(row => row.id !== state.workerRunId).every(row => row.status === "succeeded"),
reject: v => v.runs.length > 3 || v.runs.some(row => row.id !== state.workerRunId && ["failed", "cancelled", "timed_out"].includes(row.status)) ? "The retry failed or duplicated native work" : undefined });
const retried = completed.runs.filter(row => row.agentId === worker.id && row.id !== state.workerRunId); state.retryRunCount = retried.length;
const full = retried[0] && await ctx.input.api.get<HeartbeatRun & { runnerProfileJson?: { nativeExecutionInput?: { provider?: { model?: string | null } } } }>(`/api/heartbeat-runs/${retried[0].id}`); state.retryRunId = full?.id;
state.retryBoundToOriginal = !!full && retriesOriginalRun(full, String(state.workerRunId)) && [full.contextSnapshot?.issueId, full.contextSnapshot?.taskId].includes(task.id);
state.retryAdmissionAfterFix = !!full && Date.parse(String(full.createdAt)) >= Number(state.modelFixedAt);
state.retryUsedFixedModel = full?.runnerProfileJson?.nativeExecutionInput?.provider?.model === state.workingModel;
await ctx.input.page.goto(source, { waitUntil: "domcontentloaded" });
},
async observe(ctx, state) { const o = await observeRuntime(ctx, state);
const before = state.failure as HeartbeatRun, retained = await ctx.input.api.get<HeartbeatRun>(`/api/heartbeat-runs/${state.workerRunId}`);
state.originalFailureRetained = retained.id === before.id && retained.status === "failed" && retained.errorCode === before.errorCode && retained.finishedAt === before.finishedAt;
state.actualRetryResult = o.revisions.some(row => row.createdByRunId === state.retryRunId && row.createdByAgentId === (state.worker as Entity).id && (row.body ?? "").includes(`Retry website ${ctx.input.nonce}`)
&& o.documents.some(doc => doc.id === row.documentId && doc.latestRevisionId === row.id)); return o; },
async verifyResult(ctx, state) { const source = ctx.input.page.url(), task = state.task as Issue;
await ctx.input.page.goto(`/${ctx.input.fixtures.company.issuePrefix}/issues/${task.identifier ?? task.id}`, { waitUntil: "domcontentloaded" }); await ctx.input.page.reload({ waitUntil: "domcontentloaded" });
await expect(ctx.input.page.getByRole("button", { name: "Change status (current: Done)", exact: true }).first()).toBeVisible(); await ctx.input.page.goto(source, { waitUntil: "domcontentloaded" }); },
cleanup: async (_ctx, state) => releaseRuntimeWorker(state),
})];