@agentteams/runner 0.0.69-dev.141 → 0.0.69-dev.144

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

@@ -36,6 +36,7 @@ const runtime = {
     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,
@@ -108,10 +109,7 @@ test("createTriggerHandler runs the runner, reports history, and marks success",
     await handler(trigger);
     assert.deepEqual(discoveredAuthPaths, ["/auth/path"]);
     assert.equal(runnerInputs.length, 1);
-    assert.match(runnerInputs[0]?.prompt ?? "", /Continuation context \(required\)/);
-    assert.match(runnerInputs[0]?.prompt ?? "", /Previous history path: \/auth\/path\/\.agentteams\/runner\/history\/parent-1\.md/);
-    assert.match(runnerInputs[0]?.prompt ?? "", /## Requests/);
-    assert.match(runnerInputs[0]?.prompt ?? "", /## History \(latest\)/);
+    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), [
@@ -563,25 +561,22 @@ 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) => {
-        // Write harness.yml with a failing pre-hook
-        const harnessDir = join(dir, ".agentteams");
-        await mkdir(harnessDir, { recursive: true });
-        await writeFile(join(harnessDir, "harness.yml"), [
-            "preHooks:",
-            "  - name: lint-check",
-            "    command: exit 1",
-            "    onFailure: fail",
-        ].join("\n"));
         const clientCalls = [];
         let runnerCalled = false;
         const client = {
-            fetchTriggerRuntime: async () => ({
-                ...runtime,
-                authPath: dir,
+            fetchTriggerRuntime: async () => withHarnessRuntime(dir),
+            fetchHarnessConfigById: fetchServerHarness({
+                preHooks: [{ name: "lint-check", command: "exit 1", onFailure: "fail" }],
             }),
-            fetchHarnessConfig: async () => null,
             isTriggerCancelRequested: async () => false,
             updateTriggerHistory: async (...args) => {
                 clientCalls.push({ method: "updateTriggerHistory", args });
@@ -628,22 +623,13 @@ test("createTriggerHandler blocks trigger when pre-hook fails with onFailure=fai
 });
 test("createTriggerHandler continues when pre-hook fails with onFailure=warn", async () => {
     await withTempDir(async (dir) => {
-        const harnessDir = join(dir, ".agentteams");
-        await mkdir(harnessDir, { recursive: true });
-        await writeFile(join(harnessDir, "harness.yml"), [
-            "preHooks:",
-            "  - name: optional-check",
-            "    command: exit 1",
-            "    onFailure: warn",
-        ].join("\n"));
         let runnerCalled = false;
         const clientCalls = [];
         const client = {
-            fetchTriggerRuntime: async () => ({
-                ...runtime,
-                authPath: dir,
+            fetchTriggerRuntime: async () => withHarnessRuntime(dir),
+            fetchHarnessConfigById: fetchServerHarness({
+                preHooks: [{ name: "optional-check", command: "exit 1", onFailure: "warn" }],
             }),
-            fetchHarnessConfig: async () => null,
             isTriggerCancelRequested: async () => false,
             updateTriggerHistory: async (...args) => {
                 clientCalls.push({ method: "updateTriggerHistory", args });
@@ -689,15 +675,10 @@ test("createTriggerHandler continues when pre-hook fails with onFailure=warn", a
 });
 test("createTriggerHandler runs normally when no pre-hooks are defined", async () => {
     await withTempDir(async (dir) => {
-        // No harness.yml — should behave exactly as before
         let runnerCalled = false;
         const clientCalls = [];
         const client = {
-            fetchTriggerRuntime: async () => ({
-                ...runtime,
-                authPath: dir,
-            }),
-            fetchHarnessConfig: async () => null,
+            fetchTriggerRuntime: async () => ({ ...runtime, authPath: dir }),
             isTriggerCancelRequested: async () => false,
             updateTriggerHistory: async (...args) => {
                 clientCalls.push({ method: "updateTriggerHistory", args });
@@ -741,26 +722,76 @@ test("createTriggerHandler runs normally when no pre-hooks are defined", async (
         assert.equal(statusCall.args[1], "DONE");
     });
 });
-test("createTriggerHandler always runs pre-hooks without a convention trigger", async () => {
+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: always-run",
-            "    command: sh -c 'echo always > always.txt && exit 1'",
+            "  - 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,
+            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",
             }),
-            fetchHarnessConfig: async () => null,
+            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 });
@@ -808,15 +839,6 @@ test("createTriggerHandler always runs pre-hooks without a convention trigger",
 });
 test("createTriggerHandler runs convention-linked pre-hooks when the convention matches", async () => {
     await withTempDir(async (dir) => {
-        const harnessDir = join(dir, ".agentteams");
-        await mkdir(harnessDir, { recursive: true });
-        await writeFile(join(harnessDir, "harness.yml"), [
-            "preHooks:",
-            "  - name: only-on-bugfix",
-            "    command: sh -c 'echo bugfix > bugfix.txt && exit 1'",
-            "    onFailure: fail",
-            "    conventionTrigger: task:BUG_FIX",
-        ].join("\n"));
         let runnerCalled = false;
         const clientCalls = [];
         const conventions = [{
@@ -827,13 +849,18 @@ test("createTriggerHandler runs convention-linked pre-hooks when the convention
                 description: "Rules for bug fix tasks",
             }];
         const client = {
-            fetchTriggerRuntime: async () => ({
-                ...runtime,
-                authPath: dir,
+            fetchTriggerRuntime: async () => withHarnessRuntime(dir, {
                 conventions,
                 planType: "BUG_FIX",
             }),
-            fetchHarnessConfig: async () => null,
+            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 });
@@ -881,15 +908,6 @@ test("createTriggerHandler runs convention-linked pre-hooks when the convention
 });
 test("createTriggerHandler skips convention-linked pre-hooks when the convention does not match", async () => {
     await withTempDir(async (dir) => {
-        const harnessDir = join(dir, ".agentteams");
-        await mkdir(harnessDir, { recursive: true });
-        await writeFile(join(harnessDir, "harness.yml"), [
-            "preHooks:",
-            "  - name: only-on-feature",
-            "    command: sh -c 'echo feature > feature.txt && exit 1'",
-            "    onFailure: fail",
-            "    conventionTrigger: task:FEATURE",
-        ].join("\n"));
         let runnerCalled = false;
         const clientCalls = [];
         const conventions = [{
@@ -900,13 +918,18 @@ test("createTriggerHandler skips convention-linked pre-hooks when the convention
                 description: "Rules for bug fix tasks",
             }];
         const client = {
-            fetchTriggerRuntime: async () => ({
-                ...runtime,
-                authPath: dir,
+            fetchTriggerRuntime: async () => withHarnessRuntime(dir, {
                 conventions,
                 planType: "BUG_FIX",
             }),
-            fetchHarnessConfig: async () => null,
+            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 });
@@ -953,18 +976,6 @@ test("createTriggerHandler skips convention-linked pre-hooks when the convention
 });
 test("createTriggerHandler runs unconditional hooks while skipping non-matching conditional hooks", async () => {
     await withTempDir(async (dir) => {
-        const harnessDir = join(dir, ".agentteams");
-        await mkdir(harnessDir, { recursive: true });
-        await writeFile(join(harnessDir, "harness.yml"), [
-            "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",
-        ].join("\n"));
         let runnerCalled = false;
         const clientCalls = [];
         const conventions = [{
@@ -975,13 +986,21 @@ test("createTriggerHandler runs unconditional hooks while skipping non-matching
                 description: "Rules for bug fix tasks",
             }];
         const client = {
-            fetchTriggerRuntime: async () => ({
-                ...runtime,
-                authPath: dir,
+            fetchTriggerRuntime: async () => withHarnessRuntime(dir, {
                 conventions,
                 planType: "BUG_FIX",
             }),
-            fetchHarnessConfig: async () => null,
+            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 });
@@ -1027,24 +1046,15 @@ test("createTriggerHandler runs unconditional hooks while skipping non-matching
         assert.equal(statusCall.args[1], "DONE");
     });
 });
-test("createTriggerHandler injects context-matched conventions into the runner prompt", async () => {
+test("createTriggerHandler passes the API-provided runner prompt unchanged", async () => {
     await withTempDir(async (dir) => {
         const runnerInputs = [];
-        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 () => ({
                 ...runtime,
                 authPath: dir,
-                conventions,
-                planType: "BUG_FIX",
+                runnerPrompt: "Prompt generated by API\n\nDo exactly this.",
             }),
-            fetchHarnessConfig: async () => null,
             isTriggerCancelRequested: async () => false,
             updateTriggerHistory: async () => undefined,
             updateTriggerStatus: async () => undefined,
@@ -1079,12 +1089,10 @@ test("createTriggerHandler injects context-matched conventions into the runner p
         });
         await handler({ ...trigger, parentTriggerId: null });
         assert.equal(runnerInputs.length, 1);
-        assert.match(runnerInputs[0]?.prompt ?? "", /\[IMPORTANT — Convention Reference \(MUST READ\)\]/);
-        assert.match(runnerInputs[0]?.prompt ?? "", /\[Context-Matched Conventions \(AUTO-LOADED\)\]/);
-        assert.match(runnerInputs[0]?.prompt ?? "", /`\.agentteams\/rules\/bugfix\.md` — Rules for bug fix tasks/);
+        assert.equal(runnerInputs[0]?.prompt, "Prompt generated by API\n\nDo exactly this.");
     });
 });
-test("createTriggerHandler omits auto-loaded convention prompt section when no conventions match", async () => {
+test("createTriggerHandler does not append history or convention text to the API prompt", async () => {
     await withTempDir(async (dir) => {
         const runnerInputs = [];
         const conventions = [{
@@ -1100,8 +1108,8 @@ test("createTriggerHandler omits auto-loaded convention prompt section when no c
                 authPath: dir,
                 conventions,
                 planType: "BUG_FIX",
+                runnerPrompt: "Only the API prompt",
             }),
-            fetchHarnessConfig: async () => null,
             isTriggerCancelRequested: async () => false,
             updateTriggerHistory: async () => undefined,
             updateTriggerStatus: async () => undefined,
@@ -1136,7 +1144,7 @@ test("createTriggerHandler omits auto-loaded convention prompt section when no c
         });
         await handler({ ...trigger, parentTriggerId: null });
         assert.equal(runnerInputs.length, 1);
-        assert.match(runnerInputs[0]?.prompt ?? "", /\[IMPORTANT — Convention Reference \(MUST READ\)\]/);
+        assert.equal(runnerInputs[0]?.prompt, "Only the API prompt");
         assert.doesNotMatch(runnerInputs[0]?.prompt ?? "", /Context-Matched Conventions \(AUTO-LOADED\)/);
     });
 });
@@ -1145,18 +1153,12 @@ test("createTriggerHandler omits auto-loaded convention prompt section when no c
 // ---------------------------------------------------------------------------
 test("createTriggerHandler marks DONE when post-hook succeeds after runner success", async () => {
     await withTempDir(async (dir) => {
-        const harnessDir = join(dir, ".agentteams");
-        await mkdir(harnessDir, { recursive: true });
-        await writeFile(join(harnessDir, "harness.yml"), [
-            "postHooks:",
-            "  - name: quality-gate",
-            "    command: echo ok",
-            "    onFailure: fail",
-        ].join("\n"));
         const clientCalls = [];
         const client = {
-            fetchTriggerRuntime: async () => ({ ...runtime, authPath: dir }),
-            fetchHarnessConfig: async () => null,
+            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 });
@@ -1182,18 +1184,12 @@ test("createTriggerHandler marks DONE when post-hook succeeds after runner succe
 });
 test("createTriggerHandler marks FAILED when post-hook fails with onFailure=fail", async () => {
     await withTempDir(async (dir) => {
-        const harnessDir = join(dir, ".agentteams");
-        await mkdir(harnessDir, { recursive: true });
-        await writeFile(join(harnessDir, "harness.yml"), [
-            "postHooks:",
-            "  - name: quality-gate",
-            "    command: exit 1",
-            "    onFailure: fail",
-        ].join("\n"));
         const clientCalls = [];
         const client = {
-            fetchTriggerRuntime: async () => ({ ...runtime, authPath: dir }),
-            fetchHarnessConfig: async () => null,
+            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 });
@@ -1220,18 +1216,12 @@ test("createTriggerHandler marks FAILED when post-hook fails with onFailure=fail
 });
 test("createTriggerHandler marks NEEDS_REVIEW when post-hook fails with onFailure=needs_review", async () => {
     await withTempDir(async (dir) => {
-        const harnessDir = join(dir, ".agentteams");
-        await mkdir(harnessDir, { recursive: true });
-        await writeFile(join(harnessDir, "harness.yml"), [
-            "postHooks:",
-            "  - name: review-gate",
-            "    command: exit 1",
-            "    onFailure: needs_review",
-        ].join("\n"));
         const clientCalls = [];
         const client = {
-            fetchTriggerRuntime: async () => ({ ...runtime, authPath: dir }),
-            fetchHarnessConfig: async () => null,
+            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 });
@@ -1257,19 +1247,13 @@ test("createTriggerHandler marks NEEDS_REVIEW when post-hook fails with onFailur
 });
 test("createTriggerHandler skips post-hooks when runner fails", async () => {
     await withTempDir(async (dir) => {
-        const harnessDir = join(dir, ".agentteams");
-        await mkdir(harnessDir, { recursive: true });
-        await writeFile(join(harnessDir, "harness.yml"), [
-            "postHooks:",
-            "  - name: should-not-run",
-            "    command: echo unreachable",
-            "    onFailure: fail",
-        ].join("\n"));
         const clientCalls = [];
         const logEntries = [];
         const client = {
-            fetchTriggerRuntime: async () => ({ ...runtime, authPath: dir }),
-            fetchHarnessConfig: async () => null,
+            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 });
@@ -1298,14 +1282,8 @@ test("createTriggerHandler skips post-hooks when runner fails", async () => {
         assert.equal(logEntries.some((l) => l.includes("post-execution")), false, "Post-hooks should not run when runner fails");
     });
 });
-test("createTriggerHandler records injected conventions with auto-match and harness-pinned sources", async () => {
+test("createTriggerHandler leaves prompt convention audit recording to the API", async () => {
     await withTempDir(async (dir) => {
-        const harnessDir = join(dir, ".agentteams");
-        await mkdir(harnessDir, { recursive: true });
-        await writeFile(join(harnessDir, "harness.yml"), [
-            "conventionIds:",
-            "  - conv-pinned",
-        ].join("\n"));
         const conventions = [
             {
                 id: "conv-auto",
@@ -1329,20 +1307,20 @@ test("createTriggerHandler records injected conventions with auto-match and harn
                 description: null,
             },
         ];
-        const recordedBatches = [];
+        let recordCalled = false;
         const client = {
-            fetchTriggerRuntime: async () => ({
-                ...runtime,
-                authPath: dir,
+            fetchTriggerRuntime: async () => withHarnessRuntime(dir, {
                 conventions,
                 planType: "BUG_FIX",
             }),
-            fetchHarnessConfig: async () => null,
+            fetchHarnessConfigById: fetchServerHarness({
+                conventionIds: ["conv-pinned"],
+            }),
             isTriggerCancelRequested: async () => false,
             updateTriggerHistory: async () => undefined,
             updateTriggerStatus: async () => undefined,
-            recordInjectedConventions: async (triggerId, items) => {
-                recordedBatches.push({ triggerId, items });
+            recordInjectedConventions: async () => {
+                recordCalled = true;
             },
         };
         const handler = createTriggerHandler({
@@ -1371,23 +1349,11 @@ test("createTriggerHandler records injected conventions with auto-match and harn
             }),
         });
         await handler({ ...trigger, parentTriggerId: null });
-        assert.equal(recordedBatches.length, 1);
-        assert.equal(recordedBatches[0]?.triggerId, "trigger-1");
-        const items = recordedBatches[0]?.items ?? [];
-        const byId = new Map(items.map((i) => [i.conventionId, i.source]));
-        assert.equal(byId.get("conv-auto"), "AUTO_MATCH");
-        assert.equal(byId.get("conv-pinned"), "HARNESS_PINNED");
-        assert.equal(byId.has("conv-unrelated"), false);
+        assert.equal(recordCalled, false);
     });
 });
-test("createTriggerHandler swallows recordInjectedConventions failures without failing the trigger", async () => {
+test("createTriggerHandler ignores unavailable prompt convention recording client method", async () => {
     await withTempDir(async (dir) => {
-        const harnessDir = join(dir, ".agentteams");
-        await mkdir(harnessDir, { recursive: true });
-        await writeFile(join(harnessDir, "harness.yml"), [
-            "conventionIds:",
-            "  - conv-pinned",
-        ].join("\n"));
         const conventions = [
             {
                 id: "conv-pinned",
@@ -1399,13 +1365,13 @@ test("createTriggerHandler swallows recordInjectedConventions failures without f
         ];
         const clientCalls = [];
         const client = {
-            fetchTriggerRuntime: async () => ({
-                ...runtime,
-                authPath: dir,
+            fetchTriggerRuntime: async () => withHarnessRuntime(dir, {
                 conventions,
                 planType: "BUG_FIX",
             }),
-            fetchHarnessConfig: async () => null,
+            fetchHarnessConfigById: fetchServerHarness({
+                conventionIds: ["conv-pinned"],
+            }),
             isTriggerCancelRequested: async () => false,
             updateTriggerHistory: async (...args) => {
                 clientCalls.push({ method: "updateTriggerHistory", args });
@@ -1413,9 +1379,6 @@ test("createTriggerHandler swallows recordInjectedConventions failures without f
             updateTriggerStatus: async (...args) => {
                 clientCalls.push({ method: "updateTriggerStatus", args });
             },
-            recordInjectedConventions: async () => {
-                throw new Error("server unavailable");
-            },
         };
         const handler = createTriggerHandler({
             config: {