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 <noreply@paperclip.ing>

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;

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);