@koda-sl/baker-bridge 0.108.0-dev.0306d9ad9 → 0.108.0-dev.f7c15fa76

package/dist/hono/bridge-job.test.js

@@ -16,7 +16,7 @@ vi.mock("./runtime-files.ts", async (importOriginal) => {
     };
 });
 import { AVATAR_CASTING_TOOL_NAME } from "./avatar-casting.js";
-import { BridgeJobExecutor, createStallDetector, isContextOverflowRefusal, isControlChannelDeny, OUTPUT_STYLE, parsePlanDecision, remapAnswersToQuestionText, } from "./bridge-job.js";
+import { BridgeJobExecutor, createStallDetector, isContextOverflowRefusal, isControlChannelDeny, parsePlanDecision, remapAnswersToQuestionText, } from "./bridge-job.js";
 import { CONNECTION_INPUT_TOOL_NAME } from "./connection-input.js";
 import { FLOW_INPUT_TOOL_NAME } from "./flow-input.js";
 import { bridgeRuntimeFiles } from "./runtime-files.js";
@@ -63,6 +63,7 @@ function recordingRelay() {
     const agentActivityUpdates = [];
     const compactionUpdates = [];
     const reviewDigests = [];
+    const retractedEvents = [];
     const contextUsageUpdates = [];
     return {
         assistantEvents,
@@ -71,6 +72,7 @@ function recordingRelay() {
         compactionUpdates,
         contextUsageUpdates,
         reviewDigests,
+        retractedEvents,
         startPreview: () => undefined,
         previewText: () => undefined,
         previewTools: () => undefined,
@@ -86,6 +88,10 @@ function recordingRelay() {
             assistantEvents.push({ target, event, model });
             return Promise.resolve();
         },
+        retractEvents: (target, eventIds) => {
+            retractedEvents.push({ target, eventIds });
+            return Promise.resolve();
+        },
         complete: () => Promise.resolve(),
         inputRequest: () => Promise.resolve(true),
         inputResolved: () => Promise.resolve(),
@@ -223,6 +229,7 @@ function createExecutor(options) {
         now: options.now,
         readUsageBaseline: async (sessionId) => options.usageBaselines?.[sessionId],
         stalledCliExitMs: 0,
+        ...(options.mainSync ? { mainSync: options.mainSync } : {}),
     });
 }
 function resultMessage(costUsd, sessionId, modelUsage) {
@@ -308,8 +315,8 @@ describe("isControlChannelDeny", () => {
         })).toBe(false);
     });
     it("does not match a PreToolUse hook block that quotes the envelope in its explanation", () => {
-        // Live-run finding: the scaffold's guard-background-commands hook, when it
-        // still blocked backgrounded subagents, explained why by quoting the failure.
+        // Live-run finding: the scaffold's guard-background-commands hook explains
+        // WHY it blocks a backgrounded subagent by quoting the failure it prevents.
         // Its block arrives as an is_error tool_result, so an envelope-substring
         // match counted it as a deny — three blocked spawns in one turn would have
         // tripped the breaker and errored a perfectly healthy turn.
@@ -745,13 +752,13 @@ describe("BridgeJobExecutor", () => {
         const relay = recordingRelay();
         const executor = createExecutor({
             relay,
-            model: "claude-opus-4-6",
+            model: "claude-opus-5-5",
             queryResults: [
                 scriptedMessages(assistantMessage("assistant_1", "Done.", "session_next", {
                     usage: { input_tokens: 4000, cache_read_input_tokens: 96000 },
                 }), 
                 // The runtime reports Opus's catalog window as 200k through the
-                // OpenRouter passthrough — wrong. Opus 4.6 is 1M on OpenRouter.
+                // OpenRouter passthrough — wrong. Opus 5.5 is 1M on OpenRouter.
                 resultMessage(0.02, "session_next", {
                     "claude-main": {
                         inputTokens: 4000,
@@ -1163,7 +1170,8 @@ describe("BridgeJobExecutor", () => {
     // Read off a session's own `init` tool list, the CLI offers these to every
     // Session. Each one reaches past what a marketer's chat is for: the worktree
     // pair rearranges the branches Publish owns, `Workflow` fans out a fleet on
-    // the organization's OpenRouter key.
+    // the organization's OpenRouter key, and `SendMessage` addresses peers a
+    // single-session Runtime does not have.
     it("removes the tools that reach outside what a Session is", async () => {
         const queryInputs = [];
         const executor = createExecutor({
@@ -1172,12 +1180,10 @@ describe("BridgeJobExecutor", () => {
         });
         await executor.execute({ threadId: "thread_reach", turnId: "turn_reach", prompt: "Build a landing", history: history([]) }, activeControls());
         const disallowed = queryInputs[0]?.options.disallowedTools ?? [];
-        expect(disallowed).toEqual(expect.arrayContaining(["EnterWorktree", "ExitWorktree", "Workflow"]));
+        expect(disallowed).toEqual(expect.arrayContaining(["EnterWorktree", "ExitWorktree", "Workflow", "SendMessage"]));
         // `Task` is the subagent spawn itself — the scaffold's own fan-out workers
-        // ride it, so blocking multi-agent orchestration must not catch it. And
-        // `SendMessage` is how the agent follows up with a subagent it already ran.
+        // ride it, so blocking multi-agent orchestration must not catch it.
         expect(disallowed).not.toContain("Task");
-        expect(disallowed).not.toContain("SendMessage");
     });
     it("allowlists the workspace's own skills so the CLI's built-in developer skills stay out of the session", async () => {
         const workspace = await mkdtemp(join(tmpdir(), "baker-job-skills-"));
@@ -1365,42 +1371,31 @@ describe("BridgeJobExecutor", () => {
         await executor.execute({ threadId: "thread_uw", turnId: "turn_uw", prompt: "Hi", history: history([]) }, activeControls());
         expect((queryInputs[0]?.options.settings ?? {})).not.toHaveProperty("autoCompactWindow");
     });
-    // The output style is pinned on every turn, so the settings tier now always has
-    // something in it — even for a model whose window we cannot resolve and with no
-    // chat id to enable the memory directory, which used to leave it empty.
-    it("always sends the settings tier, because the output style is pinned every turn", async () => {
-        vi.stubEnv("BAKER_CHAT_ID", "");
+    // No output style is sent. `Concise` was pinned against Opus 5's preamble; on
+    // Opus 5.5 it suppressed the one-line progress notes a marketer reads while a
+    // long turn works. The voice rules live in the scaffold CLAUDE.md instead.
+    it("sends no output style, so the default voice and its progress notes survive", async () => {
         const queryInputs = [];
         const executor = createExecutor({
             queryInputs,
-            model: "claude-unknown",
-            queryResults: [scriptedMessages(resultMessage(0, "session_no_settings"))],
+            queryResults: [scriptedMessages(resultMessage(0, "session_style"))],
         });
-        await executor.execute({ threadId: "thread_ns", turnId: "turn_ns", prompt: "Hi", history: history([]) }, activeControls());
-        expect(queryInputs[0]?.options.settings).toEqual({ outputStyle: OUTPUT_STYLE });
-    });
-    // The CLI accepts an unrecognized output-style name silently — a misspelling
-    // returns a clean 200 on the default voice, with nothing at runtime to notice
-    // it. Verified against the CLI: `{"outputStyle":"NotARealStyle"}` succeeded.
-    // So the literal is pinned here rather than left to review.
-    it("names the built-in Concise style exactly", () => {
-        expect(OUTPUT_STYLE).toBe("Concise");
+        await executor.execute({ threadId: "thread_style", turnId: "turn_style_1", prompt: "Hi", history: history([]) }, activeControls());
+        expect((queryInputs[0]?.options.settings ?? {})).not.toHaveProperty("outputStyle");
     });
-    it("runs every turn under the pinned output style", async () => {
+    // Nothing to put in the settings tier (unknown model window, no chat id for the
+    // memory directory) means no `settings` key at all: the SDK forwards even `{}`
+    // to the CLI as a `--settings` flag tier.
+    it("omits the settings tier when nothing in it applies", async () => {
+        vi.stubEnv("BAKER_CHAT_ID", "");
         const queryInputs = [];
         const executor = createExecutor({
             queryInputs,
-            queryResults: [
-                scriptedMessages(resultMessage(0, "session_style")),
-                scriptedMessages(resultMessage(0, "session_style")),
-            ],
+            model: "claude-unknown",
+            queryResults: [scriptedMessages(resultMessage(0, "session_no_settings"))],
         });
-        await executor.execute({ threadId: "thread_style", turnId: "turn_style_1", prompt: "Hi", history: history([]) }, activeControls());
-        await executor.execute({ threadId: "thread_style", turnId: "turn_style_2", prompt: "Again", history: history([]) }, activeControls());
-        expect(queryInputs[0]?.options.settings).toMatchObject({ outputStyle: "Concise" });
-        // Constant across turns — the style is part of the system prompt, so a
-        // per-turn value would re-write the cache prefix on every request.
-        expect(queryInputs[1]?.options.settings).toMatchObject({ outputStyle: "Concise" });
+        await executor.execute({ threadId: "thread_ns", turnId: "turn_ns", prompt: "Hi", history: history([]) }, activeControls());
+        expect(queryInputs[0]?.options).not.toHaveProperty("settings");
     });
     it("runs exact publish commands with the prompt passed through verbatim", async () => {
         const queryInputs = [];
@@ -1478,6 +1473,154 @@ describe("BridgeJobExecutor", () => {
         expect(queryInputs[0]?.prompt).toBe("/publish");
         expect(queryInputs[0]?.reminder).toBeUndefined();
     });
+    it("brings the workspace level with main before the turn and tells the agent what changed, beside the viewing context", async () => {
+        const queryInputs = [];
+        const syncedThreads = [];
+        const syncedPublishes = [];
+        const executor = createExecutor({
+            queryInputs,
+            queryResults: [scriptedMessages(resultMessage(0, "session_main_moved"))],
+            mainSync: {
+                beforeTurn: (threadId, published) => {
+                    syncedThreads.push(threadId);
+                    syncedPublishes.push(...published.map((entry) => entry.sha));
+                    return Promise.resolve({
+                        recovered: "<system-reminder>\nBaker: this workspace now includes work published since your last look.\n</system-reminder>",
+                    });
+                },
+                refuseWrite: () => null,
+            },
+        });
+        await executor.execute({
+            threadId: "thread_main_moved",
+            turnId: "turn_main_moved",
+            prompt: "change the hero title",
+            history: history([]),
+            currentReference: { type: "landing", slug: "homepage", title: "Homepage" },
+            publishedElsewhere: [
+                {
+                    sha: "abc123",
+                    chatId: "sibling",
+                    title: "New hero",
+                    publishedAt: 1,
+                    paths: ["src/pages/hero/index.astro"],
+                },
+            ],
+        }, activeControls());
+        expect(syncedThreads).toEqual(["thread_main_moved"]);
+        expect(syncedPublishes).toEqual(["abc123"]);
+        expect(queryInputs[0]?.prompt).toBe("change the hero title");
+        expect(queryInputs[0]?.reminder).toContain("Baker: this workspace now includes work published");
+        expect(queryInputs[0]?.reminder).toContain('landing "Homepage" (slug: homepage)');
+    });
+    it("does not move the workspace under a publish command", async () => {
+        const queryInputs = [];
+        const syncedThreads = [];
+        const executor = createExecutor({
+            queryInputs,
+            queryResults: [scriptedMessages(resultMessage(0, "session_publish_main"))],
+            mainSync: {
+                beforeTurn: (threadId) => {
+                    syncedThreads.push(threadId);
+                    return Promise.resolve({ resumed: "<system-reminder>\nBaker: moved\n</system-reminder>" });
+                },
+                refuseWrite: () => null,
+            },
+        });
+        await executor.execute({ threadId: "thread_publish_main", turnId: "turn_publish_main", prompt: "/publish", history: history([]) }, activeControls());
+        expect(syncedThreads).toEqual([]);
+        expect(queryInputs[0]?.reminder).toBeUndefined();
+    });
+    it("tells a resumed session only what is new, since it remembers every earlier note", async () => {
+        const queryInputs = [];
+        const executor = createExecutor({
+            loadedBoundary: cleanBoundary("session_resumed_main"),
+            queryInputs,
+            queryResults: [scriptedMessages(resultMessage(0, "session_resumed_main_next"))],
+            mainSync: {
+                beforeTurn: () => Promise.resolve({ recovered: "<system-reminder>\nBaker: standing\n</system-reminder>" }),
+                refuseWrite: () => null,
+            },
+        });
+        await executor.execute({ threadId: "thread_resumed_main", turnId: "turn_resumed_main", prompt: "hola", history: history([]) }, activeControls());
+        expect(queryInputs[0]?.reminder).toBeUndefined();
+    });
+    it("repeats the standing workspace notice when a stale session falls back to rehydration", async () => {
+        const queryInputs = [];
+        const executor = createExecutor({
+            loadedBoundary: cleanBoundary("session_stale_main"),
+            queryInputs,
+            queryResults: [
+                scriptedError(new Error("Cannot resume: session not found")),
+                scriptedMessages(resultMessage(0, "session_stale_main_next")),
+            ],
+            mainSync: {
+                beforeTurn: () => Promise.resolve({ recovered: "<system-reminder>\nBaker: standing\n</system-reminder>" }),
+                refuseWrite: () => null,
+            },
+        });
+        await executor.execute({
+            threadId: "thread_stale_main",
+            turnId: "turn_stale_main",
+            prompt: "quita el pricing",
+            history: history([{ role: "user", text: "Persisted fact", createdAt: 1 }]),
+        }, activeControls());
+        expect(queryInputs[0]?.reminder).toBeUndefined();
+        expect(queryInputs[1]?.reminder).toContain("Baker: standing");
+    });
+    it("brings the workspace level with main before a skill command without putting a note in front of it", async () => {
+        const workspace = await mkdtemp(join(tmpdir(), "baker-job-skill-main-"));
+        await mkdir(join(workspace, ".claude", "skills", "landing"), { recursive: true });
+        projectRootMock.value = workspace;
+        const queryInputs = [];
+        const syncs = [];
+        const executor = createExecutor({
+            queryInputs,
+            queryResults: [scriptedMessages(resultMessage(0, "session_skill_main"))],
+            mainSync: {
+                beforeTurn: (threadId, _published, turn) => {
+                    syncs.push({ threadId, ...turn });
+                    return Promise.resolve({});
+                },
+                refuseWrite: () => null,
+            },
+        });
+        await executor.execute({ threadId: "thread_skill_main", turnId: "turn_skill_main", prompt: "/landing pricing", history: history([]) }, activeControls());
+        expect(syncs).toEqual([{ threadId: "thread_skill_main", withNote: false }]);
+        expect(queryInputs[0]?.prompt).toBe("/landing pricing");
+        expect(queryInputs[0]?.reminder).toBeUndefined();
+    });
+    it("refuses a write that would create a page another chat already published, with the reason for the agent", async () => {
+        let guardResult;
+        const executor = new BridgeJobExecutor({
+            sdk: {
+                query: (input) => ({
+                    async *[Symbol.asyncIterator]() {
+                        guardResult = await input.options.canUseTool?.("Write", { file_path: "/workspace/src/pages/sales-v2/index.astro", content: "v2" }, {
+                            toolUseID: "tool_write",
+                            requestId: "req_write",
+                            signal: input.options.abortController?.signal ?? new AbortController().signal,
+                        });
+                        yield resultMessage(0, "session_page_clash");
+                    },
+                }),
+            },
+            model: "claude-test",
+            sessionStore: { load: async () => undefined, save: async () => undefined, clear: async () => undefined },
+            relay: recordingRelay(),
+            mainSync: {
+                beforeTurn: () => Promise.resolve({}),
+                refuseWrite: (threadId, filePath) => threadId === "thread_page_clash" && filePath.endsWith("src/pages/sales-v2/index.astro")
+                    ? "`src/pages/sales-v2` was already published by another chat"
+                    : null,
+            },
+        });
+        await executor.execute({ threadId: "thread_page_clash", turnId: "turn_page_clash", prompt: "build sales v2" }, activeControls());
+        expect(guardResult).toEqual({
+            behavior: "deny",
+            message: "`src/pages/sales-v2` was already published by another chat",
+        });
+    });
     it("keeps the viewing-reference context beside the message when a stale session falls back to rehydration", async () => {
         const queryInputs = [];
         const executor = createExecutor({
@@ -1929,8 +2072,8 @@ describe("BridgeJobExecutor", () => {
         expect(castingRequests[0]).toMatchObject({ avatarHandle: "elena" });
     });
     it("hands the agent's own casting call the face the user picked, instead of a second picker", async () => {
-        // The tool tells the agent to call it IMMEDIATELY after `baker avatars create`, so
-        // this is the documented path, not an edge. The auto-cast owed for that create used
+        // An agent may still call it right after `baker avatars create` (the tool now says the
+        // picker opens by itself, but the call is tolerated). The auto-cast owed for that create used
         // to run under its own tool-use id and then let the explicit call through unhandled —
         // which returns the tool's `{ status: "declined" }` default. The agent was told the
         // user had rejected all four faces moments after they picked one, and the remedy in
@@ -3096,29 +3239,6 @@ describe("BridgeJobExecutor turn end with background tasks", () => {
         expect(outcome).toMatchObject({ kind: "completed", costUsd: 0.2 });
         expect(endInputAt.count).toBe(4);
     });
-    it("tells the session watchdog while a tool call or background task is running", async () => {
-        const endInputAt = { count: -1 };
-        const executor = createExecutor({
-            turnEndSettleMs: 20,
-            queryResults: [
-                cliLikeQuery(endInputAt, toolUseAssistantMessage("Bash", { command: "baker canvas run x.canvas.json" }), {
-                    type: "user",
-                    session_id: "session_bg",
-                    message: { role: "user", content: [{ type: "tool_result", tool_use_id: "toolu_stream", content: "ok" }] },
-                }, taskStarted("task_render"), resultMessage(0.1, "session_bg"), taskSettled("task_render"), resultMessage(0.2, "session_bg")),
-            ],
-        });
-        const reported = [];
-        const controls = {
-            ...activeControls(),
-            setWorkInFlight: (inFlight) => {
-                if (reported.at(-1) !== inFlight)
-                    reported.push(inFlight);
-            },
-        };
-        await executor.execute({ threadId: "thread_bg", turnId: "turn_bg", prompt: "Render", history: history([]) }, controls);
-        expect(reported).toEqual([true, false, true, false]);
-    });
     it("ends the turn when the last task settles without waking the model into a second result", async () => {
         // A settle is not guaranteed to produce another result. If only a result
         // could arm the end, this shape would strand in `for await` until the
@@ -3134,20 +3254,6 @@ describe("BridgeJobExecutor turn end with background tasks", () => {
         expect(outcome).toMatchObject({ kind: "completed", costUsd: 0.1 });
         expect(endInputAt.count).toBe(3);
     });
-    it("bills what a task spent after the last result when it settles without waking the model", async () => {
-        // The last result reported $0.10; the task kept working after it. With no
-        // second result, only the CLI's own running total can say what it cost.
-        const endInputAt = { count: -1 };
-        const query = cliLikeQuery(endInputAt, taskStarted("task_silent"), resultMessage(0.1, "session_bg"), taskSettled("task_silent"));
-        const executor = createExecutor({
-            turnEndSettleMs: 20,
-            queryResults: [
-                { ...query, usage: () => Promise.resolve({ totalCostUsd: 0.35, modelUsage: {} }) },
-            ],
-        });
-        const outcome = await executor.execute({ threadId: "thread_silent", turnId: "turn_silent", prompt: "Fan out one producer", history: history([]) }, activeControls());
-        expect(outcome).toMatchObject({ kind: "completed", costUsd: 0.35 });
-    });
     it("re-arms the settle window when a passive system event trails the result", async () => {
         // Passive trailing events (files persisted, session state) must not cancel
         // a scheduled end — only genuine model activity does. A cancel with no
@@ -3415,4 +3521,117 @@ describe("BridgeJobExecutor review mode", () => {
         expect(outcome).toMatchObject({ kind: "completed", structuredOutput: findings });
     });
 });
+describe("BridgeJobExecutor model refusals", () => {
+    function refusalNoFallback() {
+        return {
+            type: "system",
+            subtype: "model_refusal_no_fallback",
+            original_model: "claude-opus-5-5",
+            request_id: "req_1",
+            api_refusal_category: "cyber",
+            content: "Claude Code is unable to respond to this request.",
+            uuid: "refusal_notice",
+            session_id: "session_refused",
+        };
+    }
+    it("ends a refused turn with a product-language error instead of a success", async () => {
+        const executor = createExecutor({
+            queryResults: [scriptedMessages(refusalNoFallback(), resultMessage(0.01, "session_refused"))],
+        });
+        const outcome = await executor.execute({ threadId: "thread_refused", turnId: "turn_refused", prompt: "Hi", history: history([]) }, activeControls());
+        expect(outcome).toMatchObject({
+            kind: "errored",
+            errors: ["I couldn't help with that request. Try rephrasing what you need."],
+        });
+    });
+    it("records the refusal category for whoever reads the turn afterwards", async () => {
+        const turnEvents = [];
+        const executor = createExecutor({
+            turnEvents,
+            queryResults: [scriptedMessages(refusalNoFallback(), resultMessage(0.01, "session_refused"))],
+        });
+        await executor.execute({ threadId: "thread_refused", turnId: "turn_refused", prompt: "Hi", history: history([]) }, activeControls());
+        expect(turnEvents).toContainEqual(expect.objectContaining({ event: "model_refusal", detail: expect.objectContaining({ category: "cyber" }) }));
+    });
+    // The CLI renders the refusal as an assistant error frame written for a
+    // terminal user. The turn already ends on a product-language error, so that
+    // frame never reaches the chat.
+    it("does not relay the CLI's refusal frame to the chat", async () => {
+        const relay = recordingRelay();
+        const refusalFrame = {
+            type: "assistant",
+            uuid: "refusal_frame",
+            message: {
+                role: "assistant",
+                content: [{ type: "text", text: "API Error: Claude Code is unable to respond to this request." }],
+                stop_reason: "refusal",
+            },
+        };
+        const executor = createExecutor({
+            relay,
+            queryResults: [scriptedMessages(refusalFrame, refusalNoFallback(), resultMessage(0.01, "session_refused"))],
+        });
+        await executor.execute({ threadId: "thread_refused", turnId: "turn_refused", prompt: "Hi", history: history([]) }, activeControls());
+        expect(relay.assistantEvents).toEqual([]);
+    });
+    // A refused subagent is reported the same way, but the main agent gets the
+    // failed task back and carries on — the turn is still its to finish.
+    it("lets the turn complete when the main conversation carries on after a refusal", async () => {
+        const executor = createExecutor({
+            queryResults: [
+                scriptedMessages(refusalNoFallback(), assistantMessage("assistant_after", "Done another way.", "session_refused"), resultMessage(0.01, "session_refused")),
+            ],
+        });
+        const outcome = await executor.execute({ threadId: "thread_refused", turnId: "turn_refused", prompt: "Hi", history: history([]) }, activeControls());
+        expect(outcome).toMatchObject({ kind: "completed" });
+    });
+    it("keeps the product-language error when the refused turn's result is an error", async () => {
+        const erroredResult = {
+            type: "result",
+            subtype: "error_during_execution",
+            is_error: true,
+            errors: ["API Error: Claude Code is unable to respond to this request."],
+            total_cost_usd: 0.01,
+            session_id: "session_refused",
+        };
+        const executor = createExecutor({ queryResults: [scriptedMessages(refusalNoFallback(), erroredResult)] });
+        const outcome = await executor.execute({ threadId: "thread_refused", turnId: "turn_refused", prompt: "Hi", history: history([]) }, activeControls());
+        expect(outcome).toMatchObject({
+            kind: "errored",
+            errors: ["I couldn't help with that request. Try rephrasing what you need."],
+        });
+    });
+    // A fallback model retried the refused request. What the refused leg already
+    // posted is superseded, so it leaves the chat instead of sitting above the
+    // answer that replaced it.
+    it("retracts the messages a refusal fallback superseded", async () => {
+        const relay = recordingRelay();
+        const fallbackNotice = {
+            type: "system",
+            subtype: "model_refusal_fallback",
+            trigger: "refusal",
+            direction: "retry",
+            scope: "session",
+            original_model: "claude-opus-5-5",
+            fallback_model: "claude-sonnet-5",
+            request_id: "req_1",
+            api_refusal_category: "cyber",
+            retracted_message_uuids: ["refused_partial_1", "refused_partial_2"],
+            content: "Retried on a different model.",
+            uuid: "fallback_notice",
+            session_id: "session_fallback",
+        };
+        const executor = createExecutor({
+            relay,
+            queryResults: [
+                scriptedMessages(assistantMessage("refused_partial_1", "Sure, here is", "session_fallback"), fallbackNotice, assistantMessage("fallback_answer", "Here is the plan.", "session_fallback"), resultMessage(0.01, "session_fallback")),
+            ],
+        });
+        const outcome = await executor.execute({ threadId: "thread_fb", turnId: "turn_fb", prompt: "Hi", history: history([]) }, activeControls());
+        expect(relay.retractedEvents).toEqual([
+            { target: { threadId: "thread_fb", turnId: "turn_fb" }, eventIds: ["refused_partial_1", "refused_partial_2"] },
+        ]);
+        expect(outcome).toMatchObject({ kind: "completed" });
+    });
+});
 //# sourceMappingURL=bridge-job.test.js.map