@agentteams/runner 0.0.70 → 0.0.71-dev.150

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

@@ -1,6 +1,6 @@
 import assert from "node:assert/strict";
 import test, { mock } from "node:test";
-import { mkdtemp, mkdir, writeFile, rm, readFile, access } from "node:fs/promises";
+import { mkdtemp, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { logger } from "../logger.js";
@@ -561,491 +561,6 @@ const withTempDir = async (run) => {
         await rm(dir, { recursive: true, force: true });
     }
 };
-const withHarnessRuntime = (authPath, overrides = {}) => ({
-    ...runtime,
-    authPath,
-    harnessConfigId: "harness-1",
-    ...overrides,
-});
-const fetchServerHarness = (config) => async () => ({ config });
-test("createTriggerHandler blocks trigger when pre-hook fails with onFailure=fail", async () => {
-    await withTempDir(async (dir) => {
-        const clientCalls = [];
-        let runnerCalled = false;
-        const client = {
-            fetchTriggerRuntime: async () => withHarnessRuntime(dir),
-            fetchHarnessConfigById: fetchServerHarness({
-                preHooks: [{ name: "lint-check", command: "exit 1", onFailure: "fail" }],
-            }),
-            isTriggerCancelRequested: async () => false,
-            updateTriggerHistory: async (...args) => {
-                clientCalls.push({ method: "updateTriggerHistory", args });
-            },
-            updateTriggerStatus: async (...args) => {
-                clientCalls.push({ method: "updateTriggerStatus", args });
-            },
-        };
-        const handler = createTriggerHandler({
-            config: {
-                daemonToken: "daemon-token",
-                apiUrl: "https://api.example",
-                pollingIntervalMs: 5000,
-                timeoutMs: 1500,
-                idleTimeoutMs: 500,
-                runnerCmd: "opencode",
-            },
-            client: client,
-        }, {
-            createRunnerFactory: () => () => ({
-                run: async () => {
-                    runnerCalled = true;
-                    return { exitCode: 0 };
-                },
-            }),
-            createLogReporter: () => ({
-                start: () => undefined,
-                append: () => undefined,
-                stop: async () => undefined,
-            }),
-            readHistoryFile: async () => "",
-            resolveRunnerHistoryPaths: () => ({
-                currentHistoryPath: join(dir, ".agentteams/runner/history/trigger-1.md"),
-                parentHistoryPath: null,
-            }),
-        });
-        await handler({ ...trigger, parentTriggerId: null });
-        assert.equal(runnerCalled, false, "Runner should not be called when pre-hook fails");
-        const statusCall = clientCalls.find((c) => c.method === "updateTriggerStatus");
-        assert.ok(statusCall);
-        assert.equal(statusCall.args[1], "FAILED");
-        assert.ok(String(statusCall.args[2]).includes("lint-check"));
-    });
-});
-test("createTriggerHandler continues when pre-hook fails with onFailure=warn", async () => {
-    await withTempDir(async (dir) => {
-        let runnerCalled = false;
-        const clientCalls = [];
-        const client = {
-            fetchTriggerRuntime: async () => withHarnessRuntime(dir),
-            fetchHarnessConfigById: fetchServerHarness({
-                preHooks: [{ name: "optional-check", command: "exit 1", onFailure: "warn" }],
-            }),
-            isTriggerCancelRequested: async () => false,
-            updateTriggerHistory: async (...args) => {
-                clientCalls.push({ method: "updateTriggerHistory", args });
-            },
-            updateTriggerStatus: async (...args) => {
-                clientCalls.push({ method: "updateTriggerStatus", args });
-            },
-        };
-        const handler = createTriggerHandler({
-            config: {
-                daemonToken: "daemon-token",
-                apiUrl: "https://api.example",
-                pollingIntervalMs: 5000,
-                timeoutMs: 1500,
-                idleTimeoutMs: 500,
-                runnerCmd: "opencode",
-            },
-            client: client,
-        }, {
-            createRunnerFactory: () => () => ({
-                run: async () => {
-                    runnerCalled = true;
-                    return { exitCode: 0 };
-                },
-            }),
-            createLogReporter: () => ({
-                start: () => undefined,
-                append: () => undefined,
-                stop: async () => undefined,
-            }),
-            readHistoryFile: async () => "### Summary\n- done\n",
-            resolveRunnerHistoryPaths: () => ({
-                currentHistoryPath: join(dir, ".agentteams/runner/history/trigger-1.md"),
-                parentHistoryPath: null,
-            }),
-        });
-        await handler({ ...trigger, parentTriggerId: null });
-        assert.equal(runnerCalled, true, "Runner should still execute when pre-hook fails with warn");
-        const statusCall = clientCalls.find((c) => c.method === "updateTriggerStatus");
-        assert.ok(statusCall);
-        assert.equal(statusCall.args[1], "DONE");
-    });
-});
-test("createTriggerHandler runs normally when no pre-hooks are defined", async () => {
-    await withTempDir(async (dir) => {
-        let runnerCalled = false;
-        const clientCalls = [];
-        const client = {
-            fetchTriggerRuntime: async () => ({ ...runtime, authPath: dir }),
-            isTriggerCancelRequested: async () => false,
-            updateTriggerHistory: async (...args) => {
-                clientCalls.push({ method: "updateTriggerHistory", args });
-            },
-            updateTriggerStatus: async (...args) => {
-                clientCalls.push({ method: "updateTriggerStatus", args });
-            },
-        };
-        const handler = createTriggerHandler({
-            config: {
-                daemonToken: "daemon-token",
-                apiUrl: "https://api.example",
-                pollingIntervalMs: 5000,
-                timeoutMs: 1500,
-                idleTimeoutMs: 500,
-                runnerCmd: "opencode",
-            },
-            client: client,
-        }, {
-            createRunnerFactory: () => () => ({
-                run: async () => {
-                    runnerCalled = true;
-                    return { exitCode: 0 };
-                },
-            }),
-            createLogReporter: () => ({
-                start: () => undefined,
-                append: () => undefined,
-                stop: async () => undefined,
-            }),
-            readHistoryFile: async () => "### Summary\n- done\n",
-            resolveRunnerHistoryPaths: () => ({
-                currentHistoryPath: join(dir, ".agentteams/runner/history/trigger-1.md"),
-                parentHistoryPath: null,
-            }),
-        });
-        await handler({ ...trigger, parentTriggerId: null });
-        assert.equal(runnerCalled, true);
-        const statusCall = clientCalls.find((c) => c.method === "updateTriggerStatus");
-        assert.ok(statusCall);
-        assert.equal(statusCall.args[1], "DONE");
-    });
-});
-test("createTriggerHandler ignores local harness file when no server harness is selected", async () => {
-    await withTempDir(async (dir) => {
-        const harnessDir = join(dir, ".agentteams");
-        await mkdir(harnessDir, { recursive: true });
-        await writeFile(join(harnessDir, "harness.yml"), [
-            "preHooks:",
-            "  - name: local-should-not-run",
-            "    command: sh -c 'echo local > local.txt && exit 1'",
-            "    onFailure: fail",
-        ].join("\n"));
-        let runnerCalled = false;
-        const clientCalls = [];
-        const client = {
-            fetchTriggerRuntime: async () => ({ ...runtime, authPath: dir, harnessConfigId: null }),
-            isTriggerCancelRequested: async () => false,
-            updateTriggerHistory: async (...args) => {
-                clientCalls.push({ method: "updateTriggerHistory", args });
-            },
-            updateTriggerStatus: async (...args) => {
-                clientCalls.push({ method: "updateTriggerStatus", args });
-            },
-        };
-        const handler = createTriggerHandler({
-            config: {
-                daemonToken: "daemon-token",
-                apiUrl: "https://api.example",
-                pollingIntervalMs: 5000,
-                timeoutMs: 1500,
-                idleTimeoutMs: 500,
-                runnerCmd: "opencode",
-            },
-            client: client,
-        }, {
-            createRunnerFactory: () => () => ({
-                run: async () => {
-                    runnerCalled = true;
-                    return { exitCode: 0 };
-                },
-            }),
-            createLogReporter: () => ({
-                start: () => undefined,
-                append: () => undefined,
-                stop: async () => undefined,
-            }),
-            readHistoryFile: async () => "### Summary\n- done\n",
-            resolveRunnerHistoryPaths: () => ({
-                currentHistoryPath: join(dir, ".agentteams/runner/history/trigger-1.md"),
-                parentHistoryPath: null,
-            }),
-        });
-        await handler({ ...trigger, parentTriggerId: null });
-        assert.equal(runnerCalled, true);
-        await assert.rejects(access(join(dir, "local.txt")));
-        const statusCall = clientCalls.find((c) => c.method === "updateTriggerStatus");
-        assert.ok(statusCall);
-        assert.equal(statusCall.args[1], "DONE");
-    });
-});
-test("createTriggerHandler always runs pre-hooks without a convention trigger", async () => {
-    await withTempDir(async (dir) => {
-        let runnerCalled = false;
-        const clientCalls = [];
-        const client = {
-            fetchTriggerRuntime: async () => withHarnessRuntime(dir, {
-                conventions: [],
-                planType: "BUG_FIX",
-            }),
-            fetchHarnessConfigById: fetchServerHarness({
-                preHooks: [{ name: "always-run", command: "sh -c 'echo always > always.txt && exit 1'", onFailure: "fail" }],
-            }),
-            isTriggerCancelRequested: async () => false,
-            updateTriggerHistory: async (...args) => {
-                clientCalls.push({ method: "updateTriggerHistory", args });
-            },
-            updateTriggerStatus: async (...args) => {
-                clientCalls.push({ method: "updateTriggerStatus", args });
-            },
-        };
-        const handler = createTriggerHandler({
-            config: {
-                daemonToken: "daemon-token",
-                apiUrl: "https://api.example",
-                pollingIntervalMs: 5000,
-                timeoutMs: 1500,
-                idleTimeoutMs: 500,
-                runnerCmd: "opencode",
-            },
-            client: client,
-        }, {
-            createRunnerFactory: () => () => ({
-                run: async () => {
-                    runnerCalled = true;
-                    return { exitCode: 0 };
-                },
-            }),
-            createLogReporter: () => ({
-                start: () => undefined,
-                append: () => undefined,
-                stop: async () => undefined,
-            }),
-            readHistoryFile: async () => "",
-            resolveRunnerHistoryPaths: () => ({
-                currentHistoryPath: join(dir, ".agentteams/runner/history/trigger-1.md"),
-                parentHistoryPath: null,
-            }),
-        });
-        await handler({ ...trigger, parentTriggerId: null });
-        assert.equal(runnerCalled, false);
-        assert.equal(await readFile(join(dir, "always.txt"), "utf8"), "always\n");
-        const statusCall = clientCalls.find((c) => c.method === "updateTriggerStatus");
-        assert.ok(statusCall);
-        assert.equal(statusCall.args[1], "FAILED");
-        assert.match(String(statusCall.args[2]), /always-run/);
-    });
-});
-test("createTriggerHandler runs convention-linked pre-hooks when the convention matches", async () => {
-    await withTempDir(async (dir) => {
-        let runnerCalled = false;
-        const clientCalls = [];
-        const conventions = [{
-                id: "conv-bugfix",
-                filePath: ".agentteams/rules/bugfix.md",
-                trigger: "task:BUG_FIX",
-                title: "Bug Fix Convention",
-                description: "Rules for bug fix tasks",
-            }];
-        const client = {
-            fetchTriggerRuntime: async () => withHarnessRuntime(dir, {
-                conventions,
-                planType: "BUG_FIX",
-            }),
-            fetchHarnessConfigById: fetchServerHarness({
-                preHooks: [{
-                        name: "only-on-bugfix",
-                        command: "sh -c 'echo bugfix > bugfix.txt && exit 1'",
-                        onFailure: "fail",
-                        conventionTrigger: "task:BUG_FIX",
-                    }],
-            }),
-            isTriggerCancelRequested: async () => false,
-            updateTriggerHistory: async (...args) => {
-                clientCalls.push({ method: "updateTriggerHistory", args });
-            },
-            updateTriggerStatus: async (...args) => {
-                clientCalls.push({ method: "updateTriggerStatus", args });
-            },
-        };
-        const handler = createTriggerHandler({
-            config: {
-                daemonToken: "daemon-token",
-                apiUrl: "https://api.example",
-                pollingIntervalMs: 5000,
-                timeoutMs: 1500,
-                idleTimeoutMs: 500,
-                runnerCmd: "opencode",
-            },
-            client: client,
-        }, {
-            createRunnerFactory: () => () => ({
-                run: async () => {
-                    runnerCalled = true;
-                    return { exitCode: 0 };
-                },
-            }),
-            createLogReporter: () => ({
-                start: () => undefined,
-                append: () => undefined,
-                stop: async () => undefined,
-            }),
-            readHistoryFile: async () => "",
-            resolveRunnerHistoryPaths: () => ({
-                currentHistoryPath: join(dir, ".agentteams/runner/history/trigger-1.md"),
-                parentHistoryPath: null,
-            }),
-        });
-        await handler({ ...trigger, parentTriggerId: null });
-        assert.equal(runnerCalled, false);
-        assert.equal(await readFile(join(dir, "bugfix.txt"), "utf8"), "bugfix\n");
-        const statusCall = clientCalls.find((c) => c.method === "updateTriggerStatus");
-        assert.ok(statusCall);
-        assert.equal(statusCall.args[1], "FAILED");
-        assert.match(String(statusCall.args[2]), /only-on-bugfix/);
-    });
-});
-test("createTriggerHandler skips convention-linked pre-hooks when the convention does not match", async () => {
-    await withTempDir(async (dir) => {
-        let runnerCalled = false;
-        const clientCalls = [];
-        const conventions = [{
-                id: "conv-bugfix",
-                filePath: ".agentteams/rules/bugfix.md",
-                trigger: "task:BUG_FIX",
-                title: "Bug Fix Convention",
-                description: "Rules for bug fix tasks",
-            }];
-        const client = {
-            fetchTriggerRuntime: async () => withHarnessRuntime(dir, {
-                conventions,
-                planType: "BUG_FIX",
-            }),
-            fetchHarnessConfigById: fetchServerHarness({
-                preHooks: [{
-                        name: "only-on-feature",
-                        command: "sh -c 'echo feature > feature.txt && exit 1'",
-                        onFailure: "fail",
-                        conventionTrigger: "task:FEATURE",
-                    }],
-            }),
-            isTriggerCancelRequested: async () => false,
-            updateTriggerHistory: async (...args) => {
-                clientCalls.push({ method: "updateTriggerHistory", args });
-            },
-            updateTriggerStatus: async (...args) => {
-                clientCalls.push({ method: "updateTriggerStatus", args });
-            },
-        };
-        const handler = createTriggerHandler({
-            config: {
-                daemonToken: "daemon-token",
-                apiUrl: "https://api.example",
-                pollingIntervalMs: 5000,
-                timeoutMs: 1500,
-                idleTimeoutMs: 500,
-                runnerCmd: "opencode",
-            },
-            client: client,
-        }, {
-            createRunnerFactory: () => () => ({
-                run: async () => {
-                    runnerCalled = true;
-                    return { exitCode: 0 };
-                },
-            }),
-            createLogReporter: () => ({
-                start: () => undefined,
-                append: () => undefined,
-                stop: async () => undefined,
-            }),
-            readHistoryFile: async () => "### Summary\n- done\n",
-            resolveRunnerHistoryPaths: () => ({
-                currentHistoryPath: join(dir, ".agentteams/runner/history/trigger-1.md"),
-                parentHistoryPath: null,
-            }),
-        });
-        await handler({ ...trigger, parentTriggerId: null });
-        assert.equal(runnerCalled, true);
-        await assert.rejects(access(join(dir, "feature.txt")));
-        const statusCall = clientCalls.find((c) => c.method === "updateTriggerStatus");
-        assert.ok(statusCall);
-        assert.equal(statusCall.args[1], "DONE");
-    });
-});
-test("createTriggerHandler runs unconditional hooks while skipping non-matching conditional hooks", async () => {
-    await withTempDir(async (dir) => {
-        let runnerCalled = false;
-        const clientCalls = [];
-        const conventions = [{
-                id: "conv-bugfix",
-                filePath: ".agentteams/rules/bugfix.md",
-                trigger: "task:BUG_FIX",
-                title: "Bug Fix Convention",
-                description: "Rules for bug fix tasks",
-            }];
-        const client = {
-            fetchTriggerRuntime: async () => withHarnessRuntime(dir, {
-                conventions,
-                planType: "BUG_FIX",
-            }),
-            fetchHarnessConfigById: fetchServerHarness({
-                preHooks: [
-                    { name: "always-run", command: "sh -c 'echo always > always.txt'", onFailure: "warn" },
-                    {
-                        name: "only-on-feature",
-                        command: "sh -c 'echo feature > feature.txt && exit 1'",
-                        onFailure: "fail",
-                        conventionTrigger: "task:FEATURE",
-                    },
-                ],
-            }),
-            isTriggerCancelRequested: async () => false,
-            updateTriggerHistory: async (...args) => {
-                clientCalls.push({ method: "updateTriggerHistory", args });
-            },
-            updateTriggerStatus: async (...args) => {
-                clientCalls.push({ method: "updateTriggerStatus", args });
-            },
-        };
-        const handler = createTriggerHandler({
-            config: {
-                daemonToken: "daemon-token",
-                apiUrl: "https://api.example",
-                pollingIntervalMs: 5000,
-                timeoutMs: 1500,
-                idleTimeoutMs: 500,
-                runnerCmd: "opencode",
-            },
-            client: client,
-        }, {
-            createRunnerFactory: () => () => ({
-                run: async () => {
-                    runnerCalled = true;
-                    return { exitCode: 0 };
-                },
-            }),
-            createLogReporter: () => ({
-                start: () => undefined,
-                append: () => undefined,
-                stop: async () => undefined,
-            }),
-            readHistoryFile: async () => "### Summary\n- done\n",
-            resolveRunnerHistoryPaths: () => ({
-                currentHistoryPath: join(dir, ".agentteams/runner/history/trigger-1.md"),
-                parentHistoryPath: null,
-            }),
-        });
-        await handler({ ...trigger, parentTriggerId: null });
-        assert.equal(runnerCalled, true);
-        assert.equal(await readFile(join(dir, "always.txt"), "utf8"), "always\n");
-        await assert.rejects(access(join(dir, "feature.txt")));
-        const statusCall = clientCalls.find((c) => c.method === "updateTriggerStatus");
-        assert.ok(statusCall);
-        assert.equal(statusCall.args[1], "DONE");
-    });
-});
 test("createTriggerHandler passes the API-provided runner prompt unchanged", async () => {
     await withTempDir(async (dir) => {
         const runnerInputs = [];
@@ -1148,267 +663,4 @@ test("createTriggerHandler does not append history or convention text to the API
         assert.doesNotMatch(runnerInputs[0]?.prompt ?? "", /Context-Matched Conventions \(AUTO-LOADED\)/);
     });
 });
-// ---------------------------------------------------------------------------
-// Post-execution hook tests
-// ---------------------------------------------------------------------------
-test("createTriggerHandler marks DONE when post-hook succeeds after runner success", async () => {
-    await withTempDir(async (dir) => {
-        const clientCalls = [];
-        const client = {
-            fetchTriggerRuntime: async () => withHarnessRuntime(dir),
-            fetchHarnessConfigById: fetchServerHarness({
-                postHooks: [{ name: "quality-gate", command: "echo ok", onFailure: "fail" }],
-            }),
-            isTriggerCancelRequested: async () => false,
-            updateTriggerHistory: async (...args) => {
-                clientCalls.push({ method: "updateTriggerHistory", args });
-            },
-            updateTriggerStatus: async (...args) => {
-                clientCalls.push({ method: "updateTriggerStatus", args });
-            },
-        };
-        const handler = createTriggerHandler({
-            config: { daemonToken: "t", apiUrl: "https://api.example", pollingIntervalMs: 5000, timeoutMs: 1500, idleTimeoutMs: 500, runnerCmd: "opencode" },
-            client: client,
-        }, {
-            createRunnerFactory: () => () => ({ run: async () => ({ exitCode: 0 }) }),
-            createLogReporter: () => ({ start: () => undefined, append: () => undefined, stop: async () => undefined }),
-            readHistoryFile: async () => "### Summary\n- done\n",
-            resolveRunnerHistoryPaths: () => ({ currentHistoryPath: join(dir, "h.md"), parentHistoryPath: null }),
-        });
-        await handler({ ...trigger, parentTriggerId: null });
-        const statusCall = clientCalls.find((c) => c.method === "updateTriggerStatus");
-        assert.ok(statusCall);
-        assert.equal(statusCall.args[1], "DONE");
-    });
-});
-test("createTriggerHandler marks FAILED when post-hook fails with onFailure=fail", async () => {
-    await withTempDir(async (dir) => {
-        const clientCalls = [];
-        const client = {
-            fetchTriggerRuntime: async () => withHarnessRuntime(dir),
-            fetchHarnessConfigById: fetchServerHarness({
-                postHooks: [{ name: "quality-gate", command: "exit 1", onFailure: "fail" }],
-            }),
-            isTriggerCancelRequested: async () => false,
-            updateTriggerHistory: async (...args) => {
-                clientCalls.push({ method: "updateTriggerHistory", args });
-            },
-            updateTriggerStatus: async (...args) => {
-                clientCalls.push({ method: "updateTriggerStatus", args });
-            },
-        };
-        const handler = createTriggerHandler({
-            config: { daemonToken: "t", apiUrl: "https://api.example", pollingIntervalMs: 5000, timeoutMs: 1500, idleTimeoutMs: 500, runnerCmd: "opencode" },
-            client: client,
-        }, {
-            createRunnerFactory: () => () => ({ run: async () => ({ exitCode: 0 }) }),
-            createLogReporter: () => ({ start: () => undefined, append: () => undefined, stop: async () => undefined }),
-            readHistoryFile: async () => "### Summary\n- done\n",
-            resolveRunnerHistoryPaths: () => ({ currentHistoryPath: join(dir, "h.md"), parentHistoryPath: null }),
-        });
-        await handler({ ...trigger, parentTriggerId: null });
-        const statusCall = clientCalls.find((c) => c.method === "updateTriggerStatus");
-        assert.ok(statusCall);
-        assert.equal(statusCall.args[1], "FAILED");
-        assert.ok(String(statusCall.args[2]).includes("quality-gate"));
-    });
-});
-test("createTriggerHandler marks NEEDS_REVIEW when post-hook fails with onFailure=needs_review", async () => {
-    await withTempDir(async (dir) => {
-        const clientCalls = [];
-        const client = {
-            fetchTriggerRuntime: async () => withHarnessRuntime(dir),
-            fetchHarnessConfigById: fetchServerHarness({
-                postHooks: [{ name: "review-gate", command: "exit 1", onFailure: "needs_review" }],
-            }),
-            isTriggerCancelRequested: async () => false,
-            updateTriggerHistory: async (...args) => {
-                clientCalls.push({ method: "updateTriggerHistory", args });
-            },
-            updateTriggerStatus: async (...args) => {
-                clientCalls.push({ method: "updateTriggerStatus", args });
-            },
-        };
-        const handler = createTriggerHandler({
-            config: { daemonToken: "t", apiUrl: "https://api.example", pollingIntervalMs: 5000, timeoutMs: 1500, idleTimeoutMs: 500, runnerCmd: "opencode" },
-            client: client,
-        }, {
-            createRunnerFactory: () => () => ({ run: async () => ({ exitCode: 0 }) }),
-            createLogReporter: () => ({ start: () => undefined, append: () => undefined, stop: async () => undefined }),
-            readHistoryFile: async () => "### Summary\n- done\n",
-            resolveRunnerHistoryPaths: () => ({ currentHistoryPath: join(dir, "h.md"), parentHistoryPath: null }),
-        });
-        await handler({ ...trigger, parentTriggerId: null });
-        const statusCall = clientCalls.find((c) => c.method === "updateTriggerStatus");
-        assert.ok(statusCall);
-        assert.equal(statusCall.args[1], "NEEDS_REVIEW");
-    });
-});
-test("createTriggerHandler skips post-hooks when runner fails", async () => {
-    await withTempDir(async (dir) => {
-        const clientCalls = [];
-        const logEntries = [];
-        const client = {
-            fetchTriggerRuntime: async () => withHarnessRuntime(dir),
-            fetchHarnessConfigById: fetchServerHarness({
-                postHooks: [{ name: "should-not-run", command: "echo unreachable", onFailure: "fail" }],
-            }),
-            isTriggerCancelRequested: async () => false,
-            updateTriggerHistory: async (...args) => {
-                clientCalls.push({ method: "updateTriggerHistory", args });
-            },
-            updateTriggerStatus: async (...args) => {
-                clientCalls.push({ method: "updateTriggerStatus", args });
-            },
-        };
-        const handler = createTriggerHandler({
-            config: { daemonToken: "t", apiUrl: "https://api.example", pollingIntervalMs: 5000, timeoutMs: 1500, idleTimeoutMs: 500, runnerCmd: "opencode" },
-            client: client,
-        }, {
-            createRunnerFactory: () => () => ({ run: async () => ({ exitCode: 1 }) }),
-            createLogReporter: () => ({
-                start: () => undefined,
-                append: (_level, msg) => { logEntries.push(msg); },
-                stop: async () => undefined,
-            }),
-            readHistoryFile: async () => "",
-            resolveRunnerHistoryPaths: () => ({ currentHistoryPath: join(dir, "h.md"), parentHistoryPath: null }),
-        });
-        await handler({ ...trigger, parentTriggerId: null });
-        const statusCall = clientCalls.find((c) => c.method === "updateTriggerStatus");
-        assert.ok(statusCall);
-        assert.equal(statusCall.args[1], "FAILED");
-        assert.equal(logEntries.some((l) => l.includes("post-execution")), false, "Post-hooks should not run when runner fails");
-    });
-});
-test("createTriggerHandler leaves prompt convention audit recording to the API", async () => {
-    await withTempDir(async (dir) => {
-        const conventions = [
-            {
-                id: "conv-auto",
-                filePath: ".agentteams/rules/bugfix.md",
-                trigger: "task:BUG_FIX",
-                title: "Auto Match Conv",
-                description: null,
-            },
-            {
-                id: "conv-pinned",
-                filePath: ".agentteams/rules/pinned.md",
-                trigger: "always_on",
-                title: "Pinned Conv",
-                description: null,
-            },
-            {
-                id: "conv-unrelated",
-                filePath: ".agentteams/rules/unused.md",
-                trigger: "task:FEATURE",
-                title: "Unrelated Conv",
-                description: null,
-            },
-        ];
-        let recordCalled = false;
-        const client = {
-            fetchTriggerRuntime: async () => withHarnessRuntime(dir, {
-                conventions,
-                planType: "BUG_FIX",
-            }),
-            fetchHarnessConfigById: fetchServerHarness({
-                conventionIds: ["conv-pinned"],
-            }),
-            isTriggerCancelRequested: async () => false,
-            updateTriggerHistory: async () => undefined,
-            updateTriggerStatus: async () => undefined,
-            recordInjectedConventions: async () => {
-                recordCalled = true;
-            },
-        };
-        const handler = createTriggerHandler({
-            config: {
-                daemonToken: "daemon-token",
-                apiUrl: "https://api.example",
-                pollingIntervalMs: 5000,
-                timeoutMs: 1500,
-                idleTimeoutMs: 500,
-                runnerCmd: "opencode",
-            },
-            client: client,
-        }, {
-            createRunnerFactory: () => () => ({
-                run: async () => ({ exitCode: 0 }),
-            }),
-            createLogReporter: () => ({
-                start: () => undefined,
-                append: () => undefined,
-                stop: async () => undefined,
-            }),
-            readHistoryFile: async () => "### Summary\n- done\n",
-            resolveRunnerHistoryPaths: () => ({
-                currentHistoryPath: join(dir, ".agentteams/runner/history/trigger-1.md"),
-                parentHistoryPath: null,
-            }),
-        });
-        await handler({ ...trigger, parentTriggerId: null });
-        assert.equal(recordCalled, false);
-    });
-});
-test("createTriggerHandler ignores unavailable prompt convention recording client method", async () => {
-    await withTempDir(async (dir) => {
-        const conventions = [
-            {
-                id: "conv-pinned",
-                filePath: ".agentteams/rules/pinned.md",
-                trigger: null,
-                title: "Pinned Conv",
-                description: null,
-            },
-        ];
-        const clientCalls = [];
-        const client = {
-            fetchTriggerRuntime: async () => withHarnessRuntime(dir, {
-                conventions,
-                planType: "BUG_FIX",
-            }),
-            fetchHarnessConfigById: fetchServerHarness({
-                conventionIds: ["conv-pinned"],
-            }),
-            isTriggerCancelRequested: async () => false,
-            updateTriggerHistory: async (...args) => {
-                clientCalls.push({ method: "updateTriggerHistory", args });
-            },
-            updateTriggerStatus: async (...args) => {
-                clientCalls.push({ method: "updateTriggerStatus", args });
-            },
-        };
-        const handler = createTriggerHandler({
-            config: {
-                daemonToken: "daemon-token",
-                apiUrl: "https://api.example",
-                pollingIntervalMs: 5000,
-                timeoutMs: 1500,
-                idleTimeoutMs: 500,
-                runnerCmd: "opencode",
-            },
-            client: client,
-        }, {
-            createRunnerFactory: () => () => ({
-                run: async () => ({ exitCode: 0 }),
-            }),
-            createLogReporter: () => ({
-                start: () => undefined,
-                append: () => undefined,
-                stop: async () => undefined,
-            }),
-            readHistoryFile: async () => "### Summary\n- done\n",
-            resolveRunnerHistoryPaths: () => ({
-                currentHistoryPath: join(dir, ".agentteams/runner/history/trigger-1.md"),
-                parentHistoryPath: null,
-            }),
-        });
-        await handler({ ...trigger, parentTriggerId: null });
-        const statusCall = clientCalls.find((c) => c.method === "updateTriggerStatus");
-        assert.ok(statusCall);
-        assert.equal(statusCall.args[1], "DONE");
-    });
-});
 //# sourceMappingURL=trigger-handler.test.js.map