@f5-sales-demo/xcsh 20.8.2 → 20.8.3

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@f5-sales-demo/xcsh",
-	"version": "20.8.2",
+	"version": "20.8.3",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://github.com/f5-sales-demo/xcsh",
 	"author": "Can Boluk",
@@ -61,13 +61,13 @@
 	"dependencies": {
 		"@agentclientprotocol/sdk": "1.3.0",
 		"@mozilla/readability": "^0.6",
-		"@f5-sales-demo/xcsh-stats": "20.8.2",
-		"@f5-sales-demo/pi-agent-core": "20.8.2",
-		"@f5-sales-demo/pi-ai": "20.8.2",
-		"@f5-sales-demo/pi-natives": "20.8.2",
-		"@f5-sales-demo/pi-resource-management": "20.8.2",
-		"@f5-sales-demo/pi-tui": "20.8.2",
-		"@f5-sales-demo/pi-utils": "20.8.2",
+		"@f5-sales-demo/xcsh-stats": "20.8.3",
+		"@f5-sales-demo/pi-agent-core": "20.8.3",
+		"@f5-sales-demo/pi-ai": "20.8.3",
+		"@f5-sales-demo/pi-natives": "20.8.3",
+		"@f5-sales-demo/pi-resource-management": "20.8.3",
+		"@f5-sales-demo/pi-tui": "20.8.3",
+		"@f5-sales-demo/pi-utils": "20.8.3",
 		"@sinclair/typebox": "^0.34",
 		"@xterm/headless": "^6.0",
 		"ajv": "^8.20",

package/src/config/settings-schema.ts

@@ -602,6 +602,21 @@ export const SETTINGS_SCHEMA = {
 		},
 	},
 
+	"routing.tierEffort": {
+		type: "record",
+		default: {
+			utility: "low",
+			balanced: "medium",
+			frontier: "high",
+		},
+		ui: {
+			tab: "model",
+			label: "Tier Effort Mapping",
+			description: "Map routing tiers to thinking effort levels",
+			submenu: true,
+		},
+	},
+
 	"routing.pools": {
 		type: "record",
 		default: {},

package/src/index.ts

@@ -38,6 +38,13 @@ export * from "./modes";
 export * from "./modes/components";
 // Theme utilities for custom tools
 export * from "./modes/theme/theme";
+export * from "./routing/classifier";
+export * from "./routing/coordinator";
+export * from "./routing/delegation";
+export * from "./routing/presets";
+export * from "./routing/profiler";
+export * from "./routing/state-machine";
+export type * from "./routing/types";
 // SDK for programmatic usage
 export * from "./sdk";
 export * from "./session/agent-session";

package/src/internal-urls/build-info.generated.ts

@@ -17,17 +17,17 @@ export interface BuildInfo {
 }
 
 export const BUILD_INFO: BuildInfo = {
-	"version": "20.8.2",
-	"commit": "66c868524c9a033080f9783d9be773ecab7b6831",
-	"shortCommit": "66c8685",
+	"version": "20.8.3",
+	"commit": "a53c648993e3b94f865921929f85bdf491447000",
+	"shortCommit": "a53c648",
 	"branch": "main",
-	"tag": "v20.8.2",
-	"commitDate": "2026-08-08T14:08:50Z",
-	"buildDate": "2026-08-08T14:35:05.342Z",
+	"tag": "v20.8.3",
+	"commitDate": "2026-08-09T05:36:30Z",
+	"buildDate": "2026-08-09T06:08:18.709Z",
 	"dirty": true,
 	"prNumber": "",
 	"repoUrl": "https://github.com/f5-sales-demo/xcsh",
 	"repoSlug": "f5-sales-demo/xcsh",
-	"commitUrl": "https://github.com/f5-sales-demo/xcsh/commit/66c868524c9a033080f9783d9be773ecab7b6831",
-	"releaseUrl": "https://github.com/f5-sales-demo/xcsh/releases/tag/v20.8.2"
+	"commitUrl": "https://github.com/f5-sales-demo/xcsh/commit/a53c648993e3b94f865921929f85bdf491447000",
+	"releaseUrl": "https://github.com/f5-sales-demo/xcsh/releases/tag/v20.8.3"
 };

package/src/routing/classifier.ts

@@ -28,16 +28,31 @@ export async function classifyTaskHybrid(options: HybridClassifierOptions): Prom
 		});
 
 	try {
-		const utilityModel = options.pool.tiers.utility;
+		let utilityModel = options.pool.tiers.utility;
+		if (!utilityModel.includes("/") && options.pool.provider) {
+			utilityModel = `${options.pool.provider}/${utilityModel}`;
+		}
 		const rawOutput = await runner(utilityModel, options.prompt);
 
 		const parsed = JSON.parse(rawOutput);
-		const score = typeof parsed.complexityScore === "number" ? parsed.complexityScore : 40;
+		let score = typeof parsed.complexityScore === "number" ? parsed.complexityScore : 40;
+		// Enforce hard capability and validated outcome floors computed by deterministic rules
+		score = Math.max(score, baseProfile.complexityScore);
 		const confidence = typeof parsed.confidence === "number" ? parsed.confidence : 0;
-		const delegation =
-			typeof parsed.delegation === "object" && parsed.delegation !== null && !Array.isArray(parsed.delegation)
-				? parsed.delegation
-				: undefined;
+		let delegation = parsed.delegation;
+		if (Array.isArray(delegation)) {
+			delegation = { subtasks: delegation };
+		}
+		if (
+			delegation &&
+			typeof delegation === "object" &&
+			Array.isArray(delegation.subtasks) &&
+			delegation.subtasks.length > 0
+		) {
+			// keep delegation
+		} else {
+			delegation = undefined;
+		}
 		const routingUsage = typeof parsed.routingUsage === "number" ? parsed.routingUsage : undefined;
 
 		if (confidence < 0.75) {

package/src/routing/coordinator.ts

@@ -15,6 +15,7 @@ export interface EvaluateTurnOptions {
 	contextEstimate?: {
 		usedTokens: number;
 		contextWindow: number;
+		reserveTokens?: number;
 	};
 	hasImages?: boolean;
 	priorRejection?: boolean;

package/src/routing/delegation.ts

@@ -22,8 +22,8 @@ export function validateDelegationPlan(plan: ReadOnlyDelegationPlan, maxTasks =
 		return { valid: false, error: "Invalid plan: missing subtasks array" };
 	}
 
-	if (plan.subtasks.length === 0) {
-		return { valid: false, error: "Plan has 0 subtasks" };
+	if (plan.subtasks.length <= 1) {
+		return { valid: false, error: "Plan requires >1 subtasks for delegation" };
 	}
 
 	if (plan.subtasks.length > maxTasks) {
@@ -41,16 +41,19 @@ export function validateDelegationPlan(plan: ReadOnlyDelegationPlan, maxTasks =
 
 export async function executeReadOnlyDelegationPlan(
 	plan: ReadOnlyDelegationPlan,
-	executor: (subtaskPrompt: string) => Promise<string>,
+	executor: (subtaskPrompt: string, signal?: AbortSignal) => Promise<{ result: string; tokens: number }>,
 	maxTasks = 3,
-): Promise<Array<{ id: string; result: string }>> {
+	options?: { signal?: AbortSignal },
+): Promise<{ results: Array<{ id: string; result: string }>; tokensUsed: number }> {
 	const validation = validateDelegationPlan(plan, maxTasks);
 	if (!validation.valid) {
-		return [];
+		return { results: [], tokensUsed: 0 };
 	}
 
-	const results: Array<{ id: string; result: string }> = [];
-	for (const task of plan.subtasks.slice(0, maxTasks)) {
+	const tasks = plan.subtasks.slice(0, maxTasks).map(async task => {
+		if (options?.signal?.aborted) {
+			return { id: task.id, result: "Failed: Aborted", tokens: 0 };
+		}
 		try {
 			const promptPayload = [
 				`Task: ${task.title}`,
@@ -62,11 +65,19 @@ export async function executeReadOnlyDelegationPlan(
 			]
 				.filter(Boolean)
 				.join("\n");
-			const res = await executor(promptPayload);
-			results.push({ id: task.id, result: res });
+			const { result, tokens } = await executor(promptPayload, options?.signal);
+			return { id: task.id, result, tokens };
 		} catch (err) {
-			results.push({ id: task.id, result: `Failed: ${String(err)}` });
+			return { id: task.id, result: `Failed: ${String(err)}`, tokens: 0 };
 		}
-	}
-	return results;
+	});
+
+	const settled = await Promise.all(tasks);
+	let tokensUsed = 0;
+	const results = settled.map(s => {
+		tokensUsed += s.tokens;
+		return { id: s.id, result: s.result };
+	});
+
+	return { results, tokensUsed };
 }

package/src/routing/events.ts

@@ -15,6 +15,7 @@ export interface RoutingEvent {
 	escalated?: boolean;
 	contextTokens?: number;
 	durationMs?: number;
+	state?: Partial<import("./state-machine").RoutingState>;
 }
 
 export function sanitizeRoutingEvent(event: Record<string, unknown>): RoutingEvent {
@@ -33,6 +34,7 @@ export function sanitizeRoutingEvent(event: Record<string, unknown>): RoutingEve
 		"escalated",
 		"contextTokens",
 		"durationMs",
+		"state",
 	]);
 
 	const sanitized: Record<string, unknown> = {};
@@ -57,6 +59,7 @@ export function sanitizeRoutingEvent(event: Record<string, unknown>): RoutingEve
 		escalated: sanitized.escalated as boolean | undefined,
 		contextTokens: sanitized.contextTokens as number | undefined,
 		durationMs: sanitized.durationMs as number | undefined,
+		state: sanitized.state as Partial<import("./state-machine").RoutingState> | undefined,
 	};
 }
 

package/src/routing/presets.ts

@@ -5,36 +5,36 @@ export const BUILTIN_ROUTING_PRESETS: Record<string, RoutingPoolConfig> = {
 		id: "openai/gpt-5.6",
 		provider: "openai",
 		tiers: {
-			utility: "gpt-4.1-mini",
-			balanced: "gpt-4.1",
-			frontier: "gpt-5-pro",
+			utility: "gpt-5.4-mini",
+			balanced: "gpt-5.4",
+			frontier: "gpt-5.6-sol",
 		},
 	},
 	"anthropic/claude": {
 		id: "anthropic/claude",
 		provider: "anthropic",
 		tiers: {
-			utility: "claude-3.5-haiku",
-			balanced: "claude-3.5-sonnet",
-			frontier: "claude-3.7-sonnet",
+			utility: "claude-3-haiku-20240307",
+			balanced: "claude-3-5-sonnet-20241022",
+			frontier: "claude-opus-4-0",
 		},
 	},
 	"litellm/openai": {
 		id: "litellm/openai",
 		provider: "litellm",
 		tiers: {
-			utility: "luna",
-			balanced: "terra",
-			frontier: "sol",
+			utility: "gpt-5.4-mini",
+			balanced: "gpt-5.4",
+			frontier: "gpt-5.6-sol",
 		},
 	},
 	"litellm/anthropic": {
 		id: "litellm/anthropic",
 		provider: "litellm",
 		tiers: {
-			utility: "claude-3-5-haiku",
-			balanced: "claude-3-7-sonnet",
-			frontier: "claude-opus-4-5",
+			utility: "claude-3-5-haiku-20241022",
+			balanced: "claude-3-5-sonnet-20241022",
+			frontier: "claude-opus-4-0",
 		},
 	},
 };
@@ -68,7 +68,8 @@ export function validateCustomPools(pools: any): Record<string, RoutingPoolConfi
 
 		const allowMixed = typeof p.allowMixed === "boolean" ? p.allowMixed : false;
 		if (!allowMixed) {
-			const getPrefix = (model: string) => (model.includes("/") ? model.split("/")[0] : "");
+			const getPrefix = (model: string) =>
+				model.includes("/") ? model.split("/")[0] : typeof p.provider === "string" ? p.provider : "";
 			const uPrefix = getPrefix(p.tiers.utility);
 			const bPrefix = getPrefix(p.tiers.balanced);
 			const fPrefix = getPrefix(p.tiers.frontier);
@@ -118,11 +119,24 @@ export function resolveModelPool(
 	for (const [poolId, pool] of Object.entries(customPools)) {
 		if (!pool?.tiers) continue;
 		if (disabledPresets.includes(poolId) || disabledPresets.includes(pool.id)) continue;
-		if (familyPolicy === "sticky" && pool.allowMixed) continue;
+		if (familyPolicy === "sticky") {
+			if (pool.allowMixed) continue;
+			if (provider) {
+				const pProv = pool.provider ?? provider;
+				const uProv = pool.tiers.utility.includes("/") ? pool.tiers.utility.split("/")[0] : pProv;
+				const bProv = pool.tiers.balanced.includes("/") ? pool.tiers.balanced.split("/")[0] : pProv;
+				const fProv = pool.tiers.frontier.includes("/") ? pool.tiers.frontier.split("/")[0] : pProv;
+				if (uProv !== provider || bProv !== provider || fProv !== provider) {
+					continue;
+				}
+			}
+		}
 		if (provider && pool.provider && pool.provider !== provider && pool.id !== anchorModel) {
 			continue;
 		}
 
+		const qualify = (tier: string) => (tier.includes("/") ? tier : `${pool.provider ?? provider}/${tier}`);
+
 		if (
 			pool.id === anchorModel ||
 			pool.tiers.utility === anchorModel ||
@@ -131,9 +145,9 @@ export function resolveModelPool(
 			pool.tiers.utility === modelName ||
 			pool.tiers.balanced === modelName ||
 			pool.tiers.frontier === modelName ||
-			`${pool.provider ?? provider}/${pool.tiers.utility}` === anchorModel ||
-			`${pool.provider ?? provider}/${pool.tiers.balanced}` === anchorModel ||
-			`${pool.provider ?? provider}/${pool.tiers.frontier}` === anchorModel
+			qualify(pool.tiers.utility) === anchorModel ||
+			qualify(pool.tiers.balanced) === anchorModel ||
+			qualify(pool.tiers.frontier) === anchorModel
 		) {
 			return pool;
 		}
@@ -146,14 +160,16 @@ export function resolveModelPool(
 			continue; // Provider mismatch!
 		}
 
+		const qualify = (tier: string) => (tier.includes("/") ? tier : `${pool.provider}/${tier}`);
+
 		if (
 			presetId === anchorModel ||
 			pool.tiers.utility === modelName ||
 			pool.tiers.balanced === modelName ||
 			pool.tiers.frontier === modelName ||
-			`${pool.provider}/${pool.tiers.utility}` === anchorModel ||
-			`${pool.provider}/${pool.tiers.balanced}` === anchorModel ||
-			`${pool.provider}/${pool.tiers.frontier}` === anchorModel
+			qualify(pool.tiers.utility) === anchorModel ||
+			qualify(pool.tiers.balanced) === anchorModel ||
+			qualify(pool.tiers.frontier) === anchorModel
 		) {
 			return pool;
 		}

package/src/routing/profiler.ts

@@ -19,13 +19,15 @@ const COMPLEX_KEYWORDS = [
 	"refactor the session",
 	"multi-region",
 	"system design",
+	"ambiguity",
+	"target",
 ];
 
 const SIMPLE_READ_PATTERNS = [/^(summarize|read|cat|view|explain)\b/i, /\bfix typo\b/i, /\btypo in line\b/i];
 
 export function profileTaskDeterministic(input: ProfilerInput): TaskProfile {
 	const reasons: RoutingReasonCode[] = [];
-	let score = 40; // base score (default balanced)
+	let score = 30; // base score (default balanced)
 
 	const promptLower = input.prompt.toLowerCase().trim();
 

package/src/routing/resolver.ts

@@ -9,7 +9,7 @@ export interface ResolveTierResult {
 }
 
 export interface ResolveTierOptions {
-	contextEstimate?: { usedTokens: number; contextWindow: number };
+	contextEstimate?: { usedTokens: number; contextWindow: number; reserveTokens?: number };
 	getModelContextWindow?: (modelId: string) => number;
 }
 
@@ -43,6 +43,7 @@ export function resolveTierModel(
 					!checkCandidateContextEligible({
 						estimatedInputTokens: options.contextEstimate.usedTokens,
 						candidateContextWindow: candidateWin,
+						reserveTokens: options.contextEstimate.reserveTokens,
 					})
 				) {
 					return false;
@@ -64,6 +65,7 @@ export function resolveTierModel(
 				!checkCandidateContextEligible({
 					estimatedInputTokens: options.contextEstimate.usedTokens,
 					candidateContextWindow: candidateWin,
+					reserveTokens: options.contextEstimate.reserveTokens,
 				})
 			) {
 				return false;

package/src/routing/types.ts

@@ -26,7 +26,8 @@ export type RoutingReasonCode =
 	| "lint_failure"
 	| "context_capacity_promotion"
 	| "downshift_hysteresis_pending"
-	| "escalation_floor_active";
+	| "escalation_floor_active"
+	| "retry_fallback";
 
 export interface ReadOnlyDelegationSubtask {
 	id: string;
@@ -84,7 +85,7 @@ export interface RoutingDecision {
 }
 
 export interface RoutingOutcomeEvidence {
-	kind: "test_failure" | "build_failure" | "lint_failure" | "user_feedback";
+	kind: "test_failure" | "build_failure" | "lint_failure" | "user_feedback" | "retry_fallback";
 	summary: string;
 }
 
@@ -105,4 +106,5 @@ export interface RoutingSettings {
 
 	pools: Record<string, RoutingPoolConfig>;
 	disabledPresets: string[];
+	tierEffort?: Record<string, string>;
 }

package/src/session/agent-session.ts

@@ -294,6 +294,8 @@ export interface PromptOptions {
 	 * the provider `onPayload` seam (per-turn, no client-side tool registration).
 	 */
 	serverTools?: Record<string, unknown>[];
+	/** Optional abort signal for early cancellation */
+	signal?: AbortSignal;
 }
 
 /** Result from cycleModel() */
@@ -756,6 +758,17 @@ export class AgentSession {
 			void this.#queueExtensionEvent(event);
 			return;
 		}
+
+		if (
+			event.type === "routing_decision" ||
+			event.type === "routing_applied" ||
+			event.type === "routing_escalated" ||
+			event.type === "routing_skipped" ||
+			(event.type as string) === "routing_floor_cleared"
+		) {
+			this.sessionManager.appendCustomEntry("routing_event", event);
+		}
+
 		await this.#emitExtensionEvent(event);
 		this.#emit(event);
 	}
@@ -1284,34 +1297,98 @@ export class AgentSession {
 		this.#routingCoordinator.restoreState(state);
 	}
 	public recordRoutingOutcome(outcome: RoutingOutcome): void {
+		const routingMode = this.settings.get("routing.mode") as import("../routing/types").RoutingMode;
 		if (outcome.status === "rejected") {
 			const hasUserFeedback = outcome.evidence.some(e => e.kind === "user_feedback");
 			const hasTestFailure = outcome.evidence.some(e => e.kind === "test_failure");
 			const hasBuildFailure = outcome.evidence.some(e => e.kind === "build_failure");
 			const hasLintFailure = outcome.evidence.some(e => e.kind === "lint_failure");
+			const hasRetryFallback = outcome.evidence.some(e => e.kind === "retry_fallback");
 
 			const reasons: import("../routing/types").RoutingReasonCode[] = [];
 			if (hasUserFeedback) reasons.push("prior_rejection");
 			if (hasTestFailure) reasons.push("test_failure");
 			if (hasBuildFailure) reasons.push("build_failure");
 			if (hasLintFailure) reasons.push("lint_failure");
+			if (hasRetryFallback) reasons.push("retry_fallback");
 
-			this.#routingCoordinator.getStateMachine().setEscalationFloor("frontier");
+			if (reasons.length === 0) return;
 
 			const routingState = this.#routingCoordinator.getState();
-			this.#emitSessionEvent(
-				sanitizeRoutingEvent({
-					type: "routing_escalated",
-					epochId: outcome.epochId,
-					reasons: reasons,
-					mode: this.settings.get("routing.mode") as import("../routing/types").RoutingMode,
-					effectiveTier: routingState.currentTier,
-					selectedModel: this.model ? `${this.model.provider}/${this.model.id}` : undefined,
-					escalated: true,
-				}),
-			).catch(() => {});
+			let targetTier: import("../routing/types").RoutingTier = "frontier";
+			if (outcome.safeToContinue) {
+				if (routingState.currentTier === "utility") targetTier = "balanced";
+				else if (routingState.currentTier === "balanced") targetTier = "frontier";
+			}
+
+			if (routingMode === "auto") {
+				const performEscalationModelSwap = async () => {
+					try {
+						const { resolveModelPool } = await import("../routing/presets");
+						const poolId = this.settings.get("routing.pools") as any;
+						const disabledPresets = this.settings.get("routing.disabledPresets") as readonly string[];
+						const familyPolicy = this.settings.get("routing.familyPolicy") as any;
+						const pool = resolveModelPool(
+							this.model ? `${this.model.provider}/${this.model.id}` : "",
+							poolId,
+							disabledPresets,
+							familyPolicy,
+						);
+						if (!pool) return;
+						const modelId = pool.tiers[targetTier];
+						if (!modelId) return;
+						const uId = modelId.includes("/") ? modelId : `${pool.provider}/${modelId}`;
+						const targetModel = this.#modelRegistry
+							.getAvailable()
+							.find(m => `${m.provider}/${m.id}` === uId || m.id === uId);
+
+						if (!targetModel) {
+							console.warn(`Escalation aborted: target model ${uId} not available in registry.`);
+							return;
+						}
+
+						if (outcome.safeToContinue) {
+							this.agent.abort();
+						}
+
+						this.#routingCoordinator.getStateMachine().setEscalationFloor(targetTier);
+						if (outcome.safeToContinue) {
+							this.#routingCoordinator.restoreState({ currentTier: targetTier });
+						}
+
+						await this.setModelRoutingSwitch(targetModel);
+						const effortMap = this.settings.get("routing.tierEffort") as Record<string, string> | undefined;
+						const { mapTierToEffort } = await import("../routing/effort");
+						const effort = mapTierToEffort(targetTier, effortMap);
+						this.setThinkingLevel(effort as any);
+
+						this.#emitSessionEvent(
+							sanitizeRoutingEvent({
+								type: "routing_escalated",
+								epochId: `route-${Date.now()}-esc`,
+								reasons: reasons,
+								mode: routingMode,
+								effectiveTier: targetTier,
+								state: this.#routingCoordinator.getState(),
+								selectedModel: this.model ? `${this.model.provider}/${this.model.id}` : undefined,
+								escalated: true,
+							}),
+						).catch(() => {});
+
+						if (outcome.safeToContinue) {
+							this.#scheduleAgentContinue({ delayMs: 10 });
+						}
+					} catch (err) {
+						console.error("Escalation model swap failed", err);
+					}
+				};
+				this.#trackPostPromptTask(performEscalationModelSwap());
+			}
 		} else {
-			this.#routingCoordinator.getStateMachine().clearEscalationFloor();
+			if (routingMode === "auto") {
+				this.#routingCoordinator.getStateMachine().clearEscalationFloor();
+				this.#emitSessionEvent({ type: "routing_floor_cleared" } as any).catch(() => {});
+			}
 		}
 	}
 	/**
@@ -2405,7 +2482,9 @@ export class AgentSession {
 	}
 
 	buildDisplaySessionContext(): SessionContext {
-		return deobfuscateSessionContext(this.sessionManager.buildSessionContext(), this.#obfuscator);
+		const context = deobfuscateSessionContext(this.sessionManager.buildSessionContext(), this.#obfuscator);
+		context.usedTokens = calculateUsedTokens(context.messages);
+		return context;
 	}
 
 	/** Convert session messages using the same pre-LLM pipeline as the active session. */
@@ -2713,172 +2792,242 @@ export class AgentSession {
 		// Evaluate dynamic model routing if enabled
 		const routingMode = (this.settings.get("routing.mode") as RoutingMode) ?? "off";
 		if (routingMode !== "off" && this.model) {
-			const anchorModel = `${this.model.provider}/${this.model.id}`;
-			const availableModels = this.#modelRegistry.getAvailable().map(m => `${m.provider}/${m.id}`);
-			const startTime = Date.now();
-			const systemTokens = Math.round((this.systemPrompt?.length ?? 0) / 4);
-			const promptTokens = Math.round(expandedText.length / 4);
-			const toolsStr = JSON.stringify(Array.from(this.#toolRegistry.values()));
-			const toolsTokens = Math.round(toolsStr.length / 4);
-			const reserveTokens = (this.settings.get("compaction.reserveTokens") as number) ?? 0;
-			const contextEstimate = {
-				usedTokens: calculateUsedTokens(this.messages) + systemTokens + promptTokens + toolsTokens,
-				reserveTokens,
-				contextWindow: this.model.contextWindow ?? 128000,
-			};
-			const decision = await this.#routingCoordinator.evaluateTurn({
-				anchorModel,
-				mode: routingMode,
-				prompt: expandedText,
-				hasImages: options?.images && options.images.length > 0,
-				priorRejection: this.#routingCoordinator.getState().escalationFloor !== undefined,
-				availableModels,
-				customPools: validateCustomPools(this.settings.get("routing.pools")),
-				disabledPresets: (this.settings.get("routing.disabledPresets") as readonly string[]) ?? [],
-				familyPolicy: (this.settings.get("routing.familyPolicy") as "sticky" | "configured-mixed") ?? "sticky",
-				profilerMode: (this.settings.get("routing.profiler") as any) ?? "hybrid",
-				contextEstimate,
-				getModelContextWindow: (modelId: string) => {
-					const found = this.#modelRegistry
-						.getAll()
-						.find(m => `${m.provider}/${m.id}` === modelId || m.id === modelId);
-					return found?.contextWindow ?? 128000;
-				},
-				runRoutingClassifier: async (utilityModel: string, promptText: string) => {
-					const resolved = this.#modelRegistry
-						.getAll()
-						.find(m => `${m.provider}/${m.id}` === utilityModel || m.id === utilityModel);
-					if (!resolved) throw new Error("Classifier model not found");
-					const apiKey = await this.#modelRegistry.getApiKey(resolved, this.sessionId);
-					if (!apiKey) throw new Error("No API key for classifier model");
-
-					const systemInstruction = `You are a routing classifier. Analyze the user's prompt and output a JSON object: { "complexityScore": number, "confidence": number, "delegation"?: { "reason": string, "subtasks": { "id": string, "title": string, "description": string, "targetFilesOrPaths": string[], "desiredTier"?: string }[] } }. Score complexity from 0 to 100 based on required reasoning, context width, and coding effort. Return ONLY valid JSON without markdown blocks.`;
-
-					const res = await completeSimple(
-						resolved,
-						{
-							systemPrompt: systemInstruction,
-							messages: [{ role: "user", content: [{ type: "text", text: promptText }], timestamp: Date.now() }],
-						},
-						{ apiKey },
-					);
-					const rawText = res.content
-						.filter(c => c.type === "text")
-						.map(c => (c as TextContent).text)
-						.join("");
+			if (this.#activeRetryFallback) {
+				this.#emitSessionEvent({
+					type: "routing_skipped",
+					epochId: `skip-${Date.now()}`,
+					reasons: ["retry_fallback"],
+				} as any).catch(() => {});
+			} else {
+				const anchorModel = `${this.model.provider}/${this.model.id}`;
+				const availableModels =
+					this.#scopedModels.length > 0
+						? this.#scopedModels.map(sm => `${sm.model.provider}/${sm.model.id}`)
+						: this.#modelRegistry.getAvailable().map(m => `${m.provider}/${m.id}`);
+				const startTime = Date.now();
+				const systemTokens = Math.round((this.systemPrompt?.length ?? 0) / 4);
+				const promptTokens = Math.round(expandedText.length / 4);
+				const toolsStr = JSON.stringify(Array.from(this.#toolRegistry.values()));
+				const toolsTokens = Math.round(toolsStr.length / 4);
+				const reserveTokens = (this.settings.get("compaction.reserveTokens") as number) ?? 0;
+				const contextEstimate = {
+					usedTokens: calculateUsedTokens(this.messages) + systemTokens + promptTokens + toolsTokens,
+					reserveTokens,
+					contextWindow: this.model.contextWindow ?? 128000,
+				};
+				const decision = await this.#routingCoordinator.evaluateTurn({
+					anchorModel,
+					mode: routingMode,
+					prompt: expandedText,
+					hasImages: options?.images && options.images.length > 0,
+					priorRejection: this.#routingCoordinator.getState().escalationFloor !== undefined,
+					availableModels,
+					customPools: validateCustomPools(this.settings.get("routing.pools")),
+					disabledPresets: (this.settings.get("routing.disabledPresets") as readonly string[]) ?? [],
+					familyPolicy: (this.settings.get("routing.familyPolicy") as "sticky" | "configured-mixed") ?? "sticky",
+					profilerMode: (this.settings.get("routing.profiler") as any) ?? "hybrid",
+					contextEstimate,
+					getModelContextWindow: (modelId: string) => {
+						const found = this.#modelRegistry
+							.getAll()
+							.find(m => `${m.provider}/${m.id}` === modelId || m.id === modelId);
+						return found?.contextWindow ?? 128000;
+					},
+					runRoutingClassifier: async (utilityModel: string, promptText: string) => {
+						const resolved = this.#modelRegistry
+							.getAll()
+							.find(m => `${m.provider}/${m.id}` === utilityModel || m.id === utilityModel);
+						if (!resolved) throw new Error("Classifier model not found");
+						const apiKey = await this.#modelRegistry.getApiKey(resolved, this.sessionId);
+						if (!apiKey) throw new Error("No API key for classifier model");
+
+						const systemInstruction = `You are a routing classifier. Analyze the user's prompt and output a JSON object: { "complexityScore": number, "confidence": number, "delegation"?: { "reason": string, "subtasks": { "id": string, "title": string, "description": string, "targetFilesOrPaths": string[], "desiredTier"?: string }[] } }. Score complexity from 0 to 100 based on required reasoning, context width, and coding effort. Return ONLY valid JSON without markdown blocks.`;
+
+						const res = await completeSimple(
+							resolved,
+							{
+								systemPrompt: systemInstruction,
+								messages: [
+									{ role: "user", content: [{ type: "text", text: promptText }], timestamp: Date.now() },
+								],
+							},
+							{ apiKey, signal: AbortSignal.timeout(15000) },
+						);
+						const rawText = res.content
+							.filter(c => c.type === "text")
+							.map(c => (c as TextContent).text)
+							.join("");
 
-					const jsonMatch = rawText.match(/\{[\s\S]*\}/);
-					if (jsonMatch) {
-						const parsed = JSON.parse(jsonMatch[0]); // Check validity
-						if (res.usage) {
-							this.settings.getStorage()?.recordModelUsage(`${resolved.provider}/${resolved.id}`);
-							parsed.routingUsage = (res.usage as any).totalTokens ?? (res.usage as any).total ?? 0;
+						const jsonMatch = rawText.match(/\{[\s\S]*\}/);
+						if (jsonMatch) {
+							const parsed = JSON.parse(jsonMatch[0]); // Check validity
+							if (res.usage) {
+								this.settings.getStorage()?.recordModelUsage(`${resolved.provider}/${resolved.id}`);
+								parsed.routingUsage = (res.usage as any).totalTokens ?? (res.usage as any).total ?? 0;
+							}
+							return JSON.stringify(parsed);
+						}
+						throw new Error("Classifier returned malformed JSON");
+					},
+					downshiftAfterTurns: (this.settings.get("routing.downshiftAfterTurns") as number) ?? 2,
+				});
+				const durationMs = Date.now() - startTime;
+
+				this.#emitSessionEvent({
+					type: decision.applied ? "routing_applied" : "routing_decision",
+					epochId: decision.epochId,
+					mode: decision.mode,
+					provider: this.model.provider,
+					poolId: decision.poolId,
+					effectiveTier: decision.effectiveTier,
+					selectedModel: decision.selectedModel,
+					reasons: decision.reasons,
+					delegated: !!decision.delegation,
+					escalated: decision.reasons.some(
+						r => r === "context_capacity_promotion" || r === "escalation_floor_active",
+					),
+					contextTokens: contextEstimate.usedTokens,
+					routingUsage: decision.routingUsage,
+					durationMs,
+					state: this.#routingCoordinator.getState(),
+				} as any).catch(() => {});
+
+				if (decision.selectedModel && decision.applied) {
+					const targetModel = this.#modelRegistry
+						.getAvailable()
+						.find(m => `${m.provider}/${m.id}` === decision.selectedModel || m.id === decision.selectedModel);
+					if (targetModel) {
+						const currentModelId = this.model ? `${this.model.provider}/${this.model.id}` : undefined;
+						const targetModelId = `${targetModel.provider}/${targetModel.id}`;
+						if (currentModelId !== targetModelId) {
+							await this.setModelRoutingSwitch(targetModel);
+						}
+						if (decision.effectiveTier) {
+							const effortMap = this.settings.get("routing.tierEffort") as Record<string, string> | undefined;
+							const { mapTierToEffort } = await import("../routing/effort");
+							const effort = mapTierToEffort(decision.effectiveTier, effortMap);
+							this.setThinkingLevel(effort as any);
 						}
-						return JSON.stringify(parsed);
 					}
-					throw new Error("Classifier returned malformed JSON");
-				},
-				downshiftAfterTurns: (this.settings.get("routing.downshiftAfterTurns") as number) ?? 2,
-			});
-			const durationMs = Date.now() - startTime;
-
-			this.sessionManager.appendCustomEntry("routing_state", this.#routingCoordinator.getState());
-
-			this.#emitSessionEvent({
-				type: decision.applied ? "routing_applied" : "routing_decision",
-				epochId: decision.epochId,
-				mode: decision.mode,
-				provider: this.model.provider,
-				poolId: decision.poolId,
-				effectiveTier: decision.effectiveTier,
-				selectedModel: decision.selectedModel,
-				reasons: decision.reasons,
-				delegated: !!decision.delegation,
-				escalated: decision.reasons.some(
-					r => r === "context_capacity_promotion" || r === "escalation_floor_active",
-				),
-				contextTokens: contextEstimate.usedTokens,
-				routingUsage: decision.routingUsage,
-				durationMs,
-			} as any).catch(() => {});
-
-			if (decision.applied && decision.selectedModel && decision.selectedModel !== anchorModel) {
-				const targetModel = this.#modelRegistry
-					.getAvailable()
-					.find(m => `${m.provider}/${m.id}` === decision.selectedModel || m.id === decision.selectedModel);
-				if (targetModel) {
-					await this.setModelRoutingSwitch(targetModel);
 				}
-			}
 
-			if (
-				decision.applied &&
-				decision.delegation &&
-				(this.settings.get("routing.delegation") as string) === "read-only"
-			) {
-				const maxTasks = (this.settings.get("routing.delegationMaxTasks") as number) ?? 3;
-				const results = await executeReadOnlyDelegationPlan(
-					decision.delegation,
-					async subtaskPrompt => {
-						const utilityModelId = decision.poolId
-							? (this.settings.get("routing.pools") as any)?.[decision.poolId]?.tiers?.utility
-							: undefined;
-						const resolvedUtility = utilityModelId
-							? this.#modelRegistry
+				if (
+					decision.applied &&
+					decision.delegation &&
+					decision.delegation.subtasks.length > 1 &&
+					(this.settings.get("routing.delegation") as string) === "read-only"
+				) {
+					let maxTasks = (this.settings.get("routing.delegationMaxTasks") as number) ?? 3;
+					maxTasks = Math.min(Math.max(1, maxTasks), 3);
+
+					const { results, tokensUsed } = await executeReadOnlyDelegationPlan(
+						decision.delegation,
+						async (subtaskPrompt, signal) => {
+							if (signal?.aborted) return { result: "Delegation failed: Aborted", tokens: 0 };
+
+							const { resolveModelPool } = await import("../routing/presets");
+							const pool = resolveModelPool(
+								decision.poolId ?? (this.model ? `${this.model.provider}/${this.model.id}` : ""),
+								this.settings.get("routing.pools") as any,
+								this.settings.get("routing.disabledPresets") as readonly string[],
+								this.settings.get("routing.familyPolicy") as any,
+							);
+
+							let resolvedUtility = this.model;
+							if (pool?.tiers?.utility) {
+								let uId = pool.tiers.utility;
+								if (!uId.includes("/") && pool.provider) {
+									uId = `${pool.provider}/${uId}`;
+								}
+								const found = this.#modelRegistry
 									.getAvailable()
-									.find(m => `${m.provider}/${m.id}` === utilityModelId || m.id === utilityModelId)
-							: this.model;
-						if (!resolvedUtility) return "Delegation failed: no model.";
-
-						const { createAgentSession } = await import("../sdk");
-						const { SessionManager: SDKSessionManager } = await import("./session-manager");
-						const childSettings = await this.settings.cloneForCwd(process.cwd());
-						childSettings.set("routing.delegation", "off");
-						const { session: childSession } = await createAgentSession({
-							model: resolvedUtility,
-							sessionManager: SDKSessionManager.inMemory(),
-							settings: childSettings,
-							authStorage: this.#modelRegistry.authStorage,
-							modelRegistry: this.#modelRegistry,
-							toolNames: Array.from(this.#toolRegistry.values())
-								.map(t => t.name)
-								.filter(isDelegationAllowedTool),
-							enableLsp: false,
-							enableMCP: false,
-						});
+									.find(m => `${m.provider}/${m.id}` === uId || m.id === uId);
+								if (found) resolvedUtility = found;
+							}
 
-						try {
-							await childSession.prompt(subtaskPrompt);
-							return childSession
-								.buildDisplaySessionContext()
-								.messages.filter(m => m.role === "assistant")
-								.map(m =>
-									m.content
-										.filter((c: any) => c.type === "text")
-										.map((c: any) => c.text)
-										.join(""),
-								)
-								.join("\n");
-						} catch (err) {
-							return `Delegation failed: ${String(err)}`;
-						} finally {
-							await childSession.dispose();
+							if (!resolvedUtility) return { result: "Delegation failed: no model.", tokens: 0 };
+
+							const { createAgentSession } = await import("../sdk");
+							const { SessionManager: SDKSessionManager } = await import("./session-manager");
+							const childSettings = await this.settings.cloneForCwd(process.cwd());
+							childSettings.set("routing.delegation", "off");
+
+							// Fix abort race by checking right before creation
+							if (signal?.aborted) return { result: "Delegation failed: Aborted", tokens: 0 };
+
+							const { session: childSession } = await createAgentSession({
+								model: resolvedUtility,
+								sessionManager: SDKSessionManager.inMemory(),
+								settings: childSettings,
+								authStorage: this.#modelRegistry.authStorage,
+								modelRegistry: this.#modelRegistry,
+								toolNames: Array.from(this.#toolRegistry.values())
+									.map(t => t.name)
+									.filter(isDelegationAllowedTool),
+								enableLsp: false,
+								enableMCP: false,
+							});
+
+							try {
+								const onAbort = () => childSession.agent.abort();
+								signal?.addEventListener("abort", onAbort);
+								if (signal?.aborted) {
+									onAbort();
+									return { result: "Delegation failed: Aborted", tokens: 0 };
+								}
+								try {
+									await childSession.prompt(subtaskPrompt);
+									if (signal?.aborted) return { result: "Delegation failed: Aborted", tokens: 0 };
+									const resultStr = childSession
+										.buildDisplaySessionContext()
+										.messages.filter(m => m.role === "assistant")
+										.map(m =>
+											m.content
+												.filter((c: any) => c.type === "text")
+												.map((c: any) => c.text)
+												.join(""),
+										)
+										.join("\n");
+									const tokens = childSession.buildDisplaySessionContext().usedTokens || 0;
+									return { result: resultStr, tokens };
+								} finally {
+									signal?.removeEventListener("abort", onAbort);
+								}
+							} catch (err) {
+								if (signal?.aborted) return { result: "Delegation failed: Aborted", tokens: 0 };
+								return { result: `Delegation failed: ${String(err)}`, tokens: 0 };
+							} finally {
+								await childSession.dispose();
+							}
+						},
+						maxTasks,
+						{ signal: options?.signal },
+					);
+
+					if (results.length > 0) {
+						let resultsString = JSON.stringify(results, null, 2);
+						if (resultsString.length > 8000) {
+							resultsString = `${resultsString.substring(0, 8000)}\n...[truncated]`;
+						}
+						const delegationOutput = `\n\n<delegation_results>\n${resultsString}\n</delegation_results>`;
+						expandedText += delegationOutput;
+						const textBlock = userContent.find(c => c.type === "text") as Extract<
+							(typeof userContent)[0],
+							{ type: "text" }
+						>;
+						if (textBlock) {
+							textBlock.text += delegationOutput;
+						} else {
+							userContent.push({ type: "text", text: delegationOutput });
 						}
-					},
-					maxTasks,
-				);
 
-				if (results.length > 0) {
-					const delegationOutput = `\n\n<delegation_results>\n${JSON.stringify(results, null, 2)}\n</delegation_results>`;
-					expandedText += delegationOutput;
-					const textBlock = userContent.find(c => c.type === "text") as Extract<
-						(typeof userContent)[0],
-						{ type: "text" }
-					>;
-					if (textBlock) {
-						textBlock.text += delegationOutput;
-					} else {
-						userContent.push({ type: "text", text: delegationOutput });
+						this.#emitSessionEvent({
+							type: "routing_delegated",
+							epochId: decision.epochId,
+							tasks: decision.delegation.subtasks.length,
+							completed: results.length,
+							tokensUsed,
+						} as any).catch(() => {});
 					}
 				}
 			}
@@ -5707,11 +5856,6 @@ export class AgentSession {
 			this.#activeRetryFallback.lastAppliedFallbackThinkingLevel = nextThinkingLevel;
 		}
 
-		this.recordRoutingOutcome({
-			status: "rejected",
-			evidence: [{ kind: "test_failure", summary: `Fallback applied from ${currentSelector} to ${selector.raw}` }],
-		});
-
 		await this.#emitSessionEvent({
 			type: "retry_fallback_applied",
 			from: currentSelector,
@@ -6459,13 +6603,27 @@ export class AgentSession {
 	}
 
 	#syncRoutingStateFromBranch() {
-		const lastRoutingEntry = (this.sessionManager.getBranch() as any[]).findLast(
-			e => e.type === "custom" && e.customType === "routing_state",
-		);
-		if (lastRoutingEntry?.data) {
-			this.#routingCoordinator.restoreState(lastRoutingEntry.data);
-		} else {
-			this.#routingCoordinator.reset();
+		this.#routingCoordinator.reset();
+		const entries = this.sessionManager.getBranch();
+		for (const entry of entries) {
+			if (entry.type === "custom" && entry.customType === "routing_event") {
+				const event = entry.data as any;
+				if (event.state) {
+					this.#routingCoordinator.restoreState(event.state);
+				} else {
+					if (event.type === "routing_escalated") {
+						if (event.effectiveTier) {
+							this.#routingCoordinator.getStateMachine().setEscalationFloor(event.effectiveTier);
+						}
+					} else if (event.type === "routing_floor_cleared") {
+						this.#routingCoordinator.getStateMachine().clearEscalationFloor();
+					} else if (event.type === "routing_applied" || event.type === "routing_decision") {
+						if (event.effectiveTier) {
+							this.#routingCoordinator.restoreState({ currentTier: event.effectiveTier });
+						}
+					}
+				}
+			}
 		}
 	}
 

package/src/session/session-manager.ts

@@ -261,6 +261,8 @@ export interface SessionContext {
 	mode: string;
 	/** Mode-specific data from the last mode_change entry */
 	modeData?: Record<string, unknown>;
+	/** Number of tokens used across all provider requests on this branch */
+	usedTokens: number;
 }
 
 export interface SessionInfo {
@@ -532,6 +534,7 @@ export function buildSessionContext(
 			selectedMCPToolNames: [],
 			hasPersistedMCPToolSelection: false,
 			mode: "none",
+			usedTokens: 0,
 		};
 	}
 	if (leafId) {
@@ -552,6 +555,7 @@ export function buildSessionContext(
 			selectedMCPToolNames: [],
 			hasPersistedMCPToolSelection: false,
 			mode: "none",
+			usedTokens: 0,
 		};
 	}
 
@@ -704,6 +708,7 @@ export function buildSessionContext(
 		hasPersistedMCPToolSelection,
 		mode,
 		modeData,
+		usedTokens: 0, // Will be computed by the session object later
 	};
 }