@koda-sl/baker-bridge 0.165.0 → 0.171.0-dev.289ff1b9d

package/dist/hono/bridge-job.js

@@ -23,11 +23,11 @@ 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 { BEDROCK_SERVABLE_CAPABILITIES, buildAgentExtraBody, EXTRA_BODY_ENV, MODEL_CAPABILITIES_ENV, } from "./openrouter-session.js";
+import { buildAgentExtraBody, EXTRA_BODY_ENV, MODEL_CAPABILITIES_ENV, PER_TURN_EFFORT_CAPABILITIES, } 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 } from "./served-model.js";
+import { alignServedModels, readConversationModel } 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";
@@ -35,8 +35,11 @@ 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 { 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") {
@@ -217,6 +220,13 @@ 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 +255,7 @@ function disallowedToolsFor(job) {
 function modelForJob(job, sessionModel) {
     return job.review?.model ?? sessionModel;
 }
-export const REVIEW_DISALLOWED_TOOLS = ["Edit", "Write", "MultiEdit", "NotebookEdit", "ExitPlanMode", "Skill"];
+export const REVIEW_DISALLOWED_TOOLS = ["Edit", "Write", "MultiEdit", "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
@@ -432,6 +442,19 @@ 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) {
@@ -508,6 +531,66 @@ 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" } : {};
+}
+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
@@ -1169,6 +1252,8 @@ export class BridgeJobExecutor {
     holdsNoWork;
     keepCliInStep;
     judge;
+    routeJudge;
+    routeModels;
     constructor(dependencies) {
         this.sdk = dependencies.sdk;
         this.relay = dependencies.relay;
@@ -1194,9 +1279,8 @@ export class BridgeJobExecutor {
         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" }));
+        ({ judge: this.judge, routeJudge: this.routeJudge } = judgesOf(dependencies));
+        this.routeModels = dependencies.routeModels === true;
     }
     async execute(job, controls) {
         try {
@@ -1208,6 +1292,45 @@ 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) === "",
+        });
+    }
+    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 };
@@ -1219,6 +1342,8 @@ 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);
@@ -1237,6 +1362,7 @@ 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);
         }
@@ -1245,6 +1371,8 @@ 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);
@@ -1394,7 +1522,7 @@ export class BridgeJobExecutor {
         return `${block}\n\n${job.prompt}`;
     }
     async runAttempt(job, controls, state, attempt) {
-        state.model = this.model;
+        state.model = state.turnRoute?.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.
@@ -1402,7 +1530,7 @@ export class BridgeJobExecutor {
         let current = attempt;
         for (let stallRetries = 0;;) {
             try {
-                costUsd += await this.runQueryOnce(job, controls, state, current, this.model);
+                costUsd += await this.runQueryOnce(job, controls, state, current, state.model);
                 break;
             }
             catch (error) {
@@ -1447,22 +1575,22 @@ export class BridgeJobExecutor {
         return { costUsd, attemptedRehydration: attempt.attemptedRehydration };
     }
     async finishSuccessfulAttempt(job, controls, state, costUsd) {
-        const modelUsage = turnModelUsageList(state.modelUsageTotals);
+        const usage = turnUsage(state);
         if (!controls.isActive()) {
             await this.clearIfDirty(job, controls, state, "abort");
-            return { kind: "cancelled", costUsd, model: state.model, modelUsage };
+            return { kind: "cancelled", costUsd, model: state.model, ...usage };
         }
         // 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, modelUsage, errors: [MODEL_REFUSAL_MESSAGE] };
+            return { kind: "errored", costUsd, model: state.model, ...usage, 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, modelUsage };
+            return { kind: "cancelled", costUsd, model: state.model, ...usage };
         }
         // 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
@@ -1479,7 +1607,7 @@ export class BridgeJobExecutor {
             kind: "completed",
             costUsd,
             model: state.model,
-            modelUsage,
+            ...usage,
             ...(workspaceUnchanged ? { workspaceUnchanged: true } : {}),
             cleanBoundary,
             ...(state.structuredOutput === undefined ? {} : { structuredOutput: state.structuredOutput }),
@@ -1487,7 +1615,7 @@ export class BridgeJobExecutor {
     }
     errorOutcome(job, controls, state, result, error) {
         const model = state.model;
-        const modelUsage = turnModelUsageList(state.modelUsageTotals);
+        const usage = turnUsage(state);
         if (result.attemptedRehydration) {
             void this.relay.contextSource({ threadId: job.threadId, turnId: job.turnId }, "rehydration_failed", {
                 historyEntryCount: job.history?.entries.length ?? 0,
@@ -1497,7 +1625,7 @@ export class BridgeJobExecutor {
             });
         }
         if (!controls.isActive()) {
-            return { kind: "cancelled", costUsd: result.costUsd, model, modelUsage };
+            return { kind: "cancelled", costUsd: result.costUsd, model, ...usage };
         }
         const shown = userFacingTurnError(error);
         if (shown !== errorMessage(error)) {
@@ -1507,7 +1635,7 @@ export class BridgeJobExecutor {
             kind: "errored",
             costUsd: result.costUsd,
             model,
-            modelUsage,
+            ...usage,
             errors: [shown],
         };
     }
@@ -1782,6 +1910,7 @@ 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
@@ -1817,6 +1946,7 @@ export class BridgeJobExecutor {
                 }
                 : {}),
             ...hookSettingsForJob(job),
+            ...instructionSettingsForJob(job, sharedInstructions),
         };
         const agentTags = runtimeOpenRouterTags(process.env, {
             service: "agent",
@@ -1836,15 +1966,17 @@ export class BridgeJobExecutor {
             // more per level than Opus 5, so compare `low` on real Sessions before
             // treating this as tuned.
             //
-            // 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",
+            // 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),
             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() }) },
@@ -1896,6 +2028,8 @@ 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
@@ -1907,8 +2041,8 @@ export class BridgeJobExecutor {
                 ANTHROPIC_CUSTOM_HEADERS: [process.env.ANTHROPIC_CUSTOM_HEADERS, anthropicCustomHeaders(agentTags.headers)]
                     .filter(Boolean)
                     .join("\n"),
-                // Without it no Opus 5.5 request can reach Bedrock; see openrouter-session.ts.
-                [MODEL_CAPABILITIES_ENV]: BEDROCK_SERVABLE_CAPABILITIES,
+                // Lets a turn change effort without losing the prompt cache; see openrouter-session.ts.
+                [MODEL_CAPABILITIES_ENV]: PER_TURN_EFFORT_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.
@@ -1990,6 +2124,7 @@ 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);