@mupt-ai/dari-gateway 0.3.1 → 0.3.3

package/src/providers/execution.ts

@@ -58,11 +58,8 @@ import {
 export type ProviderChoice = {
   decision: RoutingDecision;
   execution: ProviderExecution;
-  role: "primary" | "fallback";
 };
 
-export type ResolveFallbackChoice = () => Promise<ProviderChoice | null>;
-
 export type PreparedStreamExecution = {
   choice: ProviderChoice;
   started: StartedStream;
@@ -86,7 +83,6 @@ export async function executeNonStreaming(args: {
   interaction: InteractionRequest;
   primary: ProviderChoice;
   primaryRetries: number;
-  resolveFallback: ResolveFallbackChoice;
   reporter: RoutedRuntimeReporter;
   protocol: RoutedProtocol;
   startedCompletion?: StartedCompletion;
@@ -111,7 +107,6 @@ export async function completeNonStreaming(args: {
   interaction: InteractionRequest;
   primary: ProviderChoice;
   primaryRetries: number;
-  resolveFallback: ResolveFallbackChoice;
   reporter: RoutedRuntimeReporter;
   protocol: RoutedProtocol;
   startedCompletion?: StartedCompletion;
@@ -157,7 +152,7 @@ export async function completeNonStreaming(args: {
       output,
       modelCost: args.reporter.modelCost({
         model: choice.decision.selectedModel, reasoning_effort: choice.decision.reasoningEffort,
-        role: choice.role, attempt: result.attempt, outcome: "completed", billingOutcome: "completed",
+        attempt: result.attempt, outcome: "completed", billingOutcome: "completed",
         execution: reportedExecution(choice.execution), message: completion.message,
       }),
       request: args.interaction,
@@ -231,7 +226,6 @@ async function completeWithRetries(args: {
   interaction: InteractionRequest;
   primary: ProviderChoice;
   primaryRetries: number;
-  resolveFallback: ResolveFallbackChoice;
   reporter: RoutedRuntimeReporter;
   startedCompletion?: StartedCompletion;
   clientSignal?: AbortSignal;
@@ -239,7 +233,6 @@ async function completeWithRetries(args: {
   return runProviderAttemptPlan({
     primary: args.primary,
     retries: args.primaryRetries,
-    resolveFallback: args.resolveFallback,
     primaryInitial: args.startedCompletion,
     isCustomerCanceled: () => customerAbortRequested(args.clientSignal),
     canceledFailure: customerCanceledProviderMessage,
@@ -459,7 +452,6 @@ export async function prepareStreamingExecution(args: {
   interaction: InteractionRequest;
   primary: ProviderChoice;
   primaryRetries: number;
-  resolveFallback: ResolveFallbackChoice;
   reporter: RoutedRuntimeReporter;
   startedStream?: StartedStream;
   initialError?: unknown;
@@ -475,7 +467,6 @@ export async function prepareStreamingExecution(args: {
   const result = await runProviderAttemptPlan({
     primary: args.primary,
     retries: args.primaryRetries,
-    resolveFallback: args.resolveFallback,
     primaryInitial,
     isCustomerCanceled: () => customerAbortRequested(args.clientSignal),
     canceledFailure: customerCanceledProviderMessage,
@@ -537,7 +528,7 @@ async function runStreamSetupAttempt(args: {
           clientSignal: args.clientSignal,
         });
     // Prime before committing so connection failures and prompt rejections
-    // stay inside the one shared retry/fallback state machine.
+    // stay inside the one shared retry state machine.
     const primed = await primeProviderStream(
       started.providerStream.events,
       started.customerAbort,
@@ -611,7 +602,6 @@ export async function executeStreaming(args: {
     protocol: args.protocol,
     providerLatencyMs: () =>
       args.failedSetupLatencyMs + Date.now() - started.providerStartedMs,
-    role: args.choice.role,
     attempt: args.attempt,
     reportBarrier: args.reportBarrier,
     delivered: observed.delivered,
@@ -630,7 +620,7 @@ export async function executeStreaming(args: {
       clientSignal: args.clientSignal,
       modelCost: (message, failed) => args.reporter.modelCost({
         model: args.choice.decision.selectedModel, reasoning_effort: args.choice.decision.reasoningEffort,
-        role: args.choice.role, attempt: args.attempt,
+        attempt: args.attempt,
         outcome: failed ? "terminal_error" : "completed",
         billingOutcome: failed ? "provider_failed" : "completed",
         execution: reportedExecution(execution), message,
@@ -673,7 +663,6 @@ function recordProviderAttempt(
   reporter.recordProviderAttempt({
     model: choice.decision.selectedModel,
     reasoning_effort: choice.decision.reasoningEffort,
-    role: choice.role,
     attempt,
     outcome,
     execution: reportedExecution(choice.execution),
@@ -720,7 +709,8 @@ async function providerFailedAttempt(
   }
   // Retrying an exhausted plan cannot succeed. The platform learns about it
   // before this request returns so the next resolve already serves the
-  // user's next subscription, or the router's subscription fallback model.
+  // user's next subscription, or the model's API credential when the router
+  // allows subscription API fallback for it.
   const switched = execution.subscriptionUserId !== undefined
     && await holdSubscription({
       userId: execution.subscriptionUserId,

package/src/providers/pi_output.ts

@@ -411,7 +411,7 @@ function reasoningText(value: unknown, type: "summary_text" | "reasoning_text"):
   );
 }
 
-function textSignature(value: unknown): { id?: string; phase?: "commentary" | "final_answer" } | null {
+export function textSignature(value: unknown): { id?: string; phase?: "commentary" | "final_answer" } | null {
   if (typeof value !== "string" || !value) return null;
   try {
     const parsed: unknown = JSON.parse(value);

package/src/providers/provider_attempt_runner.ts

@@ -31,7 +31,6 @@ export type ProviderAttemptPlanResult<TChoice, TValue> = {
 type RunProviderAttemptPlanArgs<TChoice, TValue, TInitial> = {
   primary: TChoice;
   retries: number;
-  resolveFallback: () => Promise<TChoice | null>;
   primaryInitial?: TInitial;
   isCustomerCanceled: (choice: TChoice) => boolean;
   canceledFailure: () => Record<string, unknown>;
@@ -51,8 +50,8 @@ type ChoiceResult<TChoice, TValue> = ProviderAttemptPlanResult<TChoice, TValue>;
 
 /**
  * Owns the order-sensitive provider plan shared by completion and stream setup:
- * retries within one choice, cancellation fences around asynchronous fallback
- * resolution, and one contiguous attempt record for every failed dispatch.
+ * retries within the choice, cancellation fences between attempts, and one
+ * contiguous attempt record for every failed dispatch.
  */
 export async function runProviderAttemptPlan<TChoice, TValue, TInitial>(
   args: RunProviderAttemptPlanArgs<TChoice, TValue, TInitial>,
@@ -62,29 +61,19 @@ export async function runProviderAttemptPlan<TChoice, TValue, TInitial>(
   }
   const primary = await runChoice(args, args.primary, args.primaryInitial);
   if (primary.kind !== "provider_failed") return primary;
-  // The user's next subscription serves a retry of this same choice, which
-  // beats a fallback model billed elsewhere.
+  // The user's next subscription serves the client's retry of this choice, so
+  // the failure stands even if the client has already gone.
   if (subscriptionUsageLimitFromFailure(primary.failure)?.switched === true) return primary;
-  // A disconnect before or during fallback resolution stays attributed to the
-  // primary: it is the only choice that was dispatched, and a resolved but
-  // undispatched fallback must not appear as the serving model.
-  const canceledAfterPrimary = () =>
-    syntheticCancellation(args, {
+  // A client that disconnected while the plan settled is a cancellation,
+  // attributed to the only choice that was dispatched.
+  if (args.isCustomerCanceled(args.primary)) {
+    return syntheticCancellation(args, {
       choice: args.primary,
       attempt: primary.attempt + 1,
       latencyMs: primary.latencyMs,
     });
-  if (args.isCustomerCanceled(args.primary)) return canceledAfterPrimary();
-
-  const fallback = await args.resolveFallback();
-  if (args.isCustomerCanceled(args.primary)) return canceledAfterPrimary();
-  if (fallback === null) return primary;
-
-  const fallbackResult = await runChoice(args, fallback, undefined);
-  return {
-    ...fallbackResult,
-    latencyMs: primary.latencyMs + fallbackResult.latencyMs,
-  };
+  }
+  return primary;
 }
 
 async function runChoice<TChoice, TValue, TInitial>(

package/src/providers/provider_call.ts

@@ -33,6 +33,7 @@ import type {
   ProviderKeySource,
   ResolvedRouter,
   ResolvedRouterModelConfig,
+  ServedDecision,
 } from "../types.js";
 import { awsRoleCredentials } from "./aws_assume_role.js";
 import {
@@ -97,7 +98,7 @@ export type StartedStream = {
 };
 
 export function prepareProviderExecution(args: {
-  decision: RoutingDecision;
+  decision: ServedDecision;
   credentials: ResolvedRouter;
   billable: boolean;
   routerId: string;
@@ -174,6 +175,7 @@ export function prepareProviderExecution(args: {
       ...(args.decision.leaseTurnsRemaining === undefined
         ? {}
         : { "X-Dari-Lease-Turns-Remaining": String(args.decision.leaseTurnsRemaining) }),
+      ...(args.decision.sessionPinned === true ? { "X-Dari-Session-Pinned": "true" } : {}),
     },
   };
 }

package/src/providers/stream_finalization.ts

@@ -50,7 +50,6 @@ type CreateStreamFinalizerArgs = {
   reporter: RoutedRuntimeReporter;
   protocol: RoutedProtocol;
   providerLatencyMs: () => number;
-  role: "primary" | "fallback";
   attempt: number;
   reportBarrier?: Promise<unknown>;
   delivered: () => DeliveredOutput;
@@ -171,7 +170,6 @@ function buildStreamTerminalReport(
   const attemptBase = {
     model: args.decision.selectedModel,
     reasoning_effort: args.decision.reasoningEffort,
-    role: args.role,
     attempt: args.attempt,
     execution,
   } as const;

package/src/providers/subscription_limits.ts

@@ -11,7 +11,7 @@ export type SubscriptionUsageLimit = {
   resetsAt: Date;
   reason: string;
   // The platform made the user's next subscription active, so a retry
-  // succeeds without any fallback.
+  // succeeds on it.
   switched?: boolean;
 };
 

package/src/runtime/claude_code/auxiliary_routing.ts

@@ -9,7 +9,6 @@ import { isBackgroundRequest } from "../../interaction/types.js";
 import { HttpError } from "../../http/errors.js";
 import { assertCreditAvailableBeforeRouting } from "../../telemetry/usage.js";
 import type { PreparedRoutedCompletion } from "../prepare_routed_completion.js";
-import { leaseFallbackDecision } from "../routing_lease.js";
 
 // Explicit background classes bypass the selector and every lease path.
 // Keep the existing deterministic cheapest-input-cost serving policy.
@@ -30,13 +29,7 @@ export function auxiliaryDecision(
     reasoningEffort: cheapest.reasoning_effort,
     reason: `${requestClass} request served by the cheapest routable model without selection.`,
   };
-  const fallbackDecision = leaseFallbackDecision({
-    candidates: prepared.routing.candidateResolution.candidates,
-    decision,
-    credentials: prepared.credentials,
-  });
-  if (fallbackDecision) prepared.reporter.attachFallbackDecision(fallbackDecision);
-  return fallbackDecision ? { decision, fallbackDecision } : { decision };
+  return { decision };
 }
 
 /* Ranked on estimated input cost: these requests carry a whole transcript in

package/src/runtime/explicit_model.ts

@@ -6,7 +6,7 @@ import type { RoutedDecision } from "../strategies/route_decision.js";
 import type { PreparedRoutedCompletion } from "./prepare_routed_completion.js";
 
 /* A request for `dari/model/<id>` is served by exactly that enabled model,
-   with no selector, lease, or fallback: the user chose it, like picking a
+   with no selector or lease: the user chose it, like picking a
    model in their agent's /model menu. The client's thinking level is kept
    when the model supports it; otherwise the model's default level is used. */
 export function explicitModelDecision(

package/src/runtime/harness_identity/conversation.ts

@@ -19,6 +19,11 @@ export type HarnessConversationIdentity =
       kind: "openai_chat_session";
       value: string;
       qualifiers?: string[];
+    }
+  | {
+      kind: "muse_code_thread";
+      value: string;
+      qualifiers?: string[];
     };
 
 export type HarnessConversationScope = {
@@ -46,6 +51,17 @@ export function scopedHarnessSessionId(args: {
   return scopedHarnessId({ ...args, identity });
 }
 
+// One agent of a session: the main agent on the bare session, each subagent
+// on its own qualifier or thread. Unlike the conversation id, it survives
+// compaction.
+export function scopedHarnessAgentId(args: {
+  identity: HarnessConversationIdentity;
+  sourceProtocol: SourceProtocol;
+  scope: HarnessConversationScope;
+}): string {
+  return scopedHarnessId(args);
+}
+
 export function scopedHarnessConversationId(args: {
   identity: HarnessConversationIdentity;
   sourceProtocol: SourceProtocol;

package/src/runtime/harness_identity/extract.ts

@@ -14,11 +14,10 @@ export function chatCompletionsConversationIdentity(
   headers: Headers,
   promptCacheKey?: string,
 ): HarnessConversationIdentity | undefined {
-  // x-session-affinity is the authoritative Chat Completions identity.
-  // Fall back to prompt_cache_key from the request body for callers that
-  // send a stable cache key without the affinity header, so append-only
-  // sessions (growing message history) stay grouped under one conversation.
-  const sessionId = boundedIdentity(
+  // Pi summaries use fresh cache/affinity IDs. Its explicit session header
+  // groups them with the main turns without changing provider cache affinity.
+  // Other callers use x-session-affinity, falling back to prompt_cache_key.
+  const sessionId = boundedIdentity(headers.get("x-pi-session-id"), "x-pi-session-id") ?? boundedIdentity(
     headers.get("x-session-affinity"),
     "x-session-affinity",
   ) ?? boundedIdentity(promptCacheKey, "prompt_cache_key");
@@ -34,6 +33,16 @@ export function chatCompletionsConversationIdentity(
   };
 }
 
+export function piRequestContext(headers: Headers): AgentRequestContext | undefined {
+  if (boundedIdentity(headers.get("x-pi-session-id"), "x-pi-session-id") === undefined) {
+    return undefined;
+  }
+  const kind = headers.get("x-pi-request-kind")?.trim();
+  return {
+    requestClass: kind === "turn" ? "main" : kind === "compaction" ? "compaction" : "unknown",
+  };
+}
+
 // OpenCode names the session behind every request, and a subagent's parent
 // session too. The `dari opencode` plugin adds the request kind and agent,
 // which OpenCode does not send itself. Like Claude Code's headers, these are
@@ -174,6 +183,16 @@ export function codexRequestContext(
   };
 }
 
+// Muse Code sends its thread on every Responses request. The main agent's
+// thread is its session, and each subagent has its own thread, so each keeps
+// its own conversation and lease.
+export function museCodeConversationIdentity(
+  headers: Headers,
+): HarnessConversationIdentity | undefined {
+  const threadId = boundedIdentity(headers.get("x-tbh-thread-id"), "x-tbh-thread-id");
+  return threadId === undefined ? undefined : { kind: "muse_code_thread", value: threadId };
+}
+
 export function claudeCodeConversationIdentity(
   headers: Headers,
   metadataSessionId?: string,

package/src/runtime/harness_identity/index.ts

@@ -1,4 +1,5 @@
 export {
+  scopedHarnessAgentId,
   scopedHarnessConversationId,
   scopedHarnessSessionId,
   type HarnessConversationIdentity,
@@ -10,5 +11,7 @@ export {
   codexConversationIdentity,
   codexRequestPurpose,
   codexRequestContext,
+  museCodeConversationIdentity,
   openCodeRequestContext,
+  piRequestContext,
 } from "./extract.js";

package/src/runtime/prepare_routed_completion.ts

@@ -10,7 +10,8 @@ import {
 import { isBackgroundRequest, type InteractionRequest } from "../interaction/types.js";
 import { executionProviderForModel } from "../models/execution_provider.js";
 import { codexModelConfig, subscriptionServes } from "../models/subscriptions.js";
-import { gatewayPlatform, type RequestTags } from "../platform/platform.js";
+import { explicitModelId } from "../protocol/input/router_model.js";
+import { gatewayPlatform, type RequestTags, type SessionPin } from "../platform/platform.js";
 import { resolveRouter } from "../strategies/routing.js";
 import { RequestReporter, type ReportedCandidatePruning } from "../telemetry/report.js";
 import { RoutingBillingFinalization } from "../telemetry/billing_finalization.js";
@@ -20,6 +21,7 @@ import { strictProviderAccess } from "./strict_provider_access.js";
 import type { RoutedRuntimeReporter } from "./runtime_reporter.js";
 import type { RoutedProtocol } from "./routed_protocol.js";
 import {
+  scopedHarnessAgentId,
   scopedHarnessConversationId,
   scopedHarnessSessionId,
   type HarnessConversationIdentity,
@@ -36,6 +38,9 @@ export type PreparedRoutedCompletion = {
   tags: RequestTags;
   harnessConversationIdentity?: HarnessConversationIdentity;
   routing: RoutingContext;
+  // Present when this request is served by session pinning: the session's
+  // pin key and the pair it pinned, null before its first routed turn.
+  sessionPin?: { key: string; pin: SessionPin | null };
   reporter: RoutedRuntimeReporter;
 };
 
@@ -140,6 +145,30 @@ export async function prepareRoutedCompletion(args: {
     receivedAt: args.receivedAt,
   });
   const candidateResolution = routing.candidateResolution;
+  let sessionPin: PreparedRoutedCompletion["sessionPin"];
+  if (
+    credentials.session_pinning === true &&
+    credentials.strict !== true &&
+    !background &&
+    explicitModelId(args.interaction.model) === null
+  ) {
+    // Harness identity keys the main agent and each subagent separately and
+    // survives compaction. Claude Code names its subagents only with gateway
+    // hint headers; without them, and for callers with no harness identity,
+    // each conversation is pinned on its own.
+    const identity = args.harnessConversationIdentity;
+    const unclassifiedClaudeCode = identity?.kind === "claude_code_session"
+      && args.interaction.agentContext?.requestClass === "unknown";
+    const key = identity === undefined || unclassifiedClaudeCode
+      ? routing.conversationId
+      : scopedHarnessAgentId({
+          identity,
+          sourceProtocol: args.interaction.sourceProtocol,
+          scope: harnessScope,
+        });
+    const pin = await gatewayPlatform().readSessionPin({ routerId: canonicalRouterId, pinKey: key });
+    sessionPin = { key, pin };
+  }
   const reporter = new RequestReporter({
     requestId: args.requestId,
     clientRequestId: args.clientRequestId,
@@ -184,12 +213,13 @@ export async function prepareRoutedCompletion(args: {
     tags,
     harnessConversationIdentity: args.harnessConversationIdentity,
     routing,
+    ...(sessionPin === undefined ? {} : { sessionPin }),
     reporter,
   };
 }
 
 // Ask the platform for each enabled model's credential up front, so provider
-// execution and fallback stay synchronous.
+// execution stays synchronous.
 async function withProviderCredentials(
   credentials: ResolvedRouter,
   apiKey: string,

package/src/runtime/routed_runtime.ts

@@ -39,7 +39,6 @@ import { auxiliaryDecision } from "./claude_code/auxiliary_routing.js";
 import { explicitModelDecision, strictModelDecision } from "./explicit_model.js";
 import {
   clearPendingLease,
-  committedLeaseDecision,
   leaseHoldDecision,
   leasePrefetchDue,
   leasedDecision,
@@ -47,6 +46,7 @@ import {
   prefetchNextLease,
   selectorNegotiatesLeases,
 } from "./routing_lease.js";
+import { pinSession, sessionPinHoldDecision, sessionPinnedSelection } from "./session_pin.js";
 import type { RoutedProtocol } from "./routed_protocol.js";
 import {
   createExperimentRoutedRuntimeReporter,
@@ -69,7 +69,6 @@ type SpeculativeExecution = {
 type RuntimeExecutionPlan = {
   primary: ProviderChoice;
   primaryRetries: number;
-  resolveFallback: () => Promise<ProviderChoice | null>;
   reportBarrier?: Promise<unknown>;
   startedCompletion?: StartedCompletion;
   startedStream?: StartedStream;
@@ -137,7 +136,6 @@ export async function runPreparedRoutedCompletion(args: {
       interaction: prepared.interaction,
       primary: plan.primary,
       primaryRetries: plan.primaryRetries,
-      resolveFallback: plan.resolveFallback,
       reporter: prepared.reporter,
       protocol: prepared.protocol,
       startedCompletion: plan.startedCompletion,
@@ -150,7 +148,6 @@ export async function runPreparedRoutedCompletion(args: {
     interaction: prepared.interaction,
     primary: plan.primary,
     primaryRetries: plan.primaryRetries,
-    resolveFallback: plan.resolveFallback,
     reporter: prepared.reporter,
     startedStream: plan.startedStream,
     initialError: plan.initialStreamError,
@@ -191,7 +188,6 @@ export async function runPreparedRoutedInteraction(args: {
     interaction: args.prepared.interaction,
     primary: plan.primary,
     primaryRetries: plan.primaryRetries,
-    resolveFallback: plan.resolveFallback,
     reporter: args.prepared.reporter,
     protocol: args.prepared.protocol,
     startedCompletion: plan.startedCompletion,
@@ -253,8 +249,7 @@ async function prepareRuntimeExecution(args: {
 }): Promise<RuntimeExecutionPlan> {
   const { prepared } = args;
 
-  // A strict router never selects, leases, or falls back: the pinned pair or
-  // an error.
+  // A strict router never selects or leases: the pinned pair or an error.
   if (prepared.credentials.strict === true) {
     const pinned = strictModelDecision(prepared);
     prepared.reporter.attachServingDecision(pinned.decision);
@@ -298,14 +293,20 @@ async function prepareRuntimeExecution(args: {
     return selectedExecutionPlan(prepared, auxiliary);
   }
 
+  // A session-pinning router serves the session's pin, or selects once and
+  // pins the result. Leases and speculation never apply to a pinned session.
+  if (prepared.sessionPin !== undefined && !args.requireSelectorDecision) {
+    return selectedExecutionPlan(
+      prepared,
+      await sessionPinnedDecision(prepared, args.selectorBackend),
+    );
+  }
+
   // Persisted policy leases (negotiated {action, turns}) take precedence.
   // Explicit in-process runs are selector experiments: they must observe the
   // selector and must not consume or prefetch live conversations' leases.
   const held = args.requireSelectorDecision ? null : leaseHoldDecision(prepared);
   if (held) {
-    // Serving-only attach: nextDecision stays unset so if a fallback serves
-    // this turn, execution's attachServingDecision moves both the prefix's
-    // next_model and inherited countdown onto the healthy serving pair.
     prepared.reporter.attachServingDecision(held);
     prepared.reporter.attachDecisionDetails({
       decision_source: "lease_hold",
@@ -324,7 +325,7 @@ async function prepareRuntimeExecution(args: {
     if (leasePrefetchDue(prepared)) {
       trackBackgroundTelemetry(prefetchNextLease(prepared, args.selectorBackend));
     }
-    return selectedExecutionPlan(prepared, committedLeaseDecision(prepared, held));
+    return selectedExecutionPlan(prepared, { decision: held });
   }
   const adopted = args.requireSelectorDecision ? null : pendingLeaseDecision(prepared);
   if (adopted) {
@@ -349,7 +350,7 @@ async function prepareRuntimeExecution(args: {
     // wait elapses, the next lease's own prefetch overwrites the stale rows
     // before its expiry (the menu's shortest lease exceeds the lag).
     await clearPendingLease(prepared);
-    return selectedExecutionPlan(prepared, committedLeaseDecision(prepared, adopted));
+    return selectedExecutionPlan(prepared, { decision: adopted });
   }
 
   // The stateless ten-turn hold covers per-turn policies. A lease-negotiating
@@ -380,7 +381,6 @@ async function prepareRuntimeExecution(args: {
   const primary: ProviderChoice = {
     decision: speculative.decision,
     execution: speculative.execution,
-    role: "primary",
   };
   const selectionPromise = selectDecision(
     prepared,
@@ -390,23 +390,13 @@ async function prepareRuntimeExecution(args: {
   );
   // The execution layer awaits selection as its report barrier only after the
   // provider settles, which can be long after a rejection. Mark the promise
-  // handled now; fallback still consumes the original and its rejection.
+  // handled now; the report barrier still observes the original rejection.
   selectionPromise.catch(() => undefined);
-  let fallbackPromise: Promise<ProviderChoice | null> | null = null;
-  const resolveFallback = (): Promise<ProviderChoice | null> => {
-    fallbackPromise ??= selectionPromise.then((selected) => {
-      const decision = fallbackForPrimary(prepared, primary.decision, selected);
-      if (decision) prepared.reporter.attachFallbackDecision(decision);
-      return decision ? providerChoice(prepared, decision, "fallback") : null;
-    });
-    return fallbackPromise;
-  };
   return {
     primary,
     primaryRetries: configuredPrimaryRetries(
       prepared.credentials.primary_retries,
     ),
-    resolveFallback,
     reportBarrier: selectionPromise,
     startedCompletion:
       speculative.transport === "completion" ? speculative.started : undefined,
@@ -424,20 +414,10 @@ function selectedExecutionPlan(
   selected: RoutedDecision,
 ): RuntimeExecutionPlan {
   return {
-    primary: providerChoice(prepared, selected.decision, "primary"),
+    primary: providerChoice(prepared, selected.decision),
     primaryRetries: configuredPrimaryRetries(
       prepared.credentials.primary_retries,
     ),
-    resolveFallback: async () => {
-      if (!selected.fallbackDecision) return null;
-      const fallbackDecision = selected.decision.leaseTurnsRemaining === undefined
-        ? selected.fallbackDecision
-        : {
-            ...selected.fallbackDecision,
-            leaseTurnsRemaining: selected.decision.leaseTurnsRemaining,
-          };
-      return providerChoice(prepared, fallbackDecision, "fallback");
-    },
   };
 }
 
@@ -503,6 +483,28 @@ async function startSpeculativeExecution(
   }
 }
 
+async function sessionPinnedDecision(
+  prepared: PreparedRoutedCompletion,
+  selectorBackend: SelectorBackend,
+): Promise<RoutedDecision> {
+  const held = sessionPinHoldDecision(prepared);
+  if (held) {
+    prepared.reporter.attachDecision(held);
+    prepared.reporter.attachDecisionDetails({
+      decision_source: "session_pin",
+      session_pin: { model: held.selectedModel, reasoning_effort: held.reasoningEffort },
+    });
+    return { decision: held };
+  }
+  const selected = await selectDecision(prepared, null, selectorBackend);
+  prepared.reporter.attachDecisionDetails({
+    decision_source: "selector",
+    session_pin_established: true,
+  });
+  await pinSession(prepared, selected.decision);
+  return selected;
+}
+
 async function selectDecision(
   prepared: PreparedRoutedCompletion,
   servingDecision: RoutingDecision | null,
@@ -511,7 +513,7 @@ async function selectDecision(
 ): Promise<RoutedDecision> {
   const { credentials, reporter, routing } = prepared;
   try {
-    const routed = await routeDecision({
+    const selected = await routeDecision({
       selectorMessages: routing.selectorMessages,
       selectorImages: routing.selectorImages,
       resolution: routing.candidateResolution,
@@ -521,6 +523,7 @@ async function selectDecision(
       selectorBackend,
       leaseHistory: routing.leaseHistory,
     });
+    const routed = prepared.sessionPin === undefined ? selected : sessionPinnedSelection(selected);
     if (routed.details) reporter.attachDecisionDetails(routed.details);
     if (servingDecision) {
       if (!routed.run) {
@@ -544,7 +547,6 @@ async function selectDecision(
       reporter.attachSelectorRun(routed.run);
     } else {
       reporter.attachDecision(routed.decision);
-      reporter.attachFallbackDecision(routed.fallbackDecision);
     }
     return routed;
   } catch (error) {
@@ -592,35 +594,13 @@ function configuredPrimaryRetries(value: number | undefined): number {
   return Number.isInteger(retries) && retries >= 0 && retries <= 5 ? retries : 1;
 }
 
-function fallbackForPrimary(
-  prepared: PreparedRoutedCompletion,
-  primary: RoutingDecision,
-  selected: RoutedDecision,
-): RoutingDecision | undefined {
-  if (prepared.credentials.model_fallback_enabled === false) return undefined;
-  const fallback = [selected.fallbackDecision, selected.decision].find(
-    (candidate): candidate is RoutingDecision =>
-      candidate !== undefined &&
-      candidate.selectedModel !== primary.selectedModel,
-  );
-  if (!fallback || selected.decision.leaseTurnsRemaining === undefined) {
-    return fallback;
-  }
-  return {
-    ...fallback,
-    leaseTurnsRemaining: selected.decision.leaseTurnsRemaining,
-  };
-}
-
 function providerChoice(
   prepared: PreparedRoutedCompletion,
   decision: RoutingDecision,
-  role: ProviderChoice["role"],
 ): ProviderChoice {
   return {
     decision,
     execution: providerExecution(prepared, decision),
-    role,
   };
 }