@agentteams/runner 0.0.85 → 0.0.86-dev.212

package/dist/poller.test.js

@@ -1,34 +1,34 @@
-import assert from "node:assert/strict";
-import * as fsModule from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import test, { mock } from "node:test";
-import { logger } from "./logger.js";
-import { startPolling } from "./poller.js";
+import assert from 'node:assert/strict';
+import * as fsModule from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import test, { mock } from 'node:test';
+import { logger } from './logger.js';
+import { startPolling } from './poller.js';
 const config = {
-    daemonToken: "daemon-token",
-    apiUrl: "https://api.example",
+    daemonToken: 'daemon-token',
+    apiUrl: 'https://api.example',
     pollingIntervalMs: 5000,
     timeoutMs: 1000,
     idleTimeoutMs: 500,
-    runnerCmd: "opencode",
-    preventSleepWhileBusy: false
+    runnerCmd: 'opencode',
+    preventSleepWhileBusy: false,
 };
 const trigger = {
-    id: "trigger-1",
-    prompt: "hello",
-    runnerType: "CODEX",
-    model: "o4-mini",
+    id: 'trigger-1',
+    prompt: 'hello',
+    runnerType: 'CODEX',
+    model: 'o4-mini',
     fastMode: false,
-    status: "PENDING",
-    agentConfigId: "agent-1",
+    status: 'PENDING',
+    agentConfigId: 'agent-1',
     startedAt: null,
     errorMessage: null,
     worktreeError: null,
     lastHeartbeatAt: null,
     conversationId: null,
     parentTriggerId: null,
-    createdByMemberId: "member-1",
+    createdByMemberId: 'member-1',
     planMode: false,
     targetDaemonId: null,
     claimedByDaemonId: null,
@@ -36,8 +36,8 @@ const trigger = {
     baseBranch: null,
     worktreeId: null,
     worktreeStatus: null,
-    createdAt: "2026-01-01T00:00:00.000Z",
-    updatedAt: "2026-01-01T00:00:00.000Z"
+    createdAt: '2026-01-01T00:00:00.000Z',
+    updatedAt: '2026-01-01T00:00:00.000Z',
 };
 test.afterEach(() => {
     mock.restoreAll();
@@ -48,15 +48,15 @@ const createRecordingBlocker = () => {
         events,
         blocker: {
             acquire: (label) => {
-                events.push(`acquire:${label ?? ""}`);
-                return () => events.push(`release:${label ?? ""}`);
-            }
-        }
+                events.push(`acquire:${label ?? ''}`);
+                return () => events.push(`release:${label ?? ''}`);
+            },
+        },
     };
 };
-test("startPolling handles a claimed trigger, registers auth paths, and runs scheduled cleanup", async () => {
+test('startPolling handles a claimed trigger, registers auth paths, and runs scheduled cleanup', async () => {
     const infos = [];
-    mock.method(logger, "info", (message, meta) => {
+    mock.method(logger, 'info', (message, meta) => {
         infos.push({ message, meta });
     });
     const signals = new Map();
@@ -74,10 +74,10 @@ test("startPolling handles a claimed trigger, registers auth paths, and runs sch
         fetchPendingWorktreeRemovals: async () => [],
         reportWorktreeStatus: async () => undefined,
         notifyUpdate: async () => undefined,
-        ackRestartRequest: async () => undefined
+        ackRestartRequest: async () => undefined,
     };
     const createHandler = (onAuthPathDiscovered) => {
-        onAuthPathDiscovered("/auth/path");
+        onAuthPathDiscovered('/auth/path');
         return async (value) => {
             handledTriggers.push(value.id);
         };
@@ -88,6 +88,7 @@ test("startPolling handles a claimed trigger, registers auth paths, and runs sch
         runCleanup: async (authPath) => {
             cleanupCalls.push(authPath);
         },
+        runConventionSync: async () => undefined,
         setInterval: ((callback) => {
             intervalCallbacks.push(callback);
             return { ref() { }, unref() { } };
@@ -97,39 +98,95 @@ test("startPolling handles a claimed trigger, registers auth paths, and runs sch
             signals.set(event, listener);
         }),
         processExit: (() => {
-            throw new Error("should not exit");
+            throw new Error('should not exit');
         }),
         now: () => nowValue,
         loadAuthPaths: () => [],
         saveAuthPath: (authPath) => {
             savedAuthPaths.push(authPath);
-            return "/tmp/auth-paths.json";
+            return '/tmp/auth-paths.json';
         },
         keepAlive: () => new Promise((resolve) => {
             keepAliveResolve = resolve;
-        })
+        }),
     });
     await new Promise((resolve) => setImmediate(resolve));
-    assert.deepEqual(handledTriggers, ["trigger-1"]);
+    assert.deepEqual(handledTriggers, ['trigger-1']);
     assert.deepEqual(cleanupCalls, []);
     assert.equal(intervalCallbacks.length, 1);
     nowValue = 24 * 60 * 60 * 1000 + 1;
     await intervalCallbacks[0]?.();
     await new Promise((resolve) => setImmediate(resolve));
-    assert.deepEqual(cleanupCalls, ["/auth/path"]);
-    assert.deepEqual(savedAuthPaths, ["/auth/path"]);
-    assert.equal(signals.has("SIGINT"), true);
-    assert.equal(signals.has("SIGTERM"), true);
-    assert.equal(infos.some((entry) => entry.message === "Daemon polling started"), true);
-    const resolveKeepAlive = keepAliveResolve ?? (() => {
-        throw new Error("keepAlive resolver was not registered");
+    assert.deepEqual(cleanupCalls, ['/auth/path']);
+    assert.deepEqual(savedAuthPaths, ['/auth/path']);
+    assert.equal(signals.has('SIGINT'), true);
+    assert.equal(signals.has('SIGTERM'), true);
+    assert.equal(infos.some((entry) => entry.message === 'Daemon polling started'), true);
+    const resolveKeepAlive = keepAliveResolve ??
+        (() => {
+            throw new Error('keepAlive resolver was not registered');
+        });
+    resolveKeepAlive();
+    await pollingPromise;
+});
+test('startPolling runs convention sync per auth path every 6 hours', async () => {
+    const intervalCallbacks = [];
+    const conventionSyncCalls = [];
+    let nowValue = 6 * 60 * 60 * 1000 + 1;
+    let keepAliveResolve = null;
+    const pollingPromise = startPolling(config, () => async () => undefined, {
+        createClient: () => ({
+            fetchPendingTrigger: async () => ({ data: null }),
+            claimTrigger: async () => ({ ok: true, conflict: false }),
+            fetchOrphanedCancelRequested: async () => [],
+            updateTriggerStatus: async () => undefined,
+            fetchPendingWorktreeRemovals: async () => [],
+            reportWorktreeStatus: async () => undefined,
+            notifyUpdate: async () => undefined,
+            ackRestartRequest: async () => undefined,
+        }),
+        runCleanup: async () => undefined,
+        runConventionSync: async (authPath) => {
+            conventionSyncCalls.push(authPath);
+        },
+        maybeAutoUpdate: async () => ({ cliUpdated: false, runnerUpdated: false }),
+        setInterval: ((callback) => {
+            intervalCallbacks.push(callback);
+            return { ref() { }, unref() { } };
+        }),
+        clearInterval: (() => undefined),
+        processOn: (() => undefined),
+        processExit: (() => {
+            throw new Error('should not exit');
+        }),
+        now: () => nowValue,
+        loadAuthPaths: () => ['/auth/path'],
+        saveAuthPath: () => '/tmp/auth-paths.json',
+        keepAlive: () => new Promise((resolve) => {
+            keepAliveResolve = resolve;
+        }),
     });
+    await new Promise((resolve) => setImmediate(resolve));
+    assert.deepEqual(conventionSyncCalls, ['/auth/path']);
+    assert.equal(intervalCallbacks.length, 1);
+    nowValue += 6 * 60 * 60 * 1000 - 1;
+    await intervalCallbacks[0]?.();
+    await new Promise((resolve) => setImmediate(resolve));
+    assert.deepEqual(conventionSyncCalls, ['/auth/path']);
+    nowValue += 1;
+    await intervalCallbacks[0]?.();
+    await new Promise((resolve) => setImmediate(resolve));
+    assert.deepEqual(conventionSyncCalls, ['/auth/path', '/auth/path']);
+    const resolveKeepAlive = keepAliveResolve ??
+        (() => {
+            throw new Error('keepAlive resolver was not registered');
+        });
     resolveKeepAlive();
     await pollingPromise;
 });
-test("startPolling logs conflicts and suppresses overlapping polling cycles", async () => {
+test('startPolling logs conflicts and suppresses overlapping polling cycles', async () => {
     const infos = [];
-    mock.method(logger, "info", (message, meta) => {
+    mock.method(logger, 'info', (message, meta) => {
         infos.push({ message, meta });
     });
     let releaseFetch = null;
@@ -143,12 +200,12 @@ test("startPolling logs conflicts and suppresses overlapping polling cycles", as
         fetchPendingWorktreeRemovals: async () => [],
         reportWorktreeStatus: async () => undefined,
         notifyUpdate: async () => undefined,
-        ackRestartRequest: async () => undefined
+        ackRestartRequest: async () => undefined,
     };
     const intervalCallbacks = [];
     let keepAliveResolve = null;
     const pollingPromise = startPolling(config, () => async () => {
-        throw new Error("handler should not run");
+        throw new Error('handler should not run');
     }, {
         createClient: () => client,
         runCleanup: async () => undefined,
@@ -159,30 +216,32 @@ test("startPolling logs conflicts and suppresses overlapping polling cycles", as
         clearInterval: (() => undefined),
         processOn: (() => undefined),
         processExit: (() => {
-            throw new Error("should not exit");
+            throw new Error('should not exit');
         }),
         now: () => 0,
         loadAuthPaths: () => [],
-        saveAuthPath: () => "/tmp/auth-paths.json",
+        saveAuthPath: () => '/tmp/auth-paths.json',
         keepAlive: () => new Promise((resolve) => {
             keepAliveResolve = resolve;
-        })
+        }),
     });
     await new Promise((resolve) => setImmediate(resolve));
     await intervalCallbacks[0]?.();
-    const releasePendingFetch = releaseFetch ?? (() => {
-        throw new Error("fetch release was not registered");
-    });
+    const releasePendingFetch = releaseFetch ??
+        (() => {
+            throw new Error('fetch release was not registered');
+        });
     releasePendingFetch();
     await new Promise((resolve) => setImmediate(resolve));
-    assert.equal(infos.some((entry) => entry.message === "Trigger already claimed by another daemon"), true);
-    const resolveKeepAlive = keepAliveResolve ?? (() => {
-        throw new Error("keepAlive resolver was not registered");
-    });
+    assert.equal(infos.some((entry) => entry.message === 'Trigger already claimed by another daemon'), true);
+    const resolveKeepAlive = keepAliveResolve ??
+        (() => {
+            throw new Error('keepAlive resolver was not registered');
+        });
     resolveKeepAlive();
     await pollingPromise;
 });
-test("startPolling clears the interval and exits on shutdown signals", async () => {
+test('startPolling clears the interval and exits on shutdown signals', async () => {
     const signals = new Map();
     const cleared = [];
     let keepAliveResolve = null;
@@ -197,7 +256,7 @@ test("startPolling clears the interval and exits on shutdown signals", async ()
             fetchPendingWorktreeRemovals: async () => [],
             reportWorktreeStatus: async () => undefined,
             notifyUpdate: async () => undefined,
-            ackRestartRequest: async () => undefined
+            ackRestartRequest: async () => undefined,
         }),
         runCleanup: async () => undefined,
         setInterval: (() => intervalHandle),
@@ -213,36 +272,37 @@ test("startPolling clears the interval and exits on shutdown signals", async ()
         }),
         now: () => 0,
         loadAuthPaths: () => [],
-        saveAuthPath: () => "/tmp/auth-paths.json",
+        saveAuthPath: () => '/tmp/auth-paths.json',
         keepAlive: () => new Promise((resolve) => {
             keepAliveResolve = resolve;
-        })
+        }),
     }).catch((error) => {
-        if (error.message !== "exit") {
+        if (error.message !== 'exit') {
             throw error;
         }
     });
     await new Promise((resolve) => setImmediate(resolve));
-    assert.ok(signals.get("SIGTERM"));
-    const sigterm = signals.get("SIGTERM");
+    assert.ok(signals.get('SIGTERM'));
+    const sigterm = signals.get('SIGTERM');
     assert.ok(sigterm);
     sigterm();
     assert.equal(exitCode, 0);
     assert.deepEqual(cleared, [intervalHandle]);
-    const resolveKeepAlive = keepAliveResolve ?? (() => {
-        throw new Error("keepAlive resolver was not registered");
-    });
+    const resolveKeepAlive = keepAliveResolve ??
+        (() => {
+            throw new Error('keepAlive resolver was not registered');
+        });
     resolveKeepAlive();
     await pollingPromise;
 });
-test("startPolling delegates auto-update via injected dependency", async () => {
+test('startPolling delegates auto-update via injected dependency', async () => {
     let autoUpdateCallCount = 0;
     let keepAliveResolve = null;
     const pollingPromise = startPolling(config, () => async () => undefined, {
         createClient: () => ({
             fetchPendingTrigger: async () => ({
                 data: null,
-                meta: { cliLatestVersion: null, runnerLatestVersion: "99.0.0" }
+                meta: { cliLatestVersion: null, runnerLatestVersion: '99.0.0' },
             }),
             claimTrigger: async () => ({ ok: true, conflict: false }),
             fetchOrphanedCancelRequested: async () => [],
@@ -250,7 +310,7 @@ test("startPolling delegates auto-update via injected dependency", async () => {
             fetchPendingWorktreeRemovals: async () => [],
             reportWorktreeStatus: async () => undefined,
             notifyUpdate: async () => undefined,
-            ackRestartRequest: async () => undefined
+            ackRestartRequest: async () => undefined,
         }),
         runCleanup: async () => undefined,
         maybeAutoUpdate: async () => {
@@ -263,33 +323,34 @@ test("startPolling delegates auto-update via injected dependency", async () => {
         processExit: (() => undefined),
         now: () => 0,
         loadAuthPaths: () => [],
-        saveAuthPath: () => "/tmp/auth-paths.json",
+        saveAuthPath: () => '/tmp/auth-paths.json',
         keepAlive: () => new Promise((resolve) => {
             keepAliveResolve = resolve;
-        })
+        }),
     });
     await new Promise((resolve) => setImmediate(resolve));
-    assert.equal(autoUpdateCallCount, 1, "should call injected maybeAutoUpdate on idle poll");
-    const resolveKeepAlive = keepAliveResolve ?? (() => {
-        throw new Error("keepAlive resolver was not registered");
-    });
+    assert.equal(autoUpdateCallCount, 1, 'should call injected maybeAutoUpdate on idle poll');
+    const resolveKeepAlive = keepAliveResolve ??
+        (() => {
+            throw new Error('keepAlive resolver was not registered');
+        });
     resolveKeepAlive();
     await pollingPromise;
 });
-test("startPolling restores persisted auth paths for worktree removals after restart", async () => {
+test('startPolling restores persisted auth paths for worktree removals after restart', async () => {
     const removedWorktrees = [];
     const reportedStatuses = [];
-    const tempRoot = fsModule.mkdtempSync(path.join(os.tmpdir(), "agentrunner-poller-"));
-    const authPath = path.join(tempRoot, "path");
-    const worktreePath = path.join(tempRoot, ".path-worktrees", "wt-worktree-1");
+    const tempRoot = fsModule.mkdtempSync(path.join(os.tmpdir(), 'agentrunner-poller-'));
+    const authPath = path.join(tempRoot, 'path');
+    const worktreePath = path.join(tempRoot, '.path-worktrees', 'wt-worktree-1');
     fsModule.mkdirSync(authPath, { recursive: true });
     fsModule.mkdirSync(worktreePath, { recursive: true });
     const worktreeRemovalTrigger = {
         ...trigger,
-        id: "trigger-remove",
+        id: 'trigger-remove',
         useWorktree: true,
-        worktreeId: "worktree-1",
-        worktreeStatus: "REMOVE_REQUESTED"
+        worktreeId: 'worktree-1',
+        worktreeStatus: 'REMOVE_REQUESTED',
     };
     let keepAliveResolve = null;
     const pollingPromise = startPolling(config, () => async () => undefined, {
@@ -303,7 +364,7 @@ test("startPolling restores persisted auth paths for worktree removals after res
                 reportedStatuses.push({ triggerId, status, worktreeError });
             },
             notifyUpdate: async () => undefined,
-            ackRestartRequest: async () => undefined
+            ackRestartRequest: async () => undefined,
         }),
         runCleanup: async () => undefined,
         removeWorktree: (authPath, worktreePath, worktreeId) => {
@@ -313,37 +374,40 @@ test("startPolling restores persisted auth paths for worktree removals after res
         clearInterval: (() => undefined),
         processOn: (() => undefined),
         processExit: (() => {
-            throw new Error("should not exit");
+            throw new Error('should not exit');
         }),
         now: () => 0,
         loadAuthPaths: () => [authPath],
-        saveAuthPath: () => "/tmp/auth-paths.json",
+        saveAuthPath: () => '/tmp/auth-paths.json',
         keepAlive: () => new Promise((resolve) => {
             keepAliveResolve = resolve;
-        })
+        }),
     });
     await new Promise((resolve) => setImmediate(resolve));
-    assert.deepEqual(removedWorktrees, [{
+    assert.deepEqual(removedWorktrees, [
+        {
             authPath,
             worktreePath,
-            worktreeId: "worktree-1"
-        }]);
-    assert.deepEqual(reportedStatuses, [{ triggerId: "trigger-remove", status: "REMOVED", worktreeError: undefined }]);
-    const resolveKeepAlive = keepAliveResolve ?? (() => {
-        throw new Error("keepAlive resolver was not registered");
-    });
+            worktreeId: 'worktree-1',
+        },
+    ]);
+    assert.deepEqual(reportedStatuses, [{ triggerId: 'trigger-remove', status: 'REMOVED', worktreeError: undefined }]);
+    const resolveKeepAlive = keepAliveResolve ??
+        (() => {
+            throw new Error('keepAlive resolver was not registered');
+        });
     resolveKeepAlive();
     await pollingPromise;
     fsModule.rmSync(tempRoot, { recursive: true, force: true });
 });
-test("startPolling reports FAILED when no persisted auth path matches the worktree", async () => {
+test('startPolling reports FAILED when no persisted auth path matches the worktree', async () => {
     const reportedStatuses = [];
     const worktreeRemovalTrigger = {
         ...trigger,
-        id: "trigger-remove-missing",
+        id: 'trigger-remove-missing',
         useWorktree: true,
-        worktreeId: "worktree-missing",
-        worktreeStatus: "REMOVE_REQUESTED"
+        worktreeId: 'worktree-missing',
+        worktreeStatus: 'REMOVE_REQUESTED',
     };
     let keepAliveResolve = null;
     const pollingPromise = startPolling(config, () => async () => undefined, {
@@ -357,50 +421,53 @@ test("startPolling reports FAILED when no persisted auth path matches the worktr
                 reportedStatuses.push({ triggerId, status, worktreeError });
             },
             notifyUpdate: async () => undefined,
-            ackRestartRequest: async () => undefined
+            ackRestartRequest: async () => undefined,
         }),
         runCleanup: async () => undefined,
         removeWorktree: () => {
-            throw new Error("removeWorktree should not be called");
+            throw new Error('removeWorktree should not be called');
         },
         setInterval: (() => ({ ref() { }, unref() { } })),
         clearInterval: (() => undefined),
         processOn: (() => undefined),
         processExit: (() => {
-            throw new Error("should not exit");
+            throw new Error('should not exit');
         }),
         now: () => 0,
-        loadAuthPaths: () => ["/persisted/auth/path"],
-        saveAuthPath: () => "/tmp/auth-paths.json",
+        loadAuthPaths: () => ['/persisted/auth/path'],
+        saveAuthPath: () => '/tmp/auth-paths.json',
         keepAlive: () => new Promise((resolve) => {
             keepAliveResolve = resolve;
-        })
+        }),
     });
     await new Promise((resolve) => setImmediate(resolve));
-    assert.deepEqual(reportedStatuses, [{
-            triggerId: "trigger-remove-missing",
-            status: "FAILED",
-            worktreeError: "Failed to remove RunnerBox: worktree path was not found for worktree-missing"
-        }]);
-    const resolveKeepAlive = keepAliveResolve ?? (() => {
-        throw new Error("keepAlive resolver was not registered");
-    });
+    assert.deepEqual(reportedStatuses, [
+        {
+            triggerId: 'trigger-remove-missing',
+            status: 'FAILED',
+            worktreeError: 'Failed to remove RunnerBox: worktree path was not found for worktree-missing',
+        },
+    ]);
+    const resolveKeepAlive = keepAliveResolve ??
+        (() => {
+            throw new Error('keepAlive resolver was not registered');
+        });
     resolveKeepAlive();
     await pollingPromise;
 });
-test("startPolling reports FAILED when worktree removal throws after matching a path", async () => {
+test('startPolling reports FAILED when worktree removal throws after matching a path', async () => {
     const reportedStatuses = [];
-    const tempRoot = fsModule.mkdtempSync(path.join(os.tmpdir(), "agentrunner-poller-"));
-    const authPath = path.join(tempRoot, "path");
-    const worktreePath = path.join(tempRoot, ".path-worktrees", "wt-worktree-failed");
+    const tempRoot = fsModule.mkdtempSync(path.join(os.tmpdir(), 'agentrunner-poller-'));
+    const authPath = path.join(tempRoot, 'path');
+    const worktreePath = path.join(tempRoot, '.path-worktrees', 'wt-worktree-failed');
     fsModule.mkdirSync(authPath, { recursive: true });
     fsModule.mkdirSync(worktreePath, { recursive: true });
     const worktreeRemovalTrigger = {
         ...trigger,
-        id: "trigger-remove-failed",
+        id: 'trigger-remove-failed',
         useWorktree: true,
-        worktreeId: "worktree-failed",
-        worktreeStatus: "REMOVE_REQUESTED"
+        worktreeId: 'worktree-failed',
+        worktreeStatus: 'REMOVE_REQUESTED',
     };
     let keepAliveResolve = null;
     const pollingPromise = startPolling(config, () => async () => undefined, {
@@ -414,45 +481,51 @@ test("startPolling reports FAILED when worktree removal throws after matching a
                 reportedStatuses.push({ triggerId, status, worktreeError });
             },
             notifyUpdate: async () => undefined,
-            ackRestartRequest: async () => undefined
+            ackRestartRequest: async () => undefined,
         }),
         runCleanup: async () => undefined,
         removeWorktree: () => {
-            throw new Error("permission denied");
+            throw new Error('permission denied');
         },
         setInterval: (() => ({ ref() { }, unref() { } })),
         clearInterval: (() => undefined),
         processOn: (() => undefined),
         processExit: (() => {
-            throw new Error("should not exit");
+            throw new Error('should not exit');
         }),
         now: () => 0,
         loadAuthPaths: () => [authPath],
-        saveAuthPath: () => "/tmp/auth-paths.json",
+        saveAuthPath: () => '/tmp/auth-paths.json',
         keepAlive: () => new Promise((resolve) => {
             keepAliveResolve = resolve;
-        })
+        }),
     });
     await new Promise((resolve) => setImmediate(resolve));
-    assert.deepEqual(reportedStatuses, [{
-            triggerId: "trigger-remove-failed",
-            status: "FAILED",
-            worktreeError: "permission denied"
-        }]);
-    const resolveKeepAlive = keepAliveResolve ?? (() => {
-        throw new Error("keepAlive resolver was not registered");
-    });
+    assert.deepEqual(reportedStatuses, [
+        {
+            triggerId: 'trigger-remove-failed',
+            status: 'FAILED',
+            worktreeError: 'permission denied',
+        },
+    ]);
+    const resolveKeepAlive = keepAliveResolve ??
+        (() => {
+            throw new Error('keepAlive resolver was not registered');
+        });
     resolveKeepAlive();
     await pollingPromise;
     fsModule.rmSync(tempRoot, { recursive: true, force: true });
 });
-test("startPolling acks and runs restart when meta.restartRequested is true with no pending trigger", async () => {
+test('startPolling acks and runs restart when meta.restartRequested is true with no pending trigger', async () => {
     let ackCalled = 0;
     let restartCalled = 0;
     let keepAliveResolve = null;
     const pollingPromise = startPolling(config, () => async () => undefined, {
         createClient: () => ({
-            fetchPendingTrigger: async () => ({ data: null, meta: { cliLatestVersion: null, runnerLatestVersion: null, restartRequested: true } }),
+            fetchPendingTrigger: async () => ({
+                data: null,
+                meta: { cliLatestVersion: null, runnerLatestVersion: null, restartRequested: true },
+            }),
             claimTrigger: async () => ({ ok: true, conflict: false }),
             fetchOrphanedCancelRequested: async () => [],
             updateTriggerStatus: async () => undefined,
@@ -461,11 +534,11 @@ test("startPolling acks and runs restart when meta.restartRequested is true with
             notifyUpdate: async () => undefined,
             ackRestartRequest: async () => {
                 ackCalled += 1;
-            }
+            },
         }),
         runCleanup: async () => undefined,
         maybeAutoUpdate: async () => {
-            throw new Error("auto-update must be skipped while restarting");
+            throw new Error('auto-update must be skipped while restarting');
         },
         executeRestartRequest: () => {
             restartCalled += 1;
@@ -476,30 +549,34 @@ test("startPolling acks and runs restart when meta.restartRequested is true with
         processExit: (() => undefined),
         now: () => 0,
         loadAuthPaths: () => [],
-        saveAuthPath: () => "/tmp/auth-paths.json",
+        saveAuthPath: () => '/tmp/auth-paths.json',
         keepAlive: () => new Promise((resolve) => {
             keepAliveResolve = resolve;
-        })
+        }),
     });
     await new Promise((resolve) => setImmediate(resolve));
-    assert.equal(ackCalled, 1, "ackRestartRequest should be called exactly once");
-    assert.equal(restartCalled, 1, "executeRestartRequest should be called exactly once");
-    const resolveKeepAlive = keepAliveResolve ?? (() => {
-        throw new Error("keepAlive resolver was not registered");
-    });
+    assert.equal(ackCalled, 1, 'ackRestartRequest should be called exactly once');
+    assert.equal(restartCalled, 1, 'executeRestartRequest should be called exactly once');
+    const resolveKeepAlive = keepAliveResolve ??
+        (() => {
+            throw new Error('keepAlive resolver was not registered');
+        });
     resolveKeepAlive();
     await pollingPromise;
 });
-test("startPolling restarts even when a pending trigger is present, ignoring the trigger", async () => {
+test('startPolling restarts even when a pending trigger is present, ignoring the trigger', async () => {
     let ackCalled = 0;
     let restartCalled = 0;
     let claimCalled = 0;
     let keepAliveResolve = null;
     const pollingPromise = startPolling(config, () => async () => {
-        throw new Error("trigger handler must not run when restart wins");
+        throw new Error('trigger handler must not run when restart wins');
     }, {
         createClient: () => ({
-            fetchPendingTrigger: async () => ({ data: trigger, meta: { cliLatestVersion: null, runnerLatestVersion: null, restartRequested: true } }),
+            fetchPendingTrigger: async () => ({
+                data: trigger,
+                meta: { cliLatestVersion: null, runnerLatestVersion: null, restartRequested: true },
+            }),
             claimTrigger: async () => {
                 claimCalled += 1;
                 return { ok: true, conflict: false };
@@ -511,7 +588,7 @@ test("startPolling restarts even when a pending trigger is present, ignoring the
             notifyUpdate: async () => undefined,
             ackRestartRequest: async () => {
                 ackCalled += 1;
-            }
+            },
         }),
         runCleanup: async () => undefined,
         executeRestartRequest: () => {
@@ -523,27 +600,31 @@ test("startPolling restarts even when a pending trigger is present, ignoring the
         processExit: (() => undefined),
         now: () => 0,
         loadAuthPaths: () => [],
-        saveAuthPath: () => "/tmp/auth-paths.json",
+        saveAuthPath: () => '/tmp/auth-paths.json',
         keepAlive: () => new Promise((resolve) => {
             keepAliveResolve = resolve;
-        })
+        }),
     });
     await new Promise((resolve) => setImmediate(resolve));
-    assert.equal(ackCalled, 1, "ack should run before restart");
-    assert.equal(restartCalled, 1, "restart should run even with a pending trigger");
-    assert.equal(claimCalled, 0, "trigger must not be claimed while restarting");
-    const resolveKeepAlive = keepAliveResolve ?? (() => {
-        throw new Error("keepAlive resolver was not registered");
-    });
+    assert.equal(ackCalled, 1, 'ack should run before restart');
+    assert.equal(restartCalled, 1, 'restart should run even with a pending trigger');
+    assert.equal(claimCalled, 0, 'trigger must not be claimed while restarting');
+    const resolveKeepAlive = keepAliveResolve ??
+        (() => {
+            throw new Error('keepAlive resolver was not registered');
+        });
     resolveKeepAlive();
     await pollingPromise;
 });
-test("startPolling skips restart and leaves the flag for retry when ack fails", async () => {
+test('startPolling skips restart and leaves the flag for retry when ack fails', async () => {
     let restartCalled = 0;
     let keepAliveResolve = null;
     const pollingPromise = startPolling(config, () => async () => undefined, {
         createClient: () => ({
-            fetchPendingTrigger: async () => ({ data: null, meta: { cliLatestVersion: null, runnerLatestVersion: null, restartRequested: true } }),
+            fetchPendingTrigger: async () => ({
+                data: null,
+                meta: { cliLatestVersion: null, runnerLatestVersion: null, restartRequested: true },
+            }),
             claimTrigger: async () => ({ ok: true, conflict: false }),
             fetchOrphanedCancelRequested: async () => [],
             updateTriggerStatus: async () => undefined,
@@ -551,8 +632,8 @@ test("startPolling skips restart and leaves the flag for retry when ack fails",
             reportWorktreeStatus: async () => undefined,
             notifyUpdate: async () => undefined,
             ackRestartRequest: async () => {
-                throw new Error("network down");
-            }
+                throw new Error('network down');
+            },
         }),
         runCleanup: async () => undefined,
         executeRestartRequest: () => {
@@ -564,20 +645,21 @@ test("startPolling skips restart and leaves the flag for retry when ack fails",
         processExit: (() => undefined),
         now: () => 0,
         loadAuthPaths: () => [],
-        saveAuthPath: () => "/tmp/auth-paths.json",
+        saveAuthPath: () => '/tmp/auth-paths.json',
         keepAlive: () => new Promise((resolve) => {
             keepAliveResolve = resolve;
-        })
+        }),
     });
     await new Promise((resolve) => setImmediate(resolve));
-    assert.equal(restartCalled, 0, "restart must not run when ack fails");
-    const resolveKeepAlive = keepAliveResolve ?? (() => {
-        throw new Error("keepAlive resolver was not registered");
-    });
+    assert.equal(restartCalled, 0, 'restart must not run when ack fails');
+    const resolveKeepAlive = keepAliveResolve ??
+        (() => {
+            throw new Error('keepAlive resolver was not registered');
+        });
     resolveKeepAlive();
     await pollingPromise;
 });
-test("startPolling acquires the power save blocker on start and releases it on shutdown", async () => {
+test('startPolling acquires the power save blocker on start and releases it on shutdown', async () => {
     const { events, blocker } = createRecordingBlocker();
     const signals = new Map();
     let keepAliveResolve = null;
@@ -590,7 +672,7 @@ test("startPolling acquires the power save blocker on start and releases it on s
             fetchPendingWorktreeRemovals: async () => [],
             reportWorktreeStatus: async () => undefined,
             notifyUpdate: async () => undefined,
-            ackRestartRequest: async () => undefined
+            ackRestartRequest: async () => undefined,
         }),
         runCleanup: async () => undefined,
         setInterval: (() => ({})),
@@ -601,25 +683,26 @@ test("startPolling acquires the power save blocker on start and releases it on s
         processExit: (() => undefined),
         now: () => 0,
         loadAuthPaths: () => [],
-        saveAuthPath: () => "/tmp/auth-paths.json",
+        saveAuthPath: () => '/tmp/auth-paths.json',
         powerSaveBlocker: blocker,
         keepAlive: () => new Promise((resolve) => {
             keepAliveResolve = resolve;
-        })
+        }),
     });
     await new Promise((resolve) => setImmediate(resolve));
-    assert.deepEqual(events, ["acquire:daemon-polling"], "blocker should be acquired exactly once on start");
-    const sigterm = signals.get("SIGTERM");
+    assert.deepEqual(events, ['acquire:daemon-polling'], 'blocker should be acquired exactly once on start');
+    const sigterm = signals.get('SIGTERM');
     assert.ok(sigterm);
     sigterm();
-    assert.deepEqual(events, ["acquire:daemon-polling", "release:daemon-polling"], "blocker should be released on shutdown");
-    const resolveKeepAlive = keepAliveResolve ?? (() => {
-        throw new Error("keepAlive resolver was not registered");
-    });
+    assert.deepEqual(events, ['acquire:daemon-polling', 'release:daemon-polling'], 'blocker should be released on shutdown');
+    const resolveKeepAlive = keepAliveResolve ??
+        (() => {
+            throw new Error('keepAlive resolver was not registered');
+        });
     resolveKeepAlive();
     await pollingPromise;
 });
-test("startPolling releases the power save blocker when keepAlive resolves", async () => {
+test('startPolling releases the power save blocker when keepAlive resolves', async () => {
     const { events, blocker } = createRecordingBlocker();
     let keepAliveResolve = null;
     const pollingPromise = startPolling(config, () => async () => undefined, {
@@ -631,7 +714,7 @@ test("startPolling releases the power save blocker when keepAlive resolves", asy
             fetchPendingWorktreeRemovals: async () => [],
             reportWorktreeStatus: async () => undefined,
             notifyUpdate: async () => undefined,
-            ackRestartRequest: async () => undefined
+            ackRestartRequest: async () => undefined,
         }),
         runCleanup: async () => undefined,
         setInterval: (() => ({})),
@@ -640,19 +723,20 @@ test("startPolling releases the power save blocker when keepAlive resolves", asy
         processExit: (() => undefined),
         now: () => 0,
         loadAuthPaths: () => [],
-        saveAuthPath: () => "/tmp/auth-paths.json",
+        saveAuthPath: () => '/tmp/auth-paths.json',
         powerSaveBlocker: blocker,
         keepAlive: () => new Promise((resolve) => {
             keepAliveResolve = resolve;
-        })
+        }),
     });
     await new Promise((resolve) => setImmediate(resolve));
-    assert.deepEqual(events, ["acquire:daemon-polling"]);
-    const resolveKeepAlive = keepAliveResolve ?? (() => {
-        throw new Error("keepAlive resolver was not registered");
-    });
+    assert.deepEqual(events, ['acquire:daemon-polling']);
+    const resolveKeepAlive = keepAliveResolve ??
+        (() => {
+            throw new Error('keepAlive resolver was not registered');
+        });
     resolveKeepAlive();
     await pollingPromise;
-    assert.deepEqual(events, ["acquire:daemon-polling", "release:daemon-polling"], "blocker should be released after keepAlive resolves");
+    assert.deepEqual(events, ['acquire:daemon-polling', 'release:daemon-polling'], 'blocker should be released after keepAlive resolves');
 });
 //# sourceMappingURL=poller.test.js.map