From d1463fb79ecd72f53fd36c31b50076da9d73aebd Mon Sep 17 00:00:00 2001 From: Nicky Leach Date: Fri, 16 Oct 2026 12:09:38 -0700 Subject: [PATCH] Preserve saved delivery deadlines across clock ticks (#16589) ## Thinking Path > - Paperclip manages AI agent work and message delivery. > - Delivery workers restore saved retry and maintenance deadlines. > - The coordinator converts each future deadline to a delay and back. > - A clock tick between those reads can move the deadline. > - This pull request keeps the saved future timestamp. > - A deterministic test covers the clock tick. ## Linked Issues or Issue Description Refs #16503. This separate fix addresses an unrelated CI failure found during its review. **What happened?** The unchanged delayed GitHub publication restart test intermittently reports a wake deadline one millisecond after the saved timestamp. The coordinator subtracts one clock reading from the deadline, then adds the delay to a later reading. **Expected behavior** Keep a future saved deadline exactly. Preserve the current retry behavior for expired deadlines during idle reconciliation. **Steps to reproduce** Register a task with a future `nextRunAt` timestamp. Advance `Date.now()` by one millisecond on each read. The old coordinator reports `nextWakeAt()` one millisecond after the saved timestamp. The new unit test forces this sequence. ## What Changed - Let the internal scheduler accept the existing absolute future deadline. - Keep relative retry and immediate wake scheduling unchanged. - Add a deterministic advancing-clock regression. Keep the chat integration assertion unchanged. ## Verification - Based on `origin/master` at `c91f7a6e5f`. - Coordinator suite and the unchanged delayed GitHub publication restart case: 16 passed, 1346 unrelated cases skipped. - The new regression fails against the original coordinator with the exact one-millisecond offset. - Server typecheck passed. - On head `d2db3e15d6dfafd390bab59529474abebb19d09c`, all 55 hosted checks passed, with 2 expected skips. This includes all server/chat shards, Runner checks, build, canary dry run, security checks, and end-to-end tests. - Standard Greptile and Apex are both 5/5 on that exact head, with no review threads. Apex completed after green CI; final CI verification remains fully green and the branch is mergeable. - `git diff --check` and the pre-push secret/PII scan passed. ## Risks Low risk. The change keeps the saved future timestamp. Existing tests cover retry, idle drain, preemption, and shutdown behavior. No schema or API change is required. ## Model Used OpenAI Codex, GPT-6, with reasoning, repository inspection, code execution, and testing. The exact deployment model ID and context window are not exposed in this session. ## Checklist - [x] I have included a thinking path that traces from project context to this change - [x] I have specified the model used (with version and capability details) - [x] I have checked ROADMAP.md and confirmed this PR does not duplicate planned core work - [x] I have searched GitHub for duplicate or related PRs and linked them above - [x] I have either (a) linked existing issues with `Fixes: #` / `Closes #` / `Refs #` OR (b) described the issue in-PR following the relevant issue template - [x] I have not referenced internal/instance-local Paperclip issues or links (only public GitHub references) - [x] My branch name describes the change and contains no internal Paperclip ticket id - [x] I have run tests locally and they pass - [x] I have added or updated tests where applicable - [x] I have updated relevant documentation to reflect my changes (no public contract changed) - [x] I have considered and documented any risks above - [x] All Paperclip CI gates are green - [x] Greptile is 5/5 with no open P2s, recommendations, or follow-ups - [x] I will address all Greptile and reviewer comments before requesting merge Co-authored-by: Paperclip --- .../src/__tests__/delivery-work-coordinator.test.ts | 12 ++++++++++++ server/src/services/delivery-work-coordinator.ts | 6 +++--- 2 files changed, 15 insertions(+), 3 deletions(-) diff --git a/server/src/__tests__/delivery-work-coordinator.test.ts b/server/src/__tests__/delivery-work-coordinator.test.ts index b4406a7cd5d..d3f7590a79b 100644 --- a/server/src/__tests__/delivery-work-coordinator.test.ts +++ b/server/src/__tests__/delivery-work-coordinator.test.ts @@ -45,6 +45,18 @@ describe("delivery work coordinator", () => { expect(vi.getTimerCount()).toBe(0); expect(idleWorkSnapshot().active).toBe(0); }); + it("preserves a future deadline when the clock advances between scheduling reads", async () => { + const s = setup(), t = task(); + let now = Date.now(); + const due = now + 1000; + const clock = vi.spyOn(Date, "now").mockImplementation(() => now++); + try { + await s.coordinator.register(DELIVERY_QUEUES.chatGitHubPublications, { ...t, nextRunAt: () => due }).ready; + expect(s.coordinator.nextWakeAt()).toBe(due); + expect(t.run).toHaveBeenCalledTimes(1); + expect(s.onError).not.toHaveBeenCalled(); + } finally { clock.mockRestore(); } + }); it("schedules maintenance without holding idle intent, and lets new work preempt it", async () => { const s = setup(), t = task(); let next: number | null = Date.now() + 60_000; diff --git a/server/src/services/delivery-work-coordinator.ts b/server/src/services/delivery-work-coordinator.ts index c8c9a468bf3..2efb832250d 100644 --- a/server/src/services/delivery-work-coordinator.ts +++ b/server/src/services/delivery-work-coordinator.ts @@ -35,9 +35,9 @@ export function createDeliveryWorkCoordinator(input: { let workerStopped = false; let controller: AbortController | null = null; let finishIntent: (() => void) | undefined; - function schedule(delay: number) { + function schedule(delay: number, deadline?: number) { if (workerStopped) return; - const at = Date.now() + delay; + const at = deadline ?? Date.now() + delay; if (scheduledAt !== null && scheduledAt <= at) return; scheduledAt = at; scheduler.schedule(queue, at, start); @@ -58,7 +58,7 @@ export function createDeliveryWorkCoordinator(input: { const next = task.nextRunAt?.(); if (next != null) { const delay = Math.max(0, next - Date.now()); - schedule(delay === 0 && !input.canRun() ? task.retryMs : delay); + schedule(delay === 0 && !input.canRun() ? task.retryMs : delay, delay > 0 ? next : undefined); } }).catch(error => { schedule(task.retryMs);