@devries-cameron20 / t3code-1 / commits / a35fd81174
Fork 0

The best way to control Claude Code, Codex and more from any computer or phone

fix(server): settlement sweep reads quiet open pull requests every 5 minutes (#34953)

Julius Marminge committed Nov 13, 2026 at 21:28 UTC a35fd811749c2b65d917652cbdb90b28d65b2e0c
3 files changed +185 -7
apps/server/src/orchestration-v2/PullRequestSyncReactor.ts
+2 -2
@@ -42,8 +42,8 @@ const SLOW_SYNC_INTERVAL_MS = 15 * 60 * 1_000;
42 // Every server polls every open linked pull request, and most of them sit untouched for days.
43 // One nobody has updated for QUIET_AFTER_MS is read on the quiet cadence instead of each sweep;
44 // requested refreshes, watches and a host CLI's merge command still read it at once.
45 -const QUIET_AFTER_MS = 30 * 60 * 1_000;
46 -const QUIET_SYNC_INTERVAL_MS = 5 * 60 * 1_000;
45 +export const QUIET_AFTER_MS = 30 * 60 * 1_000;
46 +export const QUIET_SYNC_INTERVAL_MS = 5 * 60 * 1_000;
47 // A pull request closed this long ago is rarely reopened, so the sweep stops reading it, as it
48 // does merged ones. A reader that sees it open, or a requested refresh, still reads it at once.
49 const CLOSED_FINAL_AFTER_MS = 24 * 60 * 60 * 1_000;
apps/server/src/orchestration-v2/ThreadSettlementService.test.ts
+144 -4
@@ -602,6 +602,7 @@ const makeHarness = Effect.fn("makeThreadSettlementHarness")(function* (options:
602 const settingsReadCount = yield* Ref.make(0);
603 const settingsChanges = yield* PubSub.unbounded<ContractServerSettings>();
604 const mergedPullRequests = yield* PubSub.unbounded<PullRequestService.PullRequestMergeEvent>();
605 + const pullRequestRefreshes = yield* PubSub.unbounded<number>();
606 const commands = yield* Ref.make<ReadonlyArray<AutoSettleCommand>>([]);
607 const branchCalls = yield* Ref.make<
608 ReadonlyArray<{ readonly cwd: string; readonly branch: string }>
@@ -737,6 +738,7 @@ const makeHarness = Effect.fn("makeThreadSettlementHarness")(function* (options:
738 subscribeMerges: PubSub.subscribe(mergedPullRequests).pipe(
739 Effect.map((subscription) => Stream.fromSubscription(subscription)),
740 ),
741 + subscribeRefreshes: Stream.fromPubSub(pullRequestRefreshes),
742 }),
743 Layer.succeed(ServerSettings.ServerSettingsService, serverSettings),
744 Layer.succeed(ServerActivation.ServerActivation, Deferred.await(activation)),
@@ -775,6 +777,7 @@ const makeHarness = Effect.fn("makeThreadSettlementHarness")(function* (options:
777 observedEvents,
778 publishEvent: (event: OrchestrationV2DomainEvent) => PubSub.publish(domainEvents, event),
779 updateSettings,
780 + publishRefresh: PubSub.publish(pullRequestRefreshes, 1),
781 publishMerge: PubSub.publish(mergedPullRequests, {
782 projectId: PROJECT_ID,
783 repository: "owner/repository",
@@ -1623,20 +1626,40 @@ describe("ThreadSettlementServiceV2 worker", () => {
1626 }),
1627 );
1628
1626 - it.effect("settles an unlinked branch thread its agent merged from a shell, past the cache", () =>
1629 + it.effect.each([
1630 + { kind: "an unlinked", linked: false },
1631 + { kind: "a quiet linked", linked: true },
1632 + ])("settles $kind branch thread its agent merged from a shell, past the cache", ({ linked }) =>
1633 Effect.gen(function* () {
1634 yield* TestClock.setTime(Date.parse(NOW));
1629 - const settled = yield* Deferred.make<void>();
1635 const thread = makeThread("shell-merged", {
1636 branch: "saved-feature",
1637 latestUserMessageAt: DateTime.makeUnsafe("2026-08-27T00:00:00.000Z"),
1638 + ...(linked
1639 + ? {
1640 + branchPullRequest: {
1641 + projectId: PROJECT_ID,
1642 + repository: "owner/repository",
1643 + number: 42,
1644 + url: "https://example.test/owner/repository/pull/42",
1645 + },
1646 + }
1647 + : {}),
1648 });
1649 const fixture = yield* makeHarness({
1650 snapshot: makeSnapshot([thread]),
1651 // The host already merged it; only a fresh read sees that past the cached open lookup.
1652 branchPullRequest: (_input, lookupOptions) =>
1653 Effect.succeed(makeBranchPullRequest(lookupOptions?.refresh ? "merged" : "open")),
1639 - onDispatch: () => Deferred.succeed(settled, undefined),
1654 + pullRequestSummary: (input, readOptions) =>
1655 + Effect.succeed({
1656 + ...makePullRequestSummary({
1657 + ...input,
1658 + state: readOptions?.bypassCache ? "merged" : "open",
1659 + updatedAt: DateTime.formatIso(DateTime.makeUnsafe(Date.parse(NOW) - 2 * DAY_MS)),
1660 + }),
1661 + ...(readOptions?.bypassCache ? { mergedAt: NOW } : {}),
1662 + }),
1663 });
1664 const at = DateTime.makeUnsafe(NOW);
1665 const runId = RunId.make("run:shell-merged");
@@ -1681,7 +1704,8 @@ describe("ThreadSettlementServiceV2 worker", () => {
1704 input: "gh pr merge 42 --squash",
1705 },
1706 });
1684 - yield* Deferred.await(settled);
1707 + yield* Queue.take(fixture.snapshotReads);
1708 + yield* reactor.drain;
1709 assert.deepStrictEqual(
1710 (yield* Ref.get(fixture.commands)).map((command) => command.threadId),
1711 [thread.id],
@@ -1728,6 +1752,122 @@ describe("ThreadSettlementServiceV2 worker", () => {
1752 }),
1753 );
1754
1755 + it.effect("reads a quiet open branch pull request every 5 minutes", () =>
1756 + Effect.gen(function* () {
1757 + yield* TestClock.setTime(Date.parse(NOW));
1758 + const fixture = yield* makeHarness({
1759 + snapshot: makeSnapshot([
1760 + makeThread("active-branch", {
1761 + branch: "feature",
1762 + latestUserMessageAt: DateTime.makeUnsafe("2026-08-27T00:00:00.000Z"),
1763 + branchPullRequest: {
1764 + projectId: PROJECT_ID,
1765 + repository: "owner/repository",
1766 + number: 42,
1767 + url: "https://example.test/owner/repository/pull/42",
1768 + },
1769 + }),
1770 + ]),
1771 + pullRequestSummary: (input) =>
1772 + Effect.succeed(
1773 + makePullRequestSummary({
1774 + ...input,
1775 + state: "open",
1776 + updatedAt: DateTime.formatIso(DateTime.makeUnsafe(Date.parse(NOW) - 2 * DAY_MS)),
1777 + }),
1778 + ),
1779 + });
1780 +
1781 + yield* Effect.gen(function* () {
1782 + const reactor = yield* ThreadSettlementService.ThreadSettlementServiceV2;
1783 + yield* startHarness(reactor, fixture.activation, fixture.snapshotReads);
1784 + assert.strictEqual((yield* Ref.get(fixture.summaryCalls)).length, 1);
1785 +
1786 + for (let minute = 0; minute < 4; minute++) {
1787 + yield* TestClock.adjust("1 minute");
1788 + yield* Queue.take(fixture.snapshotReads);
1789 + yield* reactor.drain;
1790 + }
1791 + assert.strictEqual((yield* Ref.get(fixture.summaryCalls)).length, 1);
1792 +
1793 + yield* TestClock.adjust("1 minute");
1794 + yield* Queue.take(fixture.snapshotReads);
1795 + yield* reactor.drain;
1796 + assert.strictEqual((yield* Ref.get(fixture.summaryCalls)).length, 2);
1797 +
1798 + // An app merge the host completes later sends only a refresh; reads stay on the minute
1799 + // cadence while the pull request still reads open.
1800 + yield* fixture.publishRefresh;
1801 + for (const expected of [3, 4]) {
1802 + yield* TestClock.adjust("1 minute");
1803 + yield* Queue.take(fixture.snapshotReads);
1804 + yield* reactor.drain;
1805 + assert.strictEqual((yield* Ref.get(fixture.summaryCalls)).length, expected);
1806 + }
1807 + }).pipe(Effect.provide(fixture.layer));
1808 + }),
1809 + );
1810 +
1811 + it.effect.each([
1812 + { when: "after", mergeDuringRead: false },
1813 + { when: "during", mergeDuringRead: true },
1814 + ])(
1815 + "a merge $when a quiet pull request's read, while its thread is not a candidate, rereads it next sweep",
1816 + ({ mergeDuringRead }) =>
1817 + Effect.gen(function* () {
1818 + yield* TestClock.setTime(Date.parse(NOW));
1819 + const thread = makeThread("busy-branch", {
1820 + branch: "feature",
1821 + latestUserMessageAt: DateTime.makeUnsafe("2026-08-27T00:00:00.000Z"),
1822 + branchPullRequest: {
1823 + projectId: PROJECT_ID,
1824 + repository: "owner/repository",
1825 + number: 42,
1826 + url: "https://example.test/owner/repository/pull/42",
1827 + },
1828 + });
1829 + const readStarted = yield* Deferred.make<void>();
1830 + const releaseRead = yield* Deferred.make<void>();
1831 + if (!mergeDuringRead) yield* Deferred.succeed(releaseRead, undefined);
1832 + const fixture = yield* makeHarness({
1833 + snapshot: makeSnapshot([thread]),
1834 + pullRequestSummary: (input) =>
1835 + Deferred.succeed(readStarted, undefined).pipe(
1836 + Effect.andThen(Deferred.await(releaseRead)),
1837 + Effect.as(
1838 + makePullRequestSummary({
1839 + ...input,
1840 + state: "open",
1841 + updatedAt: DateTime.formatIso(DateTime.makeUnsafe(Date.parse(NOW) - 2 * DAY_MS)),
1842 + }),
1843 + ),
1844 + ),
1845 + });
1846 +
1847 + yield* Effect.gen(function* () {
1848 + const reactor = yield* ThreadSettlementService.ThreadSettlementServiceV2;
1849 + yield* reactor.start();
1850 + yield* Deferred.succeed(fixture.activation, undefined);
1851 + yield* Queue.take(fixture.snapshotReads);
1852 + yield* Deferred.await(readStarted);
1853 + if (!mergeDuringRead) yield* reactor.drain;
1854 + assert.strictEqual((yield* Ref.get(fixture.summaryCalls)).length, 1);
1855 +
1856 + yield* Ref.set(fixture.snapshots, makeSnapshot([]));
1857 + yield* fixture.publishMerge;
1858 + yield* Queue.take(fixture.snapshotReads);
1859 + yield* Deferred.succeed(releaseRead, undefined);
1860 + yield* reactor.drain;
1861 +
1862 + yield* Ref.set(fixture.snapshots, makeSnapshot([thread]));
1863 + yield* TestClock.adjust("1 minute");
1864 + yield* Queue.take(fixture.snapshotReads);
1865 + yield* reactor.drain;
1866 + assert.strictEqual((yield* Ref.get(fixture.summaryCalls)).length, 2);
1867 + }).pipe(Effect.provide(fixture.layer));
1868 + }),
1869 + );
1870 +
1871 it.effect("rereads a branch without a pull request less often the longer its thread idles", () =>
1872 Effect.gen(function* () {
1873 yield* TestClock.setTime(Date.parse(NOW));
apps/server/src/orchestration-v2/ThreadSettlementService.ts
+39 -1
@@ -38,6 +38,7 @@ import { sourceControlDefinitions } from "../sourceControl/sourceControlDefiniti
38 import { makeNoPullRequestRechecks } from "./noPullRequestRechecks.ts";
39 import * as Orchestrator from "./Orchestrator.ts";
40 import * as ProjectionStore from "./ProjectionStore.ts";
41 +import { QUIET_AFTER_MS, QUIET_SYNC_INTERVAL_MS } from "./PullRequestSyncReactor.ts";
42
43 export interface SettlementPullRequest {
44 readonly state: "open" | "closed" | "merged";
@@ -320,6 +321,22 @@ export const make = Effect.gen(function* () {
321 // A shell merge or close sends no event, and the branch lookup caches an open pull request for
322 // a minute, so these threads' next lookup reads the host fresh.
323 const shellClosedThreads = new Set<ThreadId>();
324 + // Each summary read can be a host CLI process (one `az` per read on Azure DevOps), so a quiet
325 + // open pull request is read on the sync reactor's quiet cadence rather than every sweep.
326 + const quietOpenReadAt = new Map<string, number>();
327 + const quietReadKey = (reference: {
328 + readonly projectId: string;
329 + readonly repository: string;
330 + readonly number: number;
331 + }) => `${reference.projectId}\0${reference.repository.toLowerCase()}\0${reference.number}`;
332 + // A host can finish a merge minutes after the app's merge action and its refresh, and Azure's
333 + // updatedAt never moves while open, so pull requests stay on the fast cadence for a while after.
334 + // Sweeps that started before the pause fail the same check, so their reads record nothing.
335 + let quietPausedAtMs = Number.NEGATIVE_INFINITY;
336 + const pauseQuietReads = Effect.fn("ThreadSettlementServiceV2.pauseQuietReads")(function* () {
337 + quietPausedAtMs = DateTime.toEpochMillis(yield* DateTime.now);
338 + quietOpenReadAt.clear();
339 + });
340 const terminals = yield* TerminalManager.TerminalManager;
341 const projectScripts = yield* ProjectSetupScriptRunner.ProjectSetupScriptRunner;
342 // Repeated thread.settled retains settledAt; run the action only once per settlement.
@@ -330,6 +347,8 @@ export const make = Effect.gen(function* () {
347 mergedPullRequest: PullRequestService.PullRequestMergeEvent | null,
348 threadId?: ThreadId,
349 ) {
350 + // A thread that is not a candidate now (still running) must not keep a merged PR's quiet entry.
351 + if (mergedPullRequest !== null) yield* pauseQuietReads();
352 const settings = yield* settingsService.getSettings;
353 const automaticSettlementEnabled = autoSettlementConfigured(settings);
354 const threads = yield* projections.getSettlementCandidates(threadId);
@@ -337,6 +356,9 @@ export const make = Effect.gen(function* () {
356 const projectShells = yield* projectStore.listShells();
357 const nowMs = DateTime.toEpochMillis(yield* DateTime.now);
358 const projects = new Map(projectShells.map((project) => [project.id, project]));
359 + for (const [key, readAtMs] of quietOpenReadAt) {
360 + if (nowMs - readAtMs >= QUIET_SYNC_INTERVAL_MS) quietOpenReadAt.delete(key);
361 + }
362 // Merge events resweep all candidates because unlinked threads settle through branch lookup.
363 const candidates = threads.filter(
364 (thread) =>
@@ -509,6 +531,13 @@ export const make = Effect.gen(function* () {
531 if (!matchesMerge && !projects.has(reference.projectId)) {
532 return yield* Effect.die(new Error("linked pull request project not found"));
533 }
534 + const readKey = quietReadKey(reference);
535 + const shellClosed =
536 + group.filter((member) => shellClosedThreads.delete(member.id)).length > 0;
537 + if (shellClosed) quietOpenReadAt.delete(readKey);
538 + else if (!matchesMerge && quietOpenReadAt.has(readKey)) {
539 + return { state: "open", closedAt: null, mergedAt: null } satisfies SettlementPullRequest;
540 + }
541 const summary = matchesMerge
542 ? ({
543 state: "merged",
@@ -521,8 +550,16 @@ export const make = Effect.gen(function* () {
550 repository: reference.repository,
551 number: reference.number,
552 },
524 - { recoverTransientFailure: false },
553 + { recoverTransientFailure: false, bypassCache: shellClosed },
554 );
555 + if (
556 + "updatedAt" in summary &&
557 + summary.state === "open" &&
558 + nowMs - quietPausedAtMs >= QUIET_SYNC_INTERVAL_MS &&
559 + nowMs - Date.parse(summary.updatedAt) >= QUIET_AFTER_MS
560 + ) {
561 + quietOpenReadAt.set(readKey, nowMs);
562 + }
563 const terminal = {
564 state: summary.state,
565 closedAt: summary.closedAt ?? null,
@@ -786,6 +823,7 @@ export const make = Effect.gen(function* () {
823 }),
824 );
825 yield* forkParked(Stream.runForEach(mergedPullRequests, (event) => runSweep(event)));
826 + yield* forkParked(Stream.runForEach(pullRequests.subscribeRefreshes, pauseQuietReads));
827 yield* forkParked(
828 Stream.runForEach(events, processEvent).pipe(
829 Effect.catchCause((cause) =>