Skip to content

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

Rust

fix(coding-agent): revive tombstoned workers on retry (#836)

Sebastian Müller0859d06a5da2
diff --git a/packages/coding-agent/src/modes/daemon/daemon-supervisor.ts b/packages/coding-agent/src/modes/daemon/daemon-supervisor.ts
index de7210c79d..bc74217cae 100644
--- a/packages/coding-agent/src/modes/daemon/daemon-supervisor.ts
+++ b/packages/coding-agent/src/modes/daemon/daemon-supervisor.ts
@@ -1549,6 +1549,8 @@ export class DaemonSupervisor {
const worker = direct ?? (await this.findWorkerForClient(client, command.activeSessionId)).worker;
this.assertWorkerAccessibleToClient(client, worker, command.activeSessionId);
worker.intentionalStop = false;
+ worker.descriptor.stopRequestedAt = undefined;
+ worker.descriptor.archiveOnStop = undefined;
worker.descriptor.lifecycle = "recovering";
worker.descriptor.consecutiveFailures = 0;
this.persistWorker(worker);
diff --git a/packages/coding-agent/test/daemon-supervisor-monitor.test.ts b/packages/coding-agent/test/daemon-supervisor-monitor.test.ts
index c05afc018b..2b74a15eb8 100644
--- a/packages/coding-agent/test/daemon-supervisor-monitor.test.ts
+++ b/packages/coding-agent/test/daemon-supervisor-monitor.test.ts
@@ -1248,6 +1248,69 @@ describe("daemon worker supervisor monitoring", () => {
},
);
+ it("clears an intentional-stop tombstone before retrying a worker", async () => {
+ type RetryWorker = {
+ descriptor: {
+ workerId: string;
+ rootActiveSessionId: string;
+ rootSessionId: string;
+ lifecycle: "ready" | "recovering";
+ consecutiveFailures: number;
+ stopRequestedAt?: string;
+ archiveOnStop?: boolean;
+ };
+ intentionalStop: boolean;
+ summaries: Map<string, SessionSummary>;
+ };
+ type RetryHarness = {
+ workers: Map<string, RetryWorker>;
+ persistWorker: ReturnType<typeof vi.fn>;
+ recoverWorker: ReturnType<typeof vi.fn>;
+ handleCommand(
+ client: DaemonSocketClient,
+ command: { type: "retry_worker"; activeSessionId: string },
+ ): Promise<unknown>;
+ };
+ const worker: RetryWorker = {
+ descriptor: {
+ workerId: "worker-1",
+ rootActiveSessionId: "active-1",
+ rootSessionId: "session-1",
+ lifecycle: "ready",
+ consecutiveFailures: 2,
+ stopRequestedAt: new Date().toISOString(),
+ archiveOnStop: true,
+ },
+ intentionalStop: true,
+ summaries: new Map(),
+ };
+ const persistWorker = vi.fn(() => {
+ expect(worker.intentionalStop).toBe(false);
+ expect(worker.descriptor.stopRequestedAt).toBeUndefined();
+ expect(worker.descriptor.archiveOnStop).toBeUndefined();
+ expect(worker.descriptor.lifecycle).toBe("recovering");
+ expect(worker.descriptor.consecutiveFailures).toBe(0);
+ });
+ const recoverWorker = vi.fn(async () => {
+ worker.descriptor.lifecycle = "ready";
+ });
+ const supervisor = Object.assign(Object.create(DaemonSupervisor.prototype), {
+ workers: new Map([[worker.descriptor.workerId, worker]]),
+ persistWorker,
+ recoverWorker,
+ assertWorkerAccessibleToClient: vi.fn(),
+ }) as RetryHarness;
+
+ await supervisor.handleCommand({} as DaemonSocketClient, {
+ type: "retry_worker",
+ activeSessionId: worker.descriptor.rootSessionId,
+ });
+
+ expect(persistWorker).toHaveBeenCalledOnce();
+ expect(recoverWorker).toHaveBeenCalledWith(worker);
+ expect(persistWorker.mock.invocationCallOrder[0]).toBeLessThan(recoverWorker.mock.invocationCallOrder[0]!);
+ });
+
it("cancels an in-flight recovery after an intentional stop tombstone", async () => {
vi.useFakeTimers();
type RecoveryWorker = {