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

package/dist/hono/bridge-job.js

@@ -29,6 +29,7 @@ import { createBakerUiServer, normalizeTagInputToolInput, sanitizeTagChanges, TA
 import { blockingToolDelegated, toolRunAsCommand } from "./tool-in-shell.js";
 import { recordTurnEvent } from "./turn-events.js";
 import { addQueryModelUsage, queryModelUsage, turnModelUsageList } from "./turn-model-usage.js";
+import { settleWorkspaceAfterTasks } from "./workspace-settle.js";
 export function parsePlanDecision(value) {
     if (!value || typeof value !== "object") {
         return null;
@@ -151,10 +152,11 @@ const BASE_DISALLOWED_TOOLS = [
     // not asked to fund a research fleet. Ordinary fan-out is unaffected:
     // `Task` stays, so the scaffold's subagents still run.
     "Workflow",
-    // Cross-session messaging. A Runtime holds exactly one session, so
-    // there is never a peer to reach; every call is a dead end that costs a
-    // round trip to discover.
-    "SendMessage",
+    // NOT listed: `SendMessage`. It is how the model follows up with a
+    // subagent it already ran, and the CLI tells it to on every Agent result.
+    // The continued subagent runs in the background, but it announces itself
+    // with `task_started` / `background_tasks_changed`, so the turn stays open
+    // until it finishes (`createTurnEndController`).
     // A Session review may not change anything. Removing the definitions is
     // the second of three layers — the key it carries is read-scoped and its
     // Bash calls go through `reviewBashPolicy` — because each fails
@@ -498,9 +500,9 @@ function sdkResultError(msg) {
 // the whole turn; the deny THRESHOLD below still guards a one-off end-of-turn race.
 // The trailing colon matters: the CLI always emits the envelope followed by the
 // error that caused it ("…failed: Error: Stream closed", "…failed: AbortError: …").
-// Prose that merely NAMES the failure quotes it without one, which is how the
-// scaffold's guard-background-commands hook describes what it prevents — and its
-// block is an is_error tool_result, so a colon-less match counted a healthy
+// Prose that merely NAMES the failure quotes it without one, which is how a
+// hook explaining a block quotes it (the scaffold's former background-subagent
+// block did) — and a hook block is an is_error tool_result, so a colon-less match counted a healthy
 // blocked spawn as a deny and could trip the breaker on a healthy turn.
 const CONTROL_CHANNEL_DENY_MARKER = "Tool permission request failed:";
 // Hook failures are reported through the same is_error tool_result channel but
@@ -663,9 +665,27 @@ export function createStallDetector(input) {
             awaitingModel = (msg.type === "user" || msg.type === "stream_event") && pendingToolUses.size === 0;
         },
         stalled: () => stalled,
+        hasPendingToolUses: () => pendingToolUses.size > 0,
         dispose: () => clearInterval(timer),
     };
 }
+// A query's cost and `modelUsage` are cumulative — on every result message and
+// on the CLI's usage reply alike — so the latest reading replaces the last one
+// rather than adding to it. It is folded into the turn totals when the query
+// settles (see `runQueryOnce`). A spuriously empty later reading never wipes a
+// real earlier one.
+function recordCumulativeUsage(state, reading) {
+    const own = ownQueryUsage(reading, state.queryUsageBaseline);
+    state.observedCostUsd = own.costUsd;
+    const snapshot = queryModelUsage(own.modelUsage);
+    if (snapshot.size > 0) {
+        state.queryModelUsage = snapshot;
+    }
+    return own.costUsd;
+}
+// How long ending a turn waits on the CLI's usage reply before going ahead
+// without it. Billing a turn late is recoverable; hanging one is not.
+const USAGE_READING_TIMEOUT_MS = 5_000;
 // Decides when the turn is really over and the CLI may be told to exit.
 //
 // The prompt rides a held-open input stream (see `createHeldOpenQuery` in
@@ -687,7 +707,10 @@ export function createStallDetector(input) {
 // events must not, or the end would never re-arm. After input ends, an exit
 // guard closes the query if the CLI neither speaks nor exits, so a wedged
 // process cannot hang the turn until the session watchdog.
-function createTurnEndController(job, query, closeQuery, timings, onTurnEvent) {
+function createTurnEndController(job, query, closeQuery, timings, onTurnEvent, 
+// Runs once, before input ends on a turn that ran tasks: a task can settle
+// without waking the model, so the last result may not include what it spent.
+beforeEndInput) {
     const inFlightTasks = new Set();
     // The background_tasks_changed LEVEL signal, tracked separately from the
     // edge-paired set above: a foreground command the CLI auto-backgrounds emits
@@ -700,15 +723,52 @@ function createTurnEndController(job, query, closeQuery, timings, onTurnEvent) {
     let cleanResultSeen = false;
     let lastWasTaskLifecycle = false;
     let inputEnded = false;
+    // Between deciding to end and ending, while the usage reading is in flight.
+    // Anything that would have cancelled a pending end — model activity, a task
+    // starting — is recorded here and abandons the end instead.
+    let ending;
+    // The query stopped being drained (a Stop, a crash): a reading answering
+    // after that has no turn left to end.
+    let disposed = false;
     let settleTimer;
     let exitGuard;
     const endInput = () => {
         settleTimer = undefined;
         // Fire-time guard: a task that started during the settle window keeps the
         // channel open; a later settle re-arms the end.
-        if (inputEnded || hasInFlightWork()) {
+        if (inputEnded || ending || hasInFlightWork()) {
             return;
         }
+        if (sawAnyTask && beforeEndInput) {
+            const attempt = { interrupted: false };
+            ending = attempt;
+            let timeout;
+            const timedOut = new Promise((resolveTimeout) => {
+                timeout = setTimeout(resolveTimeout, USAGE_READING_TIMEOUT_MS);
+                timeout.unref?.();
+            });
+            void Promise.race([beforeEndInput().catch(() => undefined), timedOut]).finally(() => {
+                clearTimeout(timeout);
+                ending = undefined;
+                if (disposed) {
+                    return;
+                }
+                // Re-check at the moment input would end, as the fire-time guard above
+                // does: a wake or a task that landed during the reading keeps the
+                // channel open, and the woken turn's own result or settle ends it.
+                if (attempt.interrupted || hasInFlightWork()) {
+                    if (cleanResultSeen && !hasInFlightWork()) {
+                        scheduleEnd();
+                    }
+                    return;
+                }
+                finishEndInput();
+            });
+            return;
+        }
+        finishEndInput();
+    };
+    const finishEndInput = () => {
         inputEnded = true;
         query.endInput?.();
         onTurnEvent({
@@ -778,15 +838,21 @@ function createTurnEndController(job, query, closeQuery, timings, onTurnEvent) {
                 clearTimeout(settleTimer);
                 settleTimer = undefined;
             }
+            if (ending && (isModelActivity || hasInFlightWork())) {
+                ending.interrupted = true;
+            }
             if (exitGuard) {
                 exitGuard.refresh();
             }
         },
-        maybeEndAfter: (msg) => {
+        maybeEndAfter: (msg, refused) => {
             if (inputEnded) {
                 return;
             }
-            if (msg.type === "result" && !msg.is_error) {
+            // A refusal's error result is not thrown (the refusal already decided how
+            // the turn ends), so it has to end input like a clean one or the CLI idles
+            // on stdin until the session watchdog.
+            if (msg.type === "result" && (!msg.is_error || refused)) {
                 cleanResultSeen = true;
                 if (hasInFlightWork()) {
                     console.error(`[BridgeJob] result received with ${inFlightTasks.size} task(s) and ${backgroundTaskCount} background command(s) in flight — holding the turn open (thread ${job.threadId})`);
@@ -803,7 +869,10 @@ function createTurnEndController(job, query, closeQuery, timings, onTurnEvent) {
                 scheduleEnd();
             }
         },
+        hasInFlightWork,
+        ranTasks: () => sawAnyTask,
         dispose: () => {
+            disposed = true;
             if (settleTimer) {
                 clearTimeout(settleTimer);
                 settleTimer = undefined;
@@ -895,7 +964,7 @@ export class BridgeJobExecutor {
     readUsageBaseline;
     stalledCliExitMs;
     readFlowTree;
-    mainSync;
+    settleWorkspace;
     constructor(dependencies) {
         this.sdk = dependencies.sdk;
         this.relay = dependencies.relay;
@@ -914,9 +983,9 @@ export class BridgeJobExecutor {
             dependencies.readUsageBaseline ??
                 ((sessionId) => readUsageBaseline(sessionId, process.env.CLAUDE_CONFIG_DIR || resolve(process.env.HOME || homedir(), ".claude")));
         this.stalledCliExitMs = dependencies.stalledCliExitMs ?? STALLED_CLI_EXIT_MS;
+        this.settleWorkspace = dependencies.settleWorkspace ?? (() => settleWorkspaceAfterTasks());
         this.readFlowTree =
             dependencies.readFlowTree ?? ((flowSlug) => readRawFlowTree(bridgeRuntimeFiles.flowsDir(), flowSlug));
-        this.mainSync = dependencies.mainSync;
     }
     async execute(job, controls) {
         const state = createBridgeJobState();
@@ -929,10 +998,12 @@ export class BridgeJobExecutor {
                 return { kind: "cancelled", costUsd: 0, model: state.model };
             }
             const loaded = await this.loadTrustedBoundary(job, controls);
+            if (loaded?.kind !== "clean") {
+                request = await this.withContinuedAttachments(job, request);
+            }
             attempt = prepareSessionAttempt({
                 requestPrompt: request.prompt,
                 reminder: request.reminder,
-                recoveryReminder: request.recoveryReminder,
                 history: job.history,
                 loaded,
                 leadingCommand: request.leadingCommand,
@@ -963,12 +1034,6 @@ export class BridgeJobExecutor {
             await this.clearIfDirty(job, controls, state, classifyDirtyReason(error, controls));
             return this.errorOutcome(job, controls, state, this.resultWithObservedCost(result, state), error);
         }
-        finally {
-            // A review only reads the finished Session's workspace.
-            if (!job.review) {
-                await this.mainSync?.afterTurn();
-            }
-        }
     }
     async loadTrustedBoundary(job, controls) {
         const loaded = await this.sessionStore.load(job.threadId);
@@ -990,34 +1055,17 @@ export class BridgeJobExecutor {
         // skill) must stay the leading token, so they skip speaker attribution and
         // reference context — otherwise the prepended lines push the command off the
         // front and it lands as ordinary message text the model just echoes.
-        const bridgeCommand = verbatimSlashCommand(job.prompt);
-        const verbatim = bridgeCommand ??
+        const verbatim = verbatimSlashCommand(job.prompt) ??
             leadingSkillCommand(job.prompt, (await readSessionSkills(bridgeRuntimeFiles.projectRoot())) ?? []);
         let requestPrompt = verbatim ?? applyCurrentSenderAttribution(job.prompt, job.currentSender);
-        // Publish and compact keep the workspace as it is (Publish rebases onto main
-        // itself). A skill reads and edits the workspace, so it is brought level
-        // first — but a note beside the command would push it off the front, so
-        // the thread hears about it on its next turn.
-        const notes = bridgeCommand === null
-            ? ((await this.mainSync?.beforeTurn(job.threadId, job.publishedElsewhere ?? [], {
-                withNote: verbatim === null,
-            })) ?? {})
-            : {};
-        const viewing = verbatim === null ? currentReferenceReminder(job.currentReference) : undefined;
-        const reminder = joinReminders(notes.resumed, viewing);
-        const recoveryReminder = joinReminders(notes.recovered, viewing);
+        const reminder = verbatim === null ? currentReferenceReminder(job.currentReference) : undefined;
         if (job.attachments && job.attachments.length > 0) {
-            requestPrompt += await this.prepareAttachments(job.attachments);
+            requestPrompt += await this.prepareAttachments(job.attachments, "message");
         }
         if (!controls.isActive()) {
             return null;
         }
-        return {
-            prompt: requestPrompt,
-            ...(reminder ? { reminder } : {}),
-            ...(recoveryReminder ? { recoveryReminder } : {}),
-            leadingCommand: verbatim !== null,
-        };
+        return { prompt: requestPrompt, ...(reminder ? { reminder } : {}), leadingCommand: verbatim !== null };
     }
     /**
      * The reviewer's prompt: the brief Convex wrote, with the evidence block this
@@ -1216,6 +1264,18 @@ export class BridgeJobExecutor {
             });
         }
     }
+    /**
+     * The files of the request a late reply continues, for a turn that does not
+     * resume the Session that received them with the request. Its history names
+     * them but cannot open them.
+     */
+    async withContinuedAttachments(job, request) {
+        if (!job.continuedAttachments?.length || request.leadingCommand) {
+            return request;
+        }
+        const suffix = await this.prepareAttachments(job.continuedAttachments, "continued_request");
+        return { ...request, prompt: request.prompt + suffix };
+    }
     async invalidResumeFallbackAttempt(job, controls, request, attempt, state, error) {
         if (!attempt.usedBoundary ||
             state.sawUserVisibleSdkMessage ||
@@ -1224,6 +1284,7 @@ export class BridgeJobExecutor {
             return null;
         }
         await this.sessionStore.clear(job.threadId, { runToken: controls.runToken, reason: "sdk_error" });
+        const rebuilt = await this.withContinuedAttachments(job, request);
         void this.relay.contextSource({ threadId: job.threadId, turnId: job.turnId }, "rehydrated_invalid_resume", {
             historyEntryCount: job.history?.entries.length ?? 0,
             omittedEntryCount: job.history?.omittedEntryCount ?? 0,
@@ -1232,12 +1293,12 @@ export class BridgeJobExecutor {
         });
         // A leading command stays bare here too: a history preamble in front of it
         // would turn it into plain text (see `prepareSessionAttempt`).
-        if (request.leadingCommand) {
-            return { prompt: request.prompt, attemptedRehydration: false, resumeOptions: {} };
+        if (rebuilt.leadingCommand) {
+            return { prompt: rebuilt.prompt, attemptedRehydration: false, resumeOptions: {} };
         }
         return {
-            prompt: buildRehydratedPrompt(request.prompt, job.history),
-            ...(request.recoveryReminder ? { reminder: request.recoveryReminder } : {}),
+            prompt: buildRehydratedPrompt(rebuilt.prompt, job.history),
+            ...(rebuilt.reminder ? { reminder: rebuilt.reminder } : {}),
             attemptedRehydration: true,
             resumeOptions: {},
         };
@@ -1292,11 +1353,6 @@ export class BridgeJobExecutor {
         const malformed = refuseMalformedCall(toolName, input, job.prompt, userTurnsBefore(job));
         if (malformed)
             return Promise.resolve({ behavior: "deny", message: malformed });
-        const clash = toolName === "Write" && typeof input?.file_path === "string"
-            ? (this.mainSync?.refuseWrite(job.threadId, input.file_path) ?? null)
-            : null;
-        if (clash)
-            return Promise.resolve({ behavior: "deny", message: clash });
         // Cast what is owed FIRST, whatever comes next — including another create. Checked
         // the other way round, a second create (the agent retrying after a rejected flag,
         // which is what happens in practice) would overwrite the handle and the first
@@ -1522,7 +1578,19 @@ export class BridgeJobExecutor {
     // in-progress session.
     async drainQuery(job, controls, state, query, closeQuery) {
         const stallDetector = this.createStallDetector(job, controls, closeQuery);
-        const turnEnd = createTurnEndController(job, query, closeQuery, { settleMs: this.turnEndSettleMs, exitGuardMs: this.turnEndExitGuardMs }, this.recordTurnEvent);
+        // What the query had spent when its turn ended, read from the CLI — set
+        // only when a task ran, and higher than the last result's figure when a
+        // task kept working after it.
+        let settledCostUsd = 0;
+        // A reading that answers after the query drained (past its timeout) belongs
+        // to a query already folded into the turn — and a retry reuses `state`.
+        let drained = false;
+        const turnEnd = createTurnEndController(job, query, closeQuery, { settleMs: this.turnEndSettleMs, exitGuardMs: this.turnEndExitGuardMs }, this.recordTurnEvent, async () => {
+            const reading = await query.usage?.();
+            if (reading && !drained) {
+                settledCostUsd = recordCumulativeUsage(state, reading);
+            }
+        });
         let costUsd = 0;
         // Errors thrown while HANDLING a message (control-channel breaker, error
         // results) are real verdicts and must surface as-is; only errors from the
@@ -1532,6 +1600,7 @@ export class BridgeJobExecutor {
             for await (const msg of query) {
                 stallDetector.observeMessage(msg);
                 turnEnd.observeMessage(msg);
+                controls.setWorkInFlight?.(stallDetector.hasPendingToolUses() || turnEnd.hasInFlightWork());
                 try {
                     costUsd = await this.consumeSdkMessage(job, controls, state, msg, costUsd);
                 }
@@ -1539,7 +1608,7 @@ export class BridgeJobExecutor {
                     consumeError = true;
                     throw error;
                 }
-                turnEnd.maybeEndAfter(msg);
+                turnEnd.maybeEndAfter(msg, state.refusedWithoutFallback === true);
                 if (!controls.isActive()) {
                     closeQuery();
                     break;
@@ -1554,6 +1623,8 @@ export class BridgeJobExecutor {
             throw error;
         }
         finally {
+            drained = true;
+            controls.setWorkInFlight?.(false);
             stallDetector.dispose();
             turnEnd.dispose();
             await this.openPendingCastingAtTurnEnd(job, controls);
@@ -1561,7 +1632,11 @@ export class BridgeJobExecutor {
         if (stallDetector.stalled() && controls.isActive()) {
             throw new StreamStallError();
         }
-        return costUsd;
+        // Not for a Session review: it runs with every hook off and may not change anything.
+        if (turnEnd.ranTasks() && controls.isActive() && !job.review) {
+            await this.settleWorkspace();
+        }
+        return Math.max(costUsd, settledCostUsd);
     }
     /**
      * Open a casting the turn recorded but never reached.
@@ -1654,17 +1729,7 @@ export class BridgeJobExecutor {
         }
         trackMainRequestUsage(state, msg);
         if (msg.type === "result") {
-            const own = ownQueryUsage({ totalCostUsd: msg.total_cost_usd, modelUsage: msg.modelUsage }, state.queryUsageBaseline);
-            state.observedCostUsd = own.costUsd;
-            // A query's result `modelUsage` is cumulative (like `total_cost_usd`, which
-            // we overwrite above), so keep the latest snapshot rather than summing —
-            // it is folded into the turn totals when the query settles (see
-            // `runQueryOnce`). Guard against a spuriously empty later result wiping a
-            // real earlier one.
-            const snapshot = queryModelUsage(own.modelUsage);
-            if (snapshot.size > 0) {
-                state.queryModelUsage = snapshot;
-            }
+            const ownCostUsd = recordCumulativeUsage(state, { totalCostUsd: msg.total_cost_usd, modelUsage: msg.modelUsage });
             await this.publishContextUsage(job, state, msg.modelUsage);
             // What a Session review returns. The SDK enforces the JSON schema, so this
             // either parses against the findings contract or the review failed to
@@ -1681,7 +1746,7 @@ export class BridgeJobExecutor {
                 await this.clearIfDirty(job, controls, state, "result_error");
                 throw resultError;
             }
-            return own.costUsd;
+            return ownCostUsd;
         }
         if (isUserVisibleSdkMessage(msg)) {
             state.sawUserVisibleSdkMessage = true;
@@ -2294,7 +2359,4 @@ function userTurnsBefore(job) {
         .trim();
     return said || undefined;
 }
-function joinReminders(...blocks) {
-    return blocks.filter((block) => block !== undefined).join("\n\n") || undefined;
-}
 //# sourceMappingURL=bridge-job.js.map