@agentteams/runner 0.0.84-dev.208 → 0.0.85

package/dist/handlers/trigger-handler.test.js

@@ -1,25 +1,25 @@
-import assert from 'node:assert/strict';
-import test, { mock } from 'node:test';
-import { mkdtemp, rm, stat } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { logger } from '../logger.js';
-import { createTriggerHandler } from './trigger-handler.js';
+import assert from "node:assert/strict";
+import test, { mock } from "node:test";
+import { mkdtemp, rm, stat } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { logger } from "../logger.js";
+import { createTriggerHandler } from "./trigger-handler.js";
 const trigger = {
-    id: 'trigger-1',
-    prompt: 'Implement feature',
-    runnerType: 'CODEX',
-    model: 'o4-mini',
+    id: "trigger-1",
+    prompt: "Implement feature",
+    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: 'parent-1',
-    createdByMemberId: 'member-1',
+    parentTriggerId: "parent-1",
+    createdByMemberId: "member-1",
     planMode: false,
     targetDaemonId: null,
     claimedByDaemonId: null,
@@ -27,631 +27,633 @@ 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"
 };
 const runtime = {
-    triggerId: 'trigger-1',
-    agentConfigId: 'agent-1',
-    authPath: '/auth/path',
-    apiKey: 'api-key',
-    teamId: 'team-1',
-    projectId: 'project-1',
-    runnerPrompt: 'API runner prompt\n- History path: {{AGENTRUNNER_CURRENT_HISTORY_PATH}}\n- Previous history path: {{AGENTRUNNER_PARENT_HISTORY_PATH}}',
+    triggerId: "trigger-1",
+    agentConfigId: "agent-1",
+    authPath: "/auth/path",
+    apiKey: "api-key",
+    teamId: "team-1",
+    projectId: "project-1",
+    runnerPrompt: "API runner prompt\n- History path: {{AGENTRUNNER_CURRENT_HISTORY_PATH}}\n- Previous history path: {{AGENTRUNNER_PARENT_HISTORY_PATH}}",
     parentHistoryMarkdown: null,
     useWorktree: false,
     baseBranch: null,
-    worktreeId: null,
+    worktreeId: null
 };
 test.afterEach(() => {
     mock.restoreAll();
 });
-test('createTriggerHandler runs the runner, reports history, and marks success', async () => {
+test("createTriggerHandler runs the runner, reports history, and marks success", async () => {
     const clientCalls = [];
     const logEntries = [];
     const discoveredAuthPaths = [];
     const runnerInputs = [];
     const client = {
         fetchTriggerRuntime: async (...args) => {
-            clientCalls.push({ method: 'fetchTriggerRuntime', args });
+            clientCalls.push({ method: "fetchTriggerRuntime", args });
             return runtime;
         },
         isTriggerCancelRequested: async (...args) => {
-            clientCalls.push({ method: 'isTriggerCancelRequested', args });
+            clientCalls.push({ method: "isTriggerCancelRequested", args });
             return false;
         },
         updateTriggerHistory: async (...args) => {
-            clientCalls.push({ method: 'updateTriggerHistory', args });
+            clientCalls.push({ method: "updateTriggerHistory", args });
         },
         updateTriggerStatus: async (...args) => {
-            clientCalls.push({ method: 'updateTriggerStatus', args });
-        },
+            clientCalls.push({ method: "updateTriggerStatus", args });
+        }
     };
     const runner = {
         run: async (input) => {
             runnerInputs.push({ prompt: input.prompt, authPath: input.authPath });
-            input.onStdoutChunk?.('stdout');
-            input.onStderrChunk?.('stderr');
+            input.onStdoutChunk?.("stdout");
+            input.onStderrChunk?.("stderr");
             return { exitCode: 0 };
-        },
+        }
     };
     const handler = createTriggerHandler({
         config: {
-            daemonToken: 'daemon-token',
-            apiUrl: 'https://api.example',
+            daemonToken: "daemon-token",
+            apiUrl: "https://api.example",
             pollingIntervalMs: 5000,
             timeoutMs: 1500,
             idleTimeoutMs: 500,
-            runnerCmd: 'opencode',
-            preventSleepWhileBusy: false,
+            runnerCmd: "opencode",
+            preventSleepWhileBusy: false
         },
         client: client,
         onAuthPathDiscovered: (authPath) => {
             discoveredAuthPaths.push(authPath);
-        },
+        }
     }, {
         createRunnerFactory: () => () => runner,
         createLogReporter: () => ({
             start: () => {
-                logEntries.push({ level: 'START', message: 'started' });
+                logEntries.push({ level: "START", message: "started" });
             },
             append: (level, message) => {
                 logEntries.push({ level, message });
             },
             stop: async () => {
-                logEntries.push({ level: 'STOP', message: 'stopped' });
-            },
+                logEntries.push({ level: "STOP", message: "stopped" });
+            }
         }),
-        readHistoryFile: async () => '### Summary\n- done\n',
+        readHistoryFile: async () => "### Summary\n- done\n",
         resolveRunnerHistoryPaths: () => ({
-            currentHistoryPath: '/auth/path/.agentteams/runner/history/trigger-1.md',
-            parentHistoryPath: '/auth/path/.agentteams/runner/history/parent-1.md',
-        }),
+            currentHistoryPath: "/auth/path/.agentteams/runner/history/trigger-1.md",
+            parentHistoryPath: "/auth/path/.agentteams/runner/history/parent-1.md"
+        })
     });
     await handler(trigger);
-    assert.deepEqual(discoveredAuthPaths, ['/auth/path']);
+    assert.deepEqual(discoveredAuthPaths, ["/auth/path"]);
     assert.equal(runnerInputs.length, 1);
-    assert.equal(runnerInputs[0]?.prompt, 'API runner prompt\n- History path: /auth/path/.agentteams/runner/history/trigger-1.md\n- Previous history path: /auth/path/.agentteams/runner/history/parent-1.md');
-    assert.equal(logEntries.some((entry) => entry.level === 'INFO' && entry.message.includes('stdout')), true);
-    assert.equal(logEntries.some((entry) => entry.level === 'WARN' && entry.message.includes('stderr')), true);
-    assert.deepEqual(clientCalls.map((entry) => entry.method), ['fetchTriggerRuntime', 'isTriggerCancelRequested', 'updateTriggerHistory', 'updateTriggerStatus']);
-    assert.deepEqual(clientCalls.at(-1)?.args, ['trigger-1', 'DONE', undefined]);
+    assert.equal(runnerInputs[0]?.prompt, "API runner prompt\n- History path: /auth/path/.agentteams/runner/history/trigger-1.md\n- Previous history path: /auth/path/.agentteams/runner/history/parent-1.md");
+    assert.equal(logEntries.some((entry) => entry.level === "INFO" && entry.message.includes("stdout")), true);
+    assert.equal(logEntries.some((entry) => entry.level === "WARN" && entry.message.includes("stderr")), true);
+    assert.deepEqual(clientCalls.map((entry) => entry.method), [
+        "fetchTriggerRuntime",
+        "isTriggerCancelRequested",
+        "updateTriggerHistory",
+        "updateTriggerStatus"
+    ]);
+    assert.deepEqual(clientCalls.at(-1)?.args, ["trigger-1", "DONE", undefined]);
 });
-test('createTriggerHandler preserves the local history file and still marks success when history upload fails', async () => {
+test("createTriggerHandler preserves the local history file and still marks success when history upload fails", async () => {
     const clientCalls = [];
     const writeHistoryCalls = [];
     const client = {
         fetchTriggerRuntime: async () => runtime,
         isTriggerCancelRequested: async () => false,
         updateTriggerHistory: async (...args) => {
-            clientCalls.push({ method: 'updateTriggerHistory', args });
+            clientCalls.push({ method: "updateTriggerHistory", args });
             // 서버가 보고를 거부하는 상황(예: 공유 러너 404, 일시적 네트워크 오류)을 모사.
-            throw new Error('Failed to update trigger history (404)');
+            throw new Error("Failed to update trigger history (404)");
         },
         updateTriggerStatus: async (...args) => {
-            clientCalls.push({ method: 'updateTriggerStatus', args });
-        },
+            clientCalls.push({ method: "updateTriggerStatus", args });
+        }
     };
     const handler = createTriggerHandler({
         config: {
-            daemonToken: 'daemon-token',
-            apiUrl: 'https://api.example',
+            daemonToken: "daemon-token",
+            apiUrl: "https://api.example",
             pollingIntervalMs: 5000,
             timeoutMs: 1500,
             idleTimeoutMs: 500,
-            runnerCmd: 'opencode',
-            preventSleepWhileBusy: false,
+            runnerCmd: "opencode",
+            preventSleepWhileBusy: false
         },
-        client: client,
+        client: client
     }, {
         createRunnerFactory: () => () => ({
-            run: async () => ({ exitCode: 0, outputText: '{"type":"result"}' }),
+            run: async () => ({ exitCode: 0, outputText: "{\"type\":\"result\"}" })
         }),
         createLogReporter: () => ({
             start: () => undefined,
             append: () => undefined,
-            stop: async () => undefined,
+            stop: async () => undefined
         }),
         // 러너가 정상 히스토리 파일을 작성한 상태(Questions 섹션 포함 → 정규화 없음).
-        readHistoryFile: async () => '### Summary\n- done\n\n### Questions for User\nNone',
+        readHistoryFile: async () => "### Summary\n- done\n\n### Questions for User\nNone",
         writeHistoryFile: async (path, content) => {
             writeHistoryCalls.push({ path, content });
         },
         resolveRunnerHistoryPaths: () => ({
-            currentHistoryPath: '/auth/path/.agentteams/runner/history/trigger-1.md',
-            parentHistoryPath: null,
-        }),
+            currentHistoryPath: "/auth/path/.agentteams/runner/history/trigger-1.md",
+            parentHistoryPath: null
+        })
     });
     await handler(trigger);
     // 업로드는 1회 시도됐고(실패), 핵심: 좋은 히스토리 파일을 stdout 폴백으로 덮어쓰지 않는다.
-    assert.equal(clientCalls.filter((entry) => entry.method === 'updateTriggerHistory').length, 1);
+    assert.equal(clientCalls.filter((entry) => entry.method === "updateTriggerHistory").length, 1);
     assert.deepEqual(writeHistoryCalls, []);
     // 업로드 실패가 러너 성공을 뒤집지 않고 DONE으로 보고된다(FAILED 아님).
-    const statusCall = clientCalls.find((entry) => entry.method === 'updateTriggerStatus');
-    assert.deepEqual(statusCall?.args, ['trigger-1', 'DONE', undefined]);
+    const statusCall = clientCalls.find((entry) => entry.method === "updateTriggerStatus");
+    assert.deepEqual(statusCall?.args, ["trigger-1", "DONE", undefined]);
 });
-test('createTriggerHandler strips a UTF-8 BOM before reporting history to the database', async () => {
+test("createTriggerHandler strips a UTF-8 BOM before reporting history to the database", async () => {
     const clientCalls = [];
     const logEntries = [];
     const client = {
         fetchTriggerRuntime: async () => runtime,
         isTriggerCancelRequested: async () => false,
         updateTriggerHistory: async (...args) => {
-            clientCalls.push({ method: 'updateTriggerHistory', args });
+            clientCalls.push({ method: "updateTriggerHistory", args });
         },
         updateTriggerStatus: async (...args) => {
-            clientCalls.push({ method: 'updateTriggerStatus', args });
-        },
+            clientCalls.push({ method: "updateTriggerStatus", args });
+        }
     };
     const handler = createTriggerHandler({
         config: {
-            daemonToken: 'daemon-token',
-            apiUrl: 'https://api.example',
+            daemonToken: "daemon-token",
+            apiUrl: "https://api.example",
             pollingIntervalMs: 5000,
             timeoutMs: 1500,
             idleTimeoutMs: 500,
-            runnerCmd: 'opencode',
-            preventSleepWhileBusy: false,
+            runnerCmd: "opencode",
+            preventSleepWhileBusy: false
         },
-        client: client,
+        client: client
     }, {
         createRunnerFactory: () => () => ({
-            run: async () => ({ exitCode: 0 }),
+            run: async () => ({ exitCode: 0 })
         }),
         createLogReporter: () => ({
             start: () => undefined,
             append: (level, message) => {
                 logEntries.push({ level, message });
             },
-            stop: async () => undefined,
+            stop: async () => undefined
         }),
-        readHistoryFile: async () => '\uFEFF### Summary\n- done\n',
+        readHistoryFile: async () => "\uFEFF### Summary\n- done\n",
         resolveRunnerHistoryPaths: () => ({
-            currentHistoryPath: '/auth/path/.agentteams/runner/history/trigger-1.md',
-            parentHistoryPath: '/auth/path/.agentteams/runner/history/parent-1.md',
-        }),
+            currentHistoryPath: "/auth/path/.agentteams/runner/history/trigger-1.md",
+            parentHistoryPath: "/auth/path/.agentteams/runner/history/parent-1.md"
+        })
     });
     await handler(trigger);
     // BOM stripped, and the missing Questions for User section is appended by normalization
-    assert.deepEqual(clientCalls.at(0)?.args, ['trigger-1', '### Summary\n- done\n\n### Questions for User\nNone']);
+    assert.deepEqual(clientCalls.at(0)?.args, ["trigger-1", "### Summary\n- done\n\n### Questions for User\nNone"]);
     // observation signal: normalization is surfaced to the trigger log (web UI logs tab)
-    assert.ok(logEntries.some((entry) => entry.level === 'WARN' && entry.message.includes('Questions for User')));
+    assert.ok(logEntries.some((entry) => entry.level === "WARN" && entry.message.includes("Questions for User")));
 });
-test('createTriggerHandler keeps history unchanged when the Questions for User section exists', async () => {
+test("createTriggerHandler keeps history unchanged when the Questions for User section exists", async () => {
     const clientCalls = [];
     const logEntries = [];
     const client = {
         fetchTriggerRuntime: async () => runtime,
         isTriggerCancelRequested: async () => false,
         updateTriggerHistory: async (...args) => {
-            clientCalls.push({ method: 'updateTriggerHistory', args });
+            clientCalls.push({ method: "updateTriggerHistory", args });
         },
         updateTriggerStatus: async (...args) => {
-            clientCalls.push({ method: 'updateTriggerStatus', args });
-        },
+            clientCalls.push({ method: "updateTriggerStatus", args });
+        }
     };
-    const historyWithQuestions = '### Summary\n- done\n\n### Questions for User\n- Should we ship this now?';
+    const historyWithQuestions = "### Summary\n- done\n\n### Questions for User\n- Should we ship this now?";
     const handler = createTriggerHandler({
         config: {
-            daemonToken: 'daemon-token',
-            apiUrl: 'https://api.example',
+            daemonToken: "daemon-token",
+            apiUrl: "https://api.example",
             pollingIntervalMs: 5000,
             timeoutMs: 1500,
             idleTimeoutMs: 500,
-            runnerCmd: 'opencode',
-            preventSleepWhileBusy: false,
+            runnerCmd: "opencode",
+            preventSleepWhileBusy: false
         },
-        client: client,
+        client: client
     }, {
         createRunnerFactory: () => () => ({
-            run: async () => ({ exitCode: 0 }),
+            run: async () => ({ exitCode: 0 })
         }),
         createLogReporter: () => ({
             start: () => undefined,
             append: (level, message) => {
                 logEntries.push({ level, message });
             },
-            stop: async () => undefined,
+            stop: async () => undefined
         }),
         readHistoryFile: async () => historyWithQuestions,
         resolveRunnerHistoryPaths: () => ({
-            currentHistoryPath: '/auth/path/.agentteams/runner/history/trigger-1.md',
-            parentHistoryPath: '/auth/path/.agentteams/runner/history/parent-1.md',
-        }),
+            currentHistoryPath: "/auth/path/.agentteams/runner/history/trigger-1.md",
+            parentHistoryPath: "/auth/path/.agentteams/runner/history/parent-1.md"
+        })
     });
     await handler(trigger);
-    assert.deepEqual(clientCalls.at(0)?.args, ['trigger-1', historyWithQuestions]);
+    assert.deepEqual(clientCalls.at(0)?.args, ["trigger-1", historyWithQuestions]);
     // no normalization → no observation warning
-    assert.ok(!logEntries.some((entry) => entry.message.includes('Questions for User')));
+    assert.ok(!logEntries.some((entry) => entry.message.includes("Questions for User")));
 });
-test('createTriggerHandler restores parent history from server-side coaction content', async () => {
+test("createTriggerHandler restores parent history from server-side coaction content", async () => {
     const runnerInputs = [];
     const writtenFiles = [];
     const client = {
         fetchTriggerRuntime: async () => ({
             ...runtime,
-            parentHistoryMarkdown: '### Summary\n- restored from coaction\n',
+            parentHistoryMarkdown: "### Summary\n- restored from coaction\n"
         }),
         isTriggerCancelRequested: async () => false,
         updateTriggerHistory: async () => undefined,
-        updateTriggerStatus: async () => undefined,
+        updateTriggerStatus: async () => undefined
     };
     const handler = createTriggerHandler({
         config: {
-            daemonToken: 'daemon-token',
-            apiUrl: 'https://api.example',
+            daemonToken: "daemon-token",
+            apiUrl: "https://api.example",
             pollingIntervalMs: 5000,
             timeoutMs: 1500,
             idleTimeoutMs: 500,
-            runnerCmd: 'opencode',
-            preventSleepWhileBusy: false,
+            runnerCmd: "opencode",
+            preventSleepWhileBusy: false
         },
-        client: client,
+        client: client
     }, {
         createRunnerFactory: () => () => ({
             run: async (input) => {
                 runnerInputs.push({ prompt: input.prompt, authPath: input.authPath });
                 return { exitCode: 0 };
-            },
+            }
         }),
         createLogReporter: () => ({
             start: () => undefined,
             append: () => undefined,
-            stop: async () => undefined,
+            stop: async () => undefined
         }),
         readHistoryFile: async (path) => {
-            if (String(path).endsWith('parent-1.md')) {
-                throw new Error('ENOENT');
+            if (String(path).endsWith("parent-1.md")) {
+                throw new Error("ENOENT");
             }
-            return '### Summary\n- current\n';
+            return "### Summary\n- current\n";
         },
         writeHistoryFile: async (path, content) => {
             writtenFiles.push({ path, content });
         },
         resolveRunnerHistoryPaths: () => ({
-            currentHistoryPath: '/auth/path/.agentteams/runner/history/trigger-1.md',
-            parentHistoryPath: '/auth/path/.agentteams/runner/history/parent-1.md',
-        }),
+            currentHistoryPath: "/auth/path/.agentteams/runner/history/trigger-1.md",
+            parentHistoryPath: "/auth/path/.agentteams/runner/history/parent-1.md"
+        })
     });
     await handler(trigger);
     assert.equal(runnerInputs.length, 1);
-    assert.deepEqual(writtenFiles, [
-        {
-            path: '/auth/path/.agentteams/runner/history/parent-1.md',
-            content: '### Summary\n- restored from coaction',
-        },
-    ]);
+    assert.deepEqual(writtenFiles, [{
+            path: "/auth/path/.agentteams/runner/history/parent-1.md",
+            content: "### Summary\n- restored from coaction"
+        }]);
 });
-test('createTriggerHandler strips a UTF-8 BOM before restoring parent history from the server', async () => {
+test("createTriggerHandler strips a UTF-8 BOM before restoring parent history from the server", async () => {
     const writtenFiles = [];
     const client = {
         fetchTriggerRuntime: async () => ({
             ...runtime,
-            parentHistoryMarkdown: '\uFEFF### Summary\n- restored from coaction\n',
+            parentHistoryMarkdown: "\uFEFF### Summary\n- restored from coaction\n"
         }),
         isTriggerCancelRequested: async () => false,
         updateTriggerHistory: async () => undefined,
-        updateTriggerStatus: async () => undefined,
+        updateTriggerStatus: async () => undefined
     };
     const handler = createTriggerHandler({
         config: {
-            daemonToken: 'daemon-token',
-            apiUrl: 'https://api.example',
+            daemonToken: "daemon-token",
+            apiUrl: "https://api.example",
             pollingIntervalMs: 5000,
             timeoutMs: 1500,
             idleTimeoutMs: 500,
-            runnerCmd: 'opencode',
-            preventSleepWhileBusy: false,
+            runnerCmd: "opencode",
+            preventSleepWhileBusy: false
         },
-        client: client,
+        client: client
     }, {
         createRunnerFactory: () => () => ({
-            run: async () => ({ exitCode: 0 }),
+            run: async () => ({ exitCode: 0 })
         }),
         createLogReporter: () => ({
             start: () => undefined,
             append: () => undefined,
-            stop: async () => undefined,
+            stop: async () => undefined
         }),
-        readHistoryFile: async () => '### Summary\n- current\n',
+        readHistoryFile: async () => "### Summary\n- current\n",
         writeHistoryFile: async (path, content) => {
             writtenFiles.push({ path, content });
         },
         resolveRunnerHistoryPaths: () => ({
-            currentHistoryPath: '/auth/path/.agentteams/runner/history/trigger-1.md',
-            parentHistoryPath: '/auth/path/.agentteams/runner/history/parent-1.md',
-        }),
+            currentHistoryPath: "/auth/path/.agentteams/runner/history/trigger-1.md",
+            parentHistoryPath: "/auth/path/.agentteams/runner/history/parent-1.md"
+        })
     });
     await handler(trigger);
-    assert.deepEqual(writtenFiles, [
-        {
-            path: '/auth/path/.agentteams/runner/history/parent-1.md',
-            content: '### Summary\n- restored from coaction',
-        },
-    ]);
+    assert.deepEqual(writtenFiles, [{
+            path: "/auth/path/.agentteams/runner/history/parent-1.md",
+            content: "### Summary\n- restored from coaction"
+        }]);
 });
-test('createTriggerHandler overwrites existing parent history with server cumulative context', async () => {
+test("createTriggerHandler overwrites existing parent history with server cumulative context", async () => {
     const writtenFiles = [];
     const client = {
         fetchTriggerRuntime: async () => ({
             ...runtime,
-            parentHistoryMarkdown: '### Summary\n- cumulative from server\n',
+            parentHistoryMarkdown: "### Summary\n- cumulative from server\n"
         }),
         isTriggerCancelRequested: async () => false,
         updateTriggerHistory: async () => undefined,
-        updateTriggerStatus: async () => undefined,
+        updateTriggerStatus: async () => undefined
     };
     const handler = createTriggerHandler({
         config: {
-            daemonToken: 'daemon-token',
-            apiUrl: 'https://api.example',
+            daemonToken: "daemon-token",
+            apiUrl: "https://api.example",
             pollingIntervalMs: 5000,
             timeoutMs: 1500,
             idleTimeoutMs: 500,
-            runnerCmd: 'opencode',
-            preventSleepWhileBusy: false,
+            runnerCmd: "opencode",
+            preventSleepWhileBusy: false
         },
-        client: client,
+        client: client
     }, {
         createRunnerFactory: () => () => ({
-            run: async () => ({ exitCode: 0 }),
+            run: async () => ({ exitCode: 0 })
         }),
         createLogReporter: () => ({
             start: () => undefined,
             append: () => undefined,
-            stop: async () => undefined,
+            stop: async () => undefined
         }),
-        readHistoryFile: async () => '### Summary\n- stale local parent history\n',
+        readHistoryFile: async () => "### Summary\n- stale local parent history\n",
         writeHistoryFile: async (path, content) => {
             writtenFiles.push({ path, content });
         },
         resolveRunnerHistoryPaths: () => ({
-            currentHistoryPath: '/auth/path/.agentteams/runner/history/trigger-1.md',
-            parentHistoryPath: '/auth/path/.agentteams/runner/history/parent-1.md',
-        }),
+            currentHistoryPath: "/auth/path/.agentteams/runner/history/trigger-1.md",
+            parentHistoryPath: "/auth/path/.agentteams/runner/history/parent-1.md"
+        })
     });
     await handler(trigger);
-    assert.deepEqual(writtenFiles, [
-        {
-            path: '/auth/path/.agentteams/runner/history/parent-1.md',
-            content: '### Summary\n- cumulative from server',
-        },
-    ]);
+    assert.deepEqual(writtenFiles, [{
+            path: "/auth/path/.agentteams/runner/history/parent-1.md",
+            content: "### Summary\n- cumulative from server"
+        }]);
 });
-test('createTriggerHandler reports runner failures and falls back to last output', async () => {
+test("createTriggerHandler reports runner failures and falls back to last output", async () => {
     const clientCalls = [];
     const client = {
         fetchTriggerRuntime: async () => runtime,
         isTriggerCancelRequested: async () => false,
         updateTriggerHistory: async (...args) => {
-            clientCalls.push({ method: 'updateTriggerHistory', args });
+            clientCalls.push({ method: "updateTriggerHistory", args });
         },
         updateTriggerStatus: async (...args) => {
-            clientCalls.push({ method: 'updateTriggerStatus', args });
-        },
+            clientCalls.push({ method: "updateTriggerStatus", args });
+        }
     };
     const handler = createTriggerHandler({
         config: {
-            daemonToken: 'daemon-token',
-            apiUrl: 'https://api.example',
+            daemonToken: "daemon-token",
+            apiUrl: "https://api.example",
             pollingIntervalMs: 5000,
             timeoutMs: 1500,
             idleTimeoutMs: 500,
-            runnerCmd: 'opencode',
-            preventSleepWhileBusy: false,
+            runnerCmd: "opencode",
+            preventSleepWhileBusy: false
         },
-        client: client,
+        client: client
     }, {
         createRunnerFactory: () => () => ({
-            run: async () => ({ exitCode: 1, lastOutput: 'last output' }),
+            run: async () => ({ exitCode: 1, lastOutput: "last output" })
         }),
         createLogReporter: () => ({
             start: () => undefined,
             append: () => undefined,
-            stop: async () => undefined,
+            stop: async () => undefined
         }),
-        readHistoryFile: async () => '',
+        readHistoryFile: async () => "",
         resolveRunnerHistoryPaths: () => ({
-            currentHistoryPath: '/auth/path/.agentteams/runner/history/trigger-1.md',
-            parentHistoryPath: null,
-        }),
+            currentHistoryPath: "/auth/path/.agentteams/runner/history/trigger-1.md",
+            parentHistoryPath: null
+        })
     });
     await handler({ ...trigger, parentTriggerId: null });
-    assert.deepEqual(clientCalls.at(-1)?.args, ['trigger-1', 'FAILED', 'last output']);
+    assert.deepEqual(clientCalls.at(-1)?.args, ["trigger-1", "FAILED", "last output"]);
 });
-test('createTriggerHandler stores stdout as fallback history when the runner omits the history file', async () => {
+test("createTriggerHandler stores stdout as fallback history when the runner omits the history file", async () => {
     const clientCalls = [];
     const writtenFiles = [];
     const client = {
         fetchTriggerRuntime: async () => runtime,
         isTriggerCancelRequested: async () => false,
         updateTriggerHistory: async (...args) => {
-            clientCalls.push({ method: 'updateTriggerHistory', args });
+            clientCalls.push({ method: "updateTriggerHistory", args });
         },
         updateTriggerStatus: async (...args) => {
-            clientCalls.push({ method: 'updateTriggerStatus', args });
-        },
+            clientCalls.push({ method: "updateTriggerStatus", args });
+        }
     };
     const handler = createTriggerHandler({
         config: {
-            daemonToken: 'daemon-token',
-            apiUrl: 'https://api.example',
+            daemonToken: "daemon-token",
+            apiUrl: "https://api.example",
             pollingIntervalMs: 5000,
             timeoutMs: 1500,
             idleTimeoutMs: 500,
-            runnerCmd: 'opencode',
-            preventSleepWhileBusy: false,
+            runnerCmd: "opencode",
+            preventSleepWhileBusy: false
         },
-        client: client,
+        client: client
     }, {
         createRunnerFactory: () => () => ({
             run: async () => ({
                 exitCode: 0,
-                outputText: 'agentrunner version 0.0.11',
-            }),
+                outputText: "agentrunner version 0.0.11"
+            })
         }),
         createLogReporter: () => ({
             start: () => undefined,
             append: () => undefined,
-            stop: async () => undefined,
+            stop: async () => undefined
         }),
         writeHistoryFile: async (path, content) => {
             writtenFiles.push({ path, content });
         },
         readHistoryFile: async () => {
-            throw new Error('ENOENT');
+            throw new Error("ENOENT");
         },
         resolveRunnerHistoryPaths: () => ({
-            currentHistoryPath: '/auth/path/.agentteams/runner/history/trigger-1.md',
-            parentHistoryPath: null,
-        }),
+            currentHistoryPath: "/auth/path/.agentteams/runner/history/trigger-1.md",
+            parentHistoryPath: null
+        })
     });
     await handler({ ...trigger, parentTriggerId: null });
-    assert.deepEqual(clientCalls.map((entry) => entry.method), ['updateTriggerHistory', 'updateTriggerStatus']);
+    assert.deepEqual(clientCalls.map((entry) => entry.method), [
+        "updateTriggerHistory",
+        "updateTriggerStatus"
+    ]);
     assert.equal(writtenFiles.length, 1);
-    assert.equal(writtenFiles[0]?.path, '/auth/path/.agentteams/runner/history/trigger-1.md');
+    assert.equal(writtenFiles[0]?.path, "/auth/path/.agentteams/runner/history/trigger-1.md");
     assert.match(String(clientCalls[0]?.args[1]), /Agent output \(history file not written\)/);
     assert.match(String(clientCalls[0]?.args[1]), /agentrunner version 0\.0\.11/);
-    assert.deepEqual(clientCalls.at(-1)?.args, ['trigger-1', 'DONE', undefined]);
+    assert.deepEqual(clientCalls.at(-1)?.args, ["trigger-1", "DONE", undefined]);
 });
-test('createTriggerHandler truncates long agent output in fallback history', async () => {
+test("createTriggerHandler truncates long agent output in fallback history", async () => {
     const clientCalls = [];
     const writtenFiles = [];
-    const longOutput = 'x'.repeat(9000);
+    const longOutput = "x".repeat(9000);
     const client = {
         fetchTriggerRuntime: async () => runtime,
         isTriggerCancelRequested: async () => false,
         updateTriggerHistory: async (...args) => {
-            clientCalls.push({ method: 'updateTriggerHistory', args });
+            clientCalls.push({ method: "updateTriggerHistory", args });
         },
         updateTriggerStatus: async (...args) => {
-            clientCalls.push({ method: 'updateTriggerStatus', args });
-        },
+            clientCalls.push({ method: "updateTriggerStatus", args });
+        }
     };
     const handler = createTriggerHandler({
         config: {
-            daemonToken: 'daemon-token',
-            apiUrl: 'https://api.example',
+            daemonToken: "daemon-token",
+            apiUrl: "https://api.example",
             pollingIntervalMs: 5000,
             timeoutMs: 1500,
             idleTimeoutMs: 500,
-            runnerCmd: 'opencode',
-            preventSleepWhileBusy: false,
+            runnerCmd: "opencode",
+            preventSleepWhileBusy: false
         },
-        client: client,
+        client: client
     }, {
         createRunnerFactory: () => () => ({
             run: async () => ({
                 exitCode: 0,
-                outputText: longOutput,
-            }),
+                outputText: longOutput
+            })
         }),
         createLogReporter: () => ({
             start: () => undefined,
             append: () => undefined,
-            stop: async () => undefined,
+            stop: async () => undefined
         }),
         writeHistoryFile: async (path, content) => {
             writtenFiles.push({ path, content });
         },
         readHistoryFile: async () => {
-            throw new Error('ENOENT');
+            throw new Error("ENOENT");
         },
         resolveRunnerHistoryPaths: () => ({
-            currentHistoryPath: '/auth/path/.agentteams/runner/history/trigger-1.md',
-            parentHistoryPath: null,
-        }),
+            currentHistoryPath: "/auth/path/.agentteams/runner/history/trigger-1.md",
+            parentHistoryPath: null
+        })
     });
     await handler({ ...trigger, parentTriggerId: null });
     const fallbackContent = String(clientCalls[0]?.args[1]);
     assert.match(fallbackContent, /\*\(truncated\)\*/);
-    assert.ok(fallbackContent.length < 9000, 'Fallback history should be truncated');
-    assert.ok(fallbackContent.includes('x'.repeat(8000)), 'Fallback history should retain output up to the 8,000 character limit');
+    assert.ok(fallbackContent.length < 9000, "Fallback history should be truncated");
+    assert.ok(fallbackContent.includes("x".repeat(8000)), "Fallback history should retain output up to the 8,000 character limit");
 });
-test('createTriggerHandler preserves fallback agent output within history limit', async () => {
+test("createTriggerHandler preserves fallback agent output within history limit", async () => {
     const clientCalls = [];
     const writtenFiles = [];
-    const output = 'x'.repeat(8000);
+    const output = "x".repeat(8000);
     const client = {
         fetchTriggerRuntime: async () => runtime,
         isTriggerCancelRequested: async () => false,
         updateTriggerHistory: async (...args) => {
-            clientCalls.push({ method: 'updateTriggerHistory', args });
+            clientCalls.push({ method: "updateTriggerHistory", args });
         },
         updateTriggerStatus: async (...args) => {
-            clientCalls.push({ method: 'updateTriggerStatus', args });
-        },
+            clientCalls.push({ method: "updateTriggerStatus", args });
+        }
     };
     const handler = createTriggerHandler({
         config: {
-            daemonToken: 'daemon-token',
-            apiUrl: 'https://api.example',
+            daemonToken: "daemon-token",
+            apiUrl: "https://api.example",
             pollingIntervalMs: 5000,
             timeoutMs: 1500,
             idleTimeoutMs: 500,
-            runnerCmd: 'opencode',
-            preventSleepWhileBusy: false,
+            runnerCmd: "opencode",
+            preventSleepWhileBusy: false
         },
-        client: client,
+        client: client
     }, {
         createRunnerFactory: () => () => ({
             run: async () => ({
                 exitCode: 0,
-                outputText: output,
-            }),
+                outputText: output
+            })
         }),
         createLogReporter: () => ({
             start: () => undefined,
             append: () => undefined,
-            stop: async () => undefined,
+            stop: async () => undefined
         }),
         writeHistoryFile: async (path, content) => {
             writtenFiles.push({ path, content });
         },
         readHistoryFile: async () => {
-            throw new Error('ENOENT');
+            throw new Error("ENOENT");
         },
         resolveRunnerHistoryPaths: () => ({
-            currentHistoryPath: '/auth/path/.agentteams/runner/history/trigger-1.md',
-            parentHistoryPath: null,
-        }),
+            currentHistoryPath: "/auth/path/.agentteams/runner/history/trigger-1.md",
+            parentHistoryPath: null
+        })
     });
     await handler({ ...trigger, parentTriggerId: null });
     const fallbackContent = String(clientCalls[0]?.args[1]);
     assert.doesNotMatch(fallbackContent, /\*\(truncated\)\*/);
     assert.match(fallbackContent, new RegExp(`x{${output.length}}`));
 });
-test('createTriggerHandler cancels the runner when the server reports a cancel request', async () => {
+test("createTriggerHandler cancels the runner when the server reports a cancel request", async () => {
     const clientCalls = [];
     const client = {
         fetchTriggerRuntime: async () => runtime,
         isTriggerCancelRequested: async (...args) => {
-            clientCalls.push({ method: 'isTriggerCancelRequested', args });
+            clientCalls.push({ method: "isTriggerCancelRequested", args });
             return true;
         },
         updateTriggerHistory: async (...args) => {
-            clientCalls.push({ method: 'updateTriggerHistory', args });
+            clientCalls.push({ method: "updateTriggerHistory", args });
         },
         updateTriggerStatus: async (...args) => {
-            clientCalls.push({ method: 'updateTriggerStatus', args });
-        },
+            clientCalls.push({ method: "updateTriggerStatus", args });
+        }
     };
     const handler = createTriggerHandler({
         config: {
-            daemonToken: 'daemon-token',
-            apiUrl: 'https://api.example',
+            daemonToken: "daemon-token",
+            apiUrl: "https://api.example",
             pollingIntervalMs: 5000,
             timeoutMs: 1500,
             idleTimeoutMs: 500,
-            runnerCmd: 'opencode',
-            preventSleepWhileBusy: false,
+            runnerCmd: "opencode",
+            preventSleepWhileBusy: false
         },
-        client: client,
+        client: client
     }, {
         createRunnerFactory: () => () => ({
             run: async ({ signal }) => {
                 await new Promise((resolve) => {
-                    signal?.addEventListener('abort', () => resolve(), { once: true });
+                    signal?.addEventListener("abort", () => resolve(), { once: true });
                     if (signal?.aborted) {
                         resolve();
                     }
@@ -659,70 +661,70 @@ test('createTriggerHandler cancels the runner when the server reports a cancel r
                 return {
                     exitCode: 1,
                     cancelled: true,
-                    errorMessage: 'Runner cancelled by user',
+                    errorMessage: "Runner cancelled by user"
                 };
-            },
+            }
         }),
         createLogReporter: () => ({
             start: () => undefined,
             append: () => undefined,
-            stop: async () => undefined,
+            stop: async () => undefined
         }),
-        readHistoryFile: async () => '',
+        readHistoryFile: async () => "",
         cancelPollIntervalMs: 1,
         resolveRunnerHistoryPaths: () => ({
-            currentHistoryPath: '/auth/path/.agentteams/runner/history/trigger-1.md',
-            parentHistoryPath: null,
-        }),
+            currentHistoryPath: "/auth/path/.agentteams/runner/history/trigger-1.md",
+            parentHistoryPath: null
+        })
     });
     await handler({ ...trigger, parentTriggerId: null });
-    assert.deepEqual(clientCalls.at(-1)?.args, ['trigger-1', 'CANCELLED', 'Runner cancelled by user']);
+    assert.deepEqual(clientCalls.at(-1)?.args, ["trigger-1", "CANCELLED", "Runner cancelled by user"]);
 });
-test('createTriggerHandler marks the trigger as failed when runtime loading throws', async () => {
+test("createTriggerHandler marks the trigger as failed when runtime loading throws", async () => {
     const errors = [];
-    mock.method(logger, 'error', (message, meta) => {
+    mock.method(logger, "error", (message, meta) => {
         errors.push({ message, meta });
     });
     const clientCalls = [];
     const client = {
         fetchTriggerRuntime: async () => {
-            throw new Error('runtime boom');
+            throw new Error("runtime boom");
         },
         isTriggerCancelRequested: async () => false,
         updateTriggerHistory: async (...args) => {
-            clientCalls.push({ method: 'updateTriggerHistory', args });
+            clientCalls.push({ method: "updateTriggerHistory", args });
         },
         updateTriggerStatus: async (...args) => {
-            clientCalls.push({ method: 'updateTriggerStatus', args });
-        },
+            clientCalls.push({ method: "updateTriggerStatus", args });
+        }
     };
     const handler = createTriggerHandler({
         config: {
-            daemonToken: 'daemon-token',
-            apiUrl: 'https://api.example',
+            daemonToken: "daemon-token",
+            apiUrl: "https://api.example",
             pollingIntervalMs: 5000,
             timeoutMs: 1500,
             idleTimeoutMs: 500,
-            runnerCmd: 'opencode',
-            preventSleepWhileBusy: false,
+            runnerCmd: "opencode",
+            preventSleepWhileBusy: false
         },
-        client: client,
+        client: client
     }, {
         createLogReporter: () => ({
             start: () => undefined,
             append: () => undefined,
-            stop: async () => undefined,
-        }),
+            stop: async () => undefined
+        })
     });
     await handler({ ...trigger, parentTriggerId: null });
-    assert.deepEqual(clientCalls.at(-1)?.args, ['trigger-1', 'FAILED', 'runtime boom']);
-    assert.equal(errors.some((entry) => entry.message === 'Trigger handling failed'), true);
+    assert.deepEqual(clientCalls.at(-1)?.args, ["trigger-1", "FAILED", "runtime boom"]);
+    assert.equal(errors.some((entry) => entry.message === "Trigger handling failed"), true);
 });
 // ---------------------------------------------------------------------------
 // Pre-execution hook tests
 // ---------------------------------------------------------------------------
 const withTempDir = async (run) => {
-    const dir = await mkdtemp(join(tmpdir(), 'trigger-handler-hook-test-'));
+    const dir = await mkdtemp(join(tmpdir(), "trigger-handler-hook-test-"));
     try {
         await run(dir);
     }
@@ -730,14 +732,14 @@ const withTempDir = async (run) => {
         await rm(dir, { recursive: true, force: true });
     }
 };
-test('createTriggerHandler passes the API-provided runner prompt unchanged', async () => {
+test("createTriggerHandler passes the API-provided runner prompt unchanged", async () => {
     await withTempDir(async (dir) => {
         const runnerInputs = [];
         const client = {
             fetchTriggerRuntime: async () => ({
                 ...runtime,
                 authPath: dir,
-                runnerPrompt: 'Prompt generated by API\n\nDo exactly this.',
+                runnerPrompt: "Prompt generated by API\n\nDo exactly this.",
             }),
             isTriggerCancelRequested: async () => false,
             updateTriggerHistory: async () => undefined,
@@ -745,12 +747,12 @@ test('createTriggerHandler passes the API-provided runner prompt unchanged', asy
         };
         const handler = createTriggerHandler({
             config: {
-                daemonToken: 'daemon-token',
-                apiUrl: 'https://api.example',
+                daemonToken: "daemon-token",
+                apiUrl: "https://api.example",
                 pollingIntervalMs: 5000,
                 timeoutMs: 1500,
                 idleTimeoutMs: 500,
-                runnerCmd: 'opencode',
+                runnerCmd: "opencode",
                 preventSleepWhileBusy: false,
             },
             client: client,
@@ -766,18 +768,18 @@ test('createTriggerHandler passes the API-provided runner prompt unchanged', asy
                 append: () => undefined,
                 stop: async () => undefined,
             }),
-            readHistoryFile: async () => '### Summary\n- done\n',
+            readHistoryFile: async () => "### Summary\n- done\n",
             resolveRunnerHistoryPaths: () => ({
-                currentHistoryPath: join(dir, '.agentteams/runner/history/trigger-1.md'),
+                currentHistoryPath: join(dir, ".agentteams/runner/history/trigger-1.md"),
                 parentHistoryPath: null,
             }),
         });
         await handler({ ...trigger, parentTriggerId: null });
         assert.equal(runnerInputs.length, 1);
-        assert.equal(runnerInputs[0]?.prompt, 'Prompt generated by API\n\nDo exactly this.');
+        assert.equal(runnerInputs[0]?.prompt, "Prompt generated by API\n\nDo exactly this.");
     });
 });
-test('createTriggerHandler downloads attachments into the runner workspace and injects local paths', async () => {
+test("createTriggerHandler downloads attachments into the runner workspace and injects local paths", async () => {
     await withTempDir(async (dir) => {
         const runnerInputs = [];
         const downloadedUrls = [];
@@ -785,17 +787,15 @@ test('createTriggerHandler downloads attachments into the runner workspace and i
             fetchTriggerRuntime: async () => ({
                 ...runtime,
                 authPath: dir,
-                runnerPrompt: 'Use the attached file.',
-                attachments: [
-                    {
-                        id: 'attachment-1',
-                        originalName: '../notes file.md',
-                        mimeType: 'text/markdown',
+                runnerPrompt: "Use the attached file.",
+                attachments: [{
+                        id: "attachment-1",
+                        originalName: "../notes file.md",
+                        mimeType: "text/markdown",
                         size: 12,
-                        downloadUrl: 'https://storage.example/attachment-1',
+                        downloadUrl: "https://storage.example/attachment-1",
                         expiresInSeconds: 300,
-                    },
-                ],
+                    }],
             }),
             isTriggerCancelRequested: async () => false,
             updateTriggerHistory: async () => undefined,
@@ -803,12 +803,12 @@ test('createTriggerHandler downloads attachments into the runner workspace and i
         };
         const handler = createTriggerHandler({
             config: {
-                daemonToken: 'daemon-token',
-                apiUrl: 'https://api.example',
+                daemonToken: "daemon-token",
+                apiUrl: "https://api.example",
                 pollingIntervalMs: 5000,
                 timeoutMs: 1500,
                 idleTimeoutMs: 500,
-                runnerCmd: 'opencode',
+                runnerCmd: "opencode",
                 preventSleepWhileBusy: false,
             },
             client: client,
@@ -826,18 +826,18 @@ test('createTriggerHandler downloads attachments into the runner workspace and i
             }),
             fetchAttachmentFile: async (downloadUrl) => {
                 downloadedUrls.push(downloadUrl);
-                return new TextEncoder().encode('hello world\n');
+                return new TextEncoder().encode("hello world\n");
             },
-            readHistoryFile: async () => '### Summary\n- done\n',
+            readHistoryFile: async () => "### Summary\n- done\n",
             resolveRunnerHistoryPaths: () => ({
-                currentHistoryPath: join(dir, '.agentteams/runner/history/trigger-1.md'),
+                currentHistoryPath: join(dir, ".agentteams/runner/history/trigger-1.md"),
                 parentHistoryPath: null,
             }),
         });
         await handler({ ...trigger, parentTriggerId: null });
-        assert.deepEqual(downloadedUrls, ['https://storage.example/attachment-1']);
+        assert.deepEqual(downloadedUrls, ["https://storage.example/attachment-1"]);
         assert.equal(runnerInputs.length, 1);
-        const prompt = runnerInputs[0]?.prompt ?? '';
+        const prompt = runnerInputs[0]?.prompt ?? "";
         assert.match(prompt, /## Attached Files/);
         assert.match(prompt, /MIME type: text\/markdown/);
         assert.match(prompt, /Size: 12 bytes/);
@@ -845,28 +845,26 @@ test('createTriggerHandler downloads attachments into the runner workspace and i
         assert.doesNotMatch(prompt, /https:\/\/storage\.example/);
         const localPathMatch = prompt.match(/Local path: (.+01-attachme-notes-file\.md)$/m);
         assert.ok(localPathMatch?.[1]);
-        assert.equal(localPathMatch[1].startsWith(join(dir, '.agentteams', 'runner', 'attachments', 'trigger-1')), true);
-        const attachmentDir = join(dir, '.agentteams', 'runner', 'attachments', 'trigger-1');
+        assert.equal(localPathMatch[1].startsWith(join(dir, ".agentteams", "runner", "attachments", "trigger-1")), true);
+        const attachmentDir = join(dir, ".agentteams", "runner", "attachments", "trigger-1");
         await assert.rejects(stat(attachmentDir), /ENOENT/);
     });
 });
-test('createTriggerHandler removes the attachment directory after runner failure', async () => {
+test("createTriggerHandler removes the attachment directory after runner failure", async () => {
     await withTempDir(async (dir) => {
         const client = {
             fetchTriggerRuntime: async () => ({
                 ...runtime,
                 authPath: dir,
-                runnerPrompt: 'Use the attached file.',
-                attachments: [
-                    {
-                        id: 'attachment-1',
-                        originalName: 'notes.md',
-                        mimeType: 'text/markdown',
+                runnerPrompt: "Use the attached file.",
+                attachments: [{
+                        id: "attachment-1",
+                        originalName: "notes.md",
+                        mimeType: "text/markdown",
                         size: 12,
-                        downloadUrl: 'https://storage.example/attachment-1',
+                        downloadUrl: "https://storage.example/attachment-1",
                         expiresInSeconds: 300,
-                    },
-                ],
+                    }],
             }),
             isTriggerCancelRequested: async () => false,
             updateTriggerHistory: async () => undefined,
@@ -874,19 +872,19 @@ test('createTriggerHandler removes the attachment directory after runner failure
         };
         const handler = createTriggerHandler({
             config: {
-                daemonToken: 'daemon-token',
-                apiUrl: 'https://api.example',
+                daemonToken: "daemon-token",
+                apiUrl: "https://api.example",
                 pollingIntervalMs: 5000,
                 timeoutMs: 1500,
                 idleTimeoutMs: 500,
-                runnerCmd: 'opencode',
+                runnerCmd: "opencode",
                 preventSleepWhileBusy: false,
             },
             client: client,
         }, {
             createRunnerFactory: () => () => ({
                 run: async () => {
-                    throw new Error('runner crashed');
+                    throw new Error("runner crashed");
                 },
             }),
             createLogReporter: () => ({
@@ -894,36 +892,34 @@ test('createTriggerHandler removes the attachment directory after runner failure
                 append: () => undefined,
                 stop: async () => undefined,
             }),
-            fetchAttachmentFile: async () => new TextEncoder().encode('hello world\n'),
-            readHistoryFile: async () => '',
+            fetchAttachmentFile: async () => new TextEncoder().encode("hello world\n"),
+            readHistoryFile: async () => "",
             resolveRunnerHistoryPaths: () => ({
-                currentHistoryPath: join(dir, '.agentteams/runner/history/trigger-1.md'),
+                currentHistoryPath: join(dir, ".agentteams/runner/history/trigger-1.md"),
                 parentHistoryPath: null,
             }),
         });
         await handler({ ...trigger, parentTriggerId: null });
-        const attachmentDir = join(dir, '.agentteams', 'runner', 'attachments', 'trigger-1');
+        const attachmentDir = join(dir, ".agentteams", "runner", "attachments", "trigger-1");
         await assert.rejects(stat(attachmentDir), /ENOENT/);
     });
 });
-test('createTriggerHandler logs but does not throw when attachment cleanup fails', async () => {
+test("createTriggerHandler logs but does not throw when attachment cleanup fails", async () => {
     await withTempDir(async (dir) => {
         const cleanupCalls = [];
         const client = {
             fetchTriggerRuntime: async () => ({
                 ...runtime,
                 authPath: dir,
-                runnerPrompt: 'Use the attached file.',
-                attachments: [
-                    {
-                        id: 'attachment-1',
-                        originalName: 'notes.md',
-                        mimeType: 'text/markdown',
+                runnerPrompt: "Use the attached file.",
+                attachments: [{
+                        id: "attachment-1",
+                        originalName: "notes.md",
+                        mimeType: "text/markdown",
                         size: 12,
-                        downloadUrl: 'https://storage.example/attachment-1',
+                        downloadUrl: "https://storage.example/attachment-1",
                         expiresInSeconds: 300,
-                    },
-                ],
+                    }],
             }),
             isTriggerCancelRequested: async () => false,
             updateTriggerHistory: async () => undefined,
@@ -931,12 +927,12 @@ test('createTriggerHandler logs but does not throw when attachment cleanup fails
         };
         const handler = createTriggerHandler({
             config: {
-                daemonToken: 'daemon-token',
-                apiUrl: 'https://api.example',
+                daemonToken: "daemon-token",
+                apiUrl: "https://api.example",
                 pollingIntervalMs: 5000,
                 timeoutMs: 1500,
                 idleTimeoutMs: 500,
-                runnerCmd: 'opencode',
+                runnerCmd: "opencode",
                 preventSleepWhileBusy: false,
             },
             client: client,
@@ -949,55 +945,53 @@ test('createTriggerHandler logs but does not throw when attachment cleanup fails
                 append: () => undefined,
                 stop: async () => undefined,
             }),
-            fetchAttachmentFile: async () => new TextEncoder().encode('hello world\n'),
+            fetchAttachmentFile: async () => new TextEncoder().encode("hello world\n"),
             removeAttachmentDirectory: async (path) => {
                 cleanupCalls.push(path);
-                throw new Error('cleanup boom');
+                throw new Error("cleanup boom");
             },
-            readHistoryFile: async () => '### Summary\n- done\n',
+            readHistoryFile: async () => "### Summary\n- done\n",
             resolveRunnerHistoryPaths: () => ({
-                currentHistoryPath: join(dir, '.agentteams/runner/history/trigger-1.md'),
+                currentHistoryPath: join(dir, ".agentteams/runner/history/trigger-1.md"),
                 parentHistoryPath: null,
             }),
         });
         await handler({ ...trigger, parentTriggerId: null });
-        assert.deepEqual(cleanupCalls, [join(dir, '.agentteams', 'runner', 'attachments', 'trigger-1')]);
+        assert.deepEqual(cleanupCalls, [join(dir, ".agentteams", "runner", "attachments", "trigger-1")]);
     });
 });
-test('createTriggerHandler fails before runner execution when attachments have no runner workspace', async () => {
+test("createTriggerHandler fails before runner execution when attachments have no runner workspace", async () => {
     const clientCalls = [];
     let runnerCalled = false;
     const client = {
         fetchTriggerRuntime: async () => ({
             ...runtime,
             authPath: null,
-            attachments: [
-                {
-                    id: 'attachment-1',
-                    originalName: 'notes.md',
-                    mimeType: 'text/markdown',
+            attachments: [{
+                    id: "attachment-1",
+                    originalName: "notes.md",
+                    mimeType: "text/markdown",
                     size: 12,
-                    downloadUrl: 'https://storage.example/attachment-1',
+                    downloadUrl: "https://storage.example/attachment-1",
                     expiresInSeconds: 300,
-                },
-            ],
+                }],
         }),
         isTriggerCancelRequested: async () => false,
         updateTriggerHistory: async (...args) => {
-            clientCalls.push({ method: 'updateTriggerHistory', args });
+            clientCalls.push({ method: "updateTriggerHistory", args });
         },
         updateTriggerStatus: async (...args) => {
-            clientCalls.push({ method: 'updateTriggerStatus', args });
+            clientCalls.push({ method: "updateTriggerStatus", args });
         },
     };
     const handler = createTriggerHandler({
         config: {
-            daemonToken: 'daemon-token',
-            apiUrl: 'https://api.example',
+            daemonToken: "daemon-token",
+            apiUrl: "https://api.example",
             pollingIntervalMs: 5000,
             timeoutMs: 1500,
             idleTimeoutMs: 500,
-            runnerCmd: 'opencode',
+            runnerCmd: "opencode",
             preventSleepWhileBusy: false,
         },
         client: client,
@@ -1018,30 +1012,28 @@ test('createTriggerHandler fails before runner execution when attachments have n
     await handler({ ...trigger, parentTriggerId: null });
     assert.equal(runnerCalled, false);
     assert.deepEqual(clientCalls.at(-1)?.args, [
-        'trigger-1',
-        'FAILED',
-        'Cannot deliver attachments because runner workspace path is not configured.',
+        "trigger-1",
+        "FAILED",
+        "Cannot deliver attachments because runner workspace path is not configured."
     ]);
 });
-test('createTriggerHandler does not append history or convention text to the API prompt', async () => {
+test("createTriggerHandler does not append history or convention text to the API prompt", async () => {
     await withTempDir(async (dir) => {
         const runnerInputs = [];
-        const conventions = [
-            {
-                id: 'conv-feature',
-                filePath: '.agentteams/rules/feature.md',
-                trigger: 'task:FEATURE',
-                title: 'Feature Convention',
-                description: 'Rules for feature tasks',
-            },
-        ];
+        const conventions = [{
+                id: "conv-feature",
+                filePath: ".agentteams/rules/feature.md",
+                trigger: "task:FEATURE",
+                title: "Feature Convention",
+                description: "Rules for feature tasks",
+            }];
         const client = {
             fetchTriggerRuntime: async () => ({
                 ...runtime,
                 authPath: dir,
                 conventions,
-                planType: 'BUG_FIX',
-                runnerPrompt: 'Only the API prompt',
+                planType: "BUG_FIX",
+                runnerPrompt: "Only the API prompt",
             }),
             isTriggerCancelRequested: async () => false,
             updateTriggerHistory: async () => undefined,
@@ -1049,12 +1041,12 @@ test('createTriggerHandler does not append history or convention text to the API
         };
         const handler = createTriggerHandler({
             config: {
-                daemonToken: 'daemon-token',
-                apiUrl: 'https://api.example',
+                daemonToken: "daemon-token",
+                apiUrl: "https://api.example",
                 pollingIntervalMs: 5000,
                 timeoutMs: 1500,
                 idleTimeoutMs: 500,
-                runnerCmd: 'opencode',
+                runnerCmd: "opencode",
                 preventSleepWhileBusy: false,
             },
             client: client,
@@ -1070,16 +1062,16 @@ test('createTriggerHandler does not append history or convention text to the API
                 append: () => undefined,
                 stop: async () => undefined,
             }),
-            readHistoryFile: async () => '### Summary\n- done\n',
+            readHistoryFile: async () => "### Summary\n- done\n",
             resolveRunnerHistoryPaths: () => ({
-                currentHistoryPath: join(dir, '.agentteams/runner/history/trigger-1.md'),
+                currentHistoryPath: join(dir, ".agentteams/runner/history/trigger-1.md"),
                 parentHistoryPath: null,
             }),
         });
         await handler({ ...trigger, parentTriggerId: null });
         assert.equal(runnerInputs.length, 1);
-        assert.equal(runnerInputs[0]?.prompt, 'Only the API prompt');
-        assert.doesNotMatch(runnerInputs[0]?.prompt ?? '', /Context-Matched Conventions \(AUTO-LOADED\)/);
+        assert.equal(runnerInputs[0]?.prompt, "Only the API prompt");
+        assert.doesNotMatch(runnerInputs[0]?.prompt ?? "", /Context-Matched Conventions \(AUTO-LOADED\)/);
     });
 });
 //# sourceMappingURL=trigger-handler.test.js.map