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

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";
@@ -28,17 +27,19 @@ import { buildAgentExtraBody, EXTRA_BODY_ENV, MODEL_CAPABILITIES_ENV, PER_TURN_E
 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";
 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) {
@@ -451,9 +452,9 @@ function turnUsage(state) {
     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 }
+        // 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 }
             : {}),
     };
 }
@@ -540,6 +541,64 @@ function hookSettingsForJob(job) {
  * 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"] };
@@ -1207,7 +1266,8 @@ export class BridgeJobExecutor {
     holdsNoWork;
     keepCliInStep;
     judge;
-    effortJudge;
+    routeJudge;
+    routeModels;
     constructor(dependencies) {
         this.sdk = dependencies.sdk;
         this.relay = dependencies.relay;
@@ -1233,12 +1293,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" }));
-        this.effortJudge =
-            dependencies.effortJudge ??
-                jevJudge(process.env.OPENROUTER_API_KEY, runtimeOpenRouterTags(process.env, { service: "bridge", feature: "bridge.effortRoute" }));
+        ({ judge: this.judge, routeJudge: this.routeJudge } = judgesOf(dependencies));
+        this.routeModels = dependencies.routeModels === true;
     }
     async execute(job, controls) {
         try {
@@ -1251,24 +1307,56 @@ export class BridgeJobExecutor {
         }
     }
     /**
-     * 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.
+     * 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 decideEffort(job, request) {
-        if (job.review) {
+    async askSignals(job, request) {
+        if (job.review || !needsSignals(this.turnFacts(job, request))) {
             return null;
         }
-        const lastReply = (job.history?.entries ?? []).filter((entry) => entry.role === "assistant").at(-1);
-        return await decideTurnEffort({
+        return await askTurnSignals({
             message: job.prompt,
-            previousReply: lastReply?.text ?? "",
-            judge: this.effortJudge,
+            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,
-        }).catch(() => ({ effort: DEFAULT_TURN_EFFORT, reason: "unjudged" }));
+        };
     }
     async executeTurn(job, controls) {
         const state = createBridgeJobState();
@@ -1282,7 +1370,7 @@ export class BridgeJobExecutor {
                 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 signals = this.askSignals(job, request);
             const loaded = await this.loadTrustedBoundary(job, controls);
             if (loaded?.kind !== "clean") {
                 request = await this.withContinuedAttachments(job, request);
@@ -1301,7 +1389,7 @@ export class BridgeJobExecutor {
             state.detachedSession = attempt.detachedSession === true;
             result.attemptedRehydration = attempt.attemptedRehydration;
             this.recordAttemptContextSource(job, attempt);
-            state.effortDecision = (await effortDecision) ?? undefined;
+            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);
         }
@@ -1310,8 +1398,8 @@ 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;
+                // 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);
@@ -1461,7 +1549,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.
@@ -1469,7 +1557,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) {
@@ -1849,12 +1937,7 @@ 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 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
@@ -1914,25 +1997,13 @@ export class BridgeJobExecutor {
             // 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,
+            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).
-            ...(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()],
-                }
-                : {}),
+            ...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() }) },
@@ -1945,7 +2016,7 @@ export class BridgeJobExecutor {
             // the workspace could not be read; omit rather than allowlist nothing.
             ...(skills ? { skills } : {}),
             disallowedTools: disallowedToolsFor(job),
-            ...withCredentialScrub(reviewQueryOptions(job), job),
+            ...withSubagentHooks(withCredentialScrub(reviewQueryOptions(job), job), await this.subagentHooksFor(job, state, sharedInstructions, model)),
             // 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.
@@ -1985,7 +2056,7 @@ export class BridgeJobExecutor {
                 // 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" } : {}),
+                ...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
@@ -1999,6 +2070,10 @@ export class BridgeJobExecutor {
                     .join("\n"),
                 // 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.
+                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(),