@koda-sl/baker-bridge 0.172.0-dev.b570aa3f2 → 0.172.0-dev.f1dc1ec56

package/dist/hono/bridge-job.js

@@ -1,6 +1,7 @@
 import { readdir, readFile, stat } from "node:fs/promises";
 import { homedir } from "node:os";
 import { isAbsolute, join, relative, resolve } from "node:path";
+import { BUILDER_DISALLOWED_TOOLS, BUILDER_SYSTEM_PROMPT, builderOutputHooks, } from "../builder/builder-turn.js";
 import { capDigestSections } from "../review/digest-bundle.js";
 import { buildReviewDigest, digestPaths } from "../review/evidence.js";
 import { renderEvidenceBlock } from "../review/evidence-block.js";
@@ -23,24 +24,20 @@ import { composioScopesToInvalidate, failedCustomServers, reportMcpInvalid, serv
 import { agentModelOverride, autoCompactWindowForModel, betasForModel, contextWindowForModel, } from "./model-capabilities.js";
 import { agentShellPrefixEnv, killFirstWrapper } from "./oom-priority.js";
 import { anthropicCustomHeaders, runtimeOpenRouterTags } from "./openrouter-attribution.js";
-import { buildAgentExtraBody, EXTRA_BODY_ENV, MODEL_CAPABILITIES_ENV, PER_TURN_EFFORT_CAPABILITIES, } from "./openrouter-session.js";
+import { BEDROCK_SERVABLE_CAPABILITIES, buildAgentExtraBody, EXTRA_BODY_ENV, MODEL_CAPABILITIES_ENV, } from "./openrouter-session.js";
 import { credentialReminder, currentReferenceReminder, kickoffBriefReminder } from "./prompt-context.js";
 import { publishLanguageReminder, publishRunReminder, publishStandingReminder } from "./publish-handoff.js";
 import { bridgeRuntimeFiles } from "./runtime-files.js";
-import { alignServedModels, readConversationModel } from "./served-model.js";
+import { alignServedModels } from "./served-model.js";
 import { applyCurrentSenderAttribution, buildCancelBoundary, buildCleanBoundary, buildRehydratedPrompt, compactionRetryAttempt, emptyInProgressSession, interruptedResumeAttempt, isCliResumeRefusal, isContextOverflowError, isResumeSessionError, observeInProgressSession, prepareSessionAttempt, stallContinuationAttempt, } from "./session-continuity.js";
 import { readSessionSkills } from "./session-skills.js";
 import { ownQueryUsage, readUsageBaseline } from "./session-usage-baseline.js";
 import { skillLanguageHooks } from "./skill-language.js";
 import { BridgeSlashCommands, leadingSkillCommand, verbatimSlashCommand } from "./slash-commands.js";
-import { readAgentDefinitions, subagentHooks } from "./subagent-route.js";
 import { createBakerUiServer, normalizeTagInputToolInput, sanitizeTagChanges, TAG_INPUT_TOOL_NAME, unknownPrefillMessage, } from "./tag-input.js";
 import { blockingToolDelegated, toolRunAsCommand } from "./tool-in-shell.js";
-import { ToolResultLedger } from "./tool-result-ledger.js";
 import { recordTurnEvent } from "./turn-events.js";
 import { addQueryModelUsage, queryModelUsage, turnModelUsageList } from "./turn-model-usage.js";
-import { askTurnSignals, needsSignals, routeTurn, } from "./turn-route.js";
-import { prepareSharedInstructions } from "./workspace-instructions.js";
 import { settleWorkspaceAfterTasks } from "./workspace-settle.js";
 export function parsePlanDecision(value) {
     if (!value || typeof value !== "object") {
@@ -221,13 +218,6 @@ 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",
-    // Developer tools: design-system sync, code-review findings, Jupyter edits.
-    // None was called once in 358 production chats (Oct 2026), and each
-    // definition rides every request whenever the CLI does not defer it —
-    // DesignSync's alone is ~9k characters.
-    "DesignSync",
-    "ReportFindings",
-    "NotebookEdit",
     // 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
@@ -245,7 +235,12 @@ function disallowedToolsFor(job) {
     // calls go through `reviewBashPolicy` — because each fails differently: a
     // route could be mis-scoped, a policy could miss a spelling, and a tool the
     // model cannot see cannot be reached at all.
-    return job.review ? [...BASE_DISALLOWED_TOOLS, ...REVIEW_DISALLOWED_TOOLS] : [...BASE_DISALLOWED_TOOLS];
+    if (job.review)
+        return [...BASE_DISALLOWED_TOOLS, ...REVIEW_DISALLOWED_TOOLS];
+    // A task has nobody to answer a question: it decides, or returns the question.
+    if (job.builder)
+        return [...BASE_DISALLOWED_TOOLS, ...BUILDER_DISALLOWED_TOOLS];
+    return [...BASE_DISALLOWED_TOOLS];
 }
 /**
  * A review is pinned to one model in the backend's constants, not to whatever
@@ -256,7 +251,7 @@ function disallowedToolsFor(job) {
 function modelForJob(job, sessionModel) {
     return job.review?.model ?? sessionModel;
 }
-export const REVIEW_DISALLOWED_TOOLS = ["Edit", "Write", "MultiEdit", "ExitPlanMode", "Skill"];
+export const REVIEW_DISALLOWED_TOOLS = ["Edit", "Write", "MultiEdit", "NotebookEdit", "ExitPlanMode", "Skill"];
 /**
  * The findings contract, enforced by the SDK rather than parsed back out of
  * prose. `structured_output` on the result message is what reaches Convex, and
@@ -267,10 +262,29 @@ export function reviewQueryOptions(job) {
         ? { outputFormat: { type: "json_schema", schema: job.review.outputSchema }, hooks: reviewOutputHooks() }
         : {};
 }
+/**
+ * A task's result contract, enforced by the SDK like the review's findings, under the task's own system
+ * prompt (`../builder/builder-turn.ts`). An ordinary turn keeps the empty one the SDK sends by default.
+ */
+export function builderQueryOptions(job) {
+    return job.builder
+        ? {
+            systemPrompt: BUILDER_SYSTEM_PROMPT,
+            outputFormat: { type: "json_schema", schema: job.builder.outputSchema },
+            hooks: builderOutputHooks(),
+        }
+        : {};
+}
+/** What shapes a turn's answer: a task's contract and prompt, the review's findings, or nothing. */
+function answerOptions(job) {
+    return job.builder ? builderQueryOptions(job) : reviewQueryOptions(job);
+}
 /** What the agent's model calls are for, as OpenRouter is told (`openrouter-attribution.ts`). */
 export function agentFeature(job) {
     if (job.review)
         return "chatReview.session";
+    if (job.builder)
+        return "builder.task";
     return job.planMode ? "agent.plan" : "agent.turn";
 }
 /**
@@ -443,19 +457,6 @@ function createBridgeJobState() {
         detachedSession: false,
         modelUsageTotals: new Map(),
         queryModelUsage: new Map(),
-        toolResults: new ToolResultLedger(),
-    };
-}
-/** What a finished turn reports about its spend: per-model usage and per-tool result sizes. */
-function turnUsage(state) {
-    const toolResults = state.toolResults.summary();
-    return {
-        modelUsage: turnModelUsageList(state.modelUsageTotals),
-        ...(toolResults.length > 0 ? { toolResults } : {}),
-        // Left off when nothing was decided: Jev never answered and the model is the Runtime's.
-        ...(state.turnRoute && !(state.turnRoute.reason === "unjudged" && state.turnRoute.modelReason === "fixed")
-            ? { turnRoute: state.turnRoute }
-            : {}),
     };
 }
 function errorMessage(error) {
@@ -532,79 +533,6 @@ function hookSettingsForJob(job) {
     }
     return {};
 }
-/**
- * Which instruction files a job loads as memory. A Session review loads none:
- * its brief has it read the rulebook as the Session had it (`git show
- * <sha>:CLAUDE.md`), since Publish may already have moved the working tree past
- * it, and the auto-loaded copy is ~24k tokens of the marketer's instructions
- * written cold and re-read on every review request. The client's agent loads
- * the workspace's `CLAUDE.md` itself only when it could not be split into the
- * shared system prompt (`prepareSharedInstructions`).
- */
-/** A Session review reads no CLAUDE.md, so it has nothing to share. */
-async function sharedInstructionsFor(job) {
-    if (job.review) {
-        return null;
-    }
-    return await prepareSharedInstructions({
-        projectRoot: bridgeRuntimeFiles.projectRoot(),
-        contextDir: bridgeRuntimeFiles.instructionsDir(),
-    });
-}
-function sharedInstructionOptions(sharedInstructions) {
-    if (!sharedInstructions) {
-        return {};
-    }
-    return {
-        systemPrompt: {
-            type: "preset",
-            preset: "claude_code",
-            append: sharedInstructions.shared,
-            // Recorded once per conversation, so a scaffold sync mid-chat cannot
-            // move the cached prefix under it; it lands at the next compaction.
-            snapshot: true,
-        },
-        additionalDirectories: [bridgeRuntimeFiles.instructionsDir()],
-    };
-}
-function bridgeJudge(feature) {
-    return jevJudge(process.env.OPENROUTER_API_KEY, runtimeOpenRouterTags(process.env, { service: "bridge", feature }));
-}
-function judgesOf(dependencies) {
-    return {
-        judge: dependencies.judge ?? bridgeJudge("bridge.toolCallGuard"),
-        routeJudge: dependencies.routeJudge ?? bridgeJudge("bridge.turnRoute"),
-    };
-}
-function sharedInstructionEnv(sharedInstructions) {
-    return sharedInstructions ? { CLAUDE_CODE_ADDITIONAL_DIRECTORIES_CLAUDE_MD: "1" } : {};
-}
-/** Appends `extra`'s hook matchers after the ones `options` already carries. */
-function withSubagentHooks(options, extra) {
-    const hooks = { ...(options.hooks ?? {}) };
-    for (const [event, matchers] of Object.entries(extra)) {
-        hooks[event] = [...(hooks[event] ?? []), ...matchers];
-    }
-    return { ...options, hooks };
-}
-function recordSubagentRoute(state, agentType, route) {
-    if (state.turnRoute) {
-        state.turnRoute.subagents = [...(state.turnRoute.subagents ?? []), { agentType, ...route }];
-    }
-}
-function turnEffortOf(state) {
-    return state.turnRoute?.effort ?? "medium";
-}
-/** The agent's last message in the chat, empty on its first turn. */
-function previousReplyOf(job) {
-    return (job.history?.entries ?? []).filter((entry) => entry.role === "assistant").at(-1)?.text ?? "";
-}
-function instructionSettingsForJob(job, sharedInstructions) {
-    if (job.review) {
-        return { claudeMdExcludes: ["**/CLAUDE.md"] };
-    }
-    return sharedInstructions ? { claudeMdExcludes: [join(bridgeRuntimeFiles.projectRoot(), "CLAUDE.md")] } : {};
-}
 // Carry a Runtime-wide model override down to the fan-out workers.
 //
 // The shared subagents pin themselves to Sonnet 5.5 in their own frontmatter (see
@@ -1264,10 +1192,9 @@ export class BridgeJobExecutor {
     settleWorkspace;
     catchUpWithMain;
     holdsNoWork;
+    settleAfterPublish;
     keepCliInStep;
     judge;
-    routeJudge;
-    routeModels;
     constructor(dependencies) {
         this.sdk = dependencies.sdk;
         this.relay = dependencies.relay;
@@ -1290,11 +1217,13 @@ export class BridgeJobExecutor {
         this.settleWorkspace = dependencies.settleWorkspace ?? (() => settleWorkspaceAfterTasks());
         this.catchUpWithMain = dependencies.catchUpWithMain;
         this.holdsNoWork = dependencies.holdsNoWork;
+        this.settleAfterPublish = dependencies.settleAfterPublish;
         this.keepCliInStep = dependencies.keepCliInStep;
         this.readFlowTree =
             dependencies.readFlowTree ?? ((flowSlug) => readRawFlowTree(bridgeRuntimeFiles.flowsDir(), flowSlug));
-        ({ judge: this.judge, routeJudge: this.routeJudge } = judgesOf(dependencies));
-        this.routeModels = dependencies.routeModels === true;
+        this.judge =
+            dependencies.judge ??
+                jevJudge(process.env.OPENROUTER_API_KEY, runtimeOpenRouterTags(process.env, { service: "bridge", feature: "bridge.toolCallGuard" }));
     }
     async execute(job, controls) {
         try {
@@ -1306,58 +1235,6 @@ export class BridgeJobExecutor {
             await this.inFlightTurns.clear(job.threadId, job.turnId).catch(() => undefined);
         }
     }
-    /**
-     * What Jev reads in this turn, asked while the boundary loads (~0.3 s). Null
-     * for a Session review, which keeps its own model and effort, and for a turn
-     * that decides without it. Never throws: an unanswered judge is no signal.
-     */
-    async askSignals(job, request) {
-        if (job.review || !needsSignals(this.turnFacts(job, request))) {
-            return null;
-        }
-        return await askTurnSignals({
-            message: job.prompt,
-            previousReply: previousReplyOf(job),
-            judge: this.routeJudge,
-        }).catch(() => null);
-    }
-    /** This turn's model and effort (see `turn-route.ts`); undefined for a Session review. */
-    async routeFor(job, request, attempt, signals) {
-        if (job.review) {
-            return undefined;
-        }
-        const resumed = attempt.resumeOptions.resume;
-        const sessionModel = resumed ? await readConversationModel(resumed, claudeConfigDir()) : undefined;
-        return routeTurn({
-            ...this.turnFacts(job, request),
-            signals: await signals,
-            defaultModel: this.model,
-            routeModels: this.routeModels,
-            ...(sessionModel ? { sessionModel } : {}),
-            startedChat: previousReplyOf(job) === "",
-        });
-    }
-    /** What this turn's subagents are given (see `subagent-route.ts`); nothing for a Session review. */
-    async subagentHooksFor(job, state, sharedInstructions, model) {
-        if (job.review) {
-            return {};
-        }
-        return subagentHooks({
-            instructions: sharedInstructions?.shared ?? null,
-            definitions: await readAgentDefinitions(bridgeRuntimeFiles.projectRoot()),
-            judge: this.routeModels ? this.routeJudge : null,
-            parentModel: model,
-            onRoute: (agentType, route) => recordSubagentRoute(state, agentType, route),
-        });
-    }
-    turnFacts(job, request) {
-        return {
-            planMode: job.planMode === true,
-            leadingCommand: request.leadingCommand,
-            unattended: job.unattended === true,
-            hasAttachments: (job.attachments?.length ?? 0) > 0,
-        };
-    }
     async executeTurn(job, controls) {
         const state = createBridgeJobState();
         let result = { costUsd: 0, attemptedRehydration: false };
@@ -1369,8 +1246,6 @@ export class BridgeJobExecutor {
             if (!request?.prompt || !controls.isActive()) {
                 return { kind: "cancelled", costUsd: 0, model: state.model };
             }
-            // Asked while the boundary loads, so the answer (~0.3 s) costs the turn no time.
-            const signals = this.askSignals(job, request);
             const loaded = await this.loadTrustedBoundary(job, controls);
             if (loaded?.kind !== "clean") {
                 request = await this.withContinuedAttachments(job, request);
@@ -1389,7 +1264,6 @@ export class BridgeJobExecutor {
             state.detachedSession = attempt.detachedSession === true;
             result.attemptedRehydration = attempt.attemptedRehydration;
             this.recordAttemptContextSource(job, attempt);
-            state.turnRoute = await this.routeFor(job, request, attempt, signals);
             result = await this.runAttempt(job, controls, state, attempt);
             return await this.finishSuccessfulAttempt(job, controls, state, result.costUsd);
         }
@@ -1398,8 +1272,6 @@ export class BridgeJobExecutor {
             if (repaired && controls.isActive()) {
                 const repairState = createBridgeJobState();
                 repairState.detachedSession = repaired.detachedSession === true;
-                // The same turn, so the same model and level: a change would re-write the cache.
-                repairState.turnRoute = state.turnRoute;
                 let repairResult = { costUsd: 0, attemptedRehydration: repaired.attemptedRehydration };
                 try {
                     repairResult = await this.runAttempt(job, controls, repairState, repaired);
@@ -1549,7 +1421,7 @@ export class BridgeJobExecutor {
         return `${block}\n\n${job.prompt}`;
     }
     async runAttempt(job, controls, state, attempt) {
-        state.model = state.turnRoute?.model ?? this.model;
+        state.model = this.model;
         // A stalled stream closes the wedged query and resumes the CLI session in
         // place — the turn survives a hung upstream request instead of dying at the
         // 30-minute session watchdog with all mid-turn work stranded.
@@ -1557,7 +1429,7 @@ export class BridgeJobExecutor {
         let current = attempt;
         for (let stallRetries = 0;;) {
             try {
-                costUsd += await this.runQueryOnce(job, controls, state, current, state.model);
+                costUsd += await this.runQueryOnce(job, controls, state, current, this.model);
                 break;
             }
             catch (error) {
@@ -1602,22 +1474,22 @@ export class BridgeJobExecutor {
         return { costUsd, attemptedRehydration: attempt.attemptedRehydration };
     }
     async finishSuccessfulAttempt(job, controls, state, costUsd) {
-        const usage = turnUsage(state);
+        const modelUsage = turnModelUsageList(state.modelUsageTotals);
         if (!controls.isActive()) {
             await this.clearIfDirty(job, controls, state, "abort");
-            return { kind: "cancelled", costUsd, model: state.model, ...usage };
+            return { kind: "cancelled", costUsd, model: state.model, modelUsage };
         }
         // No boundary is handed back, so the refused exchange never becomes part of
         // the conversation the next message resumes.
         if (state.refusedWithoutFallback) {
-            return { kind: "errored", costUsd, model: state.model, ...usage, errors: [MODEL_REFUSAL_MESSAGE] };
+            return { kind: "errored", costUsd, model: state.model, modelUsage, errors: [MODEL_REFUSAL_MESSAGE] };
         }
         if (!state.postedAssistantEvent && state.turnText.length > 0) {
             await this.postSyntheticAssistantEvent(job, state);
         }
         if (!controls.isActive()) {
             await this.clearIfDirty(job, controls, state, "abort");
-            return { kind: "cancelled", costUsd, model: state.model, ...usage };
+            return { kind: "cancelled", costUsd, model: state.model, modelUsage };
         }
         // A detached turn (publish) ran in a session of its own. Handing that session
         // back as the thread's boundary would make the next chat message resume a
@@ -1630,11 +1502,17 @@ export class BridgeJobExecutor {
         // `closeRunThatChangedNothing`), and only the Runtime can vouch for its files.
         // Never after a publish turn: that one settles the chat itself.
         const workspaceUnchanged = !state.detachedSession && !job.review && this.holdsNoWork !== undefined && (await this.holdsNoWork());
+        // A publish turn's push is settled before the chat goes on: its next turn starts from what went live.
+        if (state.detachedSession) {
+            await this.settleAfterPublish?.().catch((error) => {
+                console.error(`[BridgeJob] could not settle the publish for ${job.threadId}`, error);
+            });
+        }
         return {
             kind: "completed",
             costUsd,
             model: state.model,
-            ...usage,
+            modelUsage,
             ...(workspaceUnchanged ? { workspaceUnchanged: true } : {}),
             cleanBoundary,
             ...(state.structuredOutput === undefined ? {} : { structuredOutput: state.structuredOutput }),
@@ -1642,7 +1520,7 @@ export class BridgeJobExecutor {
     }
     errorOutcome(job, controls, state, result, error) {
         const model = state.model;
-        const usage = turnUsage(state);
+        const modelUsage = turnModelUsageList(state.modelUsageTotals);
         if (result.attemptedRehydration) {
             void this.relay.contextSource({ threadId: job.threadId, turnId: job.turnId }, "rehydration_failed", {
                 historyEntryCount: job.history?.entries.length ?? 0,
@@ -1652,7 +1530,7 @@ export class BridgeJobExecutor {
             });
         }
         if (!controls.isActive()) {
-            return { kind: "cancelled", costUsd: result.costUsd, model, ...usage };
+            return { kind: "cancelled", costUsd: result.costUsd, model, modelUsage };
         }
         const shown = userFacingTurnError(error);
         if (shown !== errorMessage(error)) {
@@ -1662,7 +1540,7 @@ export class BridgeJobExecutor {
             kind: "errored",
             costUsd: result.costUsd,
             model,
-            ...usage,
+            modelUsage,
             errors: [shown],
         };
     }
@@ -1937,7 +1815,6 @@ export class BridgeJobExecutor {
         await this.alignResumedTranscript(attempt);
         const mcpServers = await this.resolveMcpServers(job);
         const skills = await readSessionSkills(bridgeRuntimeFiles.projectRoot());
-        const sharedInstructions = await sharedInstructionsFor(job);
         const autoCompactWindow = autoCompactWindowForModel(model);
         const betas = betasForModel(model);
         // No `outputStyle`: the built-in `Concise` style was pinned here against Opus 5's
@@ -1973,7 +1850,6 @@ export class BridgeJobExecutor {
                 }
                 : {}),
             ...hookSettingsForJob(job),
-            ...instructionSettingsForJob(job, sharedInstructions),
         };
         const agentTags = runtimeOpenRouterTags(process.env, {
             service: "agent",
@@ -1993,17 +1869,15 @@ export class BridgeJobExecutor {
             // more per level than Opus 5, so compare `low` on real Sessions before
             // treating this as tuned.
             //
-            // A changed top-level effort alone re-writes the cached conversation from
-            // its first tool exchange onward. It may differ between turns only because
-            // the CLI also restates it per message (`PER_TURN_EFFORT_CAPABILITIES`),
-            // which keeps the cache; prose is no substitute.
-            effort: turnEffortOf(state),
+            // MUST stay a single constant. The resolved effort is rendered into the
+            // prompt, so changing it between requests invalidates every cache
+            // breakpoint above it — on a session carrying hundreds of thousands of
+            // tokens that re-write costs far more than any per-turn tuning saves.
+            // Vary it per message only once the route accepts per-message effort
+            // (see `BEDROCK_SERVABLE_CAPABILITIES`); prose is no substitute.
+            effort: "medium",
             cwd: process.cwd(),
             settingSources: ["project"],
-            // The scaffold's CLAUDE.md, minus its `@COMPANY.md` import, as the system
-            // prompt, so every chat reads one cached copy instead of writing its own;
-            // the import loads from `instructionsDir` (see workspace-instructions.ts).
-            ...sharedInstructionOptions(sharedInstructions),
             // `baker_ui` hosts in-process interactive dashboard tools (secure tag
             // form). Always present; HTTP (Composio) servers merge alongside it.
             mcpServers: { ...(mcpServers ?? {}), baker_ui: createBakerUiServer({ credentials: credentialsEnabled() }) },
@@ -2016,7 +1890,7 @@ export class BridgeJobExecutor {
             // the workspace could not be read; omit rather than allowlist nothing.
             ...(skills ? { skills } : {}),
             disallowedTools: disallowedToolsFor(job),
-            ...withSubagentHooks(withCredentialScrub(reviewQueryOptions(job), job), await this.subagentHooksFor(job, state, sharedInstructions, model)),
+            ...withCredentialScrub(answerOptions(job), job),
             // Never omitted: since SDK 0.3.286 an omitted mode starts a third-party-provider
             // session (OpenRouter) in auto mode, where a classifier rather than `canUseTool`
             // decides tool calls.
@@ -2055,8 +1929,6 @@ export class BridgeJobExecutor {
                 // they are never TTY-gated, so every help read the agent does inside
                 // the sandbox pays ~5-10% of its tokens on colour codes it can't see.
                 NO_COLOR: "1",
-                // Loads the `CLAUDE.md` in `instructionsDir`, which imports COMPANY.md.
-                ...sharedInstructionEnv(sharedInstructions),
                 // Pin the conversation to one OpenRouter provider instance so the
                 // instance-scoped prompt cache is actually re-read across the turn's
                 // many tool-call requests. Merged into every model request body by the
@@ -2068,8 +1940,8 @@ export class BridgeJobExecutor {
                 ANTHROPIC_CUSTOM_HEADERS: [process.env.ANTHROPIC_CUSTOM_HEADERS, anthropicCustomHeaders(agentTags.headers)]
                     .filter(Boolean)
                     .join("\n"),
-                // Lets a turn change effort without losing the prompt cache; see openrouter-session.ts.
-                [MODEL_CAPABILITIES_ENV]: PER_TURN_EFFORT_CAPABILITIES,
+                // Without it no Opus 5.5 request can reach Bedrock; see openrouter-session.ts.
+                [MODEL_CAPABILITIES_ENV]: BEDROCK_SERVABLE_CAPABILITIES,
                 // The CLI names each session with a second, structured-output request on the
                 // turn's model. OpenRouter's Bedrock cannot serve that, so it was billed to
                 // OpenRouter credits on Azure or Vertex, and nothing in Baker reads the name.
@@ -2151,7 +2023,6 @@ export class BridgeJobExecutor {
             for await (const msg of query) {
                 stallDetector.observeMessage(msg);
                 turnEnd.observeMessage(msg);
-                state.toolResults.observe(msg);
                 controls.setWorkInFlight?.(stallDetector.hasPendingToolUses() || turnEnd.hasInFlightWork());
                 try {
                     costUsd = await this.consumeSdkMessage(job, controls, state, msg, costUsd);