@oh-my-pi/pi-coding-agent 17.2.11 → 17.2.12

package/dist/types/tools/read-format.d.ts

@@ -0,0 +1,104 @@
+import type { AgentToolResult } from "@oh-my-pi/pi-agent-core";
+import type { ToolSession } from "../sdk.js";
+import { type LineEntry } from "../utils/block-context.js";
+import { type LineRange } from "./path-utils.js";
+import type { ReadToolDetails } from "./read.js";
+export interface HashlineHeaderContext {
+    header: string;
+    tag: string;
+    fullText?: string;
+}
+export declare function formatReadHashlineHeader(displayPath: string, tag: string): string;
+export declare function readHashlineHeaderContext(session: ToolSession, absolutePath: string, cwd: string): Promise<HashlineHeaderContext>;
+export declare function hashlineHeaderContext(displayPath: string, tag: string): HashlineHeaderContext;
+export declare function prependHashlineHeader(text: string, context: HashlineHeaderContext | undefined): string;
+export declare function formatTextWithMode(text: string, startNum: number, shouldAddHashLines: boolean, shouldAddLineNumbers: boolean): string;
+export declare const BRACKET_CONTEXT_ELLIPSIS = "\u2026";
+export declare function formatLineEntriesWithMode(entries: readonly LineEntry[], shouldAddHashLines: boolean, shouldAddLineNumbers: boolean): string;
+/**
+ * Decide whether the kept lines surrounding an elided range collapse to a
+ * single brace-pair line in the rendered summary. Returns true when the head
+ * line ends with `{` / `(` / `[` and the tail line is the matching closer
+ * (optionally followed by terminating punctuation like `;`, `,`, or further
+ * closers — e.g. `};`, `})`, `]);`).
+ */
+export declare function canMergeBracePair(headLine: string, tailLine: string): boolean;
+export declare function formatSingleLine(line: number, text: string, shouldAddHashLines: boolean, shouldAddLineNumbers: boolean): string;
+export declare function formatMergedBraceLine(startLine: number, endLine: number, headText: string, tailText: string, shouldAddHashLines: boolean, shouldAddLineNumbers: boolean): {
+    model: string;
+    display: string;
+};
+export declare function countTextLines(text: string): number;
+export declare function contiguousLineNumbers(startLine: number, count: number): number[];
+export declare function lineNumbersFromSpans(spans: readonly {
+    startLine: number;
+    endLine: number;
+}[]): number[];
+/** Inclusive line range describing one elided span in a structural summary. */
+export interface ElidedRange {
+    start: number;
+    end: number;
+}
+/**
+ * Footer appended to summarized reads telling the model how to recover the
+ * elided body. Without this hint, agents either ignore the `…`/`{ … }`
+ * markers or burn a turn guessing the right selector (see issue #1046). The
+ * footer demonstrates the multi-range selector syntax with concrete sample
+ * ranges drawn from the actual elision so the model re-reads only what it
+ * needs instead of falling back to `:raw` or whole-file reads.
+ */
+export declare function formatSummaryElisionFooter(readPath: string, elidedRanges: ReadonlyArray<ElidedRange>, elidedLines: number): string;
+export declare const READ_CHUNK_SIZE: number;
+/**
+ * Context lines added around an explicit range read. Anchor-stale failures
+ * cluster on edits whose anchors land just outside the most recent read
+ * window, but the data (`scripts/session-stats/analyze_selector_reads.py`)
+ * shows most follow-up reads are disjoint hops, not adjacent extensions —
+ * so symmetric padding rarely pays for itself.
+ *
+ * Leading=1 catches accidental single-line reads where the anchor is the
+ * line immediately above the requested start. Trailing=3 buffers the
+ * common case where the agent asks for a narrow range and then needs the
+ * next few lines to disambiguate an anchor.
+ */
+export declare const RANGE_LEADING_CONTEXT_LINES = 1;
+export declare const RANGE_TRAILING_CONTEXT_LINES = 3;
+export declare function buildInMemoryTextResult(session: ToolSession, text: string, offset: number | undefined, limit: number | undefined, options: {
+    details?: ReadToolDetails;
+    sourcePath?: string;
+    sourceUrl?: string;
+    sourceInternal?: string;
+    entityLabel: string;
+    ignoreResultLimits?: boolean;
+    raw?: boolean;
+    immutable?: boolean;
+}): AgentToolResult<ReadToolDetails>;
+/**
+ * Render a multi-range read against in-memory text. Each range emits a
+ * formatted block with its own anchors / line numbers, blocks are joined
+ * with an elision separator, and ranges past EOF surface as `[…]` notices
+ * so the model can correct the next call. No leading/trailing context is
+ * added — multi-range callers always specify exact bounds.
+ */
+export declare function buildInMemoryMultiRangeResult(session: ToolSession, text: string, ranges: readonly LineRange[], options: {
+    details?: ReadToolDetails;
+    sourcePath?: string;
+    sourceUrl?: string;
+    sourceInternal?: string;
+    entityLabel: string;
+    raw?: boolean;
+    immutable?: boolean;
+}): AgentToolResult<ReadToolDetails>;
+export declare function decodeUtf8Text(bytes: Uint8Array): string | null;
+export declare function prependSuffixResolutionNotice(text: string, suffixResolution?: {
+    from: string;
+    to: string;
+}): string;
+/**
+ * Tag Markdown reads for the TUI's formatted preview, gated on the opt-in
+ * `read.renderMarkdown` setting. Off by default; when disabled, no local
+ * read is tagged `text/markdown`, so the renderer output is identical to
+ * the pre-setting behavior. Internal-URL reads keep their protocol-supplied
+ * `contentType` and render as Markdown regardless of the setting.
+ */
+export declare function markMarkdownContentType(session: ToolSession, details: ReadToolDetails, filePath: string): ReadToolDetails;

package/dist/types/tools/read-path-resolution.d.ts

@@ -0,0 +1,19 @@
+import type { ToolSession } from "../sdk.js";
+export declare function isRemoteMountPath(absolutePath: string): boolean;
+export declare function isNotFoundError(error: unknown): boolean;
+/** Per-execute memo of suffix-glob lookups; `null` records a confirmed miss. */
+export type SuffixMatchCache = Map<string, {
+    absolutePath: string;
+    displayPath: string;
+} | null>;
+/**
+ * Memoized {@link findUniqueWorkspaceSuffix} for a single read call. A missing
+ * path with archive/sqlite extensions probes the workspace once per stage
+ * (archive candidates, sqlite candidates, plain path) — each glob carries a
+ * 5s timeout, so repeated lookups of the same string stack into a long
+ * stall before erroring. The cache collapses repeats within one execute().
+ */
+export declare function findSuffixMatchCached(session: ToolSession, cache: SuffixMatchCache, rawPath: string, signal?: AbortSignal): Promise<{
+    absolutePath: string;
+    displayPath: string;
+} | null>;

package/dist/types/tools/read-pdf-images.d.ts

@@ -0,0 +1,12 @@
+import type { AgentToolResult } from "@oh-my-pi/pi-agent-core";
+import type { ToolSession } from "../sdk.js";
+import type { ReadToolDetails } from "./read.js";
+export declare function rewritePdfImagePlaceholders(markdown: string, pdfPath: string): string;
+export declare function splitPdfImageMemberReadPath(readPath: string): {
+    pdfPath: string;
+    member: string;
+} | null;
+export declare function readPdfImageMember(session: ToolSession, autoResizeImages: boolean, absolutePdfPath: string, pdfDisplayPath: string, member: string, suffixResolution: {
+    from: string;
+    to: string;
+} | undefined, signal?: AbortSignal): Promise<AgentToolResult<ReadToolDetails>>;

package/dist/types/tools/read-renderer.d.ts

@@ -0,0 +1,24 @@
+import type { Component } from "@oh-my-pi/pi-tui";
+import type { RenderResultOptions } from "../extensibility/custom-tools/types.js";
+import { type Theme } from "../modes/theme/theme.js";
+import type { ReadToolDetails } from "./read.js";
+interface ReadRenderArgs {
+    path?: unknown;
+    file_path?: unknown;
+    offset?: number;
+    limit?: number;
+    raw?: boolean;
+}
+export declare const readToolRenderer: {
+    renderCall(args: ReadRenderArgs, _options: RenderResultOptions, uiTheme: Theme): Component;
+    renderResult(result: {
+        content: Array<{
+            type: string;
+            text?: string;
+        }>;
+        details?: ReadToolDetails;
+        isError?: boolean;
+    }, options: RenderResultOptions, uiTheme: Theme, args?: ReadRenderArgs): Component;
+    mergeCallAndResult: boolean;
+};
+export {};

package/dist/types/tools/read-selector.d.ts

@@ -0,0 +1,27 @@
+import type { LineRange } from "./path-utils.js";
+/** Parsed representation of a path-embedded selector. */
+export type ParsedSelector = {
+    kind: "none";
+} | {
+    kind: "raw";
+} | {
+    kind: "conflicts";
+} | {
+    kind: "lines";
+    ranges: [LineRange, ...LineRange[]];
+    raw?: boolean;
+};
+/** Returns true when the selector requested verbatim/raw output (alone or combined with a range). */
+export declare function isRawSelector(parsed: ParsedSelector): boolean;
+/** Returns true when the selector requested multiple line ranges. */
+export declare function isMultiRange(parsed: ParsedSelector): boolean;
+export declare function parseSel(sel: string | undefined): ParsedSelector;
+/**
+ * Convert a single-range selector to the offset/limit pair used by internal pagination.
+ * Returns the FIRST range only — multi-range callers MUST branch on `isMultiRange` before
+ * calling this helper.
+ */
+export declare function selToOffsetLimit(parsed: ParsedSelector): {
+    offset?: number;
+    limit?: number;
+};

package/dist/types/tools/read-sqlite.d.ts

@@ -0,0 +1,16 @@
+import type { AgentToolResult } from "@oh-my-pi/pi-agent-core";
+import type { ToolSession } from "../sdk.js";
+import type { ReadToolDetails } from "./read.js";
+import { type SuffixMatchCache } from "./read-path-resolution.js";
+interface ResolvedSqliteReadPath {
+    absolutePath: string;
+    sqliteSubPath: string;
+    queryString: string;
+    suffixResolution?: {
+        from: string;
+        to: string;
+    };
+}
+export declare function resolveSqliteReadPath(session: ToolSession, readPath: string, suffixCache: SuffixMatchCache, signal?: AbortSignal): Promise<ResolvedSqliteReadPath | null>;
+export declare function readSqlite(resolvedSqlitePath: ResolvedSqliteReadPath, signal?: AbortSignal): Promise<AgentToolResult<ReadToolDetails>>;
+export {};

package/dist/types/tools/read-summary.d.ts

@@ -0,0 +1,19 @@
+import { type SummaryResult } from "@oh-my-pi/pi-natives";
+import type { ToolSession } from "../sdk.js";
+import { type ElidedRange } from "./read-format.js";
+/**
+ * Prose files (Markdown flavors and plain text) skip code-block summarization
+ * unless `read.summarize.prose` opts them in.
+ */
+export declare function isProseSummaryPath(filePath: string): boolean;
+export declare function routeReadThroughBridge(session: ToolSession, absolutePath: string, options?: {
+    line?: number;
+    limit?: number;
+}): Promise<string> | undefined;
+export declare function trySummarize(session: ToolSession, absolutePath: string, fileSize: number, signal?: AbortSignal): Promise<SummaryResult | null>;
+export declare function renderSummary(session: ToolSession, summary: SummaryResult): {
+    text: string;
+    displayText: string;
+    elidedRanges: ElidedRange[];
+    elidedLines: number;
+};

package/dist/types/tools/read.d.ts

@@ -1,10 +1,8 @@
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback, ToolTier } from "@oh-my-pi/pi-agent-core";
-import type { Component } from "@oh-my-pi/pi-tui";
-import type { RenderResultOptions } from "../extensibility/custom-tools/types.js";
-import { type Theme } from "../modes/theme/theme.js";
 import type { ToolSession } from "../sdk.js";
 import { type TruncationResult } from "../session/streaming-output.js";
 import { type OutputMeta } from "./output-meta.js";
+export { readToolRenderer } from "./read-renderer.js";
 declare const readSchema: import("@oh-my-pi/omptype").FluentType<{
     path: string;
 }, {
@@ -76,23 +74,3 @@ export declare class ReadTool implements AgentTool<typeof readSchema, ReadToolDe
     syncInspectImageState(availableOverride?: boolean): boolean;
     execute(_toolCallId: string, params: ReadParams, signal?: AbortSignal, _onUpdate?: AgentToolUpdateCallback<ReadToolDetails>, _toolContext?: AgentToolContext): Promise<AgentToolResult<ReadToolDetails>>;
 }
-interface ReadRenderArgs {
-    path?: unknown;
-    file_path?: unknown;
-    offset?: number;
-    limit?: number;
-    raw?: boolean;
-}
-export declare const readToolRenderer: {
-    renderCall(args: ReadRenderArgs, _options: RenderResultOptions, uiTheme: Theme): Component;
-    renderResult(result: {
-        content: Array<{
-            type: string;
-            text?: string;
-        }>;
-        details?: ReadToolDetails;
-        isError?: boolean;
-    }, options: RenderResultOptions, uiTheme: Theme, args?: ReadRenderArgs): Component;
-    mergeCallAndResult: boolean;
-};
-export {};

package/dist/types/tools/shell-tokenize.d.ts

@@ -17,7 +17,7 @@ export declare function tokenizeShellSegments(command: string): string[][];
  *
  * @see extractFlatShellCommandSegments
  */
-export interface FlatShellCommandSegment {
+interface FlatShellCommandSegment {
     /** Original segment text with quoting and escaping preserved. */
     text: string;
     /**
@@ -57,3 +57,4 @@ export declare function extractLeadingCdTarget(command: string): {
     path: string;
     rest: string;
 } | null;
+export {};

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

@@ -38,11 +38,6 @@ export declare function formatStartupChangelogSummary(selection: StartupChangelo
  */
 export declare function resolveBundledChangelogPath(assetPath: string, moduleUrl: string | URL): string | URL;
 export declare function parseChangelog(changelogPath: string | undefined): Promise<ChangelogEntry[]>;
-/**
- * Compare changelog entries by their parsed version parts.
- * Returns: -1 if v1 < v2, 0 if v1 === v2, 1 if v1 > v2
- */
-export declare function compareChangelogEntries(v1: ChangelogEntry, v2: ChangelogEntry): number;
 /**
  * Parse an omp changelog marker version into comparable parts.
  */

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "17.2.11",
+	"version": "17.2.12",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://omp.sh",
 	"author": "Can Boluk",
@@ -50,18 +50,18 @@
 	},
 	"dependencies": {
 		"@babel/parser": "^7.29.7",
-		"@oh-my-pi/hashline": "17.2.11",
-		"@oh-my-pi/omp-stats": "17.2.11",
-		"@oh-my-pi/omptype": "17.2.11",
-		"@oh-my-pi/pi-agent-core": "17.2.11",
-		"@oh-my-pi/pi-ai": "17.2.11",
-		"@oh-my-pi/pi-catalog": "17.2.11",
-		"@oh-my-pi/pi-mnemopi": "17.2.11",
-		"@oh-my-pi/pi-natives": "17.2.11",
-		"@oh-my-pi/pi-tui": "17.2.11",
-		"@oh-my-pi/pi-utils": "17.2.11",
-		"@oh-my-pi/pi-wire": "17.2.11",
-		"@oh-my-pi/snapcompact": "17.2.11",
+		"@oh-my-pi/hashline": "17.2.12",
+		"@oh-my-pi/omp-stats": "17.2.12",
+		"@oh-my-pi/omptype": "17.2.12",
+		"@oh-my-pi/pi-agent-core": "17.2.12",
+		"@oh-my-pi/pi-ai": "17.2.12",
+		"@oh-my-pi/pi-catalog": "17.2.12",
+		"@oh-my-pi/pi-mnemopi": "17.2.12",
+		"@oh-my-pi/pi-natives": "17.2.12",
+		"@oh-my-pi/pi-tui": "17.2.12",
+		"@oh-my-pi/pi-utils": "17.2.12",
+		"@oh-my-pi/pi-wire": "17.2.12",
+		"@oh-my-pi/snapcompact": "17.2.12",
 		"@opentelemetry/api": "^1.9.1",
 		"@opentelemetry/api-logs": "^0.220.0",
 		"@opentelemetry/context-async-hooks": "^2.9.0",

package/src/advisor/runtime.ts

@@ -5,7 +5,8 @@ import * as AIError from "@oh-my-pi/pi-ai/error";
 import { raceWithSignal } from "@oh-my-pi/pi-ai/utils/abort";
 import { type CursorExecResolvedCarrier, kCursorExecResolved } from "@oh-my-pi/pi-ai/utils/block-symbols";
 import { logger } from "@oh-my-pi/pi-utils";
-import { obfuscateToolArguments, type SecretObfuscator } from "../secrets/obfuscator";
+import { obfuscateToolArguments } from "../secrets/message-transform";
+import type { SecretObfuscator } from "../secrets/obfuscator";
 import {
 	formatExecutionSourcePreview,
 	formatSessionHistoryMarkdown,
@@ -970,14 +971,16 @@ export class AdvisorRuntime {
 					this.#wakeAllWaiters();
 					const failedMessages = this.agent.state.messages.slice(messageSnapshot);
 					const terminalFailure = this.#terminalAssistantFailure(messageSnapshot);
-					const classifierRefusal =
-						(terminalFailure !== undefined && isClassifierRefusal(terminalFailure)) ||
-						AIError.is(AIError.classify(err), AIError.Flag.ContentBlocked);
+					const rawErrorId = AIError.classify(err);
 					const terminalFailureId =
 						terminalFailure === undefined ? undefined : AIError.classifyMessage(terminalFailure);
+					const classifierRefusal =
+						(terminalFailure !== undefined && isClassifierRefusal(terminalFailure)) ||
+						(!AIError.is(rawErrorId, AIError.Flag.AccountPolicy) &&
+							AIError.is(rawErrorId, AIError.Flag.ContentBlocked));
 					const contextOverflow =
 						(terminalFailureId !== undefined && AIError.is(terminalFailureId, AIError.Flag.ContextOverflow)) ||
-						AIError.is(AIError.classify(err), AIError.Flag.ContextOverflow);
+						AIError.is(rawErrorId, AIError.Flag.ContextOverflow);
 					// A terminal provider failure that is neither retriable nor an
 					// overflow (e.g. a blocked prompt) will fail identically on every
 					// retry — classify it before rollback so the batch is dropped after
@@ -1208,12 +1211,14 @@ export class AdvisorRuntime {
 	}
 }
 
-/** Mirrors turn recovery's refusal classification and retains AIError's provider-neutral content-block fallback. */
+/** Mirrors turn recovery's refusal classification without treating account eligibility as a model refusal. */
 function isClassifierRefusal(message: AssistantMessage): boolean {
 	if (message.stopReason !== "error") return false;
+	const id = AIError.classifyMessage(message);
+	if (AIError.is(id, AIError.Flag.AccountPolicy)) return false;
 	const stopType = message.stopDetails?.type;
 	if (stopType === "refusal" || stopType === "sensitive") return true;
-	return AIError.is(AIError.classifyMessage(message), AIError.Flag.ContentBlocked);
+	return AIError.is(id, AIError.Flag.ContentBlocked);
 }
 
 /**

package/src/config/custom-models.ts

@@ -0,0 +1,188 @@
+import type { Api, Model, ModelSpec, RemoteCompactionConfig } from "@oh-my-pi/pi-ai/types";
+import { buildModel } from "@oh-my-pi/pi-catalog/build";
+import {
+	getBundledModelReferenceIndex,
+	inheritReferenceThinking,
+	resolveModelReference,
+} from "@oh-my-pi/pi-catalog/identity";
+import { getVariantAliasSources, resolveVariantAlias } from "@oh-my-pi/pi-catalog/variant-collapse";
+import { logger } from "@oh-my-pi/pi-utils";
+import { createLiveConfigHeaders, type HeaderSource } from "./model-config-values";
+import { type ModelPatch, mergeCompat, mergeRemoteCompactionConfig } from "./model-patch";
+import { parseModelString } from "./model-resolver";
+import type { ModelOverride, ProviderAuthMode } from "./models-config-schema";
+export interface CustomModelDefinitionLike extends ModelPatch {
+	id: string;
+	api?: Api;
+	baseUrl?: string;
+	cost?: Model<Api>["cost"];
+}
+
+export interface CustomModelBuildOptions {
+	useDefaults: boolean;
+}
+
+export interface CustomModelOverlay extends ModelPatch {
+	id: string;
+	provider: string;
+	api: Api;
+	baseUrl: string;
+	cost?: Model<Api>["cost"];
+	isOAuth?: boolean;
+}
+
+function mergeCustomModelHeaders(
+	providerHeaders: Record<string, string> | undefined,
+	modelHeaders: Record<string, string> | undefined,
+	authHeader: boolean | undefined,
+	apiKeyConfig: string | undefined,
+): Record<string, string> | undefined {
+	return createLiveConfigHeaders([providerHeaders, modelHeaders], { authHeader, apiKeyConfig });
+}
+
+export function mergeAuthHeaderSources(
+	sources: readonly HeaderSource[],
+	authHeader: boolean | undefined,
+	apiKeyConfig: string | undefined,
+): Record<string, string> | undefined {
+	return createLiveConfigHeaders(sources, { authHeader, apiKeyConfig });
+}
+
+/**
+ * Decide whether a custom-yaml model should force OAuth-style request shaping.
+ * - Explicit `auth: oauth` → force on.
+ *   endpoints are typically Claude-Code-style proxies (e.g. CLIProxyAPI) that expect
+ *   the cloaked request shape regardless of how the proxy itself is authenticated.
+ * - Otherwise → unset.
+ */
+function resolveCustomModelIsOAuth(api: Api, providerAuth: ProviderAuthMode | undefined): boolean | undefined {
+	if (providerAuth === "oauth") return true;
+	if (providerAuth !== undefined) return undefined;
+	if (api === "anthropic-messages") return true;
+	return undefined;
+}
+
+export function buildCustomModelOverlay(
+	providerName: string,
+	providerBaseUrl: string,
+	providerApi: Api | undefined,
+	providerHeaders: Record<string, string> | undefined,
+	providerApiKey: string | undefined,
+	authHeader: boolean | undefined,
+	providerCompat: ModelSpec<Api>["compat"] | undefined,
+	providerAuth: ProviderAuthMode | undefined,
+	providerRemoteCompaction: RemoteCompactionConfig<Api> | undefined,
+	modelDef: CustomModelDefinitionLike,
+): CustomModelOverlay | undefined {
+	const api = modelDef.api ?? providerApi;
+	if (!api) return undefined;
+	return {
+		id: modelDef.id,
+		provider: providerName,
+		api,
+		baseUrl: modelDef.baseUrl ?? providerBaseUrl,
+		name: modelDef.name,
+		reasoning: modelDef.reasoning,
+		thinking: modelDef.thinking,
+		input: modelDef.input,
+		supportsTools: modelDef.supportsTools,
+		cost: modelDef.cost,
+		contextWindow: modelDef.contextWindow,
+		maxTokens: modelDef.maxTokens,
+		omitMaxOutputTokens: modelDef.omitMaxOutputTokens,
+		headers: mergeCustomModelHeaders(providerHeaders, modelDef.headers, authHeader, providerApiKey),
+		compat: mergeCompat(providerCompat, modelDef.compat),
+		contextPromotionTarget: modelDef.contextPromotionTarget,
+		compactionModel: modelDef.compactionModel,
+		remoteCompaction: mergeRemoteCompactionConfig(providerRemoteCompaction, modelDef.remoteCompaction),
+		premiumMultiplier: modelDef.premiumMultiplier,
+		isOAuth: resolveCustomModelIsOAuth(api, providerAuth),
+	};
+}
+
+function applyStandaloneCustomModelPolicies(model: CustomModelOverlay): CustomModelOverlay {
+	if (model.id !== "gpt-5.4" || model.provider === "github-copilot" || model.contextWindow !== undefined) {
+		return model;
+	}
+	return { ...model, contextWindow: 1_000_000 };
+}
+
+export function finalizeCustomModel(model: CustomModelOverlay, options: CustomModelBuildOptions): Model<Api> {
+	const resolvedModel = options.useDefaults ? applyStandaloneCustomModelPolicies(model) : model;
+	const reference = options.useDefaults
+		? resolveModelReference(resolvedModel.id, getBundledModelReferenceIndex())
+		: undefined;
+	const cost =
+		resolvedModel.cost ??
+		reference?.cost ??
+		(options.useDefaults ? { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 } : undefined);
+	const input = resolvedModel.input ?? reference?.input ?? (options.useDefaults ? ["text"] : undefined);
+	const supportsTools = resolvedModel.supportsTools ?? reference?.supportsTools;
+	return buildModel({
+		id: resolvedModel.id,
+		name: resolvedModel.name ?? (options.useDefaults ? resolvedModel.id : undefined),
+		api: resolvedModel.api,
+		provider: resolvedModel.provider,
+		baseUrl: resolvedModel.baseUrl,
+		reasoning: resolvedModel.reasoning ?? reference?.reasoning ?? (options.useDefaults ? false : undefined),
+		thinking: inheritReferenceThinking(resolvedModel.thinking, reference, resolvedModel.provider),
+		input: input as ("text" | "image")[],
+		...(supportsTools !== undefined ? { supportsTools } : {}),
+		cost,
+		contextWindow: resolvedModel.contextWindow ?? reference?.contextWindow ?? (options.useDefaults ? 128000 : null),
+		maxTokens: resolvedModel.maxTokens ?? reference?.maxTokens ?? (options.useDefaults ? 16384 : null),
+		headers: resolvedModel.headers,
+		omitMaxOutputTokens: resolvedModel.omitMaxOutputTokens ?? reference?.omitMaxOutputTokens,
+		compat: mergeCompat(reference?.compatConfig, resolvedModel.compat),
+		contextPromotionTarget: resolvedModel.contextPromotionTarget,
+		compactionModel: resolvedModel.compactionModel,
+		remoteCompaction: resolvedModel.remoteCompaction,
+		premiumMultiplier: resolvedModel.premiumMultiplier,
+		isOAuth: resolvedModel.isOAuth,
+	} as ModelSpec<Api>);
+}
+
+export function normalizeSuppressedSelector(
+	selector: string,
+	hasLiveModel?: (provider: string, id: string) => boolean,
+): string {
+	const trimmed = selector.trim();
+	if (!trimmed) return trimmed;
+	const parsed = parseModelString(trimmed, {
+		allowMaxSuffix: true,
+		allowAutoAlias: true,
+		isLiteralModelId: (provider, id) => hasLiveModel?.(provider, id) === true,
+	});
+	if (!parsed) return trimmed;
+	// Retired effort-tier variant ids normalize to their collapsed logical id
+	// so persisted suppressions keyed by raw member ids still bind.
+	const aliasId = resolveVariantAlias(parsed.provider, parsed.id);
+	return `${parsed.provider}/${aliasId ?? parsed.id}`;
+}
+
+/**
+ * Look up a model's override, falling back to entries keyed by retired
+ * effort-tier variant ids (models.yml authored before collapsing). A raw key
+ * only re-binds when no live model holds that id.
+ */
+export function resolveModelOverrideWithAliases(
+	overrides: Map<string, ModelOverride>,
+	model: Model<Api>,
+	hasLiveModel: (provider: string, id: string) => boolean,
+): ModelOverride | undefined {
+	const direct = overrides.get(model.id);
+	if (direct) return direct;
+	for (const rawId of getVariantAliasSources(model.provider, model.id)) {
+		if (hasLiveModel(model.provider, rawId)) continue;
+		const remapped = overrides.get(rawId);
+		if (remapped) {
+			logger.debug("model override re-keyed through variant alias", {
+				provider: model.provider,
+				from: rawId,
+				to: model.id,
+			});
+			return remapped;
+		}
+	}
+	return undefined;
+}