@koda-sl/baker-bridge 0.108.0 → 0.109.0-dev.fa751dbf1

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

@@ -229,7 +229,7 @@ function createExecutor(options) {
         now: options.now,
         readUsageBaseline: async (sessionId) => options.usageBaselines?.[sessionId],
         stalledCliExitMs: 0,
-        prepareAttachments: options.prepareAttachments,
+        ...(options.mainSync ? { mainSync: options.mainSync } : {}),
     });
 }
 function resultMessage(costUsd, sessionId, modelUsage) {
@@ -1473,87 +1473,198 @@ describe("BridgeJobExecutor", () => {
         expect(queryInputs[0]?.prompt).toBe("/publish");
         expect(queryInputs[0]?.reminder).toBeUndefined();
     });
-    it("keeps the viewing-reference context beside the message when a stale session falls back to rehydration", async () => {
+    it("brings the workspace level with main before the turn and tells the agent what changed, beside the viewing context", async () => {
         const queryInputs = [];
+        const syncedThreads = [];
+        const syncedPublishes = [];
         const executor = createExecutor({
-            loadedBoundary: cleanBoundary("session_stale_viewing"),
             queryInputs,
-            queryResults: [
-                scriptedError(new Error("Cannot resume: session not found")),
-                scriptedMessages(resultMessage(0, "session_next_viewing")),
-            ],
+            queryResults: [scriptedMessages(resultMessage(0, "session_main_moved"))],
+            mainSync: {
+                beforeTurn: (threadId, published) => {
+                    syncedThreads.push(threadId);
+                    syncedPublishes.push(...published.map((entry) => entry.sha));
+                    return Promise.resolve({
+                        recovered: "<system-reminder>\nBaker: this workspace now includes work published since your last look.\n</system-reminder>",
+                    });
+                },
+                refuseWrite: () => null,
+                afterTurn: () => Promise.resolve(),
+            },
         });
         await executor.execute({
-            threadId: "thread_stale_viewing",
-            turnId: "turn_stale_viewing",
-            prompt: "quita el pricing",
-            history: history([{ role: "user", text: "Persisted fact", createdAt: 1 }]),
+            threadId: "thread_main_moved",
+            turnId: "turn_main_moved",
+            prompt: "change the hero title",
+            history: history([]),
             currentReference: { type: "landing", slug: "homepage", title: "Homepage" },
+            publishedElsewhere: [
+                {
+                    sha: "abc123",
+                    chatId: "sibling",
+                    title: "New hero",
+                    publishedAt: 1,
+                    paths: ["src/pages/hero/index.astro"],
+                },
+            ],
         }, activeControls());
-        expect(queryInputs[1]?.prompt).toContain("Current user request\nquita el pricing");
-        expect(queryInputs[1]?.prompt).not.toContain("preview pane");
-        expect(queryInputs[1]?.reminder).toContain('landing "Homepage" (slug: homepage)');
+        expect(syncedThreads).toEqual(["thread_main_moved"]);
+        expect(syncedPublishes).toEqual(["abc123"]);
+        expect(queryInputs[0]?.prompt).toBe("change the hero title");
+        expect(queryInputs[0]?.reminder).toContain("Baker: this workspace now includes work published");
+        expect(queryInputs[0]?.reminder).toContain('landing "Homepage" (slug: homepage)');
     });
-    // A late answer to a blocking prompt continues a request whose files the
-    // Session received with it. A rebuilt Session only has that request's history,
-    // which names the files but cannot open them, so they are handed over again.
-    it("hands over the continued request's files when the Session is rebuilt", async () => {
+    it("realigns the workspace once the turn ends, after whatever the agent did to it", async () => {
         const queryInputs = [];
+        const realignedAfter = [];
         const executor = createExecutor({
             queryInputs,
-            prepareAttachments: async (attachments, attachedTo) => `\n\nFILES for ${attachedTo}: ${attachments.map((attachment) => attachment.filename).join(", ")}`,
+            queryResults: [scriptedMessages(resultMessage(0, "session_after_turn"))],
+            mainSync: {
+                beforeTurn: () => Promise.resolve({}),
+                refuseWrite: () => null,
+                afterTurn: () => {
+                    realignedAfter.push(queryInputs.length);
+                    return Promise.resolve();
+                },
+            },
         });
-        await executor.execute({
-            threadId: "thread_continued_files",
-            turnId: "turn_continued_files",
-            prompt: "They have now replied: HubSpot",
-            continuedAttachments: [
-                { url: "https://files.example/logo.png", contentType: "image/png", filename: "logo.png" },
-            ],
-            history: history([{ role: "user", text: "Build a page with my logo", createdAt: 1 }]),
-        }, activeControls());
-        expect(queryInputs[0]?.prompt).toContain("FILES for continued_request: logo.png");
+        await executor.execute({ threadId: "thread_after_turn", turnId: "turn_after_turn", prompt: "edit the hero", history: history([]) }, activeControls());
+        expect(realignedAfter).toEqual([1]);
+    });
+    it("does not move the workspace under a publish command", async () => {
+        const queryInputs = [];
+        const syncedThreads = [];
+        const executor = createExecutor({
+            queryInputs,
+            queryResults: [scriptedMessages(resultMessage(0, "session_publish_main"))],
+            mainSync: {
+                beforeTurn: (threadId) => {
+                    syncedThreads.push(threadId);
+                    return Promise.resolve({ resumed: "<system-reminder>\nBaker: moved\n</system-reminder>" });
+                },
+                refuseWrite: () => null,
+                afterTurn: () => Promise.resolve(),
+            },
+        });
+        await executor.execute({ threadId: "thread_publish_main", turnId: "turn_publish_main", prompt: "/publish", history: history([]) }, activeControls());
+        expect(syncedThreads).toEqual([]);
+        expect(queryInputs[0]?.reminder).toBeUndefined();
     });
-    it("does not hand the continued request's files over again to a resumed Session", async () => {
+    it("tells a resumed session only what is new, since it remembers every earlier note", async () => {
         const queryInputs = [];
         const executor = createExecutor({
-            loadedBoundary: cleanBoundary("session_holds_files"),
+            loadedBoundary: cleanBoundary("session_resumed_main"),
             queryInputs,
-            prepareAttachments: async (attachments) => `\n\nFILES: ${attachments.map((attachment) => attachment.filename).join(", ")}`,
+            queryResults: [scriptedMessages(resultMessage(0, "session_resumed_main_next"))],
+            mainSync: {
+                beforeTurn: () => Promise.resolve({ recovered: "<system-reminder>\nBaker: standing\n</system-reminder>" }),
+                refuseWrite: () => null,
+                afterTurn: () => Promise.resolve(),
+            },
         });
-        await executor.execute({
-            threadId: "thread_resumed_files",
-            turnId: "turn_resumed_files",
-            prompt: "They have now replied: HubSpot",
-            continuedAttachments: [
-                { url: "https://files.example/logo.png", contentType: "image/png", filename: "logo.png" },
+        await executor.execute({ threadId: "thread_resumed_main", turnId: "turn_resumed_main", prompt: "hola", history: history([]) }, activeControls());
+        expect(queryInputs[0]?.reminder).toBeUndefined();
+    });
+    it("repeats the standing workspace notice when a stale session falls back to rehydration", async () => {
+        const queryInputs = [];
+        const executor = createExecutor({
+            loadedBoundary: cleanBoundary("session_stale_main"),
+            queryInputs,
+            queryResults: [
+                scriptedError(new Error("Cannot resume: session not found")),
+                scriptedMessages(resultMessage(0, "session_stale_main_next")),
             ],
-            history: history([{ role: "user", text: "Build a page with my logo", createdAt: 1 }]),
+            mainSync: {
+                beforeTurn: () => Promise.resolve({ recovered: "<system-reminder>\nBaker: standing\n</system-reminder>" }),
+                refuseWrite: () => null,
+                afterTurn: () => Promise.resolve(),
+            },
+        });
+        await executor.execute({
+            threadId: "thread_stale_main",
+            turnId: "turn_stale_main",
+            prompt: "quita el pricing",
+            history: history([{ role: "user", text: "Persisted fact", createdAt: 1 }]),
         }, activeControls());
-        expect(queryInputs[0]?.prompt).toBe("They have now replied: HubSpot");
+        expect(queryInputs[0]?.reminder).toBeUndefined();
+        expect(queryInputs[1]?.reminder).toContain("Baker: standing");
     });
-    it("hands the continued request's files over when a stale Session falls back to history", async () => {
+    it("brings the workspace level with main before a skill command without putting a note in front of it", async () => {
+        const workspace = await mkdtemp(join(tmpdir(), "baker-job-skill-main-"));
+        await mkdir(join(workspace, ".claude", "skills", "landing"), { recursive: true });
+        projectRootMock.value = workspace;
         const queryInputs = [];
+        const syncs = [];
         const executor = createExecutor({
-            loadedBoundary: cleanBoundary("session_stale_files"),
+            queryInputs,
+            queryResults: [scriptedMessages(resultMessage(0, "session_skill_main"))],
+            mainSync: {
+                beforeTurn: (threadId, _published, turn) => {
+                    syncs.push({ threadId, ...turn });
+                    return Promise.resolve({});
+                },
+                refuseWrite: () => null,
+                afterTurn: () => Promise.resolve(),
+            },
+        });
+        await executor.execute({ threadId: "thread_skill_main", turnId: "turn_skill_main", prompt: "/landing pricing", history: history([]) }, activeControls());
+        expect(syncs).toEqual([{ threadId: "thread_skill_main", withNote: false }]);
+        expect(queryInputs[0]?.prompt).toBe("/landing pricing");
+        expect(queryInputs[0]?.reminder).toBeUndefined();
+    });
+    it("refuses a write that would create a page another chat already published, with the reason for the agent", async () => {
+        let guardResult;
+        const executor = new BridgeJobExecutor({
+            sdk: {
+                query: (input) => ({
+                    async *[Symbol.asyncIterator]() {
+                        guardResult = await input.options.canUseTool?.("Write", { file_path: "/workspace/src/pages/sales-v2/index.astro", content: "v2" }, {
+                            toolUseID: "tool_write",
+                            requestId: "req_write",
+                            signal: input.options.abortController?.signal ?? new AbortController().signal,
+                        });
+                        yield resultMessage(0, "session_page_clash");
+                    },
+                }),
+            },
+            model: "claude-test",
+            sessionStore: { load: async () => undefined, save: async () => undefined, clear: async () => undefined },
+            relay: recordingRelay(),
+            mainSync: {
+                beforeTurn: () => Promise.resolve({}),
+                refuseWrite: (threadId, filePath) => threadId === "thread_page_clash" && filePath.endsWith("src/pages/sales-v2/index.astro")
+                    ? "`src/pages/sales-v2` was already published by another chat"
+                    : null,
+                afterTurn: () => Promise.resolve(),
+            },
+        });
+        await executor.execute({ threadId: "thread_page_clash", turnId: "turn_page_clash", prompt: "build sales v2" }, activeControls());
+        expect(guardResult).toEqual({
+            behavior: "deny",
+            message: "`src/pages/sales-v2` was already published by another chat",
+        });
+    });
+    it("keeps the viewing-reference context beside the message when a stale session falls back to rehydration", async () => {
+        const queryInputs = [];
+        const executor = createExecutor({
+            loadedBoundary: cleanBoundary("session_stale_viewing"),
             queryInputs,
             queryResults: [
                 scriptedError(new Error("Cannot resume: session not found")),
-                scriptedMessages(resultMessage(0, "session_rebuilt_files")),
+                scriptedMessages(resultMessage(0, "session_next_viewing")),
             ],
-            prepareAttachments: async (attachments) => `\n\nFILES: ${attachments.map((attachment) => attachment.filename).join(", ")}`,
         });
         await executor.execute({
-            threadId: "thread_stale_files",
-            turnId: "turn_stale_files",
-            prompt: "They have now replied: HubSpot",
-            continuedAttachments: [
-                { url: "https://files.example/logo.png", contentType: "image/png", filename: "logo.png" },
-            ],
-            history: history([{ role: "user", text: "Build a page with my logo", createdAt: 1 }]),
+            threadId: "thread_stale_viewing",
+            turnId: "turn_stale_viewing",
+            prompt: "quita el pricing",
+            history: history([{ role: "user", text: "Persisted fact", createdAt: 1 }]),
+            currentReference: { type: "landing", slug: "homepage", title: "Homepage" },
         }, activeControls());
-        expect(queryInputs[0]?.prompt).not.toContain("FILES");
-        expect(queryInputs[1]?.prompt).toContain("Current user request\nThey have now replied: HubSpot\n\nFILES: logo.png");
+        expect(queryInputs[1]?.prompt).toContain("Current user request\nquita el pricing");
+        expect(queryInputs[1]?.prompt).not.toContain("preview pane");
+        expect(queryInputs[1]?.reminder).toContain('landing "Homepage" (slug: homepage)');
     });
     it("clears an invalid clean boundary and retries once with rehydrated history", async () => {
         const relay = recordingRelay();
@@ -3236,35 +3347,6 @@ describe("BridgeJobExecutor turn end with background tasks", () => {
         expect(outcome).toMatchObject({ kind: "completed", costUsd: 0.1 });
         expect(endInputAt.count).toBe(3);
     });
-    // The production shape: the model refused, the CLI answered with an error
-    // result and then waited on stdin like after any other result. The error was
-    // no longer thrown, and only a clean result ended input, so the turn sat idle
-    // until the 30-minute session watchdog reported a lost connection.
-    it("ends input after the error result of a refused turn", async () => {
-        const endInputAt = { count: -1 };
-        const refusal = {
-            type: "system",
-            subtype: "model_refusal_no_fallback",
-            original_model: "claude-opus-5-5",
-            api_refusal_category: "reasoning_extraction",
-            session_id: "session_refused",
-        };
-        const erroredResult = {
-            type: "result",
-            subtype: "error_during_execution",
-            is_error: true,
-            errors: ["API Error: Claude Code is unable to respond to this request."],
-            total_cost_usd: 0.01,
-            session_id: "session_refused",
-        };
-        const executor = createExecutor({ queryResults: [cliLikeQuery(endInputAt, refusal, erroredResult)] });
-        const outcome = await executor.execute({ threadId: "thread_refused", turnId: "turn_refused", prompt: "Hi", history: history([]) }, activeControls());
-        expect(outcome).toMatchObject({
-            kind: "errored",
-            errors: ["I couldn't help with that request. Try rephrasing what you need."],
-        });
-        expect(endInputAt.count).toBe(2);
-    });
     it("does not hold the turn open for ambient skip_transcript tasks", async () => {
         const endInputAt = { count: -1 };
         const executor = createExecutor({