@koda-sl/baker-bridge 0.172.0-dev.b570aa3f2 → 0.172.0-dev.f1dc1ec56

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

@@ -1,5 +1,5 @@
 import { readFileSync } from "node:fs";
-import { mkdir, mkdtemp, readFile, rm, utimes, writeFile } from "node:fs/promises";
+import { mkdir, mkdtemp, rm, utimes, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { afterEach, describe, expect, it, vi } from "vitest";
@@ -9,19 +9,11 @@ vi.mock("./env.ts", () => ({
 // The skills allowlist is read off the workspace, so the project root has to be
 // steerable to a fixture directory. Defaults to the real root for every other test.
 const projectRootMock = vi.hoisted(() => ({ value: process.cwd() }));
-// Where the per-company instructions import is written; kept out of the real ~/.baker.
-const instructionsDirMock = vi.hoisted(() => ({
-    value: `${process.env.TMPDIR ?? "/tmp"}/baker-job-instructions-${process.pid}`,
-}));
 vi.mock("./runtime-files.ts", async (importOriginal) => {
     const actual = await importOriginal();
     return {
         ...actual,
-        bridgeRuntimeFiles: {
-            ...actual.bridgeRuntimeFiles,
-            projectRoot: () => projectRootMock.value,
-            instructionsDir: () => instructionsDirMock.value,
-        },
+        bridgeRuntimeFiles: { ...actual.bridgeRuntimeFiles, projectRoot: () => projectRootMock.value },
     };
 });
 import { AVATAR_CASTING_TOOL_NAME } from "./avatar-casting.js";
@@ -262,9 +254,7 @@ function createExecutor(options) {
         ...(options.catchUpWithMain ? { catchUpWithMain: options.catchUpWithMain } : {}),
         ...(options.keepCliInStep ? { keepCliInStep: options.keepCliInStep } : {}),
         ...(options.holdsNoWork ? { holdsNoWork: options.holdsNoWork } : {}),
-        // Never the network: a turn nobody judges runs on the default model and effort.
-        routeJudge: options.routeJudge ?? (async () => null),
-        ...(options.routeModels ? { routeModels: true } : {}),
+        ...(options.settleAfterPublish ? { settleAfterPublish: options.settleAfterPublish } : {}),
     });
 }
 function memoryInFlightTurns(initial) {
@@ -1017,39 +1007,6 @@ describe("BridgeJobExecutor", () => {
             ],
         });
     });
-    // Tool results are most of what a turn writes to the prompt cache, and nothing
-    // recorded their size: the turn now reports it next to its model usage.
-    it("reports how much each tool's results put in the context this turn", async () => {
-        const executor = createExecutor({
-            queryResults: [
-                scriptedMessages({
-                    type: "assistant",
-                    parent_tool_use_id: null,
-                    uuid: "assistant_tool",
-                    session_id: "session_tools_size",
-                    message: {
-                        id: "msg_tool",
-                        role: "assistant",
-                        content: [{ type: "tool_use", id: "tool_1", name: "Bash", input: { command: "baker ads meta ads" } }],
-                    },
-                }, {
-                    type: "user",
-                    parent_tool_use_id: null,
-                    uuid: "user_tool_result",
-                    session_id: "session_tools_size",
-                    message: {
-                        role: "user",
-                        content: [{ type: "tool_result", tool_use_id: "tool_1", content: "r".repeat(800) }],
-                    },
-                }, resultMessage(0.1, "session_tools_size")),
-            ],
-        });
-        const outcome = await executor.execute({ threadId: "thread_tools_size", turnId: "turn_tools_size", prompt: "How are the ads?", history: history([]) }, activeControls());
-        expect(outcome).toMatchObject({
-            kind: "completed",
-            toolResults: [{ tool: "baker ads meta", agent: "main", calls: 1, bytes: 800, tokens: 200 }],
-        });
-    });
     // OpenRouter answers under its own slug. A CLI resuming a transcript that names
     // the slug drops every earlier thinking block from its first request, which
     // breaks the prompt cache right after the system prompt (BAKER-331).
@@ -1104,6 +1061,25 @@ describe("BridgeJobExecutor", () => {
         // would resume a transcript holding one `/publish` and nothing else.
         expect(savedBoundaries).toEqual([]);
     });
+    it("settles the chat's Publish once a publish turn ends, and never after a chat turn", async () => {
+        let settled = 0;
+        const settleAfterPublish = () => {
+            settled += 1;
+            return Promise.resolve();
+        };
+        const publishing = createExecutor({
+            queryResults: [scriptedMessages(resultMessage(0.3, "session_publish_own"))],
+            settleAfterPublish,
+        });
+        const chatting = createExecutor({
+            queryResults: [scriptedMessages(resultMessage(0.3, "session_chat"))],
+            settleAfterPublish,
+        });
+        await publishing.execute({ threadId: "thread_publish", turnId: "turn_publish", prompt: "/publish", history: history([]) }, activeControls());
+        const afterPublish = settled;
+        await chatting.execute({ threadId: "thread_chat", turnId: "turn_chat", prompt: "hello" }, activeControls());
+        expect([afterPublish, settled]).toEqual([1, 1]);
+    });
     it("leaves the chat's session alone when a publish fails", async () => {
         const clearCalls = [];
         const executor = createExecutor({
@@ -1332,19 +1308,16 @@ describe("BridgeJobExecutor", () => {
             "x-session-id: thread_env",
         ].join("\n"));
     });
-    // With the capability on, the CLI restates the effort in its mid-conversation
-    // system message, so a turn on another effort level keeps the conversation's
-    // prompt cache. Without it, a changed top-level effort re-writes everything
-    // after the first tool exchange. Pinned on rather than left to the CLI's own
-    // default, which a remote feature gate can switch off.
-    it("turns on per-turn effort, so a turn on another effort level keeps the prompt cache", async () => {
+    // OpenRouter has no Bedrock endpoint for a per-message effort, so while the CLI
+    // sends one every Opus 5.5 request skips Bedrock and bills OpenRouter credits.
+    it("keeps the agent's model requests servable by Bedrock", async () => {
         const queryInputs = [];
         const executor = createExecutor({
             queryInputs,
             queryResults: [scriptedMessages(resultMessage(0, "session_bedrock"))],
         });
         await executor.execute({ threadId: "thread_bedrock", turnId: "turn_bedrock", prompt: "Build a landing", history: history([]) }, activeControls());
-        expect(queryInputs[0]?.options.env).toMatchObject({ CLAUDE_CODE_MODEL_CAPABILITIES: "per_turn_effort" });
+        expect(queryInputs[0]?.options.env).toMatchObject({ CLAUDE_CODE_MODEL_CAPABILITIES: "-per_turn_effort" });
     });
     // The CLI names each session with a structured-output request OpenRouter's Bedrock
     // cannot serve, so it went to Azure on OpenRouter credits; nothing reads the name.
@@ -1455,134 +1428,6 @@ describe("BridgeJobExecutor", () => {
         expect(disallowed).not.toContain("Task");
         expect(disallowed).not.toContain("SendMessage");
     });
-    // Developer tools a marketer's chat never calls (0 calls across 358
-    // production chats, Oct 2026). Each definition rides every request a session
-    // makes — DesignSync's alone is ~9k characters — whenever the CLI does not
-    // defer it.
-    it("removes the developer tools a marketer's chat never calls", async () => {
-        const queryInputs = [];
-        const executor = createExecutor({
-            queryInputs,
-            queryResults: [scriptedMessages(resultMessage(0, "session_dev_tools"))],
-        });
-        await executor.execute({ threadId: "thread_dev_tools", turnId: "turn_dev_tools", prompt: "Build a landing", history: history([]) }, activeControls());
-        const disallowed = queryInputs[0]?.options.disallowedTools ?? [];
-        expect(disallowed).toEqual(expect.arrayContaining(["DesignSync", "ReportFindings", "NotebookEdit"]));
-    });
-    // The scaffold's CLAUDE.md is the same text for every company on a scaffold
-    // version, but loaded as a memory file it lands in the first user message with
-    // no cache breakpoint after it, so every chat wrote its ~24k tokens cold. In the
-    // system prompt it ends on a breakpoint and one chat reads another's copy.
-    it("sends the workspace's shared instructions as the system prompt and loads COMPANY.md on its own", async () => {
-        const workspace = await mkdtemp(join(tmpdir(), "baker-job-instructions-"));
-        await writeFile(join(workspace, "CLAUDE.md"), "# Project Instructions\n\n## Client Context\n\nOne client per repo. Everything known about them:\n\n@COMPANY.md\n\n## Rules\n\nStage, don't ask.\n");
-        projectRootMock.value = workspace;
-        const queryInputs = [];
-        const executor = createExecutor({
-            queryInputs,
-            queryResults: [scriptedMessages(resultMessage(0, "session_instructions"))],
-        });
-        await executor.execute({ threadId: "thread_instructions", turnId: "turn_instructions", prompt: "Build a landing", history: history([]) }, activeControls());
-        const options = queryInputs[0]?.options;
-        expect(options.systemPrompt).toEqual({
-            type: "preset",
-            preset: "claude_code",
-            append: "# Project Instructions\n\n## Rules\n\nStage, don't ask.\n",
-            snapshot: true,
-        });
-        expect(options.settings).toMatchObject({ claudeMdExcludes: [join(workspace, "CLAUDE.md")] });
-        expect(options.additionalDirectories).toEqual([instructionsDirMock.value]);
-        expect(options.env?.CLAUDE_CODE_ADDITIONAL_DIRECTORIES_CLAUDE_MD).toBe("1");
-        expect(await readFile(join(instructionsDirMock.value, "CLAUDE.md"), "utf8")).toBe(`@${join(workspace, "COMPANY.md")}\n`);
-    });
-    // Excluding CLAUDE.md from the memory files took it from every subagent that
-    // loaded it there too; measured through the real CLI, `general-purpose` and
-    // `research` lost it while still reading COMPANY.md.
-    it("gives the shared instructions back to the subagents that loaded CLAUDE.md, and only to them", async () => {
-        const workspace = await mkdtemp(join(tmpdir(), "baker-job-subagent-instructions-"));
-        await writeFile(join(workspace, "CLAUDE.md"), "# Project Instructions\n\n## Client Context\n\nOne client per repo. Everything known about them:\n\n@COMPANY.md\n\n## Rules\n\nStage, don't ask.\n");
-        await mkdir(join(workspace, ".claude", "agents"), { recursive: true });
-        await writeFile(join(workspace, ".claude", "agents", "claim-checker.md"), "---\nname: claim-checker\nmodel: claude-sonnet-5-5\nomitClaudeMd: true\n---\nCheck claims.\n");
-        projectRootMock.value = workspace;
-        const queryInputs = [];
-        const executor = createExecutor({
-            queryInputs,
-            queryResults: [scriptedMessages(resultMessage(0, "session_subagent_instructions"))],
-        });
-        await executor.execute({ threadId: "thread_sub_instr", turnId: "turn_sub_instr", prompt: "Build a landing", history: history([]) }, activeControls());
-        const start = queryInputs[0]?.options.hooks?.SubagentStart?.[0]?.hooks[0];
-        const contextFor = async (agentType) => (await start?.({
-            hook_event_name: "SubagentStart",
-            agent_type: agentType,
-            agent_id: "a",
-            session_id: "s",
-            transcript_path: "",
-            cwd: "",
-        }, undefined, { signal: new AbortController().signal }))?.hookSpecificOutput?.additionalContext;
-        expect(await contextFor("general-purpose")).toContain("Stage, don't ask.");
-        expect(await contextFor("general-purpose")).not.toContain("@COMPANY.md");
-        expect(await contextFor("claim-checker")).toBeUndefined();
-        expect(await contextFor("fork")).toBeUndefined();
-    });
-    it("moves a built-in subagent that only reads to Sonnet, and records it with the turn", async () => {
-        const queryInputs = [];
-        let spawned;
-        const executor = createExecutor({
-            queryInputs,
-            model: "claude-opus-5-5",
-            routeModels: true,
-            // The turn: finished work, so Opus. The spawn: only reading.
-            routeJudge: (questions) => Promise.resolve(String(questions[0]?.instructions.message).includes("Check which step")
-                ? [0.2, 0.8, 0.9, 0.1]
-                : [0.1, 0.9, 0.1, 0.9]),
-            queryResults: [
-                {
-                    async *[Symbol.asyncIterator]() {
-                        const preToolUse = queryInputs[0]?.options.hooks?.PreToolUse?.find((m) => m.matcher === "Agent")?.hooks[0];
-                        const result = (await preToolUse?.({
-                            hook_event_name: "PreToolUse",
-                            tool_name: "Agent",
-                            tool_input: {
-                                subagent_type: "general-purpose",
-                                description: "Walk the flow",
-                                prompt: "Check which step fires the conversion.",
-                            },
-                            tool_use_id: "toolu_1",
-                            session_id: "s",
-                            transcript_path: "",
-                            cwd: "",
-                        }, "toolu_1", { signal: new AbortController().signal }));
-                        spawned = result.hookSpecificOutput?.updatedInput;
-                        yield resultMessage(0, "session_subagent_route");
-                    },
-                },
-            ],
-        });
-        const outcome = await executor.execute({ threadId: "thread_sub_route", turnId: "turn_sub_route", prompt: "Rebuild the landing", history: history([]) }, activeControls());
-        expect(spawned).toMatchObject({ subagent_type: "general-purpose", model: "sonnet", effort: "high" });
-        expect(outcome).toMatchObject({
-            turnRoute: {
-                model: "claude-opus-5-5",
-                subagents: [{ agentType: "general-purpose", model: "sonnet", effort: "high", reason: "read_only" }],
-            },
-        });
-    });
-    it("lets the CLI load a CLAUDE.md it cannot split, exactly as before", async () => {
-        const workspace = await mkdtemp(join(tmpdir(), "baker-job-instructions-old-"));
-        await writeFile(join(workspace, "CLAUDE.md"), "# Project Instructions\n\nNo company import.\n");
-        projectRootMock.value = workspace;
-        const queryInputs = [];
-        const executor = createExecutor({
-            queryInputs,
-            queryResults: [scriptedMessages(resultMessage(0, "session_instructions_old"))],
-        });
-        await executor.execute({ threadId: "thread_instructions_old", turnId: "turn_instructions_old", prompt: "Hi", history: history([]) }, activeControls());
-        const options = queryInputs[0]?.options;
-        expect(options.systemPrompt).toBeUndefined();
-        expect(options.additionalDirectories).toBeUndefined();
-        expect(options.settings ?? {}).not.toHaveProperty("claudeMdExcludes");
-        expect(options.env?.CLAUDE_CODE_ADDITIONAL_DIRECTORIES_CLAUDE_MD).toBeUndefined();
-    });
     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-"));
         for (const skill of ["landing", "brand-build", "docx"]) {
@@ -1761,10 +1606,11 @@ describe("BridgeJobExecutor", () => {
         await executor.execute({ threadId: "thread_nobeta", turnId: "turn_nobeta", prompt: "Hi", history: history([]) }, activeControls());
         expect(queryInputs[0]?.options).not.toHaveProperty("betas");
     });
-    // Effort governs thinking depth, preamble and tool-call count. A turn nobody
-    // could judge runs at Opus 5.5's own default, set explicitly so an SDK or
-    // model default change cannot move it.
-    it("runs a turn Jev could not judge at medium effort", async () => {
+    // Effort governs thinking depth, preamble and tool-call count, and the API
+    // default is `high`. A silent drift back to the default costs money twice:
+    // more tokens per turn, and — because the resolved effort is rendered into
+    // the prompt — a cache-breakpoint invalidation on the turn it changes.
+    it("sends a single constant effort so the prompt cache is never invalidated by it", async () => {
         const queryInputs = [];
         const executor = createExecutor({
             queryInputs,
@@ -1777,105 +1623,8 @@ describe("BridgeJobExecutor", () => {
         await executor.execute({ threadId: "thread_effort", turnId: "turn_effort_1", prompt: "Hi", history: history([]) }, activeControls());
         await executor.execute({ threadId: "thread_effort", turnId: "turn_effort_2", prompt: "Again", history: history([]) }, activeControls());
         expect(queryInputs[0]?.options.effort).toBe("medium");
-        expect(queryInputs[1]?.options.effort).toBe("medium");
-    });
-    it("runs a turn Jev clearly reads as small at low effort, and reports why", async () => {
-        const queryInputs = [];
-        const asked = [];
-        const executor = createExecutor({
-            queryInputs,
-            model: "claude-opus-5-5",
-            // small, complex, read-only, deliverable
-            routeJudge: (questions) => {
-                asked.push(...questions);
-                return Promise.resolve([0.92, 0.05, 0.6, 0.1]);
-            },
-            queryResults: [scriptedMessages(resultMessage(0, "session_effort_low"))],
-        });
-        const outcome = await executor.execute({
-            threadId: "thread_effort_low",
-            turnId: "turn_effort_low",
-            prompt: "¿Cuál fue el CPL de ayer?",
-            history: history([
-                { role: "user", text: "Revisa la campaña de verano", createdAt: 1 },
-                { role: "assistant", text: "Listo: la campaña de verano va bien.", createdAt: 2 },
-            ]),
-        }, activeControls());
-        expect(queryInputs[0]?.options.effort).toBe("low");
-        expect(asked[0]).toMatchObject({
-            instructions: { message: "¿Cuál fue el CPL de ayer?", previous_reply: "Listo: la campaña de verano va bien." },
-        });
-        expect(outcome).toMatchObject({
-            kind: "completed",
-            turnRoute: { model: "claude-opus-5-5", modelReason: "fixed", effort: "low", reason: "small" },
-        });
-    });
-    it("starts a chat that only reads on Sonnet, thinking harder, when the Runtime routes models", async () => {
-        const queryInputs = [];
-        const executor = createExecutor({
-            queryInputs,
-            model: "claude-opus-5-5",
-            routeModels: true,
-            routeJudge: () => Promise.resolve([0.2, 0.9, 0.85, 0.1]),
-            queryResults: [scriptedMessages(resultMessage(0, "session_reading"))],
-        });
-        const outcome = await executor.execute({ threadId: "thread_reading", turnId: "turn_reading", prompt: "¿Cómo van los anuncios?", history: history([]) }, activeControls());
-        expect(queryInputs[0]?.options).toMatchObject({ model: "claude-sonnet-5-5", effort: "high" });
-        expect(outcome).toMatchObject({
-            model: "claude-sonnet-5-5",
-            turnRoute: { model: "claude-sonnet-5-5", modelReason: "read_only", effort: "high" },
-        });
-    });
-    it("moves a chat that ran on Sonnet to Opus once a turn asks for finished work", async () => {
-        const configDir = await mkdtemp(join(tmpdir(), "bridge-turn-route-"));
-        try {
-            await mkdir(join(configDir, "projects", "-home-user-repo"), { recursive: true });
-            await writeFile(join(configDir, "projects", "-home-user-repo", "session_sonnet.jsonl"), `${JSON.stringify({ type: "assistant", requestedModel: "claude-sonnet-5-5", message: { id: "m", model: "claude-sonnet-5-5", content: [] } })}\n`);
-            vi.stubEnv("CLAUDE_CONFIG_DIR", configDir);
-            const queryInputs = [];
-            const executor = createExecutor({
-                queryInputs,
-                model: "claude-opus-5-5",
-                routeModels: true,
-                loadedBoundary: cleanBoundary("session_sonnet"),
-                routeJudge: () => Promise.resolve([0.1, 0.95, 0.2, 0.9]),
-                queryResults: [scriptedMessages(resultMessage(0, "session_sonnet"))],
-            });
-            await executor.execute({
-                threadId: "thread_upgrade",
-                turnId: "turn_upgrade",
-                prompt: "Perfecto, créame una landing con esto",
-                history: history([
-                    { role: "user", text: "¿Cómo van los anuncios?", createdAt: 1 },
-                    { role: "assistant", text: "Van bien: el CPL bajó un 12%.", createdAt: 2 },
-                ]),
-            }, activeControls());
-            expect(queryInputs[0]?.options).toMatchObject({ model: "claude-opus-5-5", effort: "medium" });
-        }
-        finally {
-            await rm(configDir, { recursive: true, force: true });
-        }
-    });
-    it("keeps a plan-mode turn at medium without asking Jev", async () => {
-        const queryInputs = [];
-        let asked = false;
-        const executor = createExecutor({
-            queryInputs,
-            routeJudge: () => {
-                asked = true;
-                return Promise.resolve([0.99, 0, 1, 0]);
-            },
-            queryResults: [scriptedMessages(resultMessage(0, "session_effort_plan"))],
-        });
-        await executor.execute({
-            threadId: "thread_effort_plan",
-            turnId: "turn_effort_plan",
-            prompt: "Plan Q4",
-            planMode: true,
-            history: history([]),
-        }, activeControls());
-        expect(queryInputs[0]?.options.effort).toBe("medium");
-        expect(asked).toBe(false);
+        // Constant across turns — a per-turn value is what would break the cache.
+        expect(queryInputs[1]?.options.effort).toBe(queryInputs[0]?.options.effort);
     });
     it("pins the auto-compact window to the context window it resolved for the model", async () => {
         const queryInputs = [];
@@ -4162,8 +3911,6 @@ describe("BridgeJobExecutor stall recovery", () => {
             kind: "completed",
             costUsd: 0.05,
             model: "claude-test",
-            // The tool result the stalled query had already received still counts.
-            toolResults: [expect.objectContaining({ calls: 1 })],
             cleanBoundary: expect.objectContaining({ sessionId: "session_a" }),
         });
         expect(queryInputs).toHaveLength(2);
@@ -4902,9 +4649,6 @@ describe("BridgeJobExecutor turn end with background tasks", () => {
     });
 });
 describe("BridgeJobExecutor review mode", () => {
-    afterEach(() => {
-        projectRootMock.value = process.cwd();
-    });
     const review = {
         reviewId: "rev_1",
         apiKey: "bk_review_key",
@@ -4962,21 +4706,6 @@ describe("BridgeJobExecutor review mode", () => {
         await executor.execute(reviewJob(), activeControls());
         expect(queryInputs[0]?.options.settings).toMatchObject({ permissions: { ask: ["Bash"] } });
     });
-    // The brief has the reviewer read the rulebook as the Session had it
-    // (`git show <sha>:CLAUDE.md`); the working tree's copy may already be newer.
-    // Auto-loading it put ~24k tokens of the marketer's instructions in front of
-    // every review request, written cold and re-read on each one.
-    it("does not load the workspace's CLAUDE.md into the reviewer, as a memory file or as the system prompt", async () => {
-        const workspace = await mkdtemp(join(tmpdir(), "baker-review-instructions-"));
-        await writeFile(join(workspace, "CLAUDE.md"), "# Project Instructions\n\n## Client Context\n\nOne client per repo. Everything known about them:\n\n@COMPANY.md\n\n## Rules\n");
-        projectRootMock.value = workspace;
-        const queryInputs = [];
-        const executor = createExecutor({ queryInputs });
-        await executor.execute(reviewJob(), activeControls());
-        expect(queryInputs[0]?.options.settings).toMatchObject({ claudeMdExcludes: ["**/CLAUDE.md"] });
-        expect(queryInputs[0]?.options.systemPrompt).toBeUndefined();
-        expect(queryInputs[0]?.options.additionalDirectories).toBeUndefined();
-    });
     it("removes every editing tool on top of the list an ordinary turn is denied", async () => {
         const queryInputs = [];
         const executor = createExecutor({ queryInputs });
@@ -5040,7 +4769,6 @@ describe("BridgeJobExecutor review mode", () => {
         expect(options.env?.BAKER_DEBUG_LOG).toBeUndefined();
         expect(options.settings ?? {}).not.toHaveProperty("disableAllHooks");
         expect(options.settings ?? {}).not.toHaveProperty("permissions");
-        expect(options.settings ?? {}).not.toHaveProperty("claudeMdExcludes");
     });
     // BAKER-3462: after an English skill body, the next line went out in English to a Spanish chat.
     const spanishTurn = "Prepara cuatro anuncios nuevos para la campaña de verano y súbelos hoy mismo";
@@ -5148,6 +4876,71 @@ describe("BridgeJobExecutor review mode", () => {
         expect(outcome).toMatchObject({ kind: "completed", structuredOutput: findings });
     });
 });
+describe("BridgeJobExecutor builder mode", () => {
+    const builder = {
+        runId: "run_1",
+        title: "Summer landing",
+        outputSchema: { type: "object", properties: { summary: { type: "string" } }, required: ["summary"] },
+    };
+    function builderJob(overrides = {}) {
+        return {
+            threadId: "thread_task",
+            turnId: "turn_1",
+            prompt: "Build the summer sale landing.",
+            unattended: true,
+            builder,
+            ...overrides,
+        };
+    }
+    it("runs the brief on the Session's own model, workspace and hooks, under a system prompt of its own", async () => {
+        const queryInputs = [];
+        const executor = createExecutor({ queryInputs, model: "claude-session-model" });
+        await executor.execute(builderJob(), activeControls());
+        const options = queryInputs[0]?.options;
+        expect(options.model).toBe("claude-session-model");
+        expect(options.systemPrompt).toEqual(expect.stringContaining("one brief"));
+        expect(options.settings ?? {}).not.toHaveProperty("disableAllHooks");
+        expect(options.disallowedTools).not.toContain("Write");
+    });
+    it("asks the SDK to enforce the task's result contract", async () => {
+        const queryInputs = [];
+        const executor = createExecutor({ queryInputs });
+        await executor.execute(builderJob(), activeControls());
+        const [taskQuery] = queryInputs;
+        if (!taskQuery)
+            throw new Error("expected the task to start one query");
+        expect(taskQuery.options.outputFormat).toEqual({
+            type: "json_schema",
+            schema: builder.outputSchema,
+        });
+    });
+    it("never offers a question to the person: it decides, or returns the question", async () => {
+        const queryInputs = [];
+        const executor = createExecutor({ queryInputs });
+        await executor.execute(builderJob(), activeControls());
+        expect(queryInputs[0]?.options.disallowedTools).toEqual(expect.arrayContaining(["AskUserQuestion", "ExitPlanMode"]));
+    });
+    it("sends a task that ends without returning its result back to StructuredOutput", async () => {
+        const queryInputs = [];
+        const executor = createExecutor({ queryInputs });
+        await executor.execute(builderJob(), activeControls());
+        const options = queryInputs[0]?.options;
+        const stop = options.hooks?.Stop?.[0]?.hooks[0];
+        const output = await stop?.({ hook_event_name: "Stop" }, undefined, {
+            signal: new AbortController().signal,
+        });
+        expect(output).toMatchObject({ decision: "block", reason: expect.stringContaining("summary") });
+    });
+    it("leaves an ordinary turn's system prompt as it is", async () => {
+        const queryInputs = [];
+        const executor = createExecutor({ queryInputs });
+        await executor.execute({ threadId: "t", turnId: "turn_1", prompt: "Build the page" }, activeControls());
+        const [turnQuery] = queryInputs;
+        if (!turnQuery)
+            throw new Error("expected the turn to start one query");
+        expect(turnQuery.options.systemPrompt).toBeUndefined();
+    });
+});
 describe("BridgeJobExecutor model refusals", () => {
     function refusalNoFallback() {
         return {
@@ -5292,6 +5085,7 @@ describe("BridgeJobExecutor model refusals", () => {
 describe("agentFeature", () => {
     it("tells OpenRouter a Session review, a plan and a chat turn apart", () => {
         expect(agentFeature({ review: {} })).toBe("chatReview.session");
+        expect(agentFeature({ builder: {} })).toBe("builder.task");
         expect(agentFeature({ planMode: true })).toBe("agent.plan");
         expect(agentFeature({})).toBe("agent.turn");
     });