@koda-sl/baker-bridge 0.59.0 → 0.61.0

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

@@ -184,6 +184,8 @@ function createExecutor(options) {
         askUserQuestionTimeoutMs: options.askUserQuestionTimeoutMs,
         stallTimeoutMs: options.stallTimeoutMs,
         stallCheckIntervalMs: options.stallCheckIntervalMs,
+        turnEndSettleMs: options.turnEndSettleMs,
+        turnEndExitGuardMs: options.turnEndExitGuardMs,
         now: options.now,
     });
 }
@@ -415,6 +417,31 @@ describe("BridgeJobExecutor", () => {
             }),
         ]);
     });
+    // Without this the only reading we ever record is the one at `result`, taken
+    // after compaction already shrank the window — so a compaction that fired far
+    // too early leaves no evidence behind.
+    it("relays the occupancy that triggered a compaction before showing the spinner", async () => {
+        const relay = recordingRelay();
+        const executor = createExecutor({
+            relay,
+            model: "claude-sonnet-5",
+            queryResults: [
+                scriptedMessages(assistantMessage("assistant_1", "Working.", "session_next", {
+                    usage: { input_tokens: 4000, cache_read_input_tokens: 150000, cache_creation_input_tokens: 1000 },
+                }), {
+                    type: "system",
+                    subtype: "status",
+                    status: "compacting",
+                    session_id: "session_next",
+                }, resultMessage(0.02, "session_next")),
+            ],
+        });
+        await executor.execute({ threadId: "thread_cc", turnId: "turn_cc", prompt: "keep going", history: history([]) }, activeControls());
+        // Two readings: one at the compaction, one at turn end. 155k against Sonnet
+        // 5's real 1M window — a compaction here would be ~6x early.
+        const reading = { target: { threadId: "thread_cc", turnId: "turn_cc" }, tokens: 155000, window: 1_000_000 };
+        expect(relay.contextUsageUpdates).toEqual([reading, reading]);
+    });
     it("relays context occupancy from the last main request, not the turn aggregate", async () => {
         const relay = recordingRelay();
         const executor = createExecutor({
@@ -687,7 +714,7 @@ describe("BridgeJobExecutor", () => {
             queryResults: [scriptedMessages(resultMessage(0, "session_mem"))],
         });
         await executor.execute({ threadId: "thread_mem", turnId: "turn_mem", prompt: "Remember this", history: history([]) }, activeControls());
-        expect(queryInputs[0]?.options.settings).toEqual({
+        expect(queryInputs[0]?.options.settings).toMatchObject({
             autoMemoryEnabled: true,
             autoMemoryDirectory: bridgeRuntimeFiles.memoryDir(),
         });
@@ -700,6 +727,45 @@ describe("BridgeJobExecutor", () => {
             queryResults: [scriptedMessages(resultMessage(0, "session_no_mem"))],
         });
         await executor.execute({ threadId: "thread_no_mem", turnId: "turn_no_mem", prompt: "No memory", history: history([]) }, activeControls());
+        const settings = (queryInputs[0]?.options.settings ?? {});
+        expect(settings).not.toHaveProperty("autoMemoryEnabled");
+        expect(settings).not.toHaveProperty("autoMemoryDirectory");
+    });
+    // Left unset, the CLI's compaction threshold falls through to a remotely-controlled
+    // client-data value or experiment gate that can cap it well under the CLI's own
+    // ceiling, with no change on our side and no warning to the user.
+    it("pins the auto-compact window to the context window it resolved for the model", async () => {
+        const queryInputs = [];
+        const executor = createExecutor({
+            queryInputs,
+            model: "claude-sonnet-5",
+            queryResults: [scriptedMessages(resultMessage(0, "session_compact_window"))],
+        });
+        await executor.execute({ threadId: "thread_cw", turnId: "turn_cw", prompt: "Hi", history: history([]) }, activeControls());
+        expect(queryInputs[0]?.options.settings).toMatchObject({ autoCompactWindow: 1_000_000 });
+    });
+    it("leaves the auto-compact window unset for a model whose window it cannot resolve", async () => {
+        const queryInputs = [];
+        const executor = createExecutor({
+            queryInputs,
+            model: "claude-unknown",
+            queryResults: [scriptedMessages(resultMessage(0, "session_unknown_window"))],
+        });
+        await executor.execute({ threadId: "thread_uw", turnId: "turn_uw", prompt: "Hi", history: history([]) }, activeControls());
+        expect((queryInputs[0]?.options.settings ?? {})).not.toHaveProperty("autoCompactWindow");
+    });
+    // The SDK forwards `settings` to the CLI whenever the key is present — an empty
+    // object still becomes a `--settings {}` flag tier. With nothing to say, say
+    // nothing rather than hand the CLI a settings override it has to parse.
+    it("omits the settings tier entirely when it has no setting to pin", async () => {
+        vi.stubEnv("BAKER_CHAT_ID", "");
+        const queryInputs = [];
+        const executor = createExecutor({
+            queryInputs,
+            model: "claude-unknown",
+            queryResults: [scriptedMessages(resultMessage(0, "session_no_settings"))],
+        });
+        await executor.execute({ threadId: "thread_ns", turnId: "turn_ns", prompt: "Hi", history: history([]) }, activeControls());
         expect(queryInputs[0]?.options).not.toHaveProperty("settings");
     });
     it("runs exact publish commands with the prompt passed through verbatim", async () => {
@@ -1425,6 +1491,9 @@ describe("BridgeJobExecutor stall recovery", () => {
         });
         expect(queryInputs).toHaveLength(2);
         expect(queryInputs[1].options.resume).toBe("session_a");
+        // Forked: the stalled CLI can outlive its SIGTERM by a few seconds and
+        // still append to its transcript — the retry must not share its file.
+        expect(queryInputs[1].options.forkSession).toBe(true);
         expect(queryInputs[1].prompt).toContain("interrupted by a connection failure");
     });
     it("catches a retry that hangs before its first message", async () => {
@@ -1518,5 +1587,235 @@ describe("BridgeJobExecutor stall recovery", () => {
         expect(outcome).toMatchObject({ kind: "completed" });
         expect(queryInputs).toHaveLength(1);
     });
+    function assistantToolUses(uuid, sessionId, toolUseIds) {
+        return {
+            type: "assistant",
+            uuid,
+            session_id: sessionId,
+            message: {
+                role: "assistant",
+                content: toolUseIds.map((id) => ({ type: "tool_use", id, name: "Bash", input: {} })),
+                stop_reason: "tool_use",
+            },
+        };
+    }
+    function toolResultFor(sessionId, toolUseId) {
+        return {
+            type: "user",
+            session_id: sessionId,
+            message: {
+                role: "user",
+                content: [{ type: "tool_result", tool_use_id: toolUseId, content: "ok" }],
+            },
+        };
+    }
+    it("does not treat silence as a stall while a parallel sibling tool is still executing", async () => {
+        // Regression: an assistant turn issues two tool calls (or a fan-out of
+        // subagents interleaves theirs); the fast one returns while the slow one —
+        // a multi-minute canvas render — is still running. The tool_result used to
+        // arm the detector and the quiet render window was mistaken for a stall,
+        // killing the CLI mid-work.
+        const queryInputs = [];
+        let release;
+        const siblingDone = new Promise((resolveSibling) => {
+            release = resolveSibling;
+        });
+        const query = {
+            close: () => release(),
+            async *[Symbol.asyncIterator]() {
+                yield assistantToolUses("assistant_par", "session_a", ["toolu_fast", "toolu_slow"]);
+                yield toolResultFor("session_a", "toolu_fast");
+                await siblingDone; // the slow sibling, running well past the stall window
+                yield toolResultFor("session_a", "toolu_slow");
+                yield resultMessage(0.01, "session_a");
+            },
+        };
+        setTimeout(release, 80);
+        const executor = createExecutor({
+            queryInputs,
+            stallTimeoutMs: 20,
+            stallCheckIntervalMs: 5,
+            queryResults: [query],
+        });
+        const outcome = await executor.execute({ threadId: "thread_par", turnId: "turn_par", prompt: "Render both" }, activeControls());
+        expect(outcome).toMatchObject({ kind: "completed" });
+        expect(queryInputs).toHaveLength(1);
+    });
+    it("still retries when the stream hangs after the last outstanding tool result", async () => {
+        // The true-positive the detector exists for: every tool has returned, the
+        // model should be talking, and nothing comes.
+        const queryInputs = [];
+        const query = (() => {
+            let release;
+            const closed = new Promise((resolveClosed) => {
+                release = resolveClosed;
+            });
+            return {
+                close: () => release(),
+                async *[Symbol.asyncIterator]() {
+                    yield assistantToolUses("assistant_only", "session_a", ["toolu_only"]);
+                    yield toolResultFor("session_a", "toolu_only");
+                    await closed; // hung upstream request
+                },
+            };
+        })();
+        const executor = createExecutor({
+            queryInputs,
+            stallTimeoutMs: 20,
+            stallCheckIntervalMs: 5,
+            queryResults: [query, scriptedMessages(resultMessage(0.03, "session_a"))],
+        });
+        const outcome = await executor.execute({ threadId: "thread_hang", turnId: "turn_hang", prompt: "Run then hang" }, activeControls());
+        expect(outcome).toMatchObject({ kind: "completed", costUsd: 0.03 });
+        expect(queryInputs).toHaveLength(2);
+    });
+    it("surfaces the control-channel breaker even when the detector also flagged a stall", async () => {
+        // A poisoned control channel is a terminal verdict for the turn — it must
+        // not be rewritten into a stall retry that resumes the poisoned session.
+        const query = {
+            close: () => undefined, // a wedged CLI that ignores the close
+            async *[Symbol.asyncIterator]() {
+                yield controlChannelDenyMessage();
+                // Quiet long enough for the stall detector to fire, then two more denies.
+                await new Promise((resolveWait) => setTimeout(resolveWait, 60));
+                yield controlChannelDenyMessage();
+                yield controlChannelDenyMessage();
+            },
+        };
+        const executor = createExecutor({
+            stallTimeoutMs: 20,
+            stallCheckIntervalMs: 5,
+            queryResults: [query],
+        });
+        const outcome = await executor.execute({ threadId: "thread_deny_stall", turnId: "turn_deny_stall", prompt: "baker canvas run x" }, activeControls());
+        expect(outcome).toMatchObject({ kind: "errored" });
+        expect(outcome.errors[0]).toContain("control-channel closed");
+    });
+});
+describe("BridgeJobExecutor turn end with background tasks", () => {
+    function taskStarted(taskId, extras) {
+        return {
+            type: "system",
+            subtype: "task_started",
+            task_id: taskId,
+            description: "Build a creative",
+            subagent_type: "creative-producer",
+            session_id: "session_bg",
+            ...extras,
+        };
+    }
+    function taskSettled(taskId) {
+        return {
+            type: "system",
+            subtype: "task_notification",
+            task_id: taskId,
+            status: "completed",
+            summary: "done",
+            session_id: "session_bg",
+        };
+    }
+    // Mimics the real CLI on a held-open input stream: it emits its messages,
+    // then stays alive until endInput() (stdin EOF) — and once input has ended,
+    // it exits instead of producing further turns.
+    function cliLikeQuery(endInputAt, ...messages) {
+        let release;
+        let inputEnded = false;
+        const ended = new Promise((resolveEnded) => {
+            release = resolveEnded;
+        });
+        let emitted = 0;
+        return {
+            close: () => release(),
+            endInput: () => {
+                if (!inputEnded) {
+                    inputEnded = true;
+                    endInputAt.count = emitted;
+                    release();
+                }
+            },
+            async *[Symbol.asyncIterator]() {
+                for (const message of messages) {
+                    if (inputEnded) {
+                        return;
+                    }
+                    await Promise.resolve();
+                    emitted += 1;
+                    yield message;
+                }
+                await ended;
+            },
+        };
+    }
+    it("ends input at the first clean result when the turn ran no tasks", async () => {
+        const endInputAt = { count: -1 };
+        const executor = createExecutor({
+            queryResults: [cliLikeQuery(endInputAt, resultMessage(0.01, "session_bg"))],
+        });
+        const outcome = await executor.execute({ threadId: "thread_plain", turnId: "turn_plain", prompt: "Say hi", history: history([]) }, activeControls());
+        expect(outcome).toMatchObject({ kind: "completed", costUsd: 0.01 });
+        expect(endInputAt.count).toBe(1);
+    });
+    it("holds the turn open past a result while a background task is in flight", async () => {
+        // The incident shape: the main turn's result lands while spawned subagents
+        // are still working. Ending input there severs the CLI's tool-permission
+        // control channel and every later tool call across the fan-out is denied.
+        const endInputAt = { count: -1 };
+        const executor = createExecutor({
+            turnEndSettleMs: 20,
+            queryResults: [
+                cliLikeQuery(endInputAt, taskStarted("task_bg"), resultMessage(0.1, "session_bg"), taskSettled("task_bg"), resultMessage(0.2, "session_bg")),
+            ],
+        });
+        const outcome = await executor.execute({ threadId: "thread_bg", turnId: "turn_bg", prompt: "Fan out producers", history: history([]) }, activeControls());
+        // All four messages were consumed before input ended: the first result did
+        // NOT close the channel, and the turn completed on the post-task result.
+        expect(outcome).toMatchObject({ kind: "completed", costUsd: 0.2 });
+        expect(endInputAt.count).toBe(4);
+    });
+    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
+        // 30-minute session watchdog errored a perfectly healthy turn.
+        const endInputAt = { count: -1 };
+        const executor = createExecutor({
+            turnEndSettleMs: 20,
+            queryResults: [
+                cliLikeQuery(endInputAt, taskStarted("task_silent"), resultMessage(0.1, "session_bg"), taskSettled("task_silent")),
+            ],
+        });
+        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.1 });
+        expect(endInputAt.count).toBe(3);
+    });
+    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
+        // re-arm would strand the turn the same way a silent settle did.
+        const endInputAt = { count: -1 };
+        const executor = createExecutor({
+            turnEndSettleMs: 20,
+            queryResults: [
+                cliLikeQuery(endInputAt, taskStarted("task_bg"), taskSettled("task_bg"), resultMessage(0.1, "session_bg"), {
+                    type: "system",
+                    subtype: "session_state_changed",
+                    session_id: "session_bg",
+                }),
+            ],
+        });
+        const outcome = await executor.execute({ threadId: "thread_trail", turnId: "turn_trail", prompt: "Fan out then idle", history: history([]) }, activeControls());
+        expect(outcome).toMatchObject({ kind: "completed", costUsd: 0.1 });
+        expect(endInputAt.count).toBe(4);
+    });
+    it("does not hold the turn open for ambient skip_transcript tasks", async () => {
+        const endInputAt = { count: -1 };
+        const executor = createExecutor({
+            queryResults: [
+                cliLikeQuery(endInputAt, taskStarted("task_ambient", { skip_transcript: true }), resultMessage(0.05, "session_bg")),
+            ],
+        });
+        const outcome = await executor.execute({ threadId: "thread_ambient", turnId: "turn_ambient", prompt: "Quick turn", history: history([]) }, activeControls());
+        expect(outcome).toMatchObject({ kind: "completed", costUsd: 0.05 });
+        expect(endInputAt.count).toBe(2);
+    });
 });
 //# sourceMappingURL=bridge-job.test.js.map