@bridge_gpt/mcp-server 0.2.62 → 0.2.66

package/build/review-tickets.js

@@ -3,12 +3,22 @@
  *
  * Reuses the `start-tickets` terminal spawn layer directly, running reviews in
  * the current `deps.cwd`. Intentionally does NOT create Worktrunk worktrees,
- * provision MCP registrations, run venv hooks, or perform difficulty/model-tier
- * routing. One terminal tab per ticket is spawned with `/review-ticket <KEY>
- * [--auto] [--rounds=<1|2>]` as the agent prompt. `--rounds` is OMITTED by
- * default so the backend's difficulty-adaptive review policy chooses the shape;
- * it is only forwarded when the caller passes an explicit `--rounds`/`--review`
- * round override.
+ * provision MCP registrations, or run venv hooks. One terminal tab per ticket
+ * is spawned with `/review-ticket <KEY> [--auto] [--rounds=<1|2>]` as the agent
+ * prompt. `--rounds` is OMITTED by default so the backend's difficulty-adaptive
+ * review policy chooses the shape; it is only forwarded when the caller passes
+ * an explicit `--rounds`/`--review` round override.
+ *
+ * BAPI-1343 — review-threshold model routing for spawned tabs: an explicit
+ * `--model` always wins and no tier lookup is made. Otherwise each ticket's
+ * `/tickets/{n}/model-tier?consumer=review` is fetched (the shared bounded
+ * `start-tickets` fetcher, at most 3 at once), and a tab gets `--model` only
+ * when the server echoes `consumer: "review"` and reports a threshold-decided
+ * (`configured` or `anomaly`) tier, mapped to an alias exactly as
+ * `start-tickets` maps it. Legacy mode, a failed or timed-out lookup, or an
+ * older server that does not echo the consumer passes no `--model` (today's
+ * behavior); there is no premium fallback. `--dry-run` makes no lookup, and the
+ * epic-dispatch path below is not re-routed.
  *
  * Optionally supports a supervisor-driven epic-dispatch path: when an
  * `EpicDispatchIdentity` is threaded through `ReviewTicketsOptions.epic`, each
@@ -18,7 +28,7 @@
  * This path is worktree-free and base-branch-free; the human CLI path leaves
  * `epic` unset and retains byte-for-byte identical behavior.
  */
-import { createDefaultStartTicketsDeps, detectTerminal, runWithConcurrency, buildAgentInvocation, shSquoteInner, powershellSquote, isCommandOnPath, resolveFirstCommandOnPath, tmuxSessionNameForTicket, TICKET_KEY_PATTERN, DEFAULT_MAX_PARALLEL, validateBranchName, fetchAndResolveBaseSha, fetchStartTicketsConfigField, resolveStartTicketsBridgeApiAccess, buildCommandProvisioningDeps, buildMcpProvisioningDeps, } from "./start-tickets.js";
+import { createDefaultStartTicketsDeps, detectTerminal, runWithConcurrency, buildAgentInvocation, shSquoteInner, powershellSquote, isCommandOnPath, resolveFirstCommandOnPath, tmuxSessionNameForTicket, TICKET_KEY_PATTERN, DEFAULT_MAX_PARALLEL, validateBranchName, fetchAndResolveBaseSha, fetchStartTicketsConfigField, resolveStartTicketsBridgeApiAccess, buildCommandProvisioningDeps, buildMcpProvisioningDeps, fetchTicketModelTiersForKeys, isThresholdDecidedTierResponse, normalizeDifficultyModelTierOverrides, fetchCodexModelCatalog, resolveRoutingAlias, validateResolvedModelAliasForAgent, } from "./start-tickets.js";
 import { provisionCommandsForWorktree } from "./command-provisioning.js";
 import { resolveCodexLaunchScope } from "./codex-launch-scope.js";
 import { WINDOWS_TERMINAL_COMMAND, WINDOWS_POWERSHELL_CANDIDATES, TMUX_COMMAND, isSupportedStartTicketsPlatform, unsupportedPlatformMessage, } from "./start-tickets-prereqs.js";
@@ -48,7 +58,7 @@ export function getReviewTicketsUsage() {
         "  --rounds=1|2                      Review depth: 1=single-pass, 2=full two-pass (default: adaptive — backend routes by difficulty)",
         "  --review KEY=auto,rounds=1        Per-ticket review mode override (repeatable)",
         "  --agent claude|cursor-agent|codex Agent command to launch in each tab (default: claude)",
-        "  --model VALUE                     Model alias to pass as --model to the agent (optional passthrough)",
+        "  --model VALUE                     Model alias for every tab (always wins). Unset: each tab is routed by the review threshold; legacy mode or an older server passes no --model",
         "  --max-parallel N                  Max tabs to spawn concurrently (default: 3)",
         "  --dry-run                         Print intended commands; creates no tabs and opens no sessions",
         "  --base-branch BRANCH              Base branch to fetch+pin for grounding (default: config base_branch, else \"main\")",
@@ -527,12 +537,125 @@ export function buildReviewPlanRows(deps, options, agent, status, overrides = {}
             rounds: mode.rounds,
             agentName: options.agentName,
             modelAlias: options.modelAlias,
+            // BAPI-1343: plan rows (the dry-run preview) never perform a tier lookup;
+            // they show only an explicit --model, or the agent default.
+            ...(!options.epic && options.modelAlias ? { modelRoutingReason: "explicit" } : {}),
             status,
             command,
             runId,
         };
     });
 }
+/**
+ * BAPI-1343 — resolve each spawned tab's model from the review threshold.
+ *
+ * One `/model-tier?consumer=review` request per key through the shared
+ * `start-tickets` fetcher (bounded at 3, never throws). A tab is routed only
+ * when the server echoes `consumer: "review"` AND reports a threshold-decided
+ * tier; the tier maps to an alias exactly as `start-tickets` maps it (registry
+ * plus `difficulty_model_tier_overrides`, read once per batch; the Codex
+ * catalog, fetched once per batch; `validateResolvedModelAliasForAgent`, run
+ * at most once per distinct alias per batch). Every other outcome returns
+ * `modelAlias: null` (no `--model`, today's behavior) — there is no premium
+ * fallback. Callers handle explicit `--model`, `--dry-run`, and epic dispatch
+ * before calling this, so it always performs lookups.
+ */
+export async function resolveReviewModelRoutingForKeys(deps, keys, agent, maxParallel) {
+    const decisions = new Map();
+    const noModel = (reason) => ({ modelAlias: null, reason });
+    let accessResult;
+    try {
+        accessResult = await resolveStartTicketsBridgeApiAccess(deps);
+    }
+    catch {
+        for (const key of keys)
+            decisions.set(key, noModel("lookup-failed"));
+        return decisions;
+    }
+    if (!accessResult.ok) {
+        for (const key of keys)
+            decisions.set(key, noModel("lookup-failed"));
+        return decisions;
+    }
+    const access = accessResult.access;
+    const tierMap = await fetchTicketModelTiersForKeys(access, keys, maxParallel, { consumer: "review" });
+    // Batch-scoped alias inputs, loaded lazily so a batch with no
+    // threshold-decided ticket makes no config/catalog request.
+    let aliasInputs = null;
+    const loadAliasInputs = () => {
+        if (!aliasInputs) {
+            aliasInputs = (async () => {
+                try {
+                    if (agent.name === "codex") {
+                        const catalogResult = await fetchCodexModelCatalog(access);
+                        return catalogResult.ok ? { overrides: null, catalog: catalogResult.catalog } : null;
+                    }
+                    const raw = await fetchStartTicketsConfigField(access, "difficulty_model_tier_overrides");
+                    return { overrides: normalizeDifficultyModelTierOverrides(raw), catalog: null };
+                }
+                catch {
+                    return null;
+                }
+            })();
+        }
+        return aliasInputs;
+    };
+    const validations = new Map();
+    const validateOnce = (alias) => {
+        let pending = validations.get(alias);
+        if (!pending) {
+            pending = validateResolvedModelAliasForAgent(deps, agent, alias).catch(() => ({ ok: false, warning: "model validation failed" }));
+            validations.set(alias, pending);
+        }
+        return pending;
+    };
+    for (const key of keys) {
+        const result = tierMap.get(key);
+        if (!result || !result.ok) {
+            decisions.set(key, noModel("lookup-failed"));
+            continue;
+        }
+        const value = result.value;
+        if (value.consumer !== "review") {
+            decisions.set(key, noModel("consumer-unrecognized"));
+            continue;
+        }
+        if (value.source === "fallback") {
+            // The server could not obtain a difficulty; its premium tier is a guess,
+            // and review routing has no premium fallback.
+            decisions.set(key, noModel("lookup-failed"));
+            continue;
+        }
+        if (!isThresholdDecidedTierResponse(value)) {
+            decisions.set(key, noModel("legacy"));
+            continue;
+        }
+        if (!value.tier) {
+            decisions.set(key, noModel("lookup-failed"));
+            continue;
+        }
+        if (!agent.supportsModelOverride) {
+            decisions.set(key, noModel("alias-unresolved"));
+            continue;
+        }
+        const inputs = await loadAliasInputs();
+        const candidate = inputs ? resolveRoutingAlias(agent, value.tier, inputs.overrides, inputs.catalog) : null;
+        if (!candidate) {
+            decisions.set(key, noModel("alias-unresolved"));
+            continue;
+        }
+        const validation = await validateOnce(candidate);
+        if (!validation.ok) {
+            decisions.set(key, noModel("alias-unresolved"));
+            continue;
+        }
+        decisions.set(key, {
+            modelAlias: validation.alias,
+            reason: value.thresholdMode === "anomaly" ? "review-threshold:anomaly" : "review-threshold:configured",
+        });
+    }
+    return decisions;
+}
 /** Build a dry-run preview base context from parsed CLI options only — never fetches. */
 function previewBaseContextFromOptions(options) {
     if (options.noRefreshBase)
@@ -590,10 +713,25 @@ export async function orchestrateReviewTickets(deps, options, overrides = {}) {
         return { ok: false, error: baseContextResult.error };
     }
     const baseContext = baseContextResult.context;
+    // BAPI-1343: per-tab review-threshold routing for the human CLI path only.
+    // An explicit --model wins with no lookup; the epic-dispatch path keeps its
+    // pre-feature shape (Epic workers take their tier from the stamped payload).
+    let routing = null;
+    if (!options.epic) {
+        if (options.modelAlias) {
+            routing = new Map(options.keys.map((key) => [key, { modelAlias: options.modelAlias ?? null, reason: "explicit" }]));
+        }
+        else {
+            routing = await resolveReviewModelRoutingForKeys(deps, options.keys, agent, options.maxParallel);
+        }
+    }
     const terminal = detectTerminal(undefined, deps.env);
     const rows = await runWithConcurrency(options.keys, options.maxParallel, async (key) => {
         const mode = resolveEffectiveReviewMode(key, options);
-        const baseShellCommand = buildReviewAgentShellCommand(agent, key, mode, deps.platform, deps.cwd, options.modelAlias, baseContext, codexLaunchArgs);
+        const decision = routing?.get(key);
+        const modelAlias = decision ? decision.modelAlias : options.modelAlias;
+        const reasonField = decision ? { modelRoutingReason: decision.reason } : {};
+        const baseShellCommand = buildReviewAgentShellCommand(agent, key, mode, deps.platform, deps.cwd, modelAlias, baseContext, codexLaunchArgs);
         let shellCommand = baseShellCommand;
         let runId;
         if (options.epic) {
@@ -608,7 +746,8 @@ export async function orchestrateReviewTickets(deps, options, overrides = {}) {
                         auto: mode.auto,
                         rounds: mode.rounds,
                         agentName: options.agentName,
-                        modelAlias: options.modelAlias,
+                        modelAlias,
+                        ...reasonField,
                         status: "spawn-failed",
                         command: shellCommand,
                         runId,
@@ -625,7 +764,8 @@ export async function orchestrateReviewTickets(deps, options, overrides = {}) {
                         auto: mode.auto,
                         rounds: mode.rounds,
                         agentName: options.agentName,
-                        modelAlias: options.modelAlias,
+                        modelAlias,
+                        ...reasonField,
                         status: "already-dispatched",
                         command: shellCommand,
                         runId,
@@ -645,7 +785,8 @@ export async function orchestrateReviewTickets(deps, options, overrides = {}) {
                     auto: mode.auto,
                     rounds: mode.rounds,
                     agentName: options.agentName,
-                    modelAlias: options.modelAlias,
+                    modelAlias,
+                    ...reasonField,
                     status: "spawned",
                     command: shellCommand,
                     runId,
@@ -687,9 +828,11 @@ export function formatReviewTicketsSummaryReport(rows) {
     const lines = ["Summary:"];
     for (const row of rows) {
         const modelPart = row.modelAlias ? row.modelAlias : "default";
+        // BAPI-1343: the closed, secret-free routing reason, when one was recorded.
+        const modelReasonPart = row.modelRoutingReason ? `  model_reason=${row.modelRoutingReason}` : "";
         const roundsPart = row.rounds !== undefined ? String(row.rounds) : "adaptive";
         const runIdPart = row.runId ? `  run_id=${row.runId}` : "";
-        lines.push(`${row.key}  auto=${row.auto}  rounds=${roundsPart}  agent=${row.agentName}  model=${modelPart}  status=${row.status}${runIdPart}`);
+        lines.push(`${row.key}  auto=${row.auto}  rounds=${roundsPart}  agent=${row.agentName}  model=${modelPart}${modelReasonPart}  status=${row.status}${runIdPart}`);
     }
     const failedRows = rows.filter((r) => r.status === "spawn-failed" || r.status === "already-dispatched");
     if (failedRows.length > 0) {

package/build/scripts/executor-protocol-contract-driver.js

@@ -45,7 +45,7 @@
 import { fileURLToPath } from "node:url";
 import path from "node:path";
 import fs from "node:fs";
-import { API, SymbolFlags } from "typescript/unstable/sync";
+import { API, SymbolFlags, TypeFlags } from "typescript/unstable/sync";
 import { isInterfaceDeclaration, isTypeAliasDeclaration } from "typescript/unstable/ast";
 import { createExecutorHttpClient, RECONCILER_LIVENESS_HEADER, HEARTBEAT_STOP_FIELD, } from "../executor/http-client.js";
 import { EXECUTOR_JOB_TYPE_VALUES, EXECUTOR_CLASSIFICATION_VALUES, EXECUTOR_MUTATION_OUTCOME_VALUES, RECONCILER_LIVENESS_VALUES, } from "../executor/types.js";
@@ -192,7 +192,15 @@ const PROJECTED_SHAPE_NAMES = [
     "ExecutorFailureWireRequest",
     "ExecutorProcessHeartbeatRequest",
 ];
-/** Return the closed string-literal members of *type*, or `undefined` when it is not one. */
+/**
+ * Return the closed string-literal members of *type*, or `undefined` when it is not one.
+ *
+ * `undefined`/`null` union members are skipped (BAPI-1301): an OPTIONAL
+ * literal property (`marker?: "a" | "b"`) is typed `"a" | "b" | undefined`
+ * under `strictNullChecks`, and its vocabulary is still exactly `["a", "b"]` —
+ * mirroring the Python side, which unwraps `Optional[Literal[...]]` before
+ * reading its members. Requiredness is compared separately.
+ */
 function literalValuesOf(type) {
     if (type.isStringLiteralType()) {
         return [type.value];
@@ -200,11 +208,13 @@ function literalValuesOf(type) {
     if (type.isUnionType()) {
         const values = [];
         for (const member of type.getTypes()) {
+            if (member.flags & (TypeFlags.Undefined | TypeFlags.Null))
+                continue;
             if (!member.isStringLiteralType())
                 return undefined;
             values.push(member.value);
         }
-        return values.sort();
+        return values.length > 0 ? values.sort() : undefined;
     }
     return undefined;
 }