@koda-sl/baker-bridge 0.148.0-dev.a87640a51 → 0.152.0-dev.1a19b1876

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

@@ -241,6 +241,8 @@ function createExecutor(options) {
         stalledCliExitMs: 0,
         prepareAttachments: options.prepareAttachments,
         ...(options.inFlightTurns ? { inFlightTurns: options.inFlightTurns } : {}),
+        ...(options.catchUpWithMain ? { catchUpWithMain: options.catchUpWithMain } : {}),
+        ...(options.keepCliInStep ? { keepCliInStep: options.keepCliInStep } : {}),
     });
 }
 function memoryInFlightTurns(initial) {
@@ -260,24 +262,6 @@ function memoryInFlightTurns(initial) {
         },
     };
 }
-// The CLI's own report of a failed model request, written as an assistant
-// message — the shape production stores (`model: "<synthetic>"`, `error`).
-function apiErrorMessage(uuid, text, error) {
-    return {
-        type: "assistant",
-        uuid,
-        session_id: "session_api_error",
-        parent_tool_use_id: null,
-        error,
-        is_api_error_message: true,
-        message: {
-            role: "assistant",
-            model: "<synthetic>",
-            content: [{ type: "text", text }],
-            stop_reason: "stop_sequence",
-        },
-    };
-}
 function resultMessage(costUsd, sessionId, modelUsage) {
     return {
         type: "result",
@@ -1345,6 +1329,38 @@ describe("BridgeJobExecutor", () => {
         }, activeControls());
         expect(queryInputs[0]?.prompt).toBe("/audit-google-ads-account 3865083115");
     });
+    it("keeps a skill command leading when catching up with main is what brought the skill in", async () => {
+        const workspace = await mkdtemp(join(tmpdir(), "baker-job-skill-caught-up-"));
+        await mkdir(join(workspace, ".claude", "skills", "landing"), { recursive: true });
+        projectRootMock.value = workspace;
+        const queryInputs = [];
+        let told = 0;
+        const executor = createExecutor({
+            queryInputs,
+            queryResults: [scriptedMessages(resultMessage(0, "session_skill_caught_up"))],
+            catchUpWithMain: async () => {
+                await mkdir(join(workspace, ".claude", "skills", "audit-google-ads-account"), { recursive: true });
+                return {
+                    inWorkspace: true,
+                    changed: [".claude/skills/audit-google-ads-account/SKILL.md"],
+                    told: () => {
+                        told += 1;
+                        return Promise.resolve();
+                    },
+                };
+            },
+        });
+        await executor.execute({
+            threadId: "thread_skill_caught_up",
+            turnId: "turn_skill_caught_up",
+            prompt: "/audit-google-ads-account 3865083115",
+            history: history([]),
+            currentSender: { name: "Dana", userId: "user_dana" },
+        }, activeControls());
+        expect(queryInputs[0]?.prompt).toBe("/audit-google-ads-account 3865083115");
+        expect(queryInputs[0]?.reminder).toBeUndefined();
+        expect(told).toBe(0);
+    });
     it("passes per-turn MCP servers into Agent SDK query options with the acting user", async () => {
         const queryInputs = [];
         const calls = [];
@@ -1668,6 +1684,110 @@ describe("BridgeJobExecutor", () => {
         expect(queryInputs[0]?.prompt).toBe("/publish");
         expect(queryInputs[0]?.reminder).toBeUndefined();
     });
+    it("tells the agent which files another chat's publish just brought into its workspace", async () => {
+        const queryInputs = [];
+        let told = 0;
+        const executor = createExecutor({
+            queryInputs,
+            catchUpWithMain: async () => ({
+                inWorkspace: true,
+                changed: ["src/pages/home/hero.md"],
+                told: () => {
+                    told += 1;
+                    return Promise.resolve();
+                },
+            }),
+        });
+        await executor.execute({
+            threadId: "thread_caught_up",
+            turnId: "turn_caught_up",
+            prompt: "Cambia el subtítulo del hero a «Sin entrada, paga en 24 meses».",
+            history: history([
+                { role: "user", text: "¿Qué pone ahora el hero de la home?", createdAt: 1 },
+                {
+                    role: "assistant",
+                    text: "El titular dice «Paneles solares para tu casa» y el subtítulo «Instala hoy y paga en 12 meses».",
+                    createdAt: 2,
+                },
+            ]),
+        }, activeControls());
+        expect(queryInputs[0]?.prompt).toContain("Sin entrada, paga en 24 meses");
+        expect(queryInputs[0]?.reminder).toContain("Read again any of them you work on");
+        expect(queryInputs[0]?.reminder).toContain("- src/pages/home/hero.md");
+        expect(told).toBe(1);
+    });
+    it("keeps the note for the next turn when the user stops this one while the workspace catches up", async () => {
+        const queryInputs = [];
+        const controls = activeControls();
+        let told = 0;
+        const executor = createExecutor({
+            queryInputs,
+            catchUpWithMain: () => {
+                controls.deactivate();
+                return Promise.resolve({
+                    inWorkspace: false,
+                    changed: ["src/pages/home/hero.md"],
+                    told: () => {
+                        told += 1;
+                        return Promise.resolve();
+                    },
+                });
+            },
+        });
+        const outcome = await executor.execute({ threadId: "thread_stopped", turnId: "turn_stopped", prompt: "Cambia el hero", history: history([]) }, controls);
+        expect(outcome.kind).toBe("cancelled");
+        expect(queryInputs).toHaveLength(0);
+        expect(told).toBe(0);
+    });
+    it("leaves the workspace of a finished Session alone while it is reviewed", async () => {
+        let caughtUp = false;
+        const executor = createExecutor({
+            catchUpWithMain: () => {
+                caughtUp = true;
+                return Promise.resolve(undefined);
+            },
+        });
+        await executor.execute({
+            threadId: "thread_review_sync",
+            turnId: "turn_review_sync",
+            prompt: "review",
+            history: history([]),
+            review: { threadIds: [], chatFacts: { chatId: "chat_1" }, outputRepair: true },
+        }, activeControls());
+        expect(caughtUp).toBe(false);
+    });
+    it("brings the CLI to the release Convex sent before the turn starts", async () => {
+        const queryInputs = [];
+        const requested = [];
+        const executor = createExecutor({
+            queryInputs,
+            keepCliInStep: (wanted) => {
+                requested.push({ wanted, turnStarted: queryInputs.length > 0 });
+                return Promise.resolve();
+            },
+        });
+        await executor.execute({ threadId: "thread_cli", turnId: "turn_cli", prompt: "Hola", cliVersion: "0.412.0", history: history([]) }, activeControls());
+        expect(requested).toEqual([{ wanted: "0.412.0", turnStarted: false }]);
+        expect(queryInputs).toHaveLength(1);
+    });
+    it("keeps the Session's CLI while it is reviewed", async () => {
+        const wanted = [];
+        const executor = createExecutor({
+            keepCliInStep: (version) => {
+                wanted.push(version);
+                return Promise.resolve();
+            },
+        });
+        await executor.execute({
+            threadId: "thread_review_cli",
+            turnId: "turn_review_cli",
+            prompt: "review",
+            cliVersion: "0.412.0",
+            history: history([]),
+            review: { threadIds: [], chatFacts: { chatId: "chat_1" }, outputRepair: true },
+        }, activeControls());
+        expect(wanted).toEqual([]);
+    });
     it("keeps the viewing-reference context beside the message when a stale session falls back to rehydration", async () => {
         const queryInputs = [];
         const executor = createExecutor({
@@ -2079,7 +2199,7 @@ describe("BridgeJobExecutor", () => {
         expect(savedBoundaries).toEqual([]);
         expect(clearCalls).toContainEqual({ threadId: "thread_result_error", reason: "result_error" });
     });
-    it("reports a provider's server error in product language, not its status line", async () => {
+    it("preserves provider status details when an SDK result error omits errors", async () => {
         const clearCalls = [];
         const executor = createExecutor({
             clearCalls,
@@ -2105,69 +2225,10 @@ describe("BridgeJobExecutor", () => {
             kind: "errored",
             costUsd: 0.17,
             model: "claude-test",
-            errors: [expect.stringContaining("on our side")],
+            errors: ["Claude Code returned an error result: API Error: 500 Internal Server Error; apiErrorStatus 500"],
         });
         expect(clearCalls).toContainEqual({ threadId: "thread_provider_result_error", reason: "result_error" });
     });
-    it("never shows the marketer a model provider's billing error, as a reply or as the turn's error", async () => {
-        const providerError = "API Error: 402 Insufficient credits. Add more using https://openrouter.ai/settings/credits";
-        const relay = recordingRelay();
-        const executor = createExecutor({
-            relay,
-            queryResults: [
-                scriptedMessages(apiErrorMessage("assistant_402", providerError, "unknown"), {
-                    type: "result",
-                    subtype: "success",
-                    is_error: true,
-                    result: providerError,
-                    api_error_status: 402,
-                    total_cost_usd: 0,
-                    session_id: "session_402",
-                }),
-            ],
-        });
-        const outcome = await executor.execute({ threadId: "thread_402", turnId: "turn_402", prompt: "Build the creatives", history: history([]) }, activeControls());
-        const shown = JSON.stringify([relay.assistantEvents, outcome.kind === "errored" ? outcome.errors : []]);
-        expect(outcome.kind).toBe("errored");
-        expect(shown).not.toMatch(/API Error|openrouter|402/i);
-    });
-    it("tells the marketer how to fix an image the provider could not read, not to send the same message again", async () => {
-        const imageError = 'API Error: 400 {"type":"error","error":{"type":"invalid_request_error","message":"Could not process image"}}';
-        const executor = createExecutor({
-            queryResults: [
-                scriptedMessages({
-                    type: "result",
-                    subtype: "success",
-                    is_error: true,
-                    result: imageError,
-                    api_error_status: 400,
-                    total_cost_usd: 0,
-                    session_id: "session_bad_image",
-                }),
-            ],
-        });
-        const outcome = await executor.execute({ threadId: "thread_bad_image", turnId: "turn_bad_image", prompt: "Use this photo", history: history([]) }, activeControls());
-        expect(outcome.kind === "errored" ? outcome.errors : []).toEqual([
-            expect.stringContaining("extension lies about its format"),
-        ]);
-    });
-    it("keeps a server error the turn recovered from out of the chat, and in the turn events", async () => {
-        const providerError = "API Error: Server error mid-response. The response above may be incomplete.";
-        const relay = recordingRelay();
-        const turnEvents = [];
-        const executor = createExecutor({
-            relay,
-            turnEvents,
-            queryResults: [
-                scriptedMessages(apiErrorMessage("assistant_server_error", providerError, "server_error"), assistantMessage("assistant_recovered", "Your three headlines are ready.", "session_recovered"), resultMessage(0.3, "session_recovered")),
-            ],
-        });
-        const outcome = await executor.execute({ threadId: "thread_recovered", turnId: "turn_recovered", prompt: "Write headlines", history: history([]) }, activeControls());
-        expect(outcome.kind).toBe("completed");
-        expect(JSON.stringify(relay.assistantEvents)).not.toContain("API Error");
-        expect(JSON.stringify(relay.assistantEvents)).toContain("Your three headlines are ready.");
-        expect(turnEvents).toContainEqual(expect.objectContaining({ event: "api_error", detail: { error: "server_error", text: providerError } }));
-    });
     it("closes SDK queries on error and inactive exits but not on natural clean completion", async () => {
         const naturalCloseCalls = [];
         const naturalExecutor = createExecutor({