@koda-sl/baker-bridge 0.168.0-dev.d78500250 → 0.169.0-dev.e03ffd565

package/dist/hono/bridge-job.js

@@ -15,7 +15,6 @@ import { CONNECTION_INPUT_TOOL_NAME, CONNECTION_PLATFORMS, connectedButNotLoaded
 import { messageContextTokens, pickContextWindow, streamEventContextUsage, turnContextUsage, } from "./context-usage.js";
 import { CREDENTIAL_INPUT_TOOL_NAME, normalizeCredentialInputToolInput, } from "./credential-input.js";
 import { credentialScrubHooks } from "./credential-scrub.js";
-import { DEFAULT_TURN_EFFORT, decideTurnEffort } from "./effort-route.js";
 import { agentStatedFlowMessage, FLOW_INPUT_TOOL_NAME, nodeTargetRefusals, normalizeFlowInputToolInput, readRawFlowTree, sanitizeFlowRequests, unknownFlowPrefillMessage, } from "./flow-input.js";
 import { writesInventedLogo } from "./invented-logo.js";
 import { jevJudge } from "./jev.js";
@@ -24,7 +23,7 @@ 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";
@@ -36,10 +35,8 @@ import { skillLanguageHooks } from "./skill-language.js";
 import { BridgeSlashCommands, leadingSkillCommand, verbatimSlashCommand } from "./slash-commands.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 { prepareSharedInstructions } from "./workspace-instructions.js";
 import { settleWorkspaceAfterTasks } from "./workspace-settle.js";
 export function parsePlanDecision(value) {
     if (!value || typeof value !== "object") {
@@ -220,13 +217,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
@@ -255,7 +245,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
@@ -442,19 +432,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 } : {}),
-        // An unjudged turn is left off: no decision on the record means Jev never answered.
-        ...(state.effortDecision && state.effortDecision.reason !== "unjudged"
-            ? { effortDecision: state.effortDecision }
-            : {}),
     };
 }
 function errorMessage(error) {
@@ -531,21 +508,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`).
- */
-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
@@ -1205,9 +1167,9 @@ export class BridgeJobExecutor {
     settleWorkspace;
     catchUpWithMain;
     holdsNoWork;
+    settleAfterPublish;
     keepCliInStep;
     judge;
-    effortJudge;
     constructor(dependencies) {
         this.sdk = dependencies.sdk;
         this.relay = dependencies.relay;
@@ -1230,15 +1192,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));
         this.judge =
             dependencies.judge ??
                 jevJudge(process.env.OPENROUTER_API_KEY, runtimeOpenRouterTags(process.env, { service: "bridge", feature: "bridge.toolCallGuard" }));
-        this.effortJudge =
-            dependencies.effortJudge ??
-                jevJudge(process.env.OPENROUTER_API_KEY, runtimeOpenRouterTags(process.env, { service: "bridge", feature: "bridge.effortRoute" }));
     }
     async execute(job, controls) {
         try {
@@ -1250,26 +1210,6 @@ export class BridgeJobExecutor {
             await this.inFlightTurns.clear(job.threadId, job.turnId).catch(() => undefined);
         }
     }
-    /**
-     * How hard the agent works on this turn (see `effort-route.ts`); null for a
-     * Session review, which keeps the default. Never throws: an unanswered judge
-     * is the default level.
-     */
-    async decideEffort(job, request) {
-        if (job.review) {
-            return null;
-        }
-        const lastReply = (job.history?.entries ?? []).filter((entry) => entry.role === "assistant").at(-1);
-        return await decideTurnEffort({
-            message: job.prompt,
-            previousReply: lastReply?.text ?? "",
-            judge: this.effortJudge,
-            planMode: job.planMode === true,
-            leadingCommand: request.leadingCommand,
-            unattended: job.unattended === true,
-            hasAttachments: (job.attachments?.length ?? 0) > 0,
-        }).catch(() => ({ effort: DEFAULT_TURN_EFFORT, reason: "unjudged" }));
-    }
     async executeTurn(job, controls) {
         const state = createBridgeJobState();
         let result = { costUsd: 0, attemptedRehydration: false };
@@ -1281,8 +1221,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 effortDecision = this.decideEffort(job, request);
             const loaded = await this.loadTrustedBoundary(job, controls);
             if (loaded?.kind !== "clean") {
                 request = await this.withContinuedAttachments(job, request);
@@ -1301,7 +1239,6 @@ export class BridgeJobExecutor {
             state.detachedSession = attempt.detachedSession === true;
             result.attemptedRehydration = attempt.attemptedRehydration;
             this.recordAttemptContextSource(job, attempt);
-            state.effortDecision = (await effortDecision) ?? undefined;
             result = await this.runAttempt(job, controls, state, attempt);
             return await this.finishSuccessfulAttempt(job, controls, state, result.costUsd);
         }
@@ -1310,8 +1247,6 @@ export class BridgeJobExecutor {
             if (repaired && controls.isActive()) {
                 const repairState = createBridgeJobState();
                 repairState.detachedSession = repaired.detachedSession === true;
-                // The same turn, so the same level: a changed one would re-write the cache.
-                repairState.effortDecision = state.effortDecision;
                 let repairResult = { costUsd: 0, attemptedRehydration: repaired.attemptedRehydration };
                 try {
                     repairResult = await this.runAttempt(job, controls, repairState, repaired);
@@ -1514,22 +1449,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
@@ -1542,11 +1477,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 }),
@@ -1554,7 +1495,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,
@@ -1564,7 +1505,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)) {
@@ -1574,7 +1515,7 @@ export class BridgeJobExecutor {
             kind: "errored",
             costUsd: result.costUsd,
             model,
-            ...usage,
+            modelUsage,
             errors: [shown],
         };
     }
@@ -1849,12 +1790,6 @@ export class BridgeJobExecutor {
         await this.alignResumedTranscript(attempt);
         const mcpServers = await this.resolveMcpServers(job);
         const skills = await readSessionSkills(bridgeRuntimeFiles.projectRoot());
-        const sharedInstructions = job.review
-            ? null
-            : await prepareSharedInstructions({
-                projectRoot: bridgeRuntimeFiles.projectRoot(),
-                contextDir: bridgeRuntimeFiles.instructionsDir(),
-            });
         const autoCompactWindow = autoCompactWindowForModel(model);
         const betas = betasForModel(model);
         // No `outputStyle`: the built-in `Concise` style was pinned here against Opus 5's
@@ -1890,7 +1825,6 @@ export class BridgeJobExecutor {
                 }
                 : {}),
             ...hookSettingsForJob(job),
-            ...instructionSettingsForJob(job, sharedInstructions),
         };
         const agentTags = runtimeOpenRouterTags(process.env, {
             service: "agent",
@@ -1910,29 +1844,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: state.effortDecision?.effort ?? DEFAULT_TURN_EFFORT,
+            // 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).
-            ...(sharedInstructions
-                ? {
-                    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()],
-                }
-                : {}),
             // `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() }) },
@@ -1984,8 +1904,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.
-                ...(sharedInstructions ? { CLAUDE_CODE_ADDITIONAL_DIRECTORIES_CLAUDE_MD: "1" } : {}),
                 // 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
@@ -1997,8 +1915,12 @@ 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.
+                CLAUDE_CODE_DISABLE_TERMINAL_TITLE: "1",
                 // The turn's message sender, so in-sandbox `baker` calls can scope to the acting user.
                 ...(job.currentSender?.userId ? { BAKER_ACTING_USER_ID: job.currentSender.userId } : {}),
                 ...subagentModelEnv(),
@@ -2076,7 +1998,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);