jeopi-cli 16.5.1 → 16.5.6

package/dist/types/tools/builtin-names.d.ts

@@ -1,6 +1,7 @@
 export declare const BUILTIN_TOOL_NAMES: readonly ["read", "bash", "edit", "ast_grep", "ast_edit", "ask", "debug", "eval", "ssh", "github", "glob", "grep", "lsp", "inspect_image", "vision_verify", "browser", "checkpoint", "rewind", "task", "job", "irc", "subagent", "todo", "web_search", "search_tool_bm25", "write", "memory_edit", "retain", "recall", "reflect", "learn", "manage_skill"];
 export type BuiltinToolName = (typeof BUILTIN_TOOL_NAMES)[number];
-/** Return the canonical tool name for current and legacy built-in tool IDs. */
+export declare const HIDDEN_TOOL_NAMES: readonly ["yield", "report_finding", "report_tool_issue", "resolve", "goal"];
+/** Canonicalize built-in IDs and legacy aliases. Leave plugin names unchanged. */
 export declare function normalizeToolName(name: string): string;
 /** Normalize and deduplicate tool names while preserving first-seen order. */
 export declare function normalizeToolNames(names: Iterable<string>): string[];

package/dist/types/web/search/providers/codex.d.ts

@@ -17,8 +17,8 @@ export interface CodexSearchParams {
  * Default-model behavior:
  * - If `PI_CODEX_WEB_SEARCH_MODEL` is set, use it exactly once and surface any
  *   upstream error verbatim.
- * - Otherwise prefer ChatGPT-account-safe bundled defaults (GPT-5.4, GPT-5
- *   Codex, GPT-5, …) and retry the next candidate only when Codex returns the
+ * - Otherwise prefer known bundled defaults, then include newly cataloged GPT
+ *   models, and retry the next candidate only when Codex returns the
  *   known 400 "model is not supported" family. This avoids selecting
  *   `gpt-5-codex-mini` first on ChatGPT accounts, which OpenAI rejects.
  */

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "jeopi-cli",
-	"version": "16.5.1",
+	"version": "16.5.6",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://github.com/akillness/jeopi",
 	"author": "Can Boluk",
@@ -57,17 +57,17 @@
 		"@agentclientprotocol/sdk": "0.25.0",
 		"@babel/parser": "^7.29.7",
 		"@mozilla/readability": "^0.6.0",
-		"jeopi-hashline": "16.5.1",
-		"jeopi-stats": "16.5.1",
-		"jeopi-agent-core": "16.5.1",
-		"jeopi-ai": "16.5.1",
-		"jeopi-catalog": "16.5.1",
-		"jeopi-mnemopi": "16.5.1",
-		"jeopi-natives": "16.5.1",
-		"jeopi-tui": "16.5.1",
-		"jeopi-utils": "16.5.1",
-		"jeopi-wire": "16.5.1",
-		"jeopi-snapcompact": "16.5.1",
+		"jeopi-hashline": "16.5.6",
+		"jeopi-stats": "16.5.6",
+		"jeopi-agent-core": "16.5.6",
+		"jeopi-ai": "16.5.6",
+		"jeopi-catalog": "16.5.6",
+		"jeopi-mnemopi": "16.5.6",
+		"jeopi-natives": "16.5.6",
+		"jeopi-tui": "16.5.6",
+		"jeopi-utils": "16.5.6",
+		"jeopi-wire": "16.5.6",
+		"jeopi-snapcompact": "16.5.6",
 		"@opentelemetry/api": "^1.9.1",
 		"@opentelemetry/context-async-hooks": "^2.7.1",
 		"@opentelemetry/exporter-trace-otlp-proto": "^0.218.0",

package/src/config/model-registry.ts

@@ -14,8 +14,13 @@ import type { AssistantMessageEventStream } from "jeopi-ai/utils/event-stream";
 import { buildModel } from "jeopi-catalog/build";
 import { isVertexExpressOpenAIUrl } from "jeopi-catalog/hosts";
 import { readModelCache } from "jeopi-catalog/model-cache";
-import { createModelManager, type ModelManagerOptions, type ModelRefreshStrategy } from "jeopi-catalog/model-manager";
-import { getBundledModels, getBundledProviders } from "jeopi-catalog/models";
+import {
+	createModelManager,
+	type ModelManagerOptions,
+	type ModelRefreshStrategy,
+	restoreCachedModelHeaders,
+} from "jeopi-catalog/model-manager";
+import { type GeneratedProvider, getBundledModels, getBundledProviders } from "jeopi-catalog/models";
 import {
 	googleAntigravityModelManagerOptions,
 	googleGeminiCliModelManagerOptions,
@@ -940,6 +945,9 @@ export class ModelRegistry {
 		this.#addImplicitDiscoverableProviders(configuredProviders);
 		let builtInModels = this.#applyHardcodedModelPolicies(this.#loadBuiltInModels(overrides));
 		const cachedStandardResult = this.#loadCachedStandardProviderModels();
+		builtInModels = builtInModels.filter(
+			model => !cachedStandardResult.unresolvedModelIdsByProvider.get(model.provider)?.has(model.id),
+		);
 		const cachedStandardModels = this.#applyHardcodedModelPolicies(cachedStandardResult.models);
 		const cachedDiscoveries = this.#applyHardcodedModelPolicies(this.#loadCachedDiscoverableModels());
 		// Only drop bundled fallback models when the cached project-catalog row is
@@ -1028,6 +1036,24 @@ export class ModelRegistry {
 	}
 
 	#resolveStartupModelCacheProviderId(providerId: string): string {
+		if (providerId === "openai" || providerId === "openai-codex") {
+			const commandKey = this.#resolveCommandBackedApiKey(providerId);
+			const apiKey = commandKey.configured ? commandKey.value : this.authStorage.getModelCacheIdentity(providerId);
+			const baseUrl =
+				this.#runtimeProviderOverrides.get(providerId)?.baseUrl ??
+				this.#providerOverrides.get(providerId)?.baseUrl ??
+				this.getProviderBaseUrl(providerId);
+			if (providerId === "openai-codex") {
+				return (
+					openaiCodexModelManagerOptions({
+						accessToken: apiKey,
+						baseUrl,
+					}).cacheProviderId ?? providerId
+				);
+			}
+			const descriptor = PROVIDER_DESCRIPTORS.find(candidate => candidate.providerId === providerId);
+			return descriptor?.createModelManagerOptions({ apiKey, baseUrl }).cacheProviderId ?? providerId;
+		}
 		const descriptor = PROVIDER_DESCRIPTORS.find(candidate => candidate.providerId === providerId);
 		if (!descriptor) {
 			return providerId;
@@ -1039,10 +1065,22 @@ export class ModelRegistry {
 		return descriptor.createModelManagerOptions({ baseUrl, fetch: this.#fetch }).cacheProviderId ?? providerId;
 	}
 
-	#loadCachedStandardProviderModels(): { models: Model<Api>[]; authoritativeFreshProviders: Set<string> } {
+	#restoreConfiguredModelHeaders(model: Model<Api>): Record<string, string> | undefined {
+		const override = this.#providerOverrides.get(model.provider);
+		const withoutHeaders = { ...model, headers: undefined };
+		const configured = override ? this.#applyProviderTransportOverride(withoutHeaders, override) : withoutHeaders;
+		return this.#applyProviderModelOverrides(model.provider, [configured])[0]?.headers;
+	}
+
+	#loadCachedStandardProviderModels(): {
+		models: Model<Api>[];
+		authoritativeFreshProviders: Set<string>;
+		unresolvedModelIdsByProvider: Map<string, ReadonlySet<string>>;
+	} {
 		const configuredDiscoveryProviders = new Set(this.#discoverableProviders.map(provider => provider.provider));
 		const cachedModels: Model<Api>[] = [];
 		const authoritativeFreshProviders = new Set<string>();
+		const unresolvedModelIdsByProvider = new Map<string, ReadonlySet<string>>();
 		for (const providerId of STARTUP_MODEL_CACHE_PROVIDER_IDS) {
 			if (configuredDiscoveryProviders.has(providerId)) {
 				continue;
@@ -1052,12 +1090,24 @@ export class ModelRegistry {
 			if (!cache) {
 				continue;
 			}
-			if (cache.fresh && cache.authoritative) {
+			const descriptor = PROVIDER_DESCRIPTORS.find(candidate => candidate.providerId === providerId);
+			const restored = restoreCachedModelHeaders(
+				cache.models,
+				getBundledModels(providerId as GeneratedProvider),
+				cache.headerOmittedModelIds,
+				cache.unrestorableHeaderModelIds,
+				descriptor?.createModelManagerOptions({}).restorableHeaderFallback,
+				model => this.#restoreConfiguredModelHeaders(model),
+			);
+			if (restored.unresolvedModelIds.size > 0) {
+				unresolvedModelIdsByProvider.set(providerId, restored.unresolvedModelIds);
+			}
+			if (cache.fresh && cache.authoritative && restored.unresolvedModelIds.size === 0) {
 				authoritativeFreshProviders.add(providerId);
 			}
-			const models = cache.models.map(model =>
-				model.provider === providerId ? model : { ...model, provider: providerId },
-			);
+			const models = restored.models
+				.filter(model => !restored.unresolvedModelIds.has(model.id))
+				.map(model => (model.provider === providerId ? model : { ...model, provider: providerId }));
 			const providerOverride = this.#providerOverrides.get(providerId);
 			const withTransport = providerOverride
 				? models.map(model => this.#applyProviderTransportOverride(model, providerOverride))
@@ -1072,7 +1122,7 @@ export class ModelRegistry {
 				: withTransport.map(model => buildModel(model));
 			cachedModels.push(...this.#applyProviderModelOverrides(providerId, withCompat));
 		}
-		return { models: cachedModels, authoritativeFreshProviders };
+		return { models: cachedModels, authoritativeFreshProviders, unresolvedModelIdsByProvider };
 	}
 
 	#loadCachedDiscoverableModels(): Model<Api>[] {
@@ -1094,6 +1144,14 @@ export class ModelRegistry {
 				});
 				continue;
 			}
+			const restored = restoreCachedModelHeaders(
+				cache.models,
+				[],
+				cache.headerOmittedModelIds,
+				cache.unrestorableHeaderModelIds,
+				undefined,
+				model => this.#restoreConfiguredModelHeaders(model),
+			);
 			const configStale = this.#isDiscoveryCacheOlderThanModelsConfig(cache.updatedAt);
 			const models = this.#applyProviderModelOverrides(
 				providerConfig.provider,
@@ -1101,7 +1159,7 @@ export class ModelRegistry {
 					providerConfig,
 					this.#applyProviderCompat(
 						providerConfig.compat,
-						cache.models.map(model => buildModel(model)),
+						restored.models.filter(model => !restored.unresolvedModelIds.has(model.id)),
 					),
 				),
 			);
@@ -1110,7 +1168,12 @@ export class ModelRegistry {
 				provider: providerConfig.provider,
 				status: "cached",
 				optional: providerConfig.optional ?? false,
-				stale: providerConfig.discovery.type === "llama.cpp" || !cache.fresh || !cache.authoritative || configStale,
+				stale:
+					providerConfig.discovery.type === "llama.cpp" ||
+					!cache.fresh ||
+					!cache.authoritative ||
+					configStale ||
+					restored.unresolvedModelIds.size > 0,
 				fetchedAt: cache.updatedAt,
 				models: models.map(model => model.id),
 			});
@@ -1126,14 +1189,18 @@ export class ModelRegistry {
 	}
 
 	#normalizeDiscoverableModels(providerConfig: DiscoveryProviderConfig, models: Model<Api>[]): Model<Api>[] {
+		const override = this.#providerOverrides.get(providerConfig.provider);
+		const withTransport = override
+			? models.map(model => this.#applyProviderTransportOverride(model, override))
+			: models;
 		const withDecoderMetadata =
 			providerConfig.discovery.type === "ollama" ||
 			providerConfig.discovery.type === "llama.cpp" ||
 			providerConfig.discovery.type === "lm-studio"
-				? models.map(model =>
+				? withTransport.map(model =>
 						buildModel({ ...model, imageInputDecoder: "stb", compat: model.compatConfig } as ModelSpec<Api>),
 					)
-				: models;
+				: withTransport;
 
 		const withRemoteCompaction = providerConfig.remoteCompaction
 			? withDecoderMetadata.map(model =>
@@ -1412,6 +1479,15 @@ export class ModelRegistry {
 	): Promise<Model<Api>[]> {
 		const cacheProviderId = this.#configuredDiscoveryCacheProviderId(providerConfig);
 		const cached = readModelCache<Api>(cacheProviderId, 24 * 60 * 60 * 1000, Date.now, this.#cacheDbPath);
+		const restored = restoreCachedModelHeaders(
+			cached?.models ?? [],
+			[],
+			cached?.headerOmittedModelIds ?? [],
+			cached?.unrestorableHeaderModelIds ?? [],
+			undefined,
+			model => this.#restoreConfiguredModelHeaders(model),
+		);
+		const usableCachedModels = restored.models.filter(model => !restored.unresolvedModelIds.has(model.id));
 		const cacheOlderThanConfig = cached !== null && this.#isDiscoveryCacheOlderThanModelsConfig(cached.updatedAt);
 		const shouldForceOnlineDiscovery =
 			strategy === "online-if-uncached" && (cacheOlderThanConfig || isAuthoritativeLocalDiscovery(providerConfig));
@@ -1426,15 +1502,10 @@ export class ModelRegistry {
 					optional: providerConfig.optional ?? false,
 					stale: cached !== null,
 					fetchedAt: cached?.updatedAt,
-					models: cached?.models.map(model => model.id) ?? [],
+					models: usableCachedModels.map(model => model.id),
 				});
 				this.#lastDiscoveryWarnings.delete(providerConfig.provider);
-				return cached
-					? this.#normalizeDiscoverableModels(
-							providerConfig,
-							cached.models.map(model => buildModel(model)),
-						)
-					: [];
+				return cached ? this.#normalizeDiscoverableModels(providerConfig, usableCachedModels) : [];
 			}
 		}
 
@@ -1444,7 +1515,10 @@ export class ModelRegistry {
 			try {
 				const models = this.#applyProviderModelOverrides(
 					providerId,
-					await discoverModelsByProviderType(providerConfig, this.#discoveryContext()),
+					this.#normalizeDiscoverableModels(
+						providerConfig,
+						await discoverModelsByProviderType(providerConfig, this.#discoveryContext()),
+					),
 				);
 				this.#lastDiscoveryWarnings.delete(providerId);
 				return models.map(toModelSpec);
@@ -1461,6 +1535,7 @@ export class ModelRegistry {
 			cacheProviderId,
 			cacheTtlMs: 24 * 60 * 60 * 1000,
 			fetchDynamicModels,
+			restoreCachedHeaders: model => this.#restoreConfiguredModelHeaders(model),
 		});
 		const result = await manager.refresh(effectiveStrategy);
 		const status = discoveryError
@@ -1594,6 +1669,8 @@ export class ModelRegistry {
 					return openaiCodexModelManagerOptions({
 						accessToken,
 						accountId,
+						baseUrl: this.getProviderBaseUrl("openai-codex"),
+						fetch: this.#fetch,
 					});
 				},
 			},
@@ -1645,6 +1722,11 @@ export class ModelRegistry {
 			}
 			options.push(descriptor.createOptions(key));
 		}
+		for (const option of options) {
+			if (option.providerId === "openai" || option.providerId === "openai-codex") {
+				option.cacheProviderId = this.#resolveStartupModelCacheProviderId(option.providerId);
+			}
+		}
 		// Append runtime model managers registered by extensions via fetchDynamicModels.
 		for (const { options: managerOpts } of this.#runtimeModelManagers.values()) {
 			options.push(managerOpts);

package/src/modes/components/assistant-message.ts

@@ -726,7 +726,7 @@ export class AssistantMessageComponent extends Container {
 		);
 
 		// Fast path: reuse Markdown children when shape is stable during streaming
-		if (this.#tryFastPathUpdate(message)) return;
+		if (this.#tryFastPathUpdate(message, opts)) return;
 
 		// Clear content container
 		this.#contentContainer.clear();

package/src/modes/controllers/streaming-reveal.ts

@@ -215,6 +215,7 @@ export class StreamingRevealController {
 	#component: StreamingRevealComponent | undefined;
 	#timer: NodeJS.Timeout | undefined;
 	#revealed = 0;
+	#targetDirty = false;
 	#hideThinkingBlock = false;
 	#proseOnlyThinking = true;
 	#smoothStreaming = true;
@@ -275,6 +276,9 @@ export class StreamingRevealController {
 		if (!this.#component) return;
 		if (!this.#smoothStreaming) {
 			const total = this.#visibleUnits(message);
+			this.#revealed = total;
+			this.#targetDirty = false;
+			this.#stopTimer();
 			this.#component.updateContent(this.#build(message, total), { transient: true });
 			return;
 		}
@@ -283,6 +287,7 @@ export class StreamingRevealController {
 			// A tool call is a transcript-order boundary: finish any leading
 			// assistant text before EventController renders the separate tool card.
 			this.#revealed = total;
+			this.#targetDirty = false;
 			this.#stopTimer();
 			this.#component.updateContent(this.#build(message, this.#revealed), {
 				transient: true,
@@ -292,8 +297,15 @@ export class StreamingRevealController {
 		if (this.#revealed > total) {
 			this.#revealed = total;
 		}
-		this.#renderCurrent();
-		this.#syncTimer(total);
+		if (this.#revealed < total) {
+			// ponytail: reuse the reveal timer; only add another scheduler if streaming needs a separate cadence.
+			this.#targetDirty = false;
+			this.#syncTimer(total);
+			return;
+		}
+		// Caught-up rewrites still need one render of the newest target at the next tick.
+		this.#startTimer();
+		this.#targetDirty = true;
 	}
 
 	stop(): void {
@@ -301,6 +313,7 @@ export class StreamingRevealController {
 		this.#target = undefined;
 		this.#component = undefined;
 		this.#revealed = 0;
+		this.#targetDirty = false;
 		this.#unitCounter.reset();
 	}
 
@@ -377,6 +390,12 @@ export class StreamingRevealController {
 		}
 		const total = this.#visibleUnits(target);
 		if (this.#revealed >= total) {
+			if (this.#targetDirty) {
+				this.#targetDirty = false;
+				this.#revealed = total;
+				this.#renderCurrent();
+				this.#requestRender();
+			}
 			this.#stopTimer();
 			return;
 		}

package/src/session/session-persistence.ts

@@ -59,9 +59,14 @@ function shouldExternalizeImagePayload(
 	return (key === TEXT_CONTENT_KEY && isImageBlock(value)) || key === "images";
 }
 
+/** Signature and encrypted fields bind their carrier to its exact bytes. */
+function isNonEmptyString(value: unknown): value is string {
+	return typeof value === "string" && value.length > 0;
+}
+
 /**
  * Recursively truncate large strings in an object for session persistence.
- * - Truncates any oversized string fields (key-agnostic)
+ * - Truncates oversized strings except signed/encrypted blocks and signature keys
  * - Externalizes oversized image payloads to blob refs
  * - Updates lineCount when content is truncated
  * - Returns original object if no changes needed (structural sharing)
@@ -76,16 +81,29 @@ function truncateForPersistence(obj: unknown, blobStore: BlobStore, key?: string
 	if (shouldExternalizeImagePayload(obj, key)) {
 		return { ...obj, data: externalizeImageDataSync(blobStore, obj.data, obj.mimeType) };
 	}
+	// Signed content and encrypted reasoning must replay byte-for-byte. Keep the
+	// whole carrier, including paired text and tool arguments; unsigned content
+	// still follows the normal size and transient-field sanitization rules.
+	if (typeof obj === "object" && "type" in obj) {
+		const signed =
+			(obj.type === "thinking" && "thinkingSignature" in obj && isNonEmptyString(obj.thinkingSignature)) ||
+			(obj.type === "text" && "textSignature" in obj && isNonEmptyString(obj.textSignature)) ||
+			(obj.type === "toolCall" && "thoughtSignature" in obj && isNonEmptyString(obj.thoughtSignature));
+		const redacted = obj.type === "redactedThinking" && "data" in obj && isNonEmptyString(obj.data);
+		const encryptedReasoning =
+			obj.type === "reasoning" && "encrypted_content" in obj && isNonEmptyString(obj.encrypted_content);
+		if (signed || redacted || encryptedReasoning) return obj;
+	}
 
 	if (typeof obj === "string") {
 		if (key === "image_url" && isImageDataUrl(obj)) {
 			return externalizeImageDataUrlSync(blobStore, obj);
 		}
 		if (obj.length > MAX_PERSIST_CHARS) {
-			// Cryptographic signatures must be preserved exactly or cleared entirely — never truncated.
-			// Truncation would produce an invalid signature that the API rejects.
+			// Unknown carrier shapes must retain opaque signatures too: clearing or
+			// truncating one loses provider context or makes replay invalid.
 			if (key === "thinkingSignature" || key === "thoughtSignature" || key === "textSignature") {
-				return "";
+				return obj;
 			}
 			const limit = Math.max(0, MAX_PERSIST_CHARS - TRUNCATION_NOTICE.length);
 			return `${truncateString(obj, limit)}${TRUNCATION_NOTICE}`;

package/src/tools/builtin-names.ts

@@ -35,15 +35,24 @@ export const BUILTIN_TOOL_NAMES = [
 
 export type BuiltinToolName = (typeof BUILTIN_TOOL_NAMES)[number];
 
+export const HIDDEN_TOOL_NAMES = ["yield", "report_finding", "report_tool_issue", "resolve", "goal"] as const;
+
 const LEGACY_BUILTIN_TOOL_NAME_ALIASES: ReadonlyMap<string, BuiltinToolName> = new Map([
 	["search", "grep"],
 	["find", "glob"],
 ]);
 
-/** Return the canonical tool name for current and legacy built-in tool IDs. */
+const CANONICAL_TOOL_NAMES: Record<string, true> = Object.fromEntries(
+	[...BUILTIN_TOOL_NAMES, ...HIDDEN_TOOL_NAMES].map(name => [name, true]),
+);
+
+/** Canonicalize built-in IDs and legacy aliases. Leave plugin names unchanged. */
 export function normalizeToolName(name: string): string {
 	const normalized = name.toLowerCase();
-	return LEGACY_BUILTIN_TOOL_NAME_ALIASES.get(normalized) ?? normalized;
+	return (
+		LEGACY_BUILTIN_TOOL_NAME_ALIASES.get(normalized) ??
+		(Object.hasOwn(CANONICAL_TOOL_NAMES, normalized) ? normalized : name)
+	);
 }
 
 /** Normalize and deduplicate tool names while preserving first-seen order. */

package/src/tools/index.ts

@@ -40,7 +40,7 @@ import { AstEditTool } from "./ast-edit";
 import { AstGrepTool } from "./ast-grep";
 import { BashTool } from "./bash";
 import { BrowserTool } from "./browser";
-import { type BuiltinToolName, normalizeToolNames } from "./builtin-names";
+import { type BuiltinToolName, type HIDDEN_TOOL_NAMES, normalizeToolNames } from "./builtin-names";
 import { type CheckpointState, CheckpointTool, type CompletedRewindState, RewindTool } from "./checkpoint";
 import { DebugTool } from "./debug";
 import { EvalTool } from "./eval";
@@ -494,7 +494,7 @@ export const HIDDEN_TOOLS: Record<string, ToolFactory> = {
 	report_tool_issue: s => createReportToolIssueTool(s),
 	resolve: s => new ResolveTool(s),
 	goal: s => new GoalTool(s),
-};
+} satisfies Record<(typeof HIDDEN_TOOL_NAMES)[number], ToolFactory>;
 
 export type ToolName = BuiltinToolName;
 

package/src/web/search/providers/codex.ts

@@ -44,17 +44,12 @@ function getDefaultModelCandidates(): string[] {
 	const bundledModels = getBundledModels("openai-codex");
 	const bundledIds = new Set(bundledModels.map(model => model.id));
 	const candidates = DEFAULT_MODEL_PREFERENCES.filter(modelId => bundledIds.has(modelId));
-
-	if (candidates.length > 0) {
-		return candidates;
-	}
-
-	const nonMini = bundledModels.find(model => !model.id.includes("mini") && !model.id.includes("spark"));
-	if (nonMini) {
-		return [nonMini.id];
+	for (const model of bundledModels) {
+		if (/^gpt-\d/.test(model.id) && !candidates.includes(model.id)) {
+			candidates.push(model.id);
+		}
 	}
-
-	return bundledModels[0]?.id ? [bundledModels[0].id] : [FALLBACK_MODEL];
+	return candidates.length > 0 ? candidates : [FALLBACK_MODEL];
 }
 
 function shouldRetryWithNextDefaultModel(error: unknown): boolean {
@@ -489,8 +484,8 @@ async function callCodexSearch(
  * Default-model behavior:
  * - If `PI_CODEX_WEB_SEARCH_MODEL` is set, use it exactly once and surface any
  *   upstream error verbatim.
- * - Otherwise prefer ChatGPT-account-safe bundled defaults (GPT-5.4, GPT-5
- *   Codex, GPT-5, …) and retry the next candidate only when Codex returns the
+ * - Otherwise prefer known bundled defaults, then include newly cataloged GPT
+ *   models, and retry the next candidate only when Codex returns the
  *   known 400 "model is not supported" family. This avoids selecting
  *   `gpt-5-codex-mini` first on ChatGPT accounts, which OpenAI rejects.
  */