fix: preserve concurrent supervisor updates

Author: pallyoung

packages/server/src/__tests__/supervisor-manager.test.ts

@@ -798,6 +798,77 @@ describe("SupervisorManager cycle triggers", () => {
     expect(deps.supervisorRepo.findById(supervisor.id)?.objective).toBe("Initial objective");
   });
 
+  it("preserves a pause request while a target reset update is still persisting", async () => {
+    const supervisor = await manager.create({
+      sessionId: "sess-objective-reset-pause-race",
+      workspaceId: "ws-1",
+      objective: "Initial objective",
+      evaluatorProviderId: "codex",
+    });
+
+    let releaseReset: (() => void) | null = null;
+    deps.targetStore.resetTargetFiles.mockImplementation(
+      async () =>
+        await new Promise<void>((resolve) => {
+          releaseReset = resolve;
+        })
+    );
+
+    const updatedPromise = manager.update(supervisor.id, {
+      objective: "New objective",
+    });
+
+    await waitFor(() => {
+      expect(deps.targetStore.resetTargetFiles).toHaveBeenCalledTimes(1);
+      expect(releaseReset).not.toBeNull();
+    });
+
+    const paused = await manager.pause(supervisor.id);
+    releaseReset?.();
+
+    const updated = await updatedPromise;
+
+    expect(paused.state).toBe("paused");
+    expect(updated.state).toBe("paused");
+    expect(updated.objective).toBe("New objective");
+    expect(manager.get(supervisor.id)?.state).toBe("paused");
+  });
+
+  it("does not resurrect a supervisor deleted during target reset persistence", async () => {
+    const supervisor = await manager.create({
+      sessionId: "sess-objective-reset-delete-race",
+      workspaceId: "ws-1",
+      objective: "Initial objective",
+      evaluatorProviderId: "codex",
+    });
+
+    let releaseReset: (() => void) | null = null;
+    deps.targetStore.resetTargetFiles.mockImplementation(
+      async () =>
+        await new Promise<void>((resolve) => {
+          releaseReset = resolve;
+        })
+    );
+
+    const updatedPromise = manager.update(supervisor.id, {
+      objective: "New objective",
+    });
+
+    await waitFor(() => {
+      expect(deps.targetStore.resetTargetFiles).toHaveBeenCalledTimes(1);
+      expect(releaseReset).not.toBeNull();
+    });
+
+    await manager.delete(supervisor.id);
+    releaseReset?.();
+
+    await expect(updatedPromise).rejects.toMatchObject({
+      code: "supervisor_not_found",
+    });
+    expect(manager.get(supervisor.id)).toBeUndefined();
+    expect(deps.supervisorRepo.findById(supervisor.id)).toBeUndefined();
+  });
+
   it("preserves a pause request while an objective change abort is in flight", async () => {
     const supervisor = await manager.create({
       sessionId: "sess-objective-pause-race",

packages/server/src/supervisor/manager.ts

@@ -449,7 +449,7 @@ export class SupervisorManager {
     };
 
     const rollbackPatch = this.toSupervisorUpdatePatch(current, Date.now());
-    let updated = this.attachCycles(this.deps.supervisorRepo.update(id, nextPatch));
+    this.deps.supervisorRepo.update(id, nextPatch);
 
     if (objectiveChanged) {
       try {
@@ -473,7 +473,11 @@ export class SupervisorManager {
       }
     }
 
-    const enriched = await this.attachTargetState(updated, workspace.path);
+    const enriched = await this.hydratePersistedSupervisor(id, workspace.path);
+    if (!enriched) {
+      await this.markTargetCancelledIfActive(workspace.path, current).catch(() => {});
+      throw this.supervisorNotFoundError(id);
+    }
 
     this.storeSnapshot(enriched);
     this.broadcastState(enriched, "updated");
@@ -1320,6 +1324,32 @@ export class SupervisorManager {
     return await this.attachTargetState(supervisor, workspace.path);
   }
 
+  private async hydratePersistedSupervisor(
+    supervisorId: string,
+    workspacePath: string
+  ): Promise<Supervisor | null> {
+    const persisted = this.deps.supervisorRepo.findById(supervisorId);
+    if (!persisted) {
+      return null;
+    }
+
+    const hydrated = await this.attachTargetState(this.attachCycles(persisted), workspacePath);
+    const latest = this.deps.supervisorRepo.findById(supervisorId);
+    if (!latest) {
+      return null;
+    }
+
+    if (latest.targetId !== hydrated.targetId) {
+      return await this.attachTargetState(this.attachCycles(latest), workspacePath);
+    }
+
+    return {
+      ...this.attachCycles(latest),
+      currentTargetMemory: hydrated.currentTargetMemory,
+      recentTargetCycles: hydrated.recentTargetCycles,
+    };
+  }
+
   private withCurrentTargetState(supervisor: Supervisor): Supervisor {
     const current = this.supervisors.get(supervisor.id);
     if (!current || current.targetId !== supervisor.targetId) {
@@ -1525,13 +1555,17 @@ export class SupervisorManager {
     this.inFlightCompletions.delete(supervisorId);
   }
 
+  private supervisorNotFoundError(id: string): { code: "supervisor_not_found"; message: string } {
+    return {
+      code: "supervisor_not_found",
+      message: `Supervisor ${id} not found`,
+    };
+  }
+
   private requireSupervisor(id: string): Supervisor {
     const supervisor = this.supervisors.get(id);
     if (!supervisor) {
-      throw {
-        code: "supervisor_not_found",
-        message: `Supervisor ${id} not found`,
-      };
+      throw this.supervisorNotFoundError(id);
     }
     return supervisor;
   }