auto-model-router 0.3.4 → 0.4.1

package/src/cost/report.ts

@@ -9,6 +9,7 @@
  */
 
 import type { Database } from "bun:sqlite";
+import { createFeedbackStore, type FeedbackCounts } from "./feedback.ts";
 
 export interface ReportTotals {
 	dispatches: number;
@@ -26,6 +27,9 @@ export interface ReportTotals {
 	modelSwitches: number;
 	/** Any row in the window carries an estimated cache count. */
 	cacheEstimated: boolean;
+	/** Turns from omp subagents (`features.isSubagent`), and their spend. */
+	subagentDispatches: number;
+	subagentSpendUsd: number;
 }
 
 export interface ReportRow {
@@ -50,6 +54,8 @@ export interface ModelRow extends ReportRow {
 	provider: string;
 	/** Dispatch counts per tier, e.g. `{ trivial: 12, moderate: 3 }`. */
 	tiers: Record<string, number>;
+	/** User verdicts from /router good|bad on turns this model served, in the window. */
+	feedback: FeedbackCounts;
 }
 
 export interface DayRow {
@@ -71,6 +77,50 @@ export interface UsageReport {
 	models: ModelRow[];
 	tiers: ReportRow[];
 	days: DayRow[];
+	/** Mean prompt composition over rows that recorded it; null when none did. */
+	anatomy: AnatomyShare | null;
+	/** What the window would have cost on one model throughout, per configured baseline. */
+	baselines: BaselineRow[];
+}
+
+export interface BaselineRow {
+	slug: string;
+	usd: number;
+	/** 1 − routed spend ÷ baseline spend; negative when the router cost more. */
+	savedShare: number;
+}
+
+/** Resolves configured baseline slugs against a catalog lookup; unknown slugs are skipped. */
+export function baselinePrices(slugs: readonly string[], find: (slug: string) => { price: { prompt: number; completion: number; cacheRead?: number } } | undefined): BaselinePrice[] {
+	const out: BaselinePrice[] = [];
+	for (const slug of slugs) {
+		const m = find(slug);
+		if (m === undefined) continue;
+		out.push({ slug, prompt: m.price.prompt, completion: m.price.completion, ...(m.price.cacheRead === undefined ? {} : { cacheRead: m.price.cacheRead }) });
+	}
+	return out;
+}
+
+/** A baseline's prices per token (the catalog's `Price`, or a subset of it). */
+export interface BaselinePrice {
+	slug: string;
+	prompt: number;
+	completion: number;
+	cacheRead?: number;
+}
+
+/** Shares of prompt bytes, 0-1, averaged over the window's dispatches. */
+export interface AnatomyShare {
+	rows: number;
+	avgMessages: number;
+	system: number;
+	user: number;
+	assistant: number;
+	tool: number;
+	/** Tool schemas relative to prompt bytes (they ride in the tools param, not the messages). */
+	schemas: number;
+	olderHalf: number;
+	staleTool: number;
 }
 
 const USD = "COALESCE(reported_usd, predicted_usd)";
@@ -129,7 +179,10 @@ function toRow(r: RawRow, windowSpend: number): ReportRow {
  * Builds the report for the last `windowDays`. `harnessId` narrows to one
  * harness (the `X-Omp-Harness` header); empty means everything.
  */
-export function buildUsageReport(db: Database, opts: { windowDays: number; harnessId?: string; nowMs?: number }): UsageReport {
+export function buildUsageReport(
+	db: Database,
+	opts: { windowDays: number; harnessId?: string; nowMs?: number; baselines?: readonly BaselinePrice[] },
+): UsageReport {
 	const nowMs = opts.nowMs ?? Date.now();
 	const windowDays = Math.max(1, opts.windowDays);
 	const sinceMs = nowMs - windowDays * 86_400_000;
@@ -146,6 +199,8 @@ export function buildUsageReport(db: Database, opts: { windowDays: number; harne
 				COALESCE(SUM(${CT}), 0) AS cached_tokens,
 				COALESCE(SUM(${COMP}), 0) AS completion_tokens,
 				SUM(CASE WHEN ${EST} THEN 1 ELSE 0 END) AS estimated_rows,
+				SUM(CASE WHEN json_extract(features, '$.isSubagent') = 1 THEN 1 ELSE 0 END) AS subagent_rows,
+				COALESCE(SUM(CASE WHEN json_extract(features, '$.isSubagent') = 1 THEN ${USD} ELSE 0 END), 0) AS subagent_spend,
 				SUM(CASE WHEN escalation_signal IS NOT NULL THEN 1 ELSE 0 END) AS escalations,
 				SUM(CASE WHEN instr(reasons, 'failover:') > 0 THEN 1 ELSE 0 END) AS failovers,
 				SUM(CASE WHEN error IS NOT NULL THEN 1 ELSE 0 END) AS errors,
@@ -160,6 +215,8 @@ export function buildUsageReport(db: Database, opts: { windowDays: number; harne
 		cached_tokens: number;
 		completion_tokens: number;
 		estimated_rows: number | null;
+		subagent_rows: number | null;
+		subagent_spend: number;
 		escalations: number | null;
 		failovers: number | null;
 		errors: number | null;
@@ -196,10 +253,12 @@ export function buildUsageReport(db: Database, opts: { windowDays: number; harne
 		rec[m.tier] = m.n;
 		mixByModel.set(m.key, rec);
 	}
+	const feedbackBySlug = createFeedbackStore(db).countsBySlug(sinceMs, harnessId);
 	const models: ModelRow[] = modelRows.map((r) => ({
 		...toRow(r, windowSpend),
 		provider: r.key.startsWith("ollama/") ? "ollama" : "openrouter",
 		tiers: mixByModel.get(r.key) ?? {},
+		feedback: feedbackBySlug.get(r.key) ?? { good: 0, bad: 0 },
 	}));
 
 	const tiers = (
@@ -221,6 +280,42 @@ export function buildUsageReport(db: Database, opts: { windowDays: number; harne
 		cacheHitRate: d.prompt_tokens > 0 ? d.cached_tokens / d.prompt_tokens : 0,
 	}));
 
+	const an = db
+		.query(
+			`SELECT COUNT(*) AS rows, AVG(json_extract(features, '$.anatomy.messages')) AS msgs,
+				AVG(json_extract(features, '$.anatomy.systemBytes')) AS sys, AVG(json_extract(features, '$.anatomy.userBytes')) AS usr,
+				AVG(json_extract(features, '$.anatomy.assistantBytes')) AS asst, AVG(json_extract(features, '$.anatomy.toolBytes')) AS tool,
+				AVG(json_extract(features, '$.toolSchemaBytes')) AS schemas,
+				AVG(json_extract(features, '$.anatomy.olderHalfBytes')) AS older, AVG(json_extract(features, '$.anatomy.staleToolBytes')) AS stale
+			 FROM ledger WHERE ${where} AND json_extract(features, '$.anatomy.messages') IS NOT NULL`,
+		)
+		.get(bind) as { rows: number; msgs: number | null; sys: number | null; usr: number | null; asst: number | null; tool: number | null; schemas: number | null; older: number | null; stale: number | null };
+	let anatomy: AnatomyShare | null = null;
+	if (an.rows > 0) {
+		const total = (an.sys ?? 0) + (an.usr ?? 0) + (an.asst ?? 0) + (an.tool ?? 0);
+		const share = (v: number | null): number => (total > 0 ? (v ?? 0) / total : 0);
+		anatomy = {
+			rows: an.rows,
+			avgMessages: Math.round(an.msgs ?? 0),
+			system: share(an.sys),
+			user: share(an.usr),
+			assistant: share(an.asst),
+			tool: share(an.tool),
+			schemas: share(an.schemas),
+			olderHalf: share(an.older),
+			staleTool: share(an.stale),
+		};
+	}
+
+	// Counterfactual: the window's tokens on one model throughout, at list
+	// price with the window's own cache hit rate (cached tokens read at the
+	// baseline's cache rate, or full price when it publishes none).
+	const baselines: BaselineRow[] = (opts.baselines ?? []).map((b) => {
+		const fresh = Math.max(0, t.prompt_tokens - t.cached_tokens);
+		const usd = fresh * b.prompt + t.cached_tokens * (b.cacheRead ?? b.prompt) + t.completion_tokens * b.completion;
+		return { slug: b.slug, usd, savedShare: usd > 0 ? 1 - t.spend / usd : 0 };
+	});
+
 	return {
 		generatedAtMs: nowMs,
 		windowDays,
@@ -239,11 +334,15 @@ export function buildUsageReport(db: Database, opts: { windowDays: number; harne
 			aborted: t.aborted ?? 0,
 			modelSwitches: switches,
 			cacheEstimated: (t.estimated_rows ?? 0) > 0,
+			subagentDispatches: t.subagent_rows ?? 0,
+			subagentSpendUsd: t.subagent_spend,
 		},
 		providers,
 		models,
 		tiers,
 		days,
+		anatomy,
+		baselines,
 	};
 }
 
@@ -294,6 +393,22 @@ export function reportView(r: UsageReport, opts: { maxModels?: number } = {}): R
 		`spend ${usd(t.spendUsd)} over ${num(t.dispatches)} dispatches in ${num(t.conversations)} conversations · ${usd(t.dispatches > 0 ? t.spendUsd / t.dispatches : 0)}/dispatch`,
 		`prompt ${num(t.promptTokens)} tok (cache hit ${pct(t.cacheHitRate, t.cacheEstimated)}) · completion ${num(t.completionTokens)} tok · switches ${num(t.modelSwitches)} · escalations ${num(t.escalations)} · failovers ${num(t.failovers)} · errors ${num(t.errors)} (${num(t.aborted)} aborted)`,
 	];
+	if (r.baselines.length > 0 && t.dispatches > 0) {
+		summary.push(
+			`same traffic on one model: ${r.baselines
+				.map((b) => `${b.slug} ${usd(b.usd)} (router ${b.savedShare >= 0 ? "saved" : "cost extra"} ${pct(Math.abs(b.savedShare))})`)
+				.join(" · ")}`,
+		);
+	}
+	if (t.subagentDispatches > 0) {
+		summary.push(`subagents: ${num(t.subagentDispatches)} dispatches, ${usd(t.subagentSpendUsd)} (${pct(t.spendUsd > 0 ? t.subagentSpendUsd / t.spendUsd : 0)} of spend)`);
+	}
+	const a = r.anatomy;
+	if (a !== null) {
+		summary.push(
+			`prompt anatomy (mean of ${num(a.rows)}): tool results ${pct(a.tool)} · assistant ${pct(a.assistant)} · user ${pct(a.user)} · system ${pct(a.system)} · tool schemas +${pct(a.schemas)} · older half ${pct(a.olderHalf)} · stale tool results ${pct(a.staleTool)} · ${num(a.avgMessages)} messages`,
+		);
+	}
 	const tables: ReportTable[] = [];
 	if (r.providers.length > 0) {
 		tables.push({
@@ -307,7 +422,7 @@ export function reportView(r: UsageReport, opts: { maxModels?: number } = {}): R
 		tables.push({
 			id: "models",
 			title: `models (top ${Math.min(maxModels, r.models.length)} of ${r.models.length} by spend)`,
-			headers: ["model", "dispatches", "spend", "share", "cache", "ttft", "speed", "tiers"],
+			headers: ["model", "dispatches", "spend", "share", "cache", "ttft", "speed", "feedback", "tiers"],
 			rows: r.models.slice(0, maxModels).map((m) => [
 				m.key,
 				num(m.dispatches),
@@ -316,6 +431,7 @@ export function reportView(r: UsageReport, opts: { maxModels?: number } = {}): R
 				pct(m.cacheHitRate, m.cacheEstimated),
 				ms(m.avgTtftMs),
 				tps(m.tokensPerSec),
+				m.feedback.good + m.feedback.bad === 0 ? "" : `+${m.feedback.good}/-${m.feedback.bad}`,
 				Object.entries(m.tiers)
 					.sort((a, b) => b[1] - a[1])
 					.map(([k, v]) => `${k}:${v}`)

package/src/cost/types.ts

@@ -177,8 +177,11 @@ export interface ModelTrust {
 	escalations: number;
 	/** Attempts that ended in an upstream error. */
 	errors: number;
-	/** Laplace-smoothed success rate, 0-1. */
+	/** Laplace-smoothed success rate, 0-1; user verdicts weigh in at filters.feedbackWeight. */
 	successRate: number;
+	/** User verdicts in the window (/router good|bad). */
+	feedbackGood?: number;
+	feedbackBad?: number;
 	/** Mean absolute relative prediction error, for forecast calibration. */
 	meanCostError: number;
 }
@@ -200,9 +203,24 @@ export interface ModelLatency {
 	tokensPerSec: number;
 }
 
+/**
+ * How often a model's prompt cache actually hit when the router expected it
+ * warm: the previous kept turn of the conversation was on the same model
+ * within `hysteresis.cacheWarmTtlMs`. Provider-side misses (a model whose
+ * cache is flaky, or absent) show up here as a low rate. Router-estimated
+ * cache counts (Ollama) are excluded: they are constructed, not observed.
+ */
+export interface ModelCacheReliability {
+	slug: string;
+	samples: number;
+	/** Mean cached / expected-cached over those samples, 0-1. */
+	hitRate: number;
+}
+
 export interface LedgerSignals {
 	trust: ModelTrust | null;
 	latency: ModelLatency | null;
+	cache?: ModelCacheReliability | null;
 }
 
 /** Measured price of a probe escalation: what the retry billed per prompt token of the failed turn. */
@@ -241,7 +259,20 @@ export interface Ledger {
 	 * escalation-cost term in candidate scoring is inert without it.
 	 */
 	escalationCost?(windowDays: number): EscalationCost | null;
+	/**
+	 * Observed cache hit rate when a warm cache was expected (see
+	 * ModelCacheReliability). Null until any sample exists. Optional so fakes
+	 * need not implement it; the stay/switch comparison assumes a reliable
+	 * cache without it.
+	 */
+	cacheReliability?(slug: string): ModelCacheReliability | null;
 	/** Observed chars-per-token ratio for a tokenizer family; null until calibrated. */
 	tokenRatio(tokenizer: string): number | null;
 	recentEntries(limit: number): LedgerEntry[];
+	/** Spend since an instant on slugs with a prefix (`ollama/`), for provider-level reconciliation. Optional. */
+	providerSpendSince?(slugPrefix: string, sinceMs: number): number;
+	/** Newest kept (non-wasted) entry for an omp session, for /router why and feedback. Optional so fakes need not implement it. */
+	latestForSession?(ompSessionId: string): LedgerEntry | null;
+	/** Newest entries for an omp session, newest first. Optional. */
+	entriesForSession?(ompSessionId: string, limit: number): LedgerEntry[];
 }

package/src/router/candidates.ts

@@ -111,12 +111,21 @@ function expectedWaitMs(latency: ModelLatency, expectedCompletionTokens: number)
  * tiny cost and capped at LATENCY_EXCESS_CAP, so the model stays cheapest. That is
  * `filters.maxExpectedWaitMs`'s job — a hard drop, applied in buildCandidates.
  */
-function latencyMultiplier(latency: ModelLatency | null, filters: FilterConfig, expectedCompletionTokens: number): number {
-	if (latency === null || filters.latencyWeight <= 0 || latency.samples < filters.latencyMinSamples) return 1;
+/**
+ * The latency weight in force for a turn: the continuation weight on a
+ * tool-result continuation when one is configured, else the general one.
+ * A person waits on first token only when the turn is theirs.
+ */
+export function latencyWeightFor(filters: FilterConfig, isToolResultContinuation: boolean): number {
+	return isToolResultContinuation && filters.latencyWeightContinuation !== undefined ? filters.latencyWeightContinuation : filters.latencyWeight;
+}
+
+function latencyMultiplier(latency: ModelLatency | null, filters: FilterConfig, expectedCompletionTokens: number, weight = filters.latencyWeight): number {
+	if (latency === null || weight <= 0 || latency.samples < filters.latencyMinSamples) return 1;
 	const waitMs = expectedWaitMs(latency, expectedCompletionTokens);
 	const refWaitMs = filters.latencyReferenceMs + (expectedCompletionTokens / filters.latencyReferenceTokensPerSec) * 1000;
 	const excess = refWaitMs > 0 ? Math.max(0, (waitMs - refWaitMs) / refWaitMs) : 0;
-	return 1 + filters.latencyWeight * Math.min(excess, LATENCY_EXCESS_CAP);
+	return 1 + weight * Math.min(excess, LATENCY_EXCESS_CAP);
 }
 
 export function buildCandidates(args: BuildCandidatesArgs): { candidates: Candidate[]; rejected: Rejection[] } {
@@ -320,7 +329,7 @@ export function buildCandidates(args: BuildCandidatesArgs): { candidates: Candid
 		// 20% of the time really costs ~25% more in retries. Latency does the same
 		// for slowness (TTFT over the reference). qualityExponent 0 makes this
 		// "cheapest above the floor"; the floor does the quality work.
-		const latencyMult = latencyMultiplier(latency, filters, expectedCompletionTokens);
+		const latencyMult = latencyMultiplier(latency, filters, expectedCompletionTokens, latencyWeightFor(filters, features.isToolResultContinuation));
 		// Escalation-cost term: the trust divisor prices a failure as a retry of
 		// THIS model, but a probe escalation re-dispatches the whole prompt on
 		// the next tier's model — measured at ~700x a cheap model's own turn cost.

package/src/router/classify.ts

@@ -10,6 +10,7 @@ import type { Ledger } from "../cost/types.ts";
 import { estimateTokens } from "../tokens/estimate.ts";
 import type { UpstreamClient } from "../upstream/types.ts";
 import { sha256Hex } from "../util/hash.ts";
+import { loadLearnedModel, predictRisk } from "./learned.ts";
 import type { NormRequest, ReasoningLevel } from "../wire/types.ts";
 import type { Classification, Features, TaskType, Tier } from "./types.ts";
 
@@ -165,6 +166,9 @@ export function scoreHeuristic(f: Features, cfg: RouterConfig): Classification {
 	// the served model must still accept image input — is enforced separately
 	// on `req.hasImages` in candidate selection, exactly as `classifyTask` does.
 	if (f.hasNewImage) add(W_IMAGES, "new image input");
+	if (f.readOnlyToolTail === true && cfg.classifier.readOnlyToolWeight > 0) {
+		add(-cfg.classifier.readOnlyToolWeight, "read-only tool loop (the model is looking, not deciding)");
+	}
 	if (f.toolCount > 0) add(W_TOOLS_OFFERED, `${f.toolCount} tools offered`);
 
 	score = Math.min(1, Math.max(0, score));
@@ -303,6 +307,15 @@ export async function classify(
 ): Promise<Classification> {
 	const heuristic = scoreHeuristic(f, cfg);
 	const cc = cfg.classifier;
+	// Advisory learned risk: recorded beside the decision, never acted on here.
+	if (cc.learnedModelPath !== "") {
+		const model = await loadLearnedModel(cc.learnedModelPath);
+		if (model !== null) {
+			const risk = predictRisk(model, f);
+			heuristic.learnedRisk = risk;
+			heuristic.reasons.push(`learned: p(escalate)=${risk.toFixed(3)}`);
+		}
+	}
 	if (cc.ambiguityThreshold <= 0 || heuristic.confidence >= cc.ambiguityThreshold) return heuristic;
 
 	const digest = buildDigest(req, f);

package/src/router/features.ts

@@ -8,7 +8,7 @@
  */
 
 import type { NormMessage, NormRequest } from "../wire/types.ts";
-import type { Features } from "./types.ts";
+import type { Features, PromptAnatomy } from "./types.ts";
 
 /**
  * Complexity signals. Deliberately small: each hit pushes the turn toward a
@@ -224,6 +224,37 @@ export function extractFeatures(req: NormRequest, promptTokens: number): Feature
 		codeBlocks === 0 &&
 		(terminators === null ? 0 : terminators.length) <= 1;
 
+	// Prompt anatomy: where the bytes sit. Cheap (one pass over textBytes) and
+	// content-free, so it is safe to record on every row.
+	const anatomy: PromptAnatomy = { messages: 0, systemBytes: 0, userBytes: 0, assistantBytes: 0, toolBytes: 0, olderHalfBytes: 0, staleToolBytes: 0 };
+	const nonSystem = messages.filter((m) => m.role !== "system");
+	const olderHalfEnd = Math.floor(nonSystem.length / 2);
+	const staleEnd = Math.max(0, nonSystem.length - 20);
+	nonSystem.forEach((m, i) => {
+		if (i < olderHalfEnd) anatomy.olderHalfBytes += m.textBytes;
+		if (m.role === "tool" && i < staleEnd) anatomy.staleToolBytes += m.textBytes;
+	});
+	for (const m of messages) {
+		anatomy.messages++;
+		if (m.role === "system") anatomy.systemBytes += m.textBytes;
+		else if (m.role === "user") anatomy.userBytes += m.textBytes;
+		else if (m.role === "assistant") anatomy.assistantBytes += m.textBytes;
+		else anatomy.toolBytes += m.textBytes;
+	}
+
+	// Read-only tool loop: the assistant call behind a tool-result tail used
+	// only tools that look at things. Tool names are the harness's own; the
+	// set covers omp's built-ins and their common aliases.
+	let readOnlyToolTail = false;
+	if (isToolResultContinuation) {
+		for (let i = messages.length - 1; i >= 0; i--) {
+			const m = messages[i];
+			if (m === undefined || m.role !== "assistant") continue;
+			if (m.toolCalls.length > 0) readOnlyToolTail = m.toolCalls.every((tc) => READ_ONLY_TOOLS.has(tc.name.toLowerCase()));
+			break;
+		}
+	}
+
 	return {
 		promptTokens,
 		newContentTokens,
@@ -246,5 +277,32 @@ export function extractFeatures(req: NormRequest, promptTokens: number): Feature
 		requestedReasoning: req.reasoning,
 		questionCount,
 		isTerseInstruction,
+		anatomy,
+		isSubagent: req.isSubagent,
+		readOnlyToolTail,
 	};
 }
+
+/** Tools that read state without changing it, in omp, Claude Code and Hermes naming. */
+export const READ_ONLY_TOOLS: ReadonlySet<string> = new Set([
+	"read",
+	"read_file",
+	"grep",
+	"glob",
+	"ls",
+	"list",
+	"list_dir",
+	"find",
+	"lsp",
+	"ast_grep",
+	"search",
+	"web_search",
+	"web_fetch",
+	"webfetch",
+	"websearch",
+	"fetch",
+	"cat",
+	"view",
+	"inspect_image",
+	"todo",
+]);

package/src/router/index.ts

@@ -38,11 +38,18 @@ export interface RouterDeps {
  */
 const NEUTRAL_TOKENIZER = "gpt";
 
-function resolveProfile(cfg: RouterConfig, requestedModel: string): ProfileConfig {
-	const exact = cfg.profiles.find((p) => p.id === requestedModel);
-	if (exact !== undefined) return exact;
+export function resolveProfile(cfg: RouterConfig, requestedModel: string, isSubagent = false): ProfileConfig {
 	const fallback = cfg.profiles[0];
 	if (fallback === undefined) throw new Error("no router profiles configured");
+	// A subagent asking for the default profile is routed under the subagent
+	// profile when one is configured and exists; an explicit other profile
+	// (auto-max, auto-cheap) is honoured as asked.
+	const exact = cfg.profiles.find((p) => p.id === requestedModel);
+	if (isSubagent && cfg.server.subagentProfile !== "" && (exact === undefined || exact.id === fallback.id)) {
+		const sub = cfg.profiles.find((p) => p.id === cfg.server.subagentProfile);
+		if (sub !== undefined) return sub;
+	}
+	if (exact !== undefined) return exact;
 	return fallback;
 }
 
@@ -52,7 +59,7 @@ export function createRouter(deps: RouterDeps): Router {
 	return {
 		async route(
 			req: NormRequest,
-			opts: { attempt: number; escalateFrom?: Tier; excludeSlugs?: readonly string[] },
+			opts: { attempt: number; escalateFrom?: Tier; excludeSlugs?: readonly string[]; forceTier?: Tier; forceSlug?: string },
 		): Promise<Decision> {
 			const state = conversations.get(req.conversationKey) ?? conversations.load(req.conversationKey);
 			const snapshot = await catalog.get();
@@ -78,6 +85,16 @@ export function createRouter(deps: RouterDeps): Router {
 					score: 1,
 					reasons: [`escalated from ${opts.escalateFrom} after attempt ${opts.attempt - 1} was rejected`],
 				};
+			} else if (opts.forceTier !== undefined) {
+				// A session override from omp: the user chose the tier for a while.
+				classification = {
+					tier: opts.forceTier,
+					task: classifyTask(features),
+					confidence: 1,
+					source: "forced",
+					score: 1,
+					reasons: [`tier ${opts.forceTier} forced by session override (/router tier)`],
+				};
 			} else {
 				classification = await classify(req, features, config, { upstream, ledger, catalog });
 			}
@@ -86,13 +103,14 @@ export function createRouter(deps: RouterDeps): Router {
 				req,
 				features,
 				classification,
-				profile: resolveProfile(config, req.requestedModel),
+				profile: resolveProfile(config, req.requestedModel, req.isSubagent),
 				state,
 				snapshot,
 				ledger,
 				cfg: config,
 				nowMs: Date.now(),
 				...(opts.excludeSlugs === undefined ? {} : { excludeSlugs: opts.excludeSlugs }),
+				...(opts.forceSlug === undefined ? {} : { forceSlug: opts.forceSlug }),
 			});
 		},
 	};