@oh-my-pi/pi-coding-agent 16.0.9 → 16.0.11

package/package.json

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

package/src/advisor/index.ts

@@ -1,3 +1,4 @@
 export * from "./advise-tool";
 export * from "./runtime";
+export * from "./transcript-recorder";
 export * from "./watchdog";

package/src/advisor/transcript-recorder.ts

@@ -0,0 +1,136 @@
+import * as path from "node:path";
+import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
+import type { Message, UserMessage } from "@oh-my-pi/pi-ai";
+import { logger } from "@oh-my-pi/pi-utils";
+import { SessionManager } from "../session/session-manager";
+
+/**
+ * Reserved transcript stem for advisor session files. Chosen so it cannot
+ * collide with a task subagent's `<id>.jsonl` (task ids are reserved against
+ * this exact stem in {@link AgentOutputManager}).
+ */
+export const ADVISOR_TRANSCRIPT_STEM = "__advisor";
+export const ADVISOR_TRANSCRIPT_FILENAME = `${ADVISOR_TRANSCRIPT_STEM}.jsonl`;
+
+const JSONL_SUFFIX = ".jsonl";
+
+/**
+ * Append-only persister for an advisor agent's transcript.
+ *
+ * The advisor is a passive reviewer with its own model usage, so — like a task
+ * subagent — its turns are written to a JSONL inside the owning session's
+ * artifacts dir (`<session>/__advisor.jsonl`, `<session>/<SubId>/__advisor.jsonl`
+ * for subagent advisors). That single file gives the advisor model proper usage
+ * attribution in `omp stats` (the stats parser scans the session dir
+ * recursively) and a read-only transcript in the Agent Hub, without making the
+ * advisor a registered, messageable peer.
+ *
+ * The target is derived from the *session file* (`getSessionFile()`), never
+ * `getArtifactsDir()` — subagents adopt the parent's artifact manager, so the
+ * artifacts dir points at the parent root and every subagent advisor would
+ * collide. The file path is resolved synchronously when a message finalizes and
+ * captured for the queued write, so a `/new`, resume, or session switch in
+ * flight can never misattribute an old advisor turn into the new session's file.
+ * On such a switch the previous writer is closed and the new file opened on the
+ * next recorded turn. The recorder never truncates: the advisor's in-memory
+ * context resets/compacts independently, but every billed turn is appended here.
+ */
+export class AdvisorTranscriptRecorder {
+	#manager: SessionManager | undefined;
+	#file: string | undefined;
+	/** Serializes the async open/close against synchronous appends so records land in order. */
+	#queue: Promise<void>;
+
+	/**
+	 * @param after Optional barrier the queue starts behind — used on the advisor
+	 *   on→off→on toggle so a fresh recorder's first `open` waits for the prior
+	 *   recorder's `close` and the two never hold the same `__advisor.jsonl` at once.
+	 */
+	constructor(
+		private readonly resolveSessionFile: () => string | undefined,
+		private readonly resolveCwd: () => string,
+		after?: Promise<unknown>,
+	) {
+		this.#queue = after
+			? after.then(
+					() => {},
+					() => {},
+				)
+			: Promise.resolve();
+	}
+
+	/**
+	 * Persist one finalized advisor message. Assistant turns carry the usage the
+	 * stats parser reads; tool results round out the Hub transcript; user deltas
+	 * (the advisor's "session update" prompts) are persisted but flagged
+	 * `synthetic`/agent-attributed so they never inflate user-message metrics.
+	 * Non-conversational message kinds are skipped.
+	 */
+	record(message: AgentMessage): void {
+		let persisted: Message;
+		switch (message.role) {
+			case "assistant":
+			case "toolResult":
+				persisted = message;
+				break;
+			case "user":
+				// Clone so the live advisor message stays untouched; mark synthetic so
+				// stats' user-message metrics skip these agent-internal review prompts.
+				persisted = { ...(message as UserMessage), synthetic: true, attribution: "agent" };
+				break;
+			default:
+				return;
+		}
+		const sessionFile = this.resolveSessionFile();
+		if (!sessionFile?.endsWith(JSONL_SUFFIX)) return;
+		const file = path.join(sessionFile.slice(0, -JSONL_SUFFIX.length), ADVISOR_TRANSCRIPT_FILENAME);
+		const cwd = this.resolveCwd();
+		this.#enqueue(async () => {
+			if (file !== this.#file) {
+				await this.#closeManager();
+				this.#manager = await SessionManager.open(file, undefined, undefined, {
+					initialCwd: cwd,
+					suppressBreadcrumb: true,
+				});
+				this.#file = file;
+			}
+			this.#manager?.appendMessage(persisted);
+		});
+	}
+
+	/** Flush pending writes (best-effort). */
+	flush(): Promise<void> {
+		return this.#enqueueResult(async () => {
+			if (this.#manager) await this.#manager.flush();
+		});
+	}
+
+	/** Flush and close the writer, releasing the session file. */
+	close(): Promise<void> {
+		return this.#enqueueResult(() => this.#closeManager());
+	}
+
+	async #closeManager(): Promise<void> {
+		const manager = this.#manager;
+		this.#manager = undefined;
+		this.#file = undefined;
+		if (!manager) return;
+		try {
+			await manager.close();
+		} catch (err) {
+			logger.debug("advisor transcript close failed", { err: String(err) });
+		}
+	}
+
+	#enqueue(work: () => Promise<void>): void {
+		this.#queue = this.#queue.then(work, work).catch(err => {
+			logger.debug("advisor transcript record failed", { err: String(err) });
+		});
+	}
+
+	#enqueueResult(work: () => Promise<void>): Promise<void> {
+		const next = this.#queue.then(work, work);
+		this.#queue = next.catch(() => {});
+		return next;
+	}
+}

package/src/cli/args.ts

@@ -214,7 +214,13 @@ export function parseArgs(inputArgs: string[], extensionFlags?: Map<string, { ty
 		} else if (arg === "--auto-approve" || arg === "--yolo") {
 			result.autoApprove = true;
 		} else if (arg.startsWith("@")) {
-			result.fileArgs.push(arg.slice(1)); // Remove @ prefix
+			let filePath = arg.slice(1);
+			if (filePath.startsWith('"') && filePath.endsWith('"') && filePath.length > 1) {
+				filePath = filePath.slice(1, -1);
+			} else if (filePath.startsWith("'") && filePath.endsWith("'") && filePath.length > 1) {
+				filePath = filePath.slice(1, -1);
+			}
+			result.fileArgs.push(filePath);
 		} else if (!arg.startsWith("-") || arg === "-") {
 			// Plain positional or lone `-` (stdin marker) — pass through as a
 			// message rather than flagging it.

package/src/cli/stats-cli.ts

@@ -4,6 +4,7 @@
  * Handles `omp stats` subcommand for viewing AI usage statistics.
  */
 
+import { truncateToWidth } from "@oh-my-pi/pi-tui/utils";
 import { APP_NAME, formatDuration, formatNumber, formatPercent } from "@oh-my-pi/pi-utils";
 import chalk from "chalk";
 import { openPath } from "../utils/open";
@@ -32,7 +33,7 @@ function createSyncProgressReporter(): {
 			const counter = chalk.cyan(`[${event.current}/${event.total}]`);
 			const line = `${counter} ${pct}%  ${label}`;
 			const columns = stream.columns ?? 120;
-			const trimmed = truncateToColumns(line, columns - 1);
+			const trimmed = truncateToWidth(line, columns - 1);
 			stream.write(`\r${trimmed.padEnd(lastWidth)}`);
 			lastWidth = trimmed.length;
 		},
@@ -50,16 +51,6 @@ function shortenSessionFile(p: string): string {
 	return idx >= 0 ? p.slice(idx + marker.length) : p;
 }
 
-function truncateToColumns(s: string, max: number): string {
-	if (max <= 0) return "";
-	const width = Bun.stringWidth(s, { countAnsiEscapeCodes: false });
-	if (width <= max) return s;
-	// Cheap right-trim with an ellipsis - we don't need ANSI-aware slicing
-	// because the colored prefix is short and the truncated tail is the
-	// dim filename, where dropping bytes is fine.
-	return `${s.slice(0, Math.max(0, max - 1))}\u2026`;
-}
-
 // =============================================================================
 // Types
 // =============================================================================

package/src/collab/host.ts

@@ -17,7 +17,7 @@ import { logger } from "@oh-my-pi/pi-utils";
 import type { BusChannel, AgentEvent as WireAgentEvent, SessionEntry as WireSessionEntry } from "@oh-my-pi/pi-wire";
 import type { InteractiveModeContext } from "../modes/types";
 import { AgentLifecycleManager } from "../registry/agent-lifecycle";
-import { AgentRegistry } from "../registry/agent-registry";
+import { type AgentRef, AgentRegistry } from "../registry/agent-registry";
 import type { AgentSessionEvent } from "../session/agent-session";
 import { stripImagesFromMessage, USER_INTERRUPT_LABEL } from "../session/messages";
 import type { SessionEntry as StoredSessionEntry } from "../session/session-entries";
@@ -133,7 +133,7 @@ export class CollabHost {
 		return this.#link;
 	}
 
-	/** Browser deep link (`https://<relay>/#<link>`) — the relay serves the web client at `/`. */
+	/** Browser deep link for the configured collab web UI. */
 	get webLink(): string {
 		return this.#webLink;
 	}
@@ -156,15 +156,15 @@ export class CollabHost {
 		return list;
 	}
 
-	async start(relayUrl: string): Promise<void> {
+	async start(relayUrl: string, webUrl = ""): Promise<void> {
 		const rawKey = generateRoomKey();
 		const writeToken = generateWriteToken();
 		const roomId = generateRoomId();
 		this.#writeToken = writeToken;
 		this.#link = formatCollabLink(relayUrl, roomId, rawKey, writeToken);
-		this.#webLink = formatCollabWebLink(relayUrl, roomId, rawKey, writeToken);
+		this.#webLink = formatCollabWebLink(relayUrl, roomId, rawKey, writeToken, webUrl);
 		this.#viewLink = formatCollabLink(relayUrl, roomId, rawKey);
-		this.#webViewLink = formatCollabWebLink(relayUrl, roomId, rawKey);
+		this.#webViewLink = formatCollabWebLink(relayUrl, roomId, rawKey, undefined, webUrl);
 		const parsed = parseCollabLink(this.#link);
 		if ("error" in parsed) throw new Error(parsed.error);
 		const key = await importRoomKey(rawKey);
@@ -445,18 +445,24 @@ export class CollabHost {
 	}
 
 	#snapshotAgents(): AgentSnapshot[] {
-		return AgentRegistry.global()
-			.list()
-			.map(ref => ({
-				id: ref.id,
-				displayName: ref.displayName,
-				kind: ref.kind,
-				parentId: ref.parentId,
-				status: ref.status,
-				hasSessionFile: !!ref.sessionFile,
-				createdAt: ref.createdAt,
-				lastActivity: ref.lastActivity,
-			}));
+		return (
+			AgentRegistry.global()
+				.list()
+				// Advisor transcripts are local observability only; never mirror them to
+				// guests (the wire AgentSnapshot kind has no `advisor`, and guests must not
+				// be able to chat/kill/revive them).
+				.filter((ref): ref is AgentRef & { kind: "main" | "sub" } => ref.kind !== "advisor")
+				.map(ref => ({
+					id: ref.id,
+					displayName: ref.displayName,
+					kind: ref.kind,
+					parentId: ref.parentId,
+					status: ref.status,
+					hasSessionFile: !!ref.sessionFile,
+					createdAt: ref.createdAt,
+					lastActivity: ref.lastActivity,
+				}))
+		);
 	}
 
 	#scheduleAgentsBroadcast(): void {
@@ -472,6 +478,12 @@ export class CollabHost {
 			this.#rejectReadOnly("agent control", fromPeer);
 			return;
 		}
+		// Advisor refs are excluded from snapshots, but reject control by id defensively:
+		// a stale/malicious client must never chat/kill/revive a read-only advisor transcript.
+		if (AgentRegistry.global().get(agentId)?.kind === "advisor") {
+			this.#socket?.send({ t: "error", message: `agent ${agentId}: advisor transcripts are read-only` }, fromPeer);
+			return;
+		}
 		const fail = (err: unknown) => {
 			logger.warn("collab agent-cmd failed", { cmd, agentId, error: String(err) });
 			this.#socket?.send({ t: "error", message: `agent ${agentId}: ${String(err)}` }, fromPeer);

package/src/collab/protocol.ts

@@ -116,6 +116,10 @@ const BARE_LINK_RE = /^([A-Za-z0-9_-]{10,64})[#.]([A-Za-z0-9_-]+)$/;
 const B64URL_RE = /^[A-Za-z0-9_-]+$/;
 const LOCAL_HOSTNAMES: Record<string, true> = { localhost: true, "127.0.0.1": true, "::1": true, "[::1]": true };
 
+function isLocalHostname(hostname: string): boolean {
+	return LOCAL_HOSTNAMES[hostname] === true;
+}
+
 export function generateRoomId(): string {
 	const bytes = new Uint8Array(ROOM_ID_BYTES);
 	crypto.getRandomValues(bytes);
@@ -143,7 +147,7 @@ function normalizeRelayOrigin(relayUrl: string): { origin: string } | { error: s
 		default:
 			return { error: `Unsupported relay URL scheme: ${url.protocol}` };
 	}
-	if (scheme === "ws:" && !LOCAL_HOSTNAMES[url.hostname]) {
+	if (scheme === "ws:" && !isLocalHostname(url.hostname)) {
 		return { error: "relay link must be wss:// (plain ws:// is only allowed for localhost)" };
 	}
 	const port = url.port ? `:${url.port}` : "";
@@ -178,24 +182,48 @@ export function formatCollabLink(relayUrl: string, roomId: string, key: Uint8Arr
 	return `${compact}/r/${roomId}.${keyText}`;
 }
 
+function normalizeCollabWebBaseUrl(relayUrl: string, webUrl?: string): string {
+	const explicitWebUrl = webUrl?.trim();
+	if (!explicitWebUrl) {
+		const normalized = normalizeRelayOrigin(relayUrl);
+		if ("error" in normalized) throw new Error(normalized.error);
+		return normalized.origin.startsWith("wss://")
+			? `https://${normalized.origin.slice("wss://".length)}`
+			: `http://${normalized.origin.slice("ws://".length)}`;
+	}
+
+	let url: URL;
+	try {
+		url = new URL(explicitWebUrl);
+	} catch {
+		throw new Error("collab.webUrl must start with http:// or https://");
+	}
+	if (url.protocol !== "http:" && url.protocol !== "https:") {
+		throw new Error("collab.webUrl must start with http:// or https://");
+	}
+	if (url.protocol === "http:" && !isLocalHostname(url.hostname)) {
+		throw new Error("collab.webUrl must use https:// unless it targets localhost");
+	}
+	if (url.search || url.hash) {
+		throw new Error("collab.webUrl must not include a query string or fragment");
+	}
+	const path = url.pathname.replace(/\/+$/, "");
+	return `${url.origin}${path}`;
+}
+
 /**
- * Render the browser deep link: `http(s)://<relay-host>/#<collab-link>`. The
- * relay serves the web client at `/`, and the whole collab link (including the
- * room key) rides in the fragment, so it never appears in any HTTP request.
- * Terminals auto-link the https form, making it click-to-join.
+ * Render the browser deep link. The browser UI may be hosted separately from
+ * the relay; the fragment always carries the relay-specific collab link, so
+ * room secrets stay out of HTTP path and query bytes.
  */
 export function formatCollabWebLink(
 	relayUrl: string,
 	roomId: string,
 	key: Uint8Array,
 	writeToken?: Uint8Array,
+	webUrl?: string,
 ): string {
-	const normalized = normalizeRelayOrigin(relayUrl);
-	if ("error" in normalized) throw new Error(normalized.error);
-	const httpOrigin = normalized.origin.startsWith("wss://")
-		? `https://${normalized.origin.slice("wss://".length)}`
-		: `http://${normalized.origin.slice("ws://".length)}`;
-	return `${httpOrigin}/#${formatCollabLink(relayUrl, roomId, key, writeToken)}`;
+	return `${normalizeCollabWebBaseUrl(relayUrl, webUrl)}/#${formatCollabLink(relayUrl, roomId, key, writeToken)}`;
 }
 
 export function parseCollabLink(link: string): ParsedCollabLink | { error: string } {
@@ -213,15 +241,20 @@ export function parseCollabLink(link: string): ParsedCollabLink | { error: strin
 	} catch {
 		return { error: `Invalid collab link: ${link}` };
 	}
+	if ((url.protocol === "http:" || url.protocol === "https:") && url.hash) {
+		const inner = url.hash.startsWith("#") ? url.hash.slice(1) : url.hash;
+		const parsed = parseCollabLink(inner);
+		if (!("error" in parsed)) return parsed;
+	}
 	const normalized = normalizeRelayOrigin(url.origin);
 	if ("error" in normalized) return normalized;
 	const match = ROOM_PATH_RE.exec(url.pathname);
 	if (!match) {
-		// Web deep link: `http(s)://<relay>/#<collab-link>` — the fragment holds
-		// the whole link, so recurse on it. The recursion terminates because
-		// the inner text is a strict suffix of the input.
+		// Non-http(s) deep links may also carry a complete collab link in the
+		// fragment. http(s) links are handled once above so invalid fragments
+		// fall through to direct relay validation instead of double-recursing.
 		const inner = url.hash.startsWith("#") ? url.hash.slice(1) : url.hash;
-		if (inner) return parseCollabLink(inner);
+		if (inner && url.protocol !== "http:" && url.protocol !== "https:") return parseCollabLink(inner);
 		return { error: "Collab link must contain a /r/<roomId> path" };
 	}
 	const roomId = match[1]!;

package/src/commit/agentic/agent.ts

@@ -1,7 +1,8 @@
-import { INTENT_FIELD, type ThinkingLevel } from "@oh-my-pi/pi-agent-core";
+import type { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
 import type { Api, Model } from "@oh-my-pi/pi-ai";
 import { Markdown } from "@oh-my-pi/pi-tui";
 import { prompt } from "@oh-my-pi/pi-utils";
+import { INTENT_FIELD } from "@oh-my-pi/pi-wire";
 import chalk from "chalk";
 import typesDescriptionPrompt from "../../commit/prompts/types-description.md" with { type: "text" };
 import type { ModelRegistry } from "../../config/model-registry";

package/src/commit/agentic/tools/git-file-diff.ts

@@ -87,7 +87,7 @@ function truncateDiffContent(diff: string): { content: string; truncated: boolea
 	const truncatedCount = lines.length - KEEP_HEAD_LINES - KEEP_TAIL_LINES;
 
 	return {
-		content: [...head, `\n... (truncated ${truncatedCount} lines) ...\n`, ...tail].join("\n"),
+		content: [...head, `\n[…${truncatedCount}ln elided…]\n`, ...tail].join("\n"),
 		truncated: true,
 	};
 }
@@ -117,7 +117,7 @@ function processDiffs(files: string[], diffs: Map<string, string>): { result: st
 			}
 			content = truncated;
 			if (content.length > remaining) {
-				content = `${content.slice(0, remaining)}\n... (diff truncated due to size) ...`;
+				content = `${content.slice(0, remaining)}\n[…${content.length - remaining}ch elided…]`;
 				if (!truncatedFiles.includes(file)) {
 					truncatedFiles.push(file);
 				}

package/src/commit/changelog/index.ts

@@ -138,7 +138,7 @@ export async function applyChangelogProposals({
 
 function truncateDiff(diff: string, maxChars: number): string {
 	if (diff.length <= maxChars) return diff;
-	return `${diff.slice(0, maxChars)}\n... (truncated)`;
+	return `${diff.slice(0, maxChars)}\n[…${diff.length - maxChars}ch elided…]`;
 }
 
 function formatExistingEntries(entries: Record<string, string[]>): string {

package/src/commit/map-reduce/map-phase.ts

@@ -126,7 +126,7 @@ function generateContextHeader(files: FileDiff[], currentFile: string): string {
 	}
 
 	if (toShow.length < sorted.length) {
-		lines.push(`... and ${sorted.length - toShow.length} more files`);
+		lines.push(`[…${sorted.length - toShow.length} files elided…]`);
 	}
 
 	return lines.join("\n");

package/src/commit/map-reduce/utils.ts

@@ -5,5 +5,5 @@ export function estimateTokens(text: string): number {
 export function truncateToTokenLimit(text: string, maxTokens: number): string {
 	const maxChars = maxTokens * 4;
 	if (text.length <= maxChars) return text;
-	return `${text.slice(0, maxChars)}\n... (truncated)`;
+	return `${text.slice(0, maxChars)}\n[…${text.length - maxChars}ch elided…]`;
 }

package/src/config/config-file.ts

@@ -40,7 +40,7 @@ function migrateJsonToYml(jsonPath: string, ymlPath: string) {
 		}
 
 		const content = fs.readFileSync(jsonPath, "utf-8");
-		const parsed = JSON.parse(content);
+		const parsed = JSONC.parse(content);
 		if (!parsed) {
 			logger.warn("migrateJsonToYml: invalid json structure", { path: jsonPath });
 			migratedPaths.add(key);

package/src/config/keybindings.ts

@@ -10,7 +10,7 @@ import {
 	KeybindingsManager as TuiKeybindingsManager,
 } from "@oh-my-pi/pi-tui";
 import { getAgentDir, isEnoent, logger } from "@oh-my-pi/pi-utils";
-import { YAML } from "bun";
+import { JSONC, YAML } from "bun";
 
 /**
  * Application-level keybindings (coding agent specific).
@@ -381,7 +381,7 @@ function loadRawConfig(filePath: string): unknown {
 	try {
 		const content = fs.readFileSync(filePath, "utf-8");
 		if (filePath.endsWith(".json")) {
-			return JSON.parse(content);
+			return JSONC.parse(content);
 		}
 		if (filePath.endsWith(".yml") || filePath.endsWith(".yaml")) {
 			return YAML.parse(content);

package/src/config/model-registry.ts

@@ -563,10 +563,16 @@ function finalizeCustomModel(model: CustomModelOverlay, options: CustomModelBuil
 	} as ModelSpec<Api>);
 }
 
-function normalizeSuppressedSelector(selector: string): string {
+function normalizeSuppressedSelector(
+	selector: string,
+	hasLiveModel?: (provider: string, id: string) => boolean,
+): string {
 	const trimmed = selector.trim();
 	if (!trimmed) return trimmed;
-	const parsed = parseModelString(trimmed);
+	const parsed = parseModelString(trimmed, {
+		allowMaxAlias: 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.
@@ -2155,14 +2161,20 @@ export class ModelRegistry {
 	 * Suppress a specific model selector (e.g., "provider/id") until a specific timestamp.
 	 */
 	suppressSelector(selector: string, untilMs: number): void {
-		this.#suppressedSelectors.set(normalizeSuppressedSelector(selector), untilMs);
+		this.#suppressedSelectors.set(
+			normalizeSuppressedSelector(selector, (provider, id) => this.find(provider, id) !== undefined),
+			untilMs,
+		);
 	}
 
 	/**
 	 * Check if a model selector is currently suppressed due to rate limits.
 	 */
 	isSelectorSuppressed(selector: string): boolean {
-		const normalizedSelector = normalizeSuppressedSelector(selector);
+		const normalizedSelector = normalizeSuppressedSelector(
+			selector,
+			(provider, id) => this.find(provider, id) !== undefined,
+		);
 		const suppressedUntil = this.#suppressedSelectors.get(normalizedSelector);
 		if (!suppressedUntil) return false;
 		if (suppressedUntil <= Date.now()) {