@koda-sl/baker-bridge 0.149.0-dev.7e6763861 → 0.150.0

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

@@ -23,7 +23,6 @@ import { CONNECTION_INPUT_TOOL_NAME } from "./connection-input.js";
 import { CREDENTIAL_INPUT_TOOL_NAME } from "./credential-input.js";
 import { FLOW_INPUT_TOOL_NAME } from "./flow-input.js";
 import { bridgeRuntimeFiles } from "./runtime-files.js";
-import { alignServedModels } from "./served-model.js";
 import { INTERRUPTED_RESUME_PROMPT } from "./session-continuity.js";
 import { TAG_INPUT_TOOL_NAME } from "./tag-input.js";
 function history(entries) {
@@ -239,14 +238,11 @@ function createExecutor(options) {
             : {}),
         now: options.now,
         readUsageBaseline: async (sessionId) => options.usageBaselines?.[sessionId],
-        alignServedModels: async (sessionId) => {
-            if (options.claudeConfigDir) {
-                await alignServedModels(sessionId, options.claudeConfigDir);
-            }
-        },
         stalledCliExitMs: 0,
         prepareAttachments: options.prepareAttachments,
         ...(options.inFlightTurns ? { inFlightTurns: options.inFlightTurns } : {}),
+        ...(options.catchUpWithMain ? { catchUpWithMain: options.catchUpWithMain } : {}),
+        ...(options.keepCliInStep ? { keepCliInStep: options.keepCliInStep } : {}),
     });
 }
 function memoryInFlightTurns(initial) {
@@ -974,10 +970,10 @@ describe("BridgeJobExecutor", () => {
                 requestedModel: "claude-opus-5-5",
                 message: { id: "msg_1", model: "anthropic/claude-opus-5.5", content: [{ type: "thinking", thinking: "t" }] },
             })}\n`);
+            vi.stubEnv("CLAUDE_CONFIG_DIR", configDir);
             const resumedFrom = [];
             const executor = createExecutor({
                 loadedBoundary: cleanBoundary("session_resume"),
-                claudeConfigDir: configDir,
                 queryResults: [
                     {
                         async *[Symbol.asyncIterator]() {
@@ -1385,6 +1381,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 = [];
@@ -1708,6 +1736,132 @@ 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("keeps the note for the next turn when the user stops this one before its prompt goes out", async () => {
+        const queryInputs = [];
+        const controls = activeControls();
+        let told = 0;
+        const executor = createExecutor({
+            queryInputs,
+            mcpServersProvider: () => {
+                controls.deactivate();
+                return Promise.resolve(undefined);
+            },
+            catchUpWithMain: () => Promise.resolve({
+                inWorkspace: true,
+                changed: ["src/pages/home/hero.md"],
+                told: () => {
+                    told += 1;
+                    return Promise.resolve();
+                },
+            }),
+        });
+        await executor.execute({ threadId: "thread_stopped_late", turnId: "turn_stopped_late", prompt: "Cambia el hero", history: history([]) }, controls);
+        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({
@@ -1811,6 +1965,36 @@ describe("BridgeJobExecutor", () => {
         expect(queryInputs[0]?.options).toMatchObject({ resume: "session_interrupted", forkSession: true });
         expect(relay.contextSources.map((entry) => entry.source)).toEqual(["interrupted_resume"]);
     });
+    it("tells a turn sent again after a restart what another chat published while it was down", async () => {
+        const queryInputs = [];
+        let told = 0;
+        const executor = createExecutor({
+            loadedBoundary: cleanBoundary("session_clean"),
+            queryInputs,
+            inFlightTurns: memoryInFlightTurns({
+                version: 1,
+                turnId: "turn_interrupted_sync",
+                sessionId: "session_interrupted",
+                updatedAtMs: 1,
+            }),
+            catchUpWithMain: () => Promise.resolve({
+                inWorkspace: false,
+                changed: ["src/pages/home/hero.md"],
+                told: () => {
+                    told += 1;
+                    return Promise.resolve();
+                },
+            }),
+        });
+        await executor.execute({
+            threadId: "thread_interrupted_sync",
+            turnId: "turn_interrupted_sync",
+            prompt: "Rebuild the five pages",
+        }, activeControls());
+        expect(queryInputs[0]?.prompt).toBe(INTERRUPTED_RESUME_PROMPT);
+        expect(queryInputs[0]?.reminder).toContain("- src/pages/home/hero.md");
+        expect(told).toBe(1);
+    });
     it("runs the turn the ordinary way when the interrupted session cannot be resumed", async () => {
         const relay = recordingRelay();
         const queryInputs = [];