Skip to content

A self-improving RLM agent for coding workflows and long-running autonomous tasks.

Rust

[RSI] fix(coding-agent): never persist completed verdicts for errored sessions (#2310)

Seth Karten8f52777f2d37
diff --git a/packages/coding-agent/.changes/errored-session-verdicts.md b/packages/coding-agent/.changes/errored-session-verdicts.md
new file mode 100644
index 0000000000..628c72da38
--- /dev/null
+++ b/packages/coding-agent/.changes/errored-session-verdicts.md
@@ -0,0 +1 @@
+- Fixed errored sessions persisting fabricated completed verdicts: a session whose last turn ended in a model error (e.g. provider 400s before any work ran) no longer lets the status classifier invent a recap and a COMPLETED verdict from the task text. Such sessions now settle to an `error` task state whose summary carries the transcript's real error message, persisted with the same journal-dedupe discipline as model verdicts, and terminal turns with `stopReason === "error"` no longer persist `completed` without a final answer. A verdict fabricated by earlier builds and persisted before a daemon restart no longer survives: the restart-seeded status is exempt from the unchanged-content fast path, so the first sweep repairs it to the error verdict.
diff --git a/packages/coding-agent/src/core/session-manager.ts b/packages/coding-agent/src/core/session-manager.ts
index cd10b6e1ee..92b699ea9c 100644
--- a/packages/coding-agent/src/core/session-manager.ts
+++ b/packages/coding-agent/src/core/session-manager.ts
@@ -183,7 +183,7 @@ export interface SessionStateEntry extends SessionEntryBase {
state: SessionState;
}
-export type AgentTaskState = "needs_input" | "completed";
+export type AgentTaskState = "needs_input" | "completed" | "error";
export interface AgentStatus {
summary: string;
diff --git a/packages/coding-agent/src/modes/agent-connection/types.ts b/packages/coding-agent/src/modes/agent-connection/types.ts
index 67550c46c2..c3941e1061 100644
--- a/packages/coding-agent/src/modes/agent-connection/types.ts
+++ b/packages/coding-agent/src/modes/agent-connection/types.ts
@@ -108,7 +108,7 @@ export interface AgentConnectionSavedSessionState {
export interface AgentConnectionAgentStatus {
summary: string;
- taskState?: "needs_input" | "completed";
+ taskState?: "needs_input" | "completed" | "error";
basedOnMessageCount: number;
}
diff --git a/packages/coding-agent/src/modes/agents-view/agents-view-state.ts b/packages/coding-agent/src/modes/agents-view/agents-view-state.ts
index e3e56e187e..e37c5abbb6 100644
--- a/packages/coding-agent/src/modes/agents-view/agents-view-state.ts
+++ b/packages/coding-agent/src/modes/agents-view/agents-view-state.ts
@@ -1262,5 +1262,8 @@ export function getSessionStatusLabel(summary: SessionSummary, heartbeat?: Unifi
if (summary.activity === "working") {
return "classifying";
}
+ if (summary.taskState === "error") {
+ return "error";
+ }
return summary.taskState === "completed" ? "completed" : "needs input";
}
diff --git a/packages/coding-agent/src/modes/daemon/daemon-client.ts b/packages/coding-agent/src/modes/daemon/daemon-client.ts
index a396a567cc..a725e652a3 100644
--- a/packages/coding-agent/src/modes/daemon/daemon-client.ts
+++ b/packages/coding-agent/src/modes/daemon/daemon-client.ts
@@ -725,6 +725,7 @@ function isDaemonSavedSessionAgentStatus(value: unknown): boolean {
typeof candidate.basedOnMessageCount === "number" &&
(candidate.taskState === undefined ||
candidate.taskState === "needs_input" ||
- candidate.taskState === "completed")
+ candidate.taskState === "completed" ||
+ candidate.taskState === "error")
);
}
diff --git a/packages/coding-agent/src/modes/daemon/daemon-session-summarizer.ts b/packages/coding-agent/src/modes/daemon/daemon-session-summarizer.ts
index 95751435a5..7a20c2e199 100644
--- a/packages/coding-agent/src/modes/daemon/daemon-session-summarizer.ts
+++ b/packages/coding-agent/src/modes/daemon/daemon-session-summarizer.ts
@@ -205,6 +205,35 @@ function isSessionWorking(state: ActiveSessionState): boolean {
return session.isSessionActive;
}
+// Recap prefix for a turn that errored; the transcript's own error text follows
+// it so the persisted verdict reports the real last event, never invented work.
+const ERROR_RECAP_PREFIX = "Model request failed";
+// Generous; the agents view truncates recaps further for display.
+const ERROR_RECAP_MAX_CHARS = 160;
+
+/**
+ * Recap for an idle session whose last turn errored, or undefined when the last
+ * turn ended normally (or never produced an assistant message). A turn that
+ * errored produced no final answer, so its verdict must come from the
+ * transcript's error — the classifier would only see the task text and invent
+ * work that never happened.
+ */
+function terminalTurnError(messages: readonly AgentMessage[]): string | undefined {
+ for (let i = messages.length - 1; i >= 0; i--) {
+ const message = messages[i];
+ if (message.role !== "assistant") {
+ continue;
+ }
+ const { stopReason, errorMessage } = message as { stopReason?: unknown; errorMessage?: unknown };
+ if (stopReason !== "error") {
+ return undefined;
+ }
+ const detail = typeof errorMessage === "string" ? errorMessage.trim() : "";
+ return detail ? `${ERROR_RECAP_PREFIX}: ${clamp(detail, ERROR_RECAP_MAX_CHARS)}` : ERROR_RECAP_PREFIX;
+ }
+ return undefined;
+}
+
/**
* Background status summarization for daemon-hosted sessions, top-level and
* subagents alike. A periodic sweep refreshes working sessions; debounced
@@ -313,15 +342,38 @@ export class DaemonSessionSummarizer {
const messageCount = messages.length;
const isWorking = isSessionWorking(state);
const previous = state.summaryState;
- // Idle sessions with a current verdict need no refresh; working sessions
- // always refresh so the recap keeps up with the in-progress turn.
+ // Idle sessions with a current verdict need no refresh — except a
+ // transcript whose terminal turn errored (owesErrorVerdict below) —
+ // while working sessions always refresh so the recap keeps up with the
+ // in-progress turn.
const contentUnchanged = previous?.basedOnMessageCount === messageCount;
const owesIdleVerdict = !isWorking && previous?.taskState === undefined;
// A blank recap means the model call hasn't succeeded yet (e.g. the
// needs_input fallback fired on a transient failure); keep retrying until a
// real summary lands so the recap isn't left permanently empty.
const owesSummary = !isWorking && !previous?.summary;
- if (contentUnchanged && !isWorking && !owesIdleVerdict && !owesSummary) {
+ // A turn that errored produced no final answer. Only a real final answer may
+ // earn a completed verdict, so skip the classifier entirely — it sees the
+ // task text with no evidence of the failure and would invent work — and
+ // settle the verdict from the transcript's actual last event instead.
+ // The pass below is synchronous, so no stale-state discard is needed.
+ const turnError = !isWorking ? terminalTurnError(messages) : undefined;
+ // A daemon restart seeds the latest persisted verdict, which pre-fix code
+ // may have fabricated as `completed` for a transcript whose terminal turn
+ // errored at this same message count. Only the error branch below repairs
+ // it, so exempt terminal errors from the unchanged-content fast return.
+ const owesErrorVerdict = turnError !== undefined && previous?.taskState !== "error";
+ if (contentUnchanged && !isWorking && !owesIdleVerdict && !owesSummary && !owesErrorVerdict) {
+ return;
+ }
+ if (turnError !== undefined) {
+ this.failedIdleGenerations.delete(id);
+ const status: AgentStatus = {
+ summary: turnError,
+ taskState: "error",
+ basedOnMessageCount: messageCount,
+ };
+ this.commitStatus(state, session, status, { isWorking, previous, persist: true });
return;
}
// The leaf entry id is the branch-tip identity (appends, edits, and branch
@@ -385,37 +437,14 @@ export class DaemonSessionSummarizer {
// message count so a still-valid needs_input isn't dropped.
const taskState =
result.taskState ?? (previous?.basedOnMessageCount === messageCount ? previous?.taskState : undefined);
- const status: AgentStatus = {
- summary: result.summary,
- taskState,
- basedOnMessageCount: messageCount,
- };
- // An idle settle refreshes the verdict's currency, which drives the roster's
- // activity axis: it must publish even when the verdict text is unchanged.
- const changed =
- previous?.summary !== status.summary ||
- previous?.taskState !== status.taskState ||
- (!isWorking && previous?.basedOnMessageCount !== status.basedOnMessageCount);
- state.summaryState = status;
- // Persist only settled idle verdicts from real classifications that
- // differ from the latest persisted entry: idle sweeps must not grow the journal.
- if (!isWorking && generated) {
- const persisted = session.sessionManager.getLatestAgentStatus();
- if (
- persisted?.summary !== status.summary ||
- persisted.taskState !== status.taskState ||
- persisted.basedOnMessageCount !== status.basedOnMessageCount
- ) {
- try {
- session.sessionManager.appendAgentStatus(status);
- } catch {
- // best-effort; in-memory status still shows
- }
- }
- }
- if (changed) {
- this.onStatusChanged?.(state);
- }
+ // Only a real classification persists; the needs_input fallback above
+ // must not grow the journal.
+ this.commitStatus(
+ state,
+ session,
+ { summary: result.summary, taskState, basedOnMessageCount: messageCount },
+ { isWorking, previous, persist: generated !== undefined },
+ );
} finally {
this.inFlight.delete(id);
// Re-debounce a request that arrived mid-pass instead of dropping it.
@@ -424,4 +453,42 @@ export class DaemonSessionSummarizer {
}
}
}
+
+ /**
+ * Publish an in-memory status and persist a settled idle verdict that differs
+ * from the latest persisted entry: sweeps must not grow the journal. `persist`
+ * is true only for real verdicts — model classifications and
+ * transcript-derived error verdicts — never for the needs_input fallback.
+ */
+ private commitStatus(
+ state: ActiveSessionState,
+ session: ActiveSessionState["runtime"]["session"],
+ status: AgentStatus,
+ { isWorking, previous, persist }: { isWorking: boolean; previous: AgentStatus | undefined; persist: boolean },
+ ): void {
+ // An idle settle refreshes the verdict's currency, which drives the roster's
+ // activity axis: it must publish even when the verdict text is unchanged.
+ const changed =
+ previous?.summary !== status.summary ||
+ previous?.taskState !== status.taskState ||
+ (!isWorking && previous?.basedOnMessageCount !== status.basedOnMessageCount);
+ state.summaryState = status;
+ if (!isWorking && persist) {
+ const persisted = session.sessionManager.getLatestAgentStatus();
+ if (
+ persisted?.summary !== status.summary ||
+ persisted.taskState !== status.taskState ||
+ persisted.basedOnMessageCount !== status.basedOnMessageCount
+ ) {
+ try {
+ session.sessionManager.appendAgentStatus(status);
+ } catch {
+ // best-effort; in-memory status still shows
+ }
+ }
+ }
+ if (changed) {
+ this.onStatusChanged?.(state);
+ }
+ }
}
diff --git a/packages/coding-agent/test/agents-view-state.test.ts b/packages/coding-agent/test/agents-view-state.test.ts
index fa0d2d8119..bb9570273b 100644
--- a/packages/coding-agent/test/agents-view-state.test.ts
+++ b/packages/coding-agent/test/agents-view-state.test.ts
@@ -1394,6 +1394,10 @@ describe("agents view state", () => {
expect(buildAgentsViewRows([makeSummary({ workerState: "ready" })])[0]?.statusLabel).toBe("needs input");
});
+ test("labels an errored session with the error state, not a fabricated verdict", () => {
+ expect(buildAgentsViewRows([makeSummary({ taskState: "error" })])[0]?.statusLabel).toBe("error");
+ });
+
test("does not override saved session cwd when reopening inactive agents", () => {
const config: AgentSessionRuntimeConfig = {
cwd: "/tmp/dashboard",
diff --git a/packages/coding-agent/test/daemon-client.test.ts b/packages/coding-agent/test/daemon-client.test.ts
index 11deb1a47a..55311f5369 100644
--- a/packages/coding-agent/test/daemon-client.test.ts
+++ b/packages/coding-agent/test/daemon-client.test.ts
@@ -589,6 +589,75 @@ describe("DaemonClient", () => {
client.close();
});
+ it("accepts an errored task state on the saved-session list wire", async () => {
+ const client = new DaemonClient("/tmp/prime-agent.sock");
+
+ const connect = client.connect();
+ expect(netMock.sockets).toHaveLength(1);
+ const socket = netMock.sockets[0]!;
+ socket.emit("connect");
+ await connect;
+ emitHello(socket);
+
+ let discoveredStatus: unknown;
+ const response = client.request(
+ { type: "list_saved_sessions", activeSessionId: "active-1", scope: "current" },
+ 30000,
+ {
+ onProgress: (message) => {
+ if (message.type === "session_list_item") {
+ discoveredStatus = message.session.agentStatus;
+ }
+ },
+ },
+ );
+ expect(socket.writes).toHaveLength(1);
+ const envelope = JSON.parse(socket.writes[0]!.trim()) as { id?: string };
+
+ socket.emit(
+ "data",
+ `${JSON.stringify({
+ id: envelope.id,
+ type: "session_list_item",
+ command: "list_saved_sessions",
+ activeSessionId: "active-1",
+ session: {
+ path: "/tmp/session-errored.jsonl",
+ id: "session-errored",
+ cwd: "/tmp",
+ created: "2026-01-01T00:00:00.000Z",
+ modified: "2026-01-02T00:00:00.000Z",
+ messageCount: 2,
+ firstMessage: "hello",
+ allMessagesText: "hello",
+ agentStatus: {
+ summary: "Model request failed: 400 enable_thinking not supported",
+ taskState: "error",
+ basedOnMessageCount: 2,
+ },
+ },
+ })}\n`,
+ );
+ socket.emit(
+ "data",
+ `${JSON.stringify({
+ id: envelope.id,
+ type: "response",
+ command: "list_saved_sessions",
+ success: true,
+ data: { sessions: [] },
+ })}\n`,
+ );
+
+ await expect(response).resolves.toMatchObject({ success: true });
+ expect(discoveredStatus).toEqual({
+ summary: "Model request failed: 400 enable_thinking not supported",
+ taskState: "error",
+ basedOnMessageCount: 2,
+ });
+ client.close();
+ });
+
it("serializes per-session config for create commands", async () => {
const client = new DaemonClient("/tmp/prime-agent.sock");
diff --git a/packages/coding-agent/test/daemon-session-summarizer-lifecycle.test.ts b/packages/coding-agent/test/daemon-session-summarizer-lifecycle.test.ts
index f3213ea25a..13df107d91 100644
--- a/packages/coding-agent/test/daemon-session-summarizer-lifecycle.test.ts
+++ b/packages/coding-agent/test/daemon-session-summarizer-lifecycle.test.ts
@@ -216,4 +216,39 @@ describe("DaemonSessionSummarizer lifecycle", () => {
summarizer.seed(state);
expect(state.summaryState).toEqual(persisted);
});
+
+ test("a session that errored before any work settles from the transcript, never the classifier", async () => {
+ vi.useFakeTimers();
+ // Every model request errored (e.g. provider 400s): no work was done, so a
+ // completed verdict would be fabricated. The real last event is the error.
+ const generate = vi.fn();
+ const onStatusChanged = vi.fn();
+ const summarizer = new DaemonSessionSummarizer(() => [], onStatusChanged, generate);
+ const state = makeState({ working: false });
+ Object.assign(state.runtime.session, {
+ messages: [
+ { role: "user", content: "write a session marker and verify the file content" },
+ { role: "assistant", content: [], stopReason: "error", errorMessage: "400 enable_thinking not supported" },
+ ],
+ });
+
+ summarizer.notifyActivity(state);
+ await vi.advanceTimersByTimeAsync(SETTLE_MS + 500);
+
+ // Zero work done: the classifier must not be paid to invent a verdict.
+ expect(generate).not.toHaveBeenCalled();
+ expect(state.summaryState).toMatchObject({
+ summary: "Model request failed: 400 enable_thinking not supported",
+ taskState: "error",
+ basedOnMessageCount: 2,
+ });
+ expect((state as unknown as { appendedStatuses: unknown[] }).appendedStatuses).toEqual([
+ {
+ summary: "Model request failed: 400 enable_thinking not supported",
+ taskState: "error",
+ basedOnMessageCount: 2,
+ },
+ ]);
+ expect(onStatusChanged).toHaveBeenCalled();
+ });
});
diff --git a/packages/coding-agent/test/daemon-session-summarizer.test.ts b/packages/coding-agent/test/daemon-session-summarizer.test.ts
index 309d8956a1..405ff25118 100644
--- a/packages/coding-agent/test/daemon-session-summarizer.test.ts
+++ b/packages/coding-agent/test/daemon-session-summarizer.test.ts
@@ -4,6 +4,7 @@ import type { AgentStatus } from "../src/core/session-manager.js";
import { SettingsManager } from "../src/core/settings-manager.js";
import type { ActiveSessionState } from "../src/modes/daemon/active-session-state.js";
import {
+ type AgentStatusResult,
buildStatusContext,
DaemonSessionSummarizer,
parseAgentStatusResponse,
@@ -18,6 +19,16 @@ function assistantMessage(text: string, tools: string[] = []): AgentMessage {
return { role: "assistant", content, timestamp: 0 } as unknown as AgentMessage;
}
+function assistantError(errorMessage?: string): AgentMessage {
+ return {
+ role: "assistant",
+ content: [],
+ stopReason: "error",
+ ...(errorMessage !== undefined ? { errorMessage } : {}),
+ timestamp: 0,
+ } as unknown as AgentMessage;
+}
+
describe("daemon session summarizer", () => {
describe("parseAgentStatusResponse", () => {
test("parses recap and completion verdict for an idle session", () => {
@@ -326,4 +337,179 @@ describe("daemon session summarizer", () => {
expect(onStatusChanged).not.toHaveBeenCalled();
});
});
+
+ describe("errored turn verdicts", () => {
+ const providerError = "400 enable_thinking is not supported for this model";
+
+ function erroredTranscript(errorMessage?: string): AgentMessage[] {
+ return [userMessage("write a session marker and verify the file content"), assistantError(errorMessage)];
+ }
+
+ // A journal-backed state: getLatestAgentStatus returns what appends recorded,
+ // falling back to a verdict that predates this run (e.g. written before a
+ // daemon restart).
+ function erroredState(options: {
+ messages: AgentMessage[];
+ isSessionActive?: boolean;
+ persistedStatus?: AgentStatus;
+ }): {
+ state: ActiveSessionState;
+ appended: AgentStatus[];
+ } {
+ const appended: AgentStatus[] = [];
+ const state = {
+ activeSessionId: "active-error",
+ summaryState: undefined,
+ runtime: {
+ session: {
+ isSessionActive: options.isSessionActive ?? false,
+ messages: options.messages,
+ modelRegistry: {},
+ settingsManager: SettingsManager.inMemory(),
+ state: { streamingMessage: undefined },
+ sessionManager: {
+ appendAgentStatus: (status: AgentStatus) => {
+ appended.push(status);
+ },
+ getLatestAgentStatus: () => appended.at(-1) ?? options.persistedStatus,
+ getLeafId: () => null,
+ },
+ },
+ },
+ } as unknown as ActiveSessionState;
+ return { state, appended };
+ }
+
+ async function runSummarize(
+ state: ActiveSessionState,
+ generate: () => Promise<AgentStatusResult | undefined>,
+ ): Promise<ReturnType<typeof vi.fn>> {
+ const onStatusChanged = vi.fn();
+ const summarizer = new DaemonSessionSummarizer(() => [state], onStatusChanged, generate);
+ await (summarizer as unknown as { summarize(state: ActiveSessionState): Promise<void> }).summarize(state);
+ return onStatusChanged;
+ }
+
+ test("an errored session persists the real error as its verdict, never a completed one", async () => {
+ const { state, appended } = erroredState({ messages: erroredTranscript(providerError) });
+ // The classifier would only see the task text and invent completed work.
+ const generate = vi.fn(async () => ({
+ summary: "Writing session marker and verifying file content",
+ taskState: "completed" as const,
+ }));
+
+ const onStatusChanged = await runSummarize(state, generate);
+
+ expect(generate).not.toHaveBeenCalled();
+ expect(state.summaryState).toEqual({
+ summary: `Model request failed: ${providerError}`,
+ taskState: "error",
+ basedOnMessageCount: 2,
+ });
+ expect(appended).toEqual([
+ { summary: `Model request failed: ${providerError}`, taskState: "error", basedOnMessageCount: 2 },
+ ]);
+ expect(onStatusChanged).toHaveBeenCalledOnce();
+ });
+
+ test("repeated sweeps over an unchanged errored transcript append nothing more", async () => {
+ const { state, appended } = erroredState({ messages: erroredTranscript(providerError) });
+ const summarizer = new DaemonSessionSummarizer(() => [state], undefined, vi.fn());
+ const internal = summarizer as unknown as { summarize(state: ActiveSessionState): Promise<void> };
+
+ await internal.summarize(state);
+ await internal.summarize(state);
+ await internal.summarize(state);
+
+ expect(appended).toHaveLength(1);
+ });
+
+ test("a restart-seeded completed verdict for an errored transcript is repaired by the sweep", async () => {
+ // Pre-fix code fabricated a completed verdict for the errored transcript
+ // and the journal kept it; a daemon restart seeds it back before the
+ // first sweep. The unchanged-content fast path must not skip the repair.
+ const persisted: AgentStatus = {
+ summary: "Writing session marker and verifying file content",
+ taskState: "completed",
+ basedOnMessageCount: 2,
+ };
+ const { state, appended } = erroredState({
+ messages: erroredTranscript(providerError),
+ persistedStatus: persisted,
+ });
+ const generate = vi.fn(async () => ({ summary: "unreached", taskState: "completed" as const }));
+ const summarizer = new DaemonSessionSummarizer(() => [state], undefined, generate);
+ // Daemon-mode bind() restores the persisted verdict on restart.
+ summarizer.seed(state);
+ const internal = summarizer as unknown as { summarize(state: ActiveSessionState): Promise<void> };
+
+ await internal.summarize(state);
+
+ expect(generate).not.toHaveBeenCalled();
+ expect(state.summaryState).toEqual({
+ summary: `Model request failed: ${providerError}`,
+ taskState: "error",
+ basedOnMessageCount: 2,
+ });
+ expect(appended).toEqual([
+ { summary: `Model request failed: ${providerError}`, taskState: "error", basedOnMessageCount: 2 },
+ ]);
+
+ // Repaired once: later sweeps append nothing more.
+ await internal.summarize(state);
+ await internal.summarize(state);
+ expect(appended).toHaveLength(1);
+ });
+
+ test("an errored turn without an error message still settles to the error verdict", async () => {
+ const { state, appended } = erroredState({ messages: erroredTranscript(undefined) });
+
+ await runSummarize(state, async () => undefined);
+
+ expect(state.summaryState).toMatchObject({ summary: "Model request failed", taskState: "error" });
+ expect(appended).toHaveLength(1);
+ });
+
+ test("a successful final answer after an error earns a normal model verdict", async () => {
+ const { state, appended } = erroredState({ messages: erroredTranscript(providerError) });
+ const generate = vi.fn(async () => ({ summary: "Wrote the marker file", taskState: "completed" as const }));
+ const summarizer = new DaemonSessionSummarizer(() => [state], undefined, generate);
+ const internal = summarizer as unknown as { summarize(state: ActiveSessionState): Promise<void> };
+
+ await internal.summarize(state); // error verdict settles first
+ expect(state.summaryState?.taskState).toBe("error");
+
+ // The user retries and the turn succeeds: the classifier may judge again.
+ (state.runtime.session as unknown as { messages: AgentMessage[] }).messages = [
+ ...erroredTranscript(providerError),
+ userMessage("retry the marker task"),
+ assistantMessage("Wrote .session-marker and verified its content"),
+ ];
+ await internal.summarize(state);
+
+ expect(generate).toHaveBeenCalledTimes(1);
+ expect(state.summaryState).toMatchObject({ summary: "Wrote the marker file", taskState: "completed" });
+ expect(appended.at(-1)).toMatchObject({ taskState: "completed" });
+ });
+
+ test("a working session is never error-settled, even with an errored trailing assistant message", async () => {
+ // While working (e.g. mid-retry) the model refresh keeps recapping;
+ // verdicts settle only when the session goes idle.
+ const { state, appended } = erroredState({
+ messages: erroredTranscript(providerError),
+ isSessionActive: true,
+ });
+ const generate = vi.fn(async () => ({ summary: "Retrying the failed request" }));
+
+ await runSummarize(state, generate);
+
+ expect(generate).toHaveBeenCalledOnce();
+ expect(state.summaryState).toEqual({
+ summary: "Retrying the failed request",
+ taskState: undefined,
+ basedOnMessageCount: 2,
+ });
+ expect(appended).toHaveLength(0);
+ });
+ });
});