@koda-sl/baker-bridge 0.159.0 → 0.161.0-dev.61e0a90f3

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

@@ -924,7 +924,7 @@ describe("BridgeJobExecutor", () => {
             kind: "completed",
             costUsd: 0.1,
             model: "claude-test",
-            cleanBoundary: { version: 2, sessionId: "session_next", resumeSessionAt: "assistant_next", updatedAtMs: 1234 },
+            cleanBoundary: { version: 2, sessionId: "session_next", updatedAtMs: 1234 },
         });
         expect(savedBoundaries).toEqual([]);
     });
@@ -2532,9 +2532,9 @@ describe("BridgeJobExecutor", () => {
     });
     // BAKER-1025 (AskUserQuestion), the request_tag_input sighting, and the ExitPlanMode and
     // request_connection sightings: each held the turn ~900 s before the same deny, although
-    // the card stays up and a later answer resumes the chat as a new turn anyway.
+    // the card stays up and a later answer resumes the chat as a new turn anyway. A question
+    // card is the exception since it picks for the user (BAKER-3550): see the test below.
     it.each([
-        { toolName: "AskUserQuestion", input: { questions: [{ question: "Which budget?" }] }, planMode: false },
         { toolName: "ExitPlanMode", input: { plan: "Draft flow" }, planMode: true },
         {
             toolName: "mcp__baker_ui__request_tag_input",
@@ -2592,10 +2592,15 @@ describe("BridgeJobExecutor", () => {
             return Promise.resolve();
         };
         let guardResult;
+        let reachedTool = () => undefined;
+        const toolReached = new Promise((resolve) => {
+            reachedTool = resolve;
+        });
         const executor = new BridgeJobExecutor({
             sdk: {
                 query: (input) => ({
                     async *[Symbol.asyncIterator]() {
+                        reachedTool();
                         guardResult = await input.options.canUseTool?.("AskUserQuestion", { questions: [{ label: "Confirm?" }] }, {
                             toolUseID: "tool_1",
                             requestId: "req_1",
@@ -2612,10 +2617,20 @@ describe("BridgeJobExecutor", () => {
                 clear: async () => undefined,
             },
             relay,
-            askUserQuestionTimeoutMs: 1,
         });
         const controls = activeControls();
-        const outcome = await executor.execute({ threadId: "thread_question_timeout", turnId: "turn_question_timeout", prompt: "Ask first" }, controls);
+        vi.useFakeTimers({ toFake: ["setTimeout", "clearTimeout", "setInterval", "clearInterval"] });
+        let outcome;
+        try {
+            const running = executor.execute({ threadId: "thread_question_timeout", turnId: "turn_question_timeout", prompt: "Ask first" }, controls);
+            await toolReached;
+            await vi.advanceTimersByTimeAsync(120_000);
+            await vi.runOnlyPendingTimersAsync();
+            outcome = await running;
+        }
+        finally {
+            vi.useRealTimers();
+        }
         // The unanswered prompt denies the tool with guidance — the turn completes
         // cleanly so the user can answer with a normal message later.
         expect(guardResult).toMatchObject({ behavior: "deny" });
@@ -2630,6 +2645,93 @@ describe("BridgeJobExecutor", () => {
         // recovery turn. Posting input-resolved here would clear it.
         expect(inputResolvedCalls).toBe(0);
     });
+    // BAKER-3550: a question card answers itself with the recommended option after a
+    // countdown, so the turn must still be waiting when that pick arrives.
+    it("holds a question card's turn past the countdown that picks for the user, then lets it go", async () => {
+        vi.useFakeTimers({ toFake: ["setTimeout", "clearTimeout", "setInterval", "clearInterval"] });
+        try {
+            let guardResult;
+            let reachedTool = () => undefined;
+            const toolReached = new Promise((resolve) => {
+                reachedTool = resolve;
+            });
+            const controls = activeControls();
+            const executor = new BridgeJobExecutor({
+                sdk: {
+                    query: (queryInput) => ({
+                        async *[Symbol.asyncIterator]() {
+                            reachedTool();
+                            guardResult = await queryInput.options.canUseTool?.("AskUserQuestion", { questions: [{ question: "Which budget?", options: [{ label: "Low" }, { label: "High" }] }] }, {
+                                toolUseID: "tool_countdown",
+                                requestId: "req_countdown",
+                                signal: queryInput.options.abortController?.signal ?? new AbortController().signal,
+                            });
+                            yield resultMessage(0, "session_countdown");
+                        },
+                    }),
+                },
+                model: "claude-test",
+                sessionStore: { load: async () => undefined, save: async () => undefined, clear: async () => undefined },
+                relay: recordingRelay(),
+            });
+            const outcome = executor.execute({ threadId: "thread_countdown", turnId: "turn_countdown", prompt: "Ask first" }, controls);
+            await toolReached;
+            await vi.advanceTimersByTimeAsync(65_000);
+            expect(guardResult).toBeUndefined();
+            expect(controls.pendingQuestions.has("tool_countdown")).toBe(true);
+            await vi.advanceTimersByTimeAsync(60_000);
+            expect(guardResult).toMatchObject({ behavior: "deny", message: expect.stringContaining("has not answered") });
+            await vi.runOnlyPendingTimersAsync();
+            await outcome;
+        }
+        finally {
+            vi.useRealTimers();
+        }
+    });
+    it("carries on the same turn with the recommended option Baker picked, and tells the agent nobody answered", async () => {
+        const relay = recordingRelay();
+        let guardResult;
+        const controls = activeControls();
+        const question = "Which colour should the ad use?";
+        const executor = new BridgeJobExecutor({
+            sdk: {
+                query: (input) => ({
+                    async *[Symbol.asyncIterator]() {
+                        const decision = input.options.canUseTool?.("AskUserQuestion", {
+                            questions: [
+                                { question, header: "Colour", options: [{ label: "Blue" }, { label: "Teal (Recommended)" }] },
+                            ],
+                        }, {
+                            toolUseID: "tool_auto",
+                            requestId: "req_auto",
+                            signal: input.options.abortController?.signal ?? new AbortController().signal,
+                        });
+                        while (!controls.pendingQuestions.has("tool_auto")) {
+                            await Promise.resolve();
+                        }
+                        controls.pendingQuestions
+                            .get("tool_auto")
+                            ?.resolve({ answers: { q0: "Teal (Recommended)" }, chosenBy: "auto" });
+                        guardResult = await decision;
+                        yield resultMessage(0, "session_auto");
+                    },
+                }),
+            },
+            model: "claude-test",
+            sessionStore: { load: async () => undefined, save: async () => undefined, clear: async () => undefined },
+            relay,
+        });
+        await executor.execute({ threadId: "thread_auto", turnId: "turn_auto", prompt: "Make an ad" }, controls);
+        expect(guardResult).toMatchObject({
+            behavior: "allow",
+            updatedInput: {
+                answers: { [question]: "Teal (Recommended)" },
+                annotations: {
+                    [question]: { notes: expect.stringMatching(/nobody answered.*picked the recommended option automatically/i) },
+                },
+            },
+        });
+    });
     // Without this the run deadlocks: the wait expires, the deny tells the agent to
     // end its turn, and the pending card it leaves behind parks the thread on a
     // question nobody will ever answer — stranding the Session and its Task.
@@ -4617,6 +4719,43 @@ describe("BridgeJobExecutor review mode", () => {
         expect(options.settings ?? {}).not.toHaveProperty("disableAllHooks");
         expect(options.settings ?? {}).not.toHaveProperty("permissions");
     });
+    // 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";
+    async function contextAfterSkillLoad(options) {
+        const hook = options.hooks?.PostToolUse?.find((matcher) => matcher.matcher === "Skill")?.hooks[0];
+        const output = await hook?.({
+            hook_event_name: "PostToolUse",
+            tool_name: "Skill",
+            tool_input: { skill: "creative-canvas-ads" },
+            tool_response: "Launching skill: creative-canvas-ads",
+            tool_use_id: "t1",
+            session_id: "s",
+            transcript_path: "",
+            cwd: "/",
+        }, "t1", { signal: new AbortController().signal });
+        return output && "hookSpecificOutput" in output && output.hookSpecificOutput?.hookEventName === "PostToolUse"
+            ? output.hookSpecificOutput.additionalContext
+            : undefined;
+    }
+    it("restates a Spanish chat's language to the agent right after a skill loads", async () => {
+        const queryInputs = [];
+        const executor = createExecutor({ queryInputs });
+        await executor.execute({ threadId: "t", turnId: "turn_1", prompt: spanishTurn, currentSender: { name: "Fernando" } }, activeControls());
+        const options = queryInputs[0]?.options;
+        if (!options)
+            throw new Error("expected the turn to start one query");
+        expect((await contextAfterSkillLoad(options))?.startsWith("Baker: the language of this chat.")).toBe(true);
+    });
+    it("adds no language note to a review, which loads no skill and writes to nobody", async () => {
+        const queryInputs = [];
+        const executor = createExecutor({ queryInputs });
+        await executor.execute(reviewJob({ prompt: spanishTurn, currentSender: { name: "Fernando" } }), activeControls());
+        const options = queryInputs[0]?.options;
+        if (!options)
+            throw new Error("expected the review to start one query");
+        expect(options.hooks?.PostToolUse?.some((matcher) => matcher.matcher === "Skill")).toBe(false);
+        expect(options.hooks?.UserPromptExpansion).toBeUndefined();
+    });
     it("denies a mutating shell command and says why, so the reviewer reports it", async () => {
         // The Session it is reading is over. A write would change the very evidence
         // its findings cite, and nobody is left to review what the reviewer did.