@koda-sl/baker-bridge 0.110.0-dev.6a86a7961 → 0.110.0-dev.ec7b0e42b

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

@@ -223,13 +223,14 @@ function createExecutor(options) {
         stallCheckIntervalMs: options.stallCheckIntervalMs,
         turnEndSettleMs: options.turnEndSettleMs,
         turnEndExitGuardMs: options.turnEndExitGuardMs,
+        settleWorkspace: options.settleWorkspace ?? (() => Promise.resolve()),
         ...(options.turnEvents
             ? { recordTurnEvent: (event) => options.turnEvents?.push(event) }
             : {}),
         now: options.now,
         readUsageBaseline: async (sessionId) => options.usageBaselines?.[sessionId],
         stalledCliExitMs: 0,
-        ...(options.mainSync ? { mainSync: options.mainSync } : {}),
+        prepareAttachments: options.prepareAttachments,
     });
 }
 function resultMessage(costUsd, sessionId, modelUsage) {
@@ -315,8 +316,8 @@ describe("isControlChannelDeny", () => {
         })).toBe(false);
     });
     it("does not match a PreToolUse hook block that quotes the envelope in its explanation", () => {
-        // Live-run finding: the scaffold's guard-background-commands hook explains
-        // WHY it blocks a backgrounded subagent by quoting the failure it prevents.
+        // Live-run finding: the scaffold's guard-background-commands hook, when it
+        // still blocked backgrounded subagents, explained why by quoting the failure.
         // Its block arrives as an is_error tool_result, so an envelope-substring
         // match counted it as a deny — three blocked spawns in one turn would have
         // tripped the breaker and errored a perfectly healthy turn.
@@ -1170,8 +1171,7 @@ describe("BridgeJobExecutor", () => {
     // Read off a session's own `init` tool list, the CLI offers these to every
     // Session. Each one reaches past what a marketer's chat is for: the worktree
     // pair rearranges the branches Publish owns, `Workflow` fans out a fleet on
-    // the organization's OpenRouter key, and `SendMessage` addresses peers a
-    // single-session Runtime does not have.
+    // the organization's OpenRouter key.
     it("removes the tools that reach outside what a Session is", async () => {
         const queryInputs = [];
         const executor = createExecutor({
@@ -1180,10 +1180,12 @@ describe("BridgeJobExecutor", () => {
         });
         await executor.execute({ threadId: "thread_reach", turnId: "turn_reach", prompt: "Build a landing", history: history([]) }, activeControls());
         const disallowed = queryInputs[0]?.options.disallowedTools ?? [];
-        expect(disallowed).toEqual(expect.arrayContaining(["EnterWorktree", "ExitWorktree", "Workflow", "SendMessage"]));
+        expect(disallowed).toEqual(expect.arrayContaining(["EnterWorktree", "ExitWorktree", "Workflow"]));
         // `Task` is the subagent spawn itself — the scaffold's own fan-out workers
-        // ride it, so blocking multi-agent orchestration must not catch it.
+        // ride it, so blocking multi-agent orchestration must not catch it. And
+        // `SendMessage` is how the agent follows up with a subagent it already ran.
         expect(disallowed).not.toContain("Task");
+        expect(disallowed).not.toContain("SendMessage");
     });
     it("allowlists the workspace's own skills so the CLI's built-in developer skills stay out of the session", async () => {
         const workspace = await mkdtemp(join(tmpdir(), "baker-job-skills-"));
@@ -1473,198 +1475,87 @@ describe("BridgeJobExecutor", () => {
         expect(queryInputs[0]?.prompt).toBe("/publish");
         expect(queryInputs[0]?.reminder).toBeUndefined();
     });
-    it("brings the workspace level with main before the turn and tells the agent what changed, beside the viewing context", async () => {
+    it("keeps the viewing-reference context beside the message when a stale session falls back to rehydration", async () => {
         const queryInputs = [];
-        const syncedThreads = [];
-        const syncedPublishes = [];
         const executor = createExecutor({
+            loadedBoundary: cleanBoundary("session_stale_viewing"),
             queryInputs,
-            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(),
-            },
+            queryResults: [
+                scriptedError(new Error("Cannot resume: session not found")),
+                scriptedMessages(resultMessage(0, "session_next_viewing")),
+            ],
         });
         await executor.execute({
-            threadId: "thread_main_moved",
-            turnId: "turn_main_moved",
-            prompt: "change the hero title",
-            history: history([]),
+            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" },
-            publishedElsewhere: [
-                {
-                    sha: "abc123",
-                    chatId: "sibling",
-                    title: "New hero",
-                    publishedAt: 1,
-                    paths: ["src/pages/hero/index.astro"],
-                },
-            ],
         }, activeControls());
-        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)');
-    });
-    it("realigns the workspace once the turn ends, after whatever the agent did to it", async () => {
-        const queryInputs = [];
-        const realignedAfter = [];
-        const executor = createExecutor({
-            queryInputs,
-            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_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("tells a resumed session only what is new, since it remembers every earlier note", async () => {
-        const queryInputs = [];
-        const executor = createExecutor({
-            loadedBoundary: cleanBoundary("session_resumed_main"),
-            queryInputs,
-            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_main", turnId: "turn_resumed_main", prompt: "hola", history: history([]) }, activeControls());
-        expect(queryInputs[0]?.reminder).toBeUndefined();
+        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("repeats the standing workspace notice when a stale session falls back to rehydration", async () => {
+    // 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 () => {
         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")),
-            ],
-            mainSync: {
-                beforeTurn: () => Promise.resolve({ recovered: "<system-reminder>\nBaker: standing\n</system-reminder>" }),
-                refuseWrite: () => null,
-                afterTurn: () => Promise.resolve(),
-            },
+            prepareAttachments: async (attachments, attachedTo) => `\n\nFILES for ${attachedTo}: ${attachments.map((attachment) => attachment.filename).join(", ")}`,
         });
         await executor.execute({
-            threadId: "thread_stale_main",
-            turnId: "turn_stale_main",
-            prompt: "quita el pricing",
-            history: history([{ role: "user", text: "Persisted fact", createdAt: 1 }]),
+            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]?.reminder).toBeUndefined();
-        expect(queryInputs[1]?.reminder).toContain("Baker: standing");
+        expect(queryInputs[0]?.prompt).toContain("FILES for continued_request: logo.png");
     });
-    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;
+    it("does not hand the continued request's files over again to a resumed Session", async () => {
         const queryInputs = [];
-        const syncs = [];
         const executor = createExecutor({
+            loadedBoundary: cleanBoundary("session_holds_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",
+            prepareAttachments: async (attachments) => `\n\nFILES: ${attachments.map((attachment) => attachment.filename).join(", ")}`,
         });
+        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" },
+            ],
+            history: history([{ role: "user", text: "Build a page with my logo", createdAt: 1 }]),
+        }, activeControls());
+        expect(queryInputs[0]?.prompt).toBe("They have now replied: HubSpot");
     });
-    it("keeps the viewing-reference context beside the message when a stale session falls back to rehydration", async () => {
+    it("hands the continued request's files over when a stale Session falls back to history", async () => {
         const queryInputs = [];
         const executor = createExecutor({
-            loadedBoundary: cleanBoundary("session_stale_viewing"),
+            loadedBoundary: cleanBoundary("session_stale_files"),
             queryInputs,
             queryResults: [
                 scriptedError(new Error("Cannot resume: session not found")),
-                scriptedMessages(resultMessage(0, "session_next_viewing")),
+                scriptedMessages(resultMessage(0, "session_rebuilt_files")),
             ],
+            prepareAttachments: async (attachments) => `\n\nFILES: ${attachments.map((attachment) => attachment.filename).join(", ")}`,
         });
         await executor.execute({
-            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" },
+            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 }]),
         }, 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(queryInputs[0]?.prompt).not.toContain("FILES");
+        expect(queryInputs[1]?.prompt).toContain("Current user request\nThey have now replied: HubSpot\n\nFILES: logo.png");
     });
     it("clears an invalid clean boundary and retries once with rehydrated history", async () => {
         const relay = recordingRelay();
@@ -3263,6 +3154,29 @@ describe("BridgeJobExecutor turn end with background tasks", () => {
         expect(outcome).toMatchObject({ kind: "completed", costUsd: 0.2 });
         expect(endInputAt.count).toBe(4);
     });
+    it("tells the session watchdog while a tool call or background task is running", async () => {
+        const endInputAt = { count: -1 };
+        const executor = createExecutor({
+            turnEndSettleMs: 20,
+            queryResults: [
+                cliLikeQuery(endInputAt, toolUseAssistantMessage("Bash", { command: "baker canvas run x.canvas.json" }), {
+                    type: "user",
+                    session_id: "session_bg",
+                    message: { role: "user", content: [{ type: "tool_result", tool_use_id: "toolu_stream", content: "ok" }] },
+                }, taskStarted("task_render"), resultMessage(0.1, "session_bg"), taskSettled("task_render"), resultMessage(0.2, "session_bg")),
+            ],
+        });
+        const reported = [];
+        const controls = {
+            ...activeControls(),
+            setWorkInFlight: (inFlight) => {
+                if (reported.at(-1) !== inFlight)
+                    reported.push(inFlight);
+            },
+        };
+        await executor.execute({ threadId: "thread_bg", turnId: "turn_bg", prompt: "Render", history: history([]) }, controls);
+        expect(reported).toEqual([true, false, true, false]);
+    });
     it("ends the turn when the last task settles without waking the model into a second result", async () => {
         // A settle is not guaranteed to produce another result. If only a result
         // could arm the end, this shape would strand in `for await` until the
@@ -3278,6 +3192,120 @@ describe("BridgeJobExecutor turn end with background tasks", () => {
         expect(outcome).toMatchObject({ kind: "completed", costUsd: 0.1 });
         expect(endInputAt.count).toBe(3);
     });
+    it("bills what a task spent after the last result when it settles without waking the model", async () => {
+        // The last result reported $0.10; the task kept working after it. With no
+        // second result, only the CLI's own running total can say what it cost.
+        const endInputAt = { count: -1 };
+        const query = cliLikeQuery(endInputAt, taskStarted("task_silent"), resultMessage(0.1, "session_bg"), taskSettled("task_silent"));
+        const executor = createExecutor({
+            turnEndSettleMs: 20,
+            queryResults: [
+                { ...query, usage: () => Promise.resolve({ totalCostUsd: 0.35, modelUsage: {} }) },
+            ],
+        });
+        const outcome = await executor.execute({ threadId: "thread_silent", turnId: "turn_silent", prompt: "Fan out one producer", history: history([]) }, activeControls());
+        expect(outcome).toMatchObject({ kind: "completed", costUsd: 0.35 });
+    });
+    it("settles the workspace itself when a turn that ran tasks ends, since its last Stop may never come", async () => {
+        // A task settling without waking the model ends the turn with no further
+        // Stop, so the end-of-turn hooks that deferred to a later Stop never run.
+        let settled = 0;
+        const executor = createExecutor({
+            turnEndSettleMs: 5,
+            settleWorkspace: () => {
+                settled += 1;
+                return Promise.resolve();
+            },
+            queryResults: [
+                cliLikeQuery({ count: -1 }, taskStarted("task_silent"), resultMessage(0.1, "session_bg"), taskSettled("task_silent")),
+                cliLikeQuery({ count: -1 }, resultMessage(0.1, "session_plain")),
+            ],
+        });
+        await executor.execute({ threadId: "thread_silent", turnId: "turn_silent", prompt: "Fan out", history: history([]) }, activeControls());
+        expect(settled).toBe(1);
+        await executor.execute({ threadId: "thread_plain", turnId: "turn_plain", prompt: "Say hi", history: history([]) }, activeControls());
+        expect(settled).toBe(1);
+    });
+    it("leaves the workspace untouched after a Session review that ran tasks", async () => {
+        // A review runs with every hook off and may not change anything; the
+        // settle steps format files and reconcile a publish.
+        let settled = 0;
+        const executor = createExecutor({
+            turnEndSettleMs: 5,
+            settleWorkspace: () => {
+                settled += 1;
+                return Promise.resolve();
+            },
+            queryResults: [
+                cliLikeQuery({ count: -1 }, taskStarted("task_read"), taskSettled("task_read"), {
+                    ...resultMessage(0.1, "session_review"),
+                    structured_output: { summary: "fine", findings: [] },
+                }),
+            ],
+        });
+        const outcome = await executor.execute({
+            threadId: "thread_review",
+            turnId: "turn_review",
+            prompt: "You are reviewing…",
+            review: {
+                reviewId: "rev_1",
+                apiKey: "bk_review_key",
+                modelAuthToken: "sk-or-platform",
+                model: "claude-review-model",
+                outputSchema: { type: "object" },
+                threadIds: ["thread_visible"],
+            },
+        }, activeControls());
+        expect(outcome).toMatchObject({ kind: "completed" });
+        expect(settled).toBe(0);
+    });
+    it("keeps input open for a wake that lands while the usage reading is in flight", async () => {
+        // The usage reading sits between deciding to end and ending. A wake queued
+        // in the CLI can land inside it; closing stdin then would deny the woken
+        // turn's first permission-gated tool call.
+        const endInputAt = { count: -1 };
+        const query = cliLikeQuery(endInputAt, taskStarted("task_bg"), resultMessage(0.1, "session_bg"), taskSettled("task_bg"), { pauseMs: 40 }, wakeMessage(), 
+        // The woken turn is still on time-to-first-token when the reading returns.
+        { pauseMs: 150 }, resultMessage(0.2, "session_bg"));
+        const executor = createExecutor({
+            turnEndSettleMs: 5,
+            queryResults: [
+                {
+                    ...query,
+                    usage: () => new Promise((resolveUsage) => setTimeout(() => resolveUsage({ totalCostUsd: 0.2, modelUsage: {} }), 100)),
+                },
+            ],
+        });
+        await executor.execute({ threadId: "thread_wake", turnId: "turn_wake", prompt: "Fan out", history: history([]) }, activeControls());
+        expect(endInputAt.count).toBe(5);
+    });
+    it("leaves a query that ended during the usage reading alone when the reading returns", async () => {
+        // A Stop can close the CLI while the reading is in flight. The run is over
+        // by the time it answers; ending the turn then would log a turn end that
+        // never happened and arm an exit guard against a query nobody is draining.
+        const query = cliLikeQuery({ count: -1 }, taskStarted("task_bg"), resultMessage(0.1, "session_bg"), taskSettled("task_bg"));
+        let answerUsage;
+        const turnEvents = [];
+        const executor = createExecutor({
+            turnEndSettleMs: 5,
+            turnEvents,
+            queryResults: [
+                {
+                    ...query,
+                    usage: () => {
+                        query.close?.();
+                        return new Promise((resolveUsage) => {
+                            answerUsage = () => resolveUsage({ totalCostUsd: 0.2, modelUsage: {} });
+                        });
+                    },
+                },
+            ],
+        });
+        await executor.execute({ threadId: "thread_stop", turnId: "turn_stop", prompt: "Fan out", history: history([]) }, activeControls());
+        answerUsage();
+        await new Promise((resolveTick) => setImmediate(resolveTick));
+        expect(turnEvents.map((event) => event.event)).not.toContain("turn_end");
+    });
     it("re-arms the settle window when a passive system event trails the result", async () => {
         // Passive trailing events (files persisted, session state) must not cancel
         // a scheduled end — only genuine model activity does. A cancel with no
@@ -3347,6 +3375,35 @@ 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({