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.mdnew file mode 100644index 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.tsindex 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.tsindex 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.tsindex 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?: Unifiif (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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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);+ });+ });});