@agentteams/runner 0.0.84-dev.208 → 0.0.85

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);
         };
@@ -97,40 +97,39 @@ 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 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;
@@ -144,12 +143,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,
@@ -160,32 +159,30 @@ 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;
@@ -200,7 +197,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),
@@ -216,37 +213,36 @@ 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 () => [],
@@ -254,7 +250,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 () => {
@@ -267,34 +263,33 @@ 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, {
@@ -308,7 +303,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) => {
@@ -318,40 +313,37 @@ 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, {
@@ -365,53 +357,50 @@ 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, {
@@ -425,51 +414,45 @@ 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,
@@ -478,11 +461,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;
@@ -493,34 +476,30 @@ 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 };
@@ -532,7 +511,7 @@ test('startPolling restarts even when a pending trigger is present, ignoring the
             notifyUpdate: async () => undefined,
             ackRestartRequest: async () => {
                 ackCalled += 1;
-            },
+            }
         }),
         runCleanup: async () => undefined,
         executeRestartRequest: () => {
@@ -544,31 +523,27 @@ 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,
@@ -576,8 +551,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: () => {
@@ -589,21 +564,20 @@ 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;
@@ -616,7 +590,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: (() => ({})),
@@ -627,26 +601,25 @@ 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, {
@@ -658,7 +631,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: (() => ({})),
@@ -667,20 +640,19 @@ 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