@oh-my-pi/pi-coding-agent 16.2.5 → 16.2.7

package/src/commands/bench.ts

@@ -1,5 +1,6 @@
 import { Args, Command, Flags } from "@oh-my-pi/pi-utils/cli";
 import { runBenchCommand } from "../cli/bench-cli";
+import { SERVICE_TIER_OPENAI_VALUES } from "../config/service-tier";
 
 export default class Bench extends Command {
 	static description =
@@ -14,16 +15,22 @@ export default class Bench extends Command {
 	};
 
 	static flags = {
-		runs: Flags.integer({ description: "Requests per model (results are averaged)", default: 1 }),
+		runs: Flags.integer({ description: "Requests per model (results are averaged)", default: 10 }),
 		"max-tokens": Flags.integer({ description: "Max output tokens per request", default: 512 }),
 		prompt: Flags.string({ description: "Custom prompt text (default: bundled bench prompt)" }),
+		"service-tier": Flags.string({
+			description: "Service tier applied per model family (default: configured `tier.*` settings; `none` omits it)",
+			options: SERVICE_TIER_OPENAI_VALUES,
+		}),
 		json: Flags.boolean({ description: "Output JSON" }),
+		par: Flags.integer({ description: "Execute runs with N parallel queries/requests", default: 4 }),
 	};
 
 	static examples = [
 		"# Compare two models\n  omp bench anthropic/claude-opus-4-5 openai/gpt-5.2",
 		"# Fuzzy selectors work\n  omp bench opus sonnet",
 		"# Average over 3 runs each\n  omp bench opus gpt-5.2 --runs 3",
+		"# Force priority serving tier\n  omp bench openai-codex/gpt-5.5:low --runs 10 --service-tier priority",
 		"# Machine-readable output\n  omp bench opus --json",
 	];
 
@@ -35,7 +42,9 @@ export default class Bench extends Command {
 				runs: flags.runs,
 				maxTokens: flags["max-tokens"],
 				prompt: flags.prompt,
+				serviceTier: flags["service-tier"],
 				json: flags.json,
+				par: flags.par,
 			},
 		});
 	}

package/src/config/mcp-schema.json

@@ -22,7 +22,16 @@
     },
     "disabledServers": {
       "type": "array",
-      "description": "User-level denylist for disabling discovered servers by name.",
+      "description": "User-level denylist for disabling discovered servers by name. Highest precedence: a server here is hidden regardless of any other source.",
+      "items": {
+        "type": "string",
+        "minLength": 1
+      },
+      "uniqueItems": true
+    },
+    "enabledServers": {
+      "type": "array",
+      "description": "User-level allowlist that overrides a discovered server's `enabled: false` flag (e.g. when the source config is owned by another tool such as opencode.json). The denylist still wins.",
       "items": {
         "type": "string",
         "minLength": 1
@@ -92,7 +101,7 @@
         },
         "prompt": {
           "type": "string",
-          "description": "OAuth `prompt` parameter sent during authorization (default: \"consent\" so the provider always shows its account/consent screen; set to \"\" to omit)."
+          "description": "OAuth `prompt` parameter sent during authorization (default: omit unless the requested scope contains `offline_access`, which sends \"consent\"; set to \"\" to always omit)."
         }
       },
       "description": "Explicit OAuth client settings for servers that need them during /mcp reauth or initial connect."

package/src/config/model-discovery.ts

@@ -122,6 +122,12 @@ type OllamaDiscoveredModelMetadata = {
 type LlamaCppDiscoveredServerMetadata = {
 	contextWindow?: number;
 	input?: ("text" | "image")[];
+	maxTokens?: "contextWindow";
+};
+
+type LlamaCppDiscoveredModelRuntimeMetadata = {
+	contextWindow: number;
+	maxTokens: number;
 };
 
 type LlamaCppModelListEntry = {
@@ -143,6 +149,44 @@ function toPositiveNumberOrUndefined(value: unknown): number | undefined {
 	return undefined;
 }
 
+function isLlamaCppUnlimitedSentinel(value: unknown): boolean {
+	if (typeof value === "number") {
+		return value === -1;
+	}
+	if (typeof value === "string" && value.trim()) {
+		return Number(value) === -1;
+	}
+	return false;
+}
+
+/**
+ * llama.cpp `/props.default_generation_settings.params.{max_tokens,n_predict}`
+ * are per-request defaults the server applies when a client omits the field —
+ * clients can still raise them per call. Positive values therefore are NOT
+ * hard model caps; only the `-1` unlimited sentinel reliably tells us the
+ * server bounds generation by the runtime context window. Anything else
+ * leaves the discovery default in place.
+ */
+function extractLlamaCppMaxTokens(payload: Record<string, unknown>): "contextWindow" | undefined {
+	const generationSettings = payload.default_generation_settings;
+	const params = isRecord(generationSettings) ? generationSettings.params : undefined;
+	const candidates = [
+		isRecord(params) ? params.max_tokens : undefined,
+		isRecord(params) ? params.n_predict : undefined,
+		isRecord(generationSettings) ? generationSettings.max_tokens : undefined,
+		isRecord(generationSettings) ? generationSettings.n_predict : undefined,
+		payload.max_tokens,
+		payload.n_predict,
+	];
+	return candidates.some(isLlamaCppUnlimitedSentinel) ? "contextWindow" : undefined;
+}
+
+function resolveLlamaCppMaxTokens(contextWindow: number, maxTokens: "contextWindow" | undefined): number {
+	return maxTokens === "contextWindow"
+		? contextWindow
+		: Math.min(contextWindow, maxTokens ?? DISCOVERY_DEFAULT_MAX_TOKENS);
+}
+
 function extractOllamaRuntimeContextWindow(payload: Record<string, unknown>): number | undefined {
 	const parameters = payload.parameters;
 	if (typeof parameters !== "string") {
@@ -353,6 +397,7 @@ async function discoverLlamaCppServerMetadata(
 		}
 		return {
 			contextWindow: extractLlamaCppContextWindow(payload),
+			maxTokens: extractLlamaCppMaxTokens(payload),
 			input: extractLlamaCppInputCapabilities(payload),
 		};
 	} catch {
@@ -410,7 +455,7 @@ export async function discoverLlamaCppModels(
 				imageInputDecoder: "stb",
 				cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
 				contextWindow,
-				maxTokens: Math.min(contextWindow, DISCOVERY_DEFAULT_MAX_TOKENS),
+				maxTokens: resolveLlamaCppMaxTokens(contextWindow, serverMetadata?.maxTokens),
 				headers,
 				compat: {
 					supportsStore: false,
@@ -423,24 +468,37 @@ export async function discoverLlamaCppModels(
 	return discovered;
 }
 
-export async function discoverLlamaCppModelContextWindow(
+export async function discoverLlamaCppModelRuntimeMetadata(
 	model: Pick<Model<Api>, "provider" | "id" | "baseUrl" | "headers">,
 	ctx: DiscoveryContext,
-): Promise<number | undefined> {
+): Promise<LlamaCppDiscoveredModelRuntimeMetadata | undefined> {
 	const baseUrl = normalizeLlamaCppBaseUrl(model.baseUrl);
 	const modelsUrl = `${baseUrl}/models`;
 	const baseHeaders: Record<string, string> = { ...(model.headers ?? {}) };
 	const attempt = async (headers: Record<string, string>) => {
-		const response = await ctx.fetch(modelsUrl, {
-			headers,
-			signal: AbortSignal.timeout(250),
-		});
+		const [response, serverMetadata] = await Promise.all([
+			ctx.fetch(modelsUrl, {
+				headers,
+				signal: AbortSignal.timeout(250),
+			}),
+			discoverLlamaCppServerMetadata(ctx, baseUrl, headers),
+		]);
 		if (!response.ok) {
 			return undefined;
 		}
 		const entries = parseLlamaCppModelList(await response.json());
 		const entry = entries.find(entry => entry.id === model.id);
-		return entry?.runtimeContextWindow ?? entry?.trainingContextWindow;
+		if (!entry) {
+			return undefined;
+		}
+		const contextWindow = entry.runtimeContextWindow ?? serverMetadata?.contextWindow ?? entry.trainingContextWindow;
+		if (contextWindow === undefined) {
+			return undefined;
+		}
+		return {
+			contextWindow,
+			maxTokens: resolveLlamaCppMaxTokens(contextWindow, serverMetadata?.maxTokens),
+		};
 	};
 	try {
 		const apiKey = await ctx.getBearerApiKeyResolver(model.provider);

package/src/config/model-registry.ts

@@ -75,7 +75,7 @@ import {
 	DISCOVERY_DEFAULT_MAX_TOKENS,
 	type DiscoveryContext,
 	type DiscoveryProviderConfig,
-	discoverLlamaCppModelContextWindow,
+	discoverLlamaCppModelRuntimeMetadata,
 	discoverModelsByProviderType,
 	getImplicitOllamaBaseUrl,
 	getOllamaContextLengthOverride,
@@ -873,10 +873,11 @@ export class ModelRegistry {
 		if (!isLlamaCppDiscovery) {
 			return model;
 		}
-		const contextWindow = await discoverLlamaCppModelContextWindow(model, this.#nonResolvingDiscoveryContext());
-		if (contextWindow === undefined) {
+		const runtimeMetadata = await discoverLlamaCppModelRuntimeMetadata(model, this.#nonResolvingDiscoveryContext());
+		if (runtimeMetadata === undefined) {
 			return this.find(model.provider, model.id) ?? model;
 		}
+		const { contextWindow, maxTokens } = runtimeMetadata;
 		const current = this.find(model.provider, model.id) ?? model;
 		const override = this.#resolveLiveModelOverride(current);
 		const customModel = this.#resolveLiveCustomModelOverlay(current);
@@ -888,13 +889,19 @@ export class ModelRegistry {
 		) {
 			patch.contextWindow = contextWindow;
 		}
-		const maxTokens = Math.min(contextWindow, DISCOVERY_DEFAULT_MAX_TOKENS);
+		const effectiveContextWindow =
+			override?.contextWindow ??
+			customModel?.contextWindow ??
+			patch.contextWindow ??
+			current.contextWindow ??
+			contextWindow;
+		const effectiveMaxTokens = Math.min(maxTokens, effectiveContextWindow);
 		if (
 			override?.maxTokens === undefined &&
 			customModel?.maxTokens === undefined &&
-			current.maxTokens !== maxTokens
+			current.maxTokens !== effectiveMaxTokens
 		) {
-			patch.maxTokens = maxTokens;
+			patch.maxTokens = effectiveMaxTokens;
 		}
 		if (patch.contextWindow === undefined && patch.maxTokens === undefined) {
 			return current;

package/src/config/service-tier.ts

@@ -1,87 +1,116 @@
-import type { ServiceTier } from "@oh-my-pi/pi-ai";
+import type { ServiceTier, ServiceTierByFamily } from "@oh-my-pi/pi-ai";
 import type { SubmenuOption } from "./settings-schema";
 
 /**
- * Service-tier setting values shared by every "Service Tier" setting. `"none"`
- * is the omit-the-parameter sentinel; the remaining values mirror
- * {@link ServiceTier}.
+ * Per-family service-tier setting values. `"none"` is the omit-the-parameter
+ * sentinel; the rest mirror the wire {@link ServiceTier} values each provider
+ * family actually realizes. OpenAI accepts the full set; Anthropic realizes
+ * only `priority` (fast mode); Google (Gemini API + Vertex) realizes
+ * `flex`/`priority`.
  */
-export const SERVICE_TIER_SETTING_VALUES = [
+export const SERVICE_TIER_OPENAI_VALUES = ["none", "auto", "default", "flex", "scale", "priority"] as const;
+export const SERVICE_TIER_ANTHROPIC_VALUES = ["none", "priority"] as const;
+export const SERVICE_TIER_GOOGLE_VALUES = ["none", "flex", "priority"] as const;
+
+export type ServiceTierOpenAISettingValue = (typeof SERVICE_TIER_OPENAI_VALUES)[number];
+export type ServiceTierAnthropicSettingValue = (typeof SERVICE_TIER_ANTHROPIC_VALUES)[number];
+export type ServiceTierGoogleSettingValue = (typeof SERVICE_TIER_GOOGLE_VALUES)[number];
+
+/**
+ * Inherit-capable single value for the subagent/advisor tiers. The chosen tier
+ * is broadcast across families and applied to whichever family the spawned
+ * model belongs to (clamped to what that family realizes); `"inherit"` defers
+ * to the main agent's live per-family selection.
+ */
+export const SERVICE_TIER_INHERIT_SETTING_VALUES = [
+	"inherit",
 	"none",
 	"auto",
 	"default",
 	"flex",
 	"scale",
 	"priority",
-	"openai-only",
-	"claude-only",
 ] as const;
 
-export type ServiceTierSettingValue = (typeof SERVICE_TIER_SETTING_VALUES)[number];
-
-/** Variant value set for scoped service-tier settings (subagent/advisor) that can defer to the main agent. */
-export const SERVICE_TIER_INHERIT_SETTING_VALUES = ["inherit", ...SERVICE_TIER_SETTING_VALUES] as const;
-
 export type ServiceTierInheritSettingValue = (typeof SERVICE_TIER_INHERIT_SETTING_VALUES)[number];
 
-/** Submenu descriptions shared by the base `serviceTier` setting. */
-export const SERVICE_TIER_OPTIONS: ReadonlyArray<SubmenuOption<ServiceTierSettingValue>> = [
-	{ value: "none", label: "None", description: "Omit service_tier parameter" },
-	{ value: "auto", label: "Auto", description: "Use provider default tier selection (OpenAI)" },
-	{ value: "default", label: "Default", description: "Standard priority processing (OpenAI)" },
-	{ value: "flex", label: "Flex", description: "Flexible capacity tier when available (OpenAI)" },
-	{ value: "scale", label: "Scale", description: "Scale Tier credits when available (OpenAI)" },
+export const SERVICE_TIER_OPENAI_OPTIONS: ReadonlyArray<SubmenuOption<ServiceTierOpenAISettingValue>> = [
+	{ value: "none", label: "None", description: "Omit service_tier (standard processing)" },
+	{ value: "auto", label: "Auto", description: "Provider default tier selection" },
+	{ value: "default", label: "Default", description: "Standard priority processing" },
+	{ value: "flex", label: "Flex", description: "Lower cost, higher latency when available" },
+	{ value: "scale", label: "Scale", description: "Scale Tier credits when available" },
+	{ value: "priority", label: "Priority", description: "Faster, higher cost (premium request)" },
+];
+
+export const SERVICE_TIER_ANTHROPIC_OPTIONS: ReadonlyArray<SubmenuOption<ServiceTierAnthropicSettingValue>> = [
+	{ value: "none", label: "None", description: "Standard processing" },
 	{
 		value: "priority",
 		label: "Priority",
-		description: "Priority on every supported provider (OpenAI `service_tier`, Anthropic fast mode)",
-	},
-	{
-		value: "openai-only",
-		label: "Priority (OpenAI only)",
-		description: "Priority on OpenAI/OpenAI-Codex requests; ignored elsewhere",
-	},
-	{
-		value: "claude-only",
-		label: "Priority (Claude only)",
-		description: "Anthropic fast mode on direct Claude requests; ignored elsewhere (incl. Bedrock/Vertex)",
+		description: 'Fast mode (`speed: "fast"`) on supported direct Claude models; ignored on Bedrock/Vertex',
 	},
 ];
 
-/** Submenu descriptions for inherit-capable service-tier settings. */
+export const SERVICE_TIER_GOOGLE_OPTIONS: ReadonlyArray<SubmenuOption<ServiceTierGoogleSettingValue>> = [
+	{ value: "none", label: "None", description: "Standard processing" },
+	{ value: "flex", label: "Flex", description: "Lower cost, higher latency (Gemini API + Vertex)" },
+	{ value: "priority", label: "Priority", description: "Faster, higher reliability (Gemini API + Vertex)" },
+];
+
 export const SERVICE_TIER_INHERIT_OPTIONS: ReadonlyArray<SubmenuOption<ServiceTierInheritSettingValue>> = [
-	{ value: "inherit", label: "Inherit", description: "Use the main agent's Service Tier" },
-	...SERVICE_TIER_OPTIONS,
+	{ value: "inherit", label: "Inherit", description: "Match the main agent's live per-family tiers" },
+	{ value: "none", label: "None", description: "Standard processing" },
+	{ value: "auto", label: "Auto", description: "Provider default tier selection (OpenAI family)" },
+	{ value: "default", label: "Default", description: "Standard priority processing (OpenAI family)" },
+	{ value: "flex", label: "Flex", description: "Flexible capacity tier (OpenAI/Google families)" },
+	{ value: "scale", label: "Scale", description: "Scale Tier credits (OpenAI family)" },
+	{ value: "priority", label: "Priority", description: "Priority on every supported family of the spawned model" },
 ];
 
+/** Map a per-family setting value to a wire {@link ServiceTier}, or `undefined` to omit. */
+export function serviceTierSettingToTier(value: string): ServiceTier | undefined {
+	if (value === "none" || value === "" || value === "inherit") return undefined;
+	return value as ServiceTier;
+}
+
+/** Assemble the live per-family tier map from the three `tier.*` setting values. */
+export function buildServiceTierByFamily(openai: string, anthropic: string, google: string): ServiceTierByFamily {
+	const out: ServiceTierByFamily = {};
+	const o = serviceTierSettingToTier(openai);
+	if (o) out.openai = o;
+	const a = serviceTierSettingToTier(anthropic);
+	if (a) out.anthropic = a;
+	const g = serviceTierSettingToTier(google);
+	if (g) out.google = g;
+	return out;
+}
+
 /**
- * Resolve a service-tier setting value to the wire {@link ServiceTier} (or
- * `undefined` to omit). `"inherit"` defers to `inherited`; `"none"` omits.
+ * Broadcast a single chosen tier across families, clamped to what each family
+ * realizes: OpenAI takes any tier, Anthropic only `priority`, Google only
+ * `flex`/`priority`. Used by the subagent/advisor single-value settings and the
+ * `omp bench --service-tier` flag, which apply one tier to whatever family the
+ * target model belongs to.
  */
-export function resolveServiceTierSetting(value: string, inherited: ServiceTier | undefined): ServiceTier | undefined {
-	if (value === "inherit") return inherited;
-	if (value === "none" || value === "") return undefined;
-	return value as ServiceTier;
+export function serviceTierForAllFamilies(tier: ServiceTier | undefined): ServiceTierByFamily {
+	if (!tier) return {};
+	const out: ServiceTierByFamily = { openai: tier };
+	if (tier === "priority") out.anthropic = "priority";
+	if (tier === "flex" || tier === "priority") out.google = tier;
+	return out;
 }
 
 /**
- * Resolve the `serviceTier` *setting value* to stamp onto a subagent's settings
- * snapshot.
+ * Resolve a subagent/advisor service-tier setting to a per-family map.
  *
- * - A concrete `subagentSetting` (`"none"` or a tier) wins outright.
- * - `"inherit"` defers to the parent's live effective tier when the caller has a
- *   live session (`inherited` passed as `ServiceTier | null`, where `null` means
- *   the parent explicitly has no tier — e.g. `/fast off`). When no live session
- *   is available (`inherited === undefined`, e.g. cold subagent revive) it falls
- *   back to the parent's configured `serviceTier` setting so behavior matches a
- *   plain settings snapshot.
+ * - A concrete tier is broadcast across families (see
+ *   {@link serviceTierForAllFamilies}).
+ * - `"none"` yields an empty map.
+ * - `"inherit"` defers to `inherited` — the parent's live per-family tiers when
+ *   a live session supplied them, else the empty map.
  */
-export function resolveSubagentServiceTier(
-	subagentSetting: string,
-	configuredTier: ServiceTierSettingValue,
-	inherited: ServiceTier | null | undefined,
-): ServiceTierSettingValue {
-	if (subagentSetting !== "inherit") return subagentSetting as ServiceTierSettingValue;
-	if (inherited === undefined) return configuredTier;
-	return inherited ?? "none";
+export function resolveSubagentServiceTier(setting: string, inherited: ServiceTierByFamily): ServiceTierByFamily {
+	if (setting === "inherit") return inherited;
+	return serviceTierForAllFamilies(serviceTierSettingToTier(setting));
 }

package/src/config/settings-schema.ts

@@ -36,10 +36,14 @@ import {
 import { EDIT_MODES } from "../utils/edit-mode";
 import { SEARCH_PROVIDER_OPTIONS, SEARCH_PROVIDER_PREFERENCES, type SearchProviderId } from "../web/search/types";
 import {
+	SERVICE_TIER_ANTHROPIC_OPTIONS,
+	SERVICE_TIER_ANTHROPIC_VALUES,
+	SERVICE_TIER_GOOGLE_OPTIONS,
+	SERVICE_TIER_GOOGLE_VALUES,
 	SERVICE_TIER_INHERIT_OPTIONS,
 	SERVICE_TIER_INHERIT_SETTING_VALUES,
-	SERVICE_TIER_OPTIONS,
-	SERVICE_TIER_SETTING_VALUES,
+	SERVICE_TIER_OPENAI_OPTIONS,
+	SERVICE_TIER_OPENAI_VALUES,
 } from "./service-tier";
 
 /** Unified settings schema - single source of truth for all settings.
@@ -1214,72 +1218,74 @@ export const SETTINGS_SCHEMA = {
 		},
 	},
 
-	serviceTier: {
+	"tier.openai": {
 		type: "enum",
-		values: SERVICE_TIER_SETTING_VALUES,
+		values: SERVICE_TIER_OPENAI_VALUES,
 		default: "none",
 		ui: {
 			tab: "model",
 			group: "Sampling",
-			label: "Service Tier",
+			label: "Service Tier — OpenAI",
 			description:
-				'Processing priority hint (none = omit). OpenAI accepts the tier values directly; Anthropic realizes `priority` as `speed: "fast"` on supported Opus models. Scoped values target one family.',
-			options: SERVICE_TIER_OPTIONS,
+				"Processing tier for OpenAI / OpenAI-Codex requests, and OpenAI-family models routed via OpenRouter (none = omit). Sent as `service_tier`.",
+			options: SERVICE_TIER_OPENAI_OPTIONS,
 		},
 	},
 
-	serviceTierSubagent: {
+	"tier.anthropic": {
 		type: "enum",
-		values: SERVICE_TIER_INHERIT_SETTING_VALUES,
-		default: "inherit",
+		values: SERVICE_TIER_ANTHROPIC_VALUES,
+		default: "none",
 		ui: {
 			tab: "model",
 			group: "Sampling",
-			label: "Service Tier - Subagent",
+			label: "Service Tier — Anthropic",
 			description:
-				"Service Tier for spawned task/eval subagents. Inherit = match the main agent's live tier (tracks /fast); pick a value to scope subagents independently.",
-			options: SERVICE_TIER_INHERIT_OPTIONS,
+				'Processing tier for Claude requests. `priority` realizes fast mode (`speed: "fast"`) on supported direct Anthropic models; ignored on Bedrock/Vertex Claude and via OpenRouter.',
+			options: SERVICE_TIER_ANTHROPIC_OPTIONS,
 		},
 	},
 
-	serviceTierAdvisor: {
+	"tier.google": {
 		type: "enum",
-		values: SERVICE_TIER_INHERIT_SETTING_VALUES,
+		values: SERVICE_TIER_GOOGLE_VALUES,
 		default: "none",
 		ui: {
 			tab: "model",
 			group: "Sampling",
-			label: "Service Tier - Advisor",
+			label: "Service Tier — Google",
+			description:
+				"Processing tier for Gemini (Google AI Studio + Vertex) requests, and Google-family models routed via OpenRouter (none = omit). Sent as the top-level `serviceTier` field.",
+			options: SERVICE_TIER_GOOGLE_OPTIONS,
+		},
+	},
+
+	"tier.subagent": {
+		type: "enum",
+		values: SERVICE_TIER_INHERIT_SETTING_VALUES,
+		default: "inherit",
+		ui: {
+			tab: "model",
+			group: "Sampling",
+			label: "Service Tier — Subagent",
 			description:
-				"Service Tier for the advisor model. None = standard processing; Inherit = match the main agent's live tier; pick a value (e.g. Priority) to run the advisor on a faster serving path.",
+				"Service Tier for spawned task/eval subagents. Inherit = match the main agent's live per-family tiers (tracks /fast); pick a value to apply it to whichever family the subagent's model belongs to.",
 			options: SERVICE_TIER_INHERIT_OPTIONS,
-			condition: "advisorEnabled",
 		},
 	},
 
-	fastModeScope: {
+	"tier.advisor": {
 		type: "enum",
-		values: ["both", "openai", "claude"] as const,
-		default: "both",
+		values: SERVICE_TIER_INHERIT_SETTING_VALUES,
+		default: "none",
 		ui: {
 			tab: "model",
 			group: "Sampling",
-			label: "Fast Mode Scope",
+			label: "Service Tier — Advisor",
 			description:
-				'Which providers `/fast on` (and the fast-mode toggle) target. "both" = priority on every supported provider; "openai"/"claude" scope it to one family (mirrors serviceTier openai-only/claude-only).',
-			options: [
-				{ value: "both", label: "Both", description: "Priority on every supported provider" },
-				{
-					value: "openai",
-					label: "OpenAI only",
-					description: "Priority on OpenAI/OpenAI-Codex requests; ignored elsewhere",
-				},
-				{
-					value: "claude",
-					label: "Claude only",
-					description: "Anthropic fast mode on direct Claude requests; ignored elsewhere",
-				},
-			],
+				"Service Tier for the advisor model. None = standard processing; Inherit = match the main agent's live per-family tiers; pick a value to apply it to the advisor model's family.",
+			options: SERVICE_TIER_INHERIT_OPTIONS,
+			condition: "advisorEnabled",
 		},
 	},
 

package/src/config/settings.ts

@@ -1148,6 +1148,53 @@ export class Settings {
 		// the incoherent "hashline edits without addressable anchors" state.
 		delete raw.readHashLines;
 
+		// serviceTier (single enum with scoped openai-only/claude-only sentinels)
+		// → per-family tier.openai/tier.anthropic/tier.google; serviceTierSubagent
+		// → tier.subagent; serviceTierAdvisor → tier.advisor. `fastModeScope` is
+		// dropped — per-family scoping is now expressed by the three tier settings.
+		const tierObj = isRecord(raw.tier) ? raw.tier : {};
+		let tierTouched = false;
+		const setTier = (family: string, value: unknown): void => {
+			if (value !== undefined && !(family in tierObj)) {
+				tierObj[family] = value;
+				tierTouched = true;
+			}
+		};
+		if (typeof raw.serviceTier === "string") {
+			switch (raw.serviceTier) {
+				case "priority":
+					setTier("openai", "priority");
+					setTier("anthropic", "priority");
+					setTier("google", "priority");
+					break;
+				case "openai-only":
+					setTier("openai", "priority");
+					break;
+				case "claude-only":
+					setTier("anthropic", "priority");
+					break;
+				case "auto":
+				case "default":
+				case "flex":
+				case "scale":
+					setTier("openai", raw.serviceTier);
+					break;
+			}
+			delete raw.serviceTier;
+		}
+		const mapInheritTier = (value: unknown): unknown =>
+			value === "openai-only" || value === "claude-only" ? "priority" : value;
+		if ("serviceTierSubagent" in raw) {
+			setTier("subagent", mapInheritTier(raw.serviceTierSubagent));
+			delete raw.serviceTierSubagent;
+		}
+		if ("serviceTierAdvisor" in raw) {
+			setTier("advisor", mapInheritTier(raw.serviceTierAdvisor));
+			delete raw.serviceTierAdvisor;
+		}
+		if (tierTouched) raw.tier = tierObj;
+		delete raw.fastModeScope;
+
 		return raw;
 	}