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

package/dist/types/utils/git.d.ts

@@ -63,8 +63,18 @@ export interface StatusOptions {
     readonly untrackedFiles?: "all" | "no" | "normal";
     readonly z?: boolean;
 }
+export interface CommitAuthor {
+    readonly date?: string;
+    readonly email: string;
+    readonly name: string;
+}
+export interface CommitDetails {
+    readonly author: CommitAuthor;
+    readonly message: string;
+}
 export interface CommitOptions {
     readonly allowEmpty?: boolean;
+    readonly author?: CommitAuthor;
     readonly files?: readonly string[];
     readonly signal?: AbortSignal;
 }
@@ -78,6 +88,7 @@ export interface PatchOptions {
     readonly cached?: boolean;
     readonly check?: boolean;
     readonly env?: Record<string, string | undefined>;
+    readonly threeWay?: boolean;
     readonly signal?: AbortSignal;
 }
 export interface RestoreOptions {
@@ -195,12 +206,18 @@ export declare const show: ((cwd: string, revision: string, options?: {
     /** Get the path prefix of the current directory relative to the repo root. */
     prefix(cwd: string, signal?: AbortSignal): Promise<string>;
 };
+/** Read commit message and author metadata for replay/rewrite flows. */
+export declare function commitDetails(cwd: string, revision: string, signal?: AbortSignal): Promise<CommitDetails>;
 export declare const log: {
     /** Recent commit subjects (one-line each). */
     subjects(cwd: string, count: number, signal?: AbortSignal): Promise<string[]>;
     /** Recent commits as `<short-sha> <subject>` onelines. */
     onelines(cwd: string, count: number, signal?: AbortSignal): Promise<string[]>;
 };
+export declare const revList: {
+    /** Commits in `base..head`, oldest first. */
+    range(cwd: string, base: string, head: string, signal?: AbortSignal): Promise<string[]>;
+};
 export declare const branch: {
     /** Current branch name, or null if detached/unavailable. */
     current(cwd: string, signal?: AbortSignal): Promise<string | null>;

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "16.2.6",
+	"version": "16.2.7",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://omp.sh",
 	"author": "Can Boluk",
@@ -55,17 +55,17 @@
 		"@agentclientprotocol/sdk": "0.25.0",
 		"@babel/parser": "^7.29.7",
 		"@mozilla/readability": "^0.6.0",
-		"@oh-my-pi/hashline": "16.2.6",
-		"@oh-my-pi/omp-stats": "16.2.6",
-		"@oh-my-pi/pi-agent-core": "16.2.6",
-		"@oh-my-pi/pi-ai": "16.2.6",
-		"@oh-my-pi/pi-catalog": "16.2.6",
-		"@oh-my-pi/pi-mnemopi": "16.2.6",
-		"@oh-my-pi/pi-natives": "16.2.6",
-		"@oh-my-pi/pi-tui": "16.2.6",
-		"@oh-my-pi/pi-utils": "16.2.6",
-		"@oh-my-pi/pi-wire": "16.2.6",
-		"@oh-my-pi/snapcompact": "16.2.6",
+		"@oh-my-pi/hashline": "16.2.7",
+		"@oh-my-pi/omp-stats": "16.2.7",
+		"@oh-my-pi/pi-agent-core": "16.2.7",
+		"@oh-my-pi/pi-ai": "16.2.7",
+		"@oh-my-pi/pi-catalog": "16.2.7",
+		"@oh-my-pi/pi-mnemopi": "16.2.7",
+		"@oh-my-pi/pi-natives": "16.2.7",
+		"@oh-my-pi/pi-tui": "16.2.7",
+		"@oh-my-pi/pi-utils": "16.2.7",
+		"@oh-my-pi/pi-wire": "16.2.7",
+		"@oh-my-pi/snapcompact": "16.2.7",
 		"@opentelemetry/api": "^1.9.1",
 		"@opentelemetry/context-async-hooks": "^2.7.1",
 		"@opentelemetry/exporter-trace-otlp-proto": "^0.218.0",

package/src/cli/bench-cli.ts

@@ -10,9 +10,10 @@ import type {
 	Model,
 	ProviderSessionState,
 	ServiceTier,
+	ServiceTierByFamily,
 	SimpleStreamOptions,
 } from "@oh-my-pi/pi-ai";
-import { streamSimple } from "@oh-my-pi/pi-ai";
+import { resolveModelServiceTier, streamSimple } from "@oh-my-pi/pi-ai";
 import { buildModelProviderPriorityRank, type CanonicalModelVariant } from "@oh-my-pi/pi-catalog/identity";
 import { replaceTabs, truncateToWidth } from "@oh-my-pi/pi-tui";
 import { formatDuration, getProjectDir } from "@oh-my-pi/pi-utils";
@@ -25,7 +26,7 @@ import {
 	getModelMatchPreferences,
 	resolveCliModel,
 } from "../config/model-resolver";
-import { resolveServiceTierSetting } from "../config/service-tier";
+import { buildServiceTierByFamily, serviceTierForAllFamilies, serviceTierSettingToTier } from "../config/service-tier";
 import { Settings } from "../config/settings";
 import benchPrompt from "../prompts/bench.md" with { type: "text" };
 import { discoverAuthStorage, loadCliExtensionProviders } from "../sdk";
@@ -106,8 +107,8 @@ export interface BenchSummary {
 	maxTokens: number;
 	models: BenchModelReport[];
 	failures: number;
-	/** Requested service tier passed to every request; absent when none was requested. Scoped tiers (`openai-only`/`claude-only`) may be dropped per-provider downstream. */
-	serviceTier?: ServiceTier;
+	/** Requested per-family service tiers, resolved per model before reaching the wire. */
+	serviceTierByFamily?: ServiceTierByFamily;
 }
 
 type BenchStreamSimple = (
@@ -518,12 +519,18 @@ export async function runBenchCommand(command: BenchCommandArgs, deps: BenchDepe
 	const runtime = await (deps.createRuntime ?? createDefaultRuntime)();
 	try {
 		const targets = resolveBenchModels(command.models, runtime.modelRegistry, runtime.settings, writeStderr);
-		// Explicit `--service-tier` wins; otherwise fall back to the configured
-		// `serviceTier` setting (`none`/unset omits the wire field). Scope-aware
-		// gating to the model's provider happens downstream in the provider layer.
-		const serviceTierValue = command.flags.serviceTier ?? runtime.settings?.get("serviceTier");
-		const serviceTier = serviceTierValue ? resolveServiceTierSetting(serviceTierValue, undefined) : undefined;
-		if (!json && serviceTier) writeStdout(`${chalk.dim(`service tier: ${serviceTier}`)}\n`);
+		// Explicit `--service-tier` (a single value broadcast across families) wins;
+		// otherwise fall back to the configured per-family `tier.*` settings. Each
+		// model resolves its own family's tier below before reaching the wire.
+		const flagTier = command.flags.serviceTier ? serviceTierSettingToTier(command.flags.serviceTier) : undefined;
+		const serviceTierByFamily = command.flags.serviceTier
+			? serviceTierForAllFamilies(flagTier)
+			: buildServiceTierByFamily(
+					runtime.settings?.get("tier.openai") ?? "none",
+					runtime.settings?.get("tier.anthropic") ?? "none",
+					runtime.settings?.get("tier.google") ?? "none",
+				);
+		if (!json && flagTier) writeStdout(`${chalk.dim(`service tier: ${flagTier}`)}\n`);
 		const reports: BenchModelReport[] = [];
 		for (const { selector, model, thinking } of targets) {
 			if (!json) {
@@ -564,7 +571,7 @@ export async function runBenchCommand(command: BenchCommandArgs, deps: BenchDepe
 						maxTokens,
 						reasoning: toReasoningEffort(thinking),
 						disableReasoning: shouldDisableReasoning(thinking) ? true : undefined,
-						serviceTier,
+						serviceTier: resolveModelServiceTier(serviceTierByFamily, model),
 					},
 					streamFn,
 					now,
@@ -606,7 +613,7 @@ export async function runBenchCommand(command: BenchCommandArgs, deps: BenchDepe
 			reports.push(buildModelReport(selector, model, thinking, results));
 		}
 		const failures = reports.reduce((sum, report) => sum + report.results.filter(result => !result.ok).length, 0);
-		const summary: BenchSummary = { runs, maxTokens, models: reports, failures, serviceTier };
+		const summary: BenchSummary = { runs, maxTokens, models: reports, failures, serviceTierByFamily };
 		if (json) {
 			writeStdout(`${JSON.stringify(summary, null, 2)}\n`);
 		} else if (reports.length > 1 || runs > 1) {

package/src/cli/tiny-models-cli.ts

@@ -28,12 +28,21 @@ interface ProgressReporter {
 interface DownloadResult {
 	model: TinyLocalModelKey;
 	ok: boolean;
+	error?: string;
 }
 
 function writeLine(text = ""): void {
 	process.stdout.write(`${text}\n`);
 }
 
+function downloadErrorSummary(error: string | undefined): string | undefined {
+	return error
+		?.split(/\r?\n/)
+		.map(line => line.trim())
+		.find(line => line.length > 0)
+		?.replace(/^Error:\s*/, "");
+}
+
 export function resolveModels(model: string | undefined): TinyLocalModelKey[] {
 	if (!model) return [DEFAULT_TINY_TITLE_LOCAL_MODEL_KEY];
 	// `all` is a prefetch convenience: skip models that fail before load (unsupported
@@ -101,10 +110,15 @@ async function downloadOne(modelKey: TinyLocalModelKey, json: boolean | undefine
 	const label = getTinyLocalModelSpec(modelKey)?.label ?? modelKey;
 	if (!json && !process.stdout.isTTY) writeLine(`Downloading ${label} (${modelKey})...`);
 	const progress = makeProgressReporter(modelKey, json);
-	const ok = await tinyTitleClient.downloadModel(modelKey, { onProgress: progress.onProgress });
-	progress.finish(ok);
-	if (!json && !process.stdout.isTTY) writeLine(ok ? `Downloaded ${label}.` : `Failed to download ${label}.`);
-	return { model: modelKey, ok };
+	const result = await tinyTitleClient.downloadModel(modelKey, { onProgress: progress.onProgress });
+	progress.finish(result.ok);
+	const error = downloadErrorSummary(result.error);
+	if (!json && !process.stdout.isTTY) {
+		writeLine(result.ok ? `Downloaded ${label}.` : `Failed to download ${label}${error ? `: ${error}` : ""}.`);
+	} else if (!json && !result.ok && error) {
+		writeLine(`${label} failed: ${error}`);
+	}
+	return result.error ? { model: modelKey, ok: result.ok, error: result.error } : { model: modelKey, ok: result.ok };
 }
 
 export async function runTinyModelsCommand(command: TinyModelsCommandArgs): Promise<void> {

package/src/commands/bench.ts

@@ -1,6 +1,6 @@
 import { Args, Command, Flags } from "@oh-my-pi/pi-utils/cli";
 import { runBenchCommand } from "../cli/bench-cli";
-import { SERVICE_TIER_SETTING_VALUES } from "../config/service-tier";
+import { SERVICE_TIER_OPENAI_VALUES } from "../config/service-tier";
 
 export default class Bench extends Command {
 	static description =
@@ -19,8 +19,8 @@ export default class Bench extends Command {
 		"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 hint (default: configured `serviceTier` setting; `none` omits it)",
-			options: SERVICE_TIER_SETTING_VALUES,
+			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 }),

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

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;
 	}
 

package/src/eval/agent-bridge.ts

@@ -405,8 +405,10 @@ export async function runEvalAgent(args: unknown, options: EvalAgentBridgeOption
 		parentMnemopiSessionState: options.session.getMnemopiSessionState?.(),
 		parentTelemetry: options.session.getTelemetry?.(),
 		parentAgentId: options.session.getAgentId?.() ?? MAIN_AGENT_ID,
-		// Live source of truth for `serviceTierSubagent: inherit` (null = explicit none).
-		parentServiceTier: options.session.getServiceTier ? (options.session.getServiceTier() ?? null) : undefined,
+		// Live source of truth for `tier.subagent: inherit` (null = explicit none).
+		parentServiceTier: options.session.getServiceTierByFamily
+			? (options.session.getServiceTierByFamily() ?? null)
+			: undefined,
 		// Deliberately omit parentEvalSessionId: the parent's Python kernel is
 		// blocked on this bridge call, so sharing the eval session would deadlock
 		// (subagent queues behind the parent's in-flight execution, parent waits