@koda-sl/baker-bridge 0.149.0-dev.74f6c7937 → 0.154.0-dev.db7cf2f5d

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) {
@@ -1345,6 +1347,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 +1702,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({
@@ -1771,6 +1931,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 = [];
@@ -1799,23 +1989,6 @@ describe("BridgeJobExecutor", () => {
         expect(clearCalls).toEqual([]);
         expect(relay.contextSources.map((entry) => entry.source)).toEqual(["interrupted_resume", "local_resume"]);
     });
-    it("keeps the chat's conversation when an interrupted publish that cannot be resumed is run again", async () => {
-        const executor = createExecutor({
-            loadedBoundary: cleanBoundary("session_clean"),
-            inFlightTurns: memoryInFlightTurns({
-                version: 1,
-                turnId: "turn_publish",
-                sessionId: "session_never_written",
-                updatedAtMs: 1,
-            }),
-            queryResults: [
-                scriptedError(new Error("No conversation found with session ID: session_never_written")),
-                scriptedMessages(assistantMessage("assistant_published", "Published", "session_publish_only"), resultMessage(0.2, "session_publish_only")),
-            ],
-        });
-        const outcome = await executor.execute({ threadId: "thread_publish", turnId: "turn_publish", prompt: "/publish" }, activeControls());
-        expect(outcome).toMatchObject({ kind: "completed", cleanBoundary: undefined });
-    });
     it("keeps the running turn's session on record until the turn ends", async () => {
         const recorded = [];
         const inFlightTurns = memoryInFlightTurns();