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

package/dist/hono/bridge-job.js

@@ -29,7 +29,6 @@ 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;
@@ -152,11 +151,10 @@ 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",
-    // 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`).
+    // 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",
     // 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
@@ -500,9 +498,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 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
+// 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
 // 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
@@ -665,27 +663,9 @@ 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
@@ -707,10 +687,7 @@ const USAGE_READING_TIMEOUT_MS = 5_000;
 // 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, 
-// 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) {
+function createTurnEndController(job, query, closeQuery, timings, onTurnEvent) {
     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
@@ -723,52 +700,15 @@ beforeEndInput) {
     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 || ending || hasInFlightWork()) {
+        if (inputEnded || 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({
@@ -838,21 +778,15 @@ beforeEndInput) {
                 clearTimeout(settleTimer);
                 settleTimer = undefined;
             }
-            if (ending && (isModelActivity || hasInFlightWork())) {
-                ending.interrupted = true;
-            }
             if (exitGuard) {
                 exitGuard.refresh();
             }
         },
-        maybeEndAfter: (msg, refused) => {
+        maybeEndAfter: (msg) => {
             if (inputEnded) {
                 return;
             }
-            // 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)) {
+            if (msg.type === "result" && !msg.is_error) {
                 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})`);
@@ -869,10 +803,7 @@ beforeEndInput) {
                 scheduleEnd();
             }
         },
-        hasInFlightWork,
-        ranTasks: () => sawAnyTask,
         dispose: () => {
-            disposed = true;
             if (settleTimer) {
                 clearTimeout(settleTimer);
                 settleTimer = undefined;
@@ -964,7 +895,7 @@ export class BridgeJobExecutor {
     readUsageBaseline;
     stalledCliExitMs;
     readFlowTree;
-    settleWorkspace;
+    mainSync;
     constructor(dependencies) {
         this.sdk = dependencies.sdk;
         this.relay = dependencies.relay;
@@ -983,9 +914,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();
@@ -998,12 +929,10 @@ 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,
@@ -1034,6 +963,12 @@ 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);
@@ -1055,17 +990,34 @@ 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 verbatim = verbatimSlashCommand(job.prompt) ??
+        const bridgeCommand = verbatimSlashCommand(job.prompt);
+        const verbatim = bridgeCommand ??
             leadingSkillCommand(job.prompt, (await readSessionSkills(bridgeRuntimeFiles.projectRoot())) ?? []);
         let requestPrompt = verbatim ?? applyCurrentSenderAttribution(job.prompt, job.currentSender);
-        const reminder = verbatim === null ? currentReferenceReminder(job.currentReference) : undefined;
+        // 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);
         if (job.attachments && job.attachments.length > 0) {
-            requestPrompt += await this.prepareAttachments(job.attachments, "message");
+            requestPrompt += await this.prepareAttachments(job.attachments);
         }
         if (!controls.isActive()) {
             return null;
         }
-        return { prompt: requestPrompt, ...(reminder ? { reminder } : {}), leadingCommand: verbatim !== null };
+        return {
+            prompt: requestPrompt,
+            ...(reminder ? { reminder } : {}),
+            ...(recoveryReminder ? { recoveryReminder } : {}),
+            leadingCommand: verbatim !== null,
+        };
     }
     /**
      * The reviewer's prompt: the brief Convex wrote, with the evidence block this
@@ -1264,18 +1216,6 @@ 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 ||
@@ -1284,7 +1224,6 @@ 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,
@@ -1293,12 +1232,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 (rebuilt.leadingCommand) {
-            return { prompt: rebuilt.prompt, attemptedRehydration: false, resumeOptions: {} };
+        if (request.leadingCommand) {
+            return { prompt: request.prompt, attemptedRehydration: false, resumeOptions: {} };
         }
         return {
-            prompt: buildRehydratedPrompt(rebuilt.prompt, job.history),
-            ...(rebuilt.reminder ? { reminder: rebuilt.reminder } : {}),
+            prompt: buildRehydratedPrompt(request.prompt, job.history),
+            ...(request.recoveryReminder ? { reminder: request.recoveryReminder } : {}),
             attemptedRehydration: true,
             resumeOptions: {},
         };
@@ -1353,6 +1292,11 @@ 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
@@ -1578,19 +1522,7 @@ export class BridgeJobExecutor {
     // in-progress session.
     async drainQuery(job, controls, state, query, closeQuery) {
         const stallDetector = this.createStallDetector(job, controls, closeQuery);
-        // 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);
-            }
-        });
+        const turnEnd = createTurnEndController(job, query, closeQuery, { settleMs: this.turnEndSettleMs, exitGuardMs: this.turnEndExitGuardMs }, this.recordTurnEvent);
         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
@@ -1600,7 +1532,6 @@ 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);
                 }
@@ -1608,7 +1539,7 @@ export class BridgeJobExecutor {
                     consumeError = true;
                     throw error;
                 }
-                turnEnd.maybeEndAfter(msg, state.refusedWithoutFallback === true);
+                turnEnd.maybeEndAfter(msg);
                 if (!controls.isActive()) {
                     closeQuery();
                     break;
@@ -1623,8 +1554,6 @@ export class BridgeJobExecutor {
             throw error;
         }
         finally {
-            drained = true;
-            controls.setWorkInFlight?.(false);
             stallDetector.dispose();
             turnEnd.dispose();
             await this.openPendingCastingAtTurnEnd(job, controls);
@@ -1632,11 +1561,7 @@ export class BridgeJobExecutor {
         if (stallDetector.stalled() && controls.isActive()) {
             throw new StreamStallError();
         }
-        // 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);
+        return costUsd;
     }
     /**
      * Open a casting the turn recorded but never reached.
@@ -1729,7 +1654,17 @@ export class BridgeJobExecutor {
         }
         trackMainRequestUsage(state, msg);
         if (msg.type === "result") {
-            const ownCostUsd = recordCumulativeUsage(state, { totalCostUsd: msg.total_cost_usd, modelUsage: msg.modelUsage });
+            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;
+            }
             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
@@ -1746,7 +1681,7 @@ export class BridgeJobExecutor {
                 await this.clearIfDirty(job, controls, state, "result_error");
                 throw resultError;
             }
-            return ownCostUsd;
+            return own.costUsd;
         }
         if (isUserVisibleSdkMessage(msg)) {
             state.sawUserVisibleSdkMessage = true;
@@ -2359,4 +2294,7 @@ 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