Skip to content

Commit d736e5b

Browse files
fix(server): post-turn remote refresh survives overlap and divergence failure
A failed ahead/behind read no longer skips the PR lookup, overlapping divergence-only refreshes catch up after the in-flight one, and the warning log stays to path length and error tag. Co-authored-by: Cursor <[email protected]>
1 parent cbaa176 commit d736e5b

2 files changed

Lines changed: 128 additions & 10 deletions

File tree

‎apps/server/src/orchestration-v2/RunFinalizationService.test.ts‎

Lines changed: 106 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,7 @@
11
import { assert, it } from "@effect/vitest";
22
import {
33
CheckpointScopeId,
4+
GitManagerError,
45
RunId,
56
ThreadId,
67
type OrchestrationV2ThreadShell,
@@ -310,3 +311,108 @@ it.effect("replaces a still-running PR lookup when a newer turn finishes", () =>
310311
assert.strictEqual(lookups, 2);
311312
}).pipe(Effect.provide(layer));
312313
});
314+
315+
it.effect("still looks up a PR when the divergence refresh fails", () => {
316+
const threadId = ThreadId.make("thread-divergence-fail");
317+
const runId = RunId.make("completed-run");
318+
const lookedUp = Deferred.makeUnsafe<void>();
319+
const layer = RunFinalization.layerObserver.pipe(
320+
Layer.provide(
321+
Layer.mergeAll(
322+
Layer.mock(WorkspaceEntries.WorkspaceEntries)({ refresh: () => Effect.void }),
323+
Layer.mock(PullRequestService.PullRequestService)({
324+
refreshAfterTurn: () => Effect.void,
325+
}),
326+
Layer.mock(VcsStatusBroadcaster.VcsStatusBroadcaster)({
327+
refreshLocalStatus: () =>
328+
Effect.succeed({
329+
isRepo: true,
330+
hasPrimaryRemote: true,
331+
isDefaultRef: false,
332+
refName: "feature",
333+
hasWorkingTreeChanges: false,
334+
workingTree: { files: [], insertions: 0, deletions: 0 },
335+
}),
336+
refreshDivergence: () =>
337+
Effect.fail(
338+
new GitManagerError({
339+
operation: "refreshDivergence",
340+
cwd: "/repo",
341+
detail: "transient remote read failed",
342+
}),
343+
),
344+
refreshPullRequestStatus: () =>
345+
Deferred.succeed(lookedUp, undefined).pipe(Effect.as(null)),
346+
}),
347+
Layer.mock(ProjectionStore.ProjectionStoreV2)({
348+
getThreadShell: () =>
349+
Effect.succeed({
350+
id: threadId,
351+
branch: "feature",
352+
activeRunId: null,
353+
} as OrchestrationV2ThreadShell),
354+
}),
355+
),
356+
),
357+
);
358+
return Effect.gen(function* () {
359+
const observer = yield* RunFinalization.RunFinalizationObserver;
360+
yield* observer.refresh({ cwd: "/repo", threadId, runId });
361+
yield* Deferred.await(lookedUp);
362+
}).pipe(Effect.provide(layer));
363+
});
364+
365+
it.effect("runs a second divergence-only refresh after an overlapping one finishes", () => {
366+
const threadId = ThreadId.make("thread-divergence-overlap");
367+
const runId = RunId.make("completed-run");
368+
const firstStarted = Deferred.makeUnsafe<void>();
369+
const releaseFirst = Deferred.makeUnsafe<void>();
370+
const secondFinished = Deferred.makeUnsafe<void>();
371+
let divergenceRefreshes = 0;
372+
const layer = RunFinalization.layerObserver.pipe(
373+
Layer.provide(
374+
Layer.mergeAll(
375+
Layer.mock(WorkspaceEntries.WorkspaceEntries)({ refresh: () => Effect.void }),
376+
Layer.mock(PullRequestService.PullRequestService)({
377+
refreshAfterTurn: () => Effect.void,
378+
}),
379+
Layer.mock(VcsStatusBroadcaster.VcsStatusBroadcaster)({
380+
refreshLocalStatus: () =>
381+
Effect.succeed({
382+
isRepo: true,
383+
hasPrimaryRemote: true,
384+
isDefaultRef: true,
385+
refName: "main",
386+
hasWorkingTreeChanges: false,
387+
workingTree: { files: [], insertions: 0, deletions: 0 },
388+
}),
389+
refreshDivergence: () =>
390+
Effect.suspend(() => {
391+
divergenceRefreshes += 1;
392+
if (divergenceRefreshes === 1) {
393+
return Deferred.succeed(firstStarted, undefined).pipe(
394+
Effect.andThen(Deferred.await(releaseFirst)),
395+
Effect.as(null),
396+
);
397+
}
398+
return Deferred.succeed(secondFinished, undefined).pipe(Effect.as(null));
399+
}),
400+
refreshPullRequestStatus: () =>
401+
Effect.die("default-branch finalization must not look up a PR"),
402+
}),
403+
Layer.mock(ProjectionStore.ProjectionStoreV2)({
404+
getThreadShell: () => Effect.die("default branch skips the thread shell"),
405+
}),
406+
),
407+
),
408+
);
409+
return Effect.gen(function* () {
410+
const observer = yield* RunFinalization.RunFinalizationObserver;
411+
yield* observer.refresh({ cwd: "/repo", threadId, runId });
412+
yield* Deferred.await(firstStarted);
413+
yield* observer.refresh({ cwd: "/repo", threadId, runId });
414+
yield* Deferred.succeed(releaseFirst, undefined);
415+
yield* Deferred.await(secondFinished);
416+
assert.strictEqual(divergenceRefreshes, 2);
417+
}).pipe(Effect.provide(layer));
418+
});

‎apps/server/src/orchestration-v2/RunFinalizationService.ts‎

Lines changed: 22 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -99,6 +99,8 @@ export const layerObserver = Layer.effect(
9999
const pullRequests = yield* PullRequestService.PullRequestService;
100100
const pullRequestLookups = yield* FiberMap.make<string>();
101101
const divergenceRefreshes = yield* FiberMap.make<string>();
102+
// A second divergence-only finalization must not vanish behind onlyIfMissing when HEAD moved.
103+
const divergenceRefreshesWanted = new Set<string>();
102104
return {
103105
refreshAfterTurn: pullRequests.refreshAfterTurn,
104106
refresh: Effect.fn("RunFinalizationService.refresh")(
@@ -116,23 +118,33 @@ export const layerObserver = Layer.effect(
116118
// runs. That CLI can take minutes, so the next turn must not wait for it. A newer
117119
// turn's lookup replaces a running one, but divergence alone must neither cancel a
118120
// lookup nor be skipped for one.
119-
const divergence = vcsStatus.refreshDivergence(cwd);
120-
const logFailure = (error: { readonly message: string }) =>
121+
const logFailure = (error: { readonly _tag: string }) =>
121122
Effect.logWarning("failed to refresh remote status after run completion", {
122123
threadId,
123-
cwd,
124-
detail: error.message,
124+
cwdLength: cwd.length,
125+
errorTag: error._tag,
125126
});
126-
yield* shouldLookUpPullRequest
127-
? divergence.pipe(
127+
if (shouldLookUpPullRequest) {
128+
// A failed divergence must not skip discovering a PR the forge would still find.
129+
yield* vcsStatus
130+
.refreshDivergence(cwd)
131+
.pipe(
132+
Effect.catch(logFailure),
128133
Effect.andThen(vcsStatus.refreshPullRequestStatus(cwd)),
129134
Effect.catch(logFailure),
130135
FiberMap.run(pullRequestLookups, cwd),
131-
)
132-
: divergence.pipe(
133-
Effect.catch(logFailure),
134-
FiberMap.run(divergenceRefreshes, cwd, { onlyIfMissing: true }),
135136
);
137+
return;
138+
}
139+
divergenceRefreshesWanted.add(cwd);
140+
yield* Effect.suspend(() => {
141+
divergenceRefreshesWanted.delete(cwd);
142+
return vcsStatus.refreshDivergence(cwd);
143+
}).pipe(
144+
Effect.catch(logFailure),
145+
Effect.repeat({ while: () => divergenceRefreshesWanted.has(cwd) }),
146+
FiberMap.run(divergenceRefreshes, cwd, { onlyIfMissing: true }),
147+
);
136148
},
137149
(effect, { cwd }) =>
138150
effect.pipe(Effect.mapError((cause) => new RunFinalizationRefreshError({ cwd, cause }))),

0 commit comments

Comments
 (0)