@herbertgao/pi-extensions 2026.9.18 → 2026.9.20

package/node_modules/pi-web-access/openai-search.ts

@@ -5,7 +5,7 @@ import { activityMonitor } from "./activity.ts";
 import { normalizeDomain } from "./domain-filter-normalization.ts";
 import type { SearchOptions, SearchResponse, SearchResult } from "./perplexity.ts";
 import { hasCredentialSource, redactCredential, resolveCredential } from "./credential-source.ts";
-import { getWebSearchConfigPath } from "./utils.ts";
+import { fetchWithCredentialRedirects, getWebSearchConfigPath } from "./utils.ts";
 
 const OPENAI_RESPONSES_URL = "https://api.openai.com/v1/responses";
 const CODEX_RESPONSES_URL = "https://chatgpt.com/backend-api/codex/responses";
@@ -13,13 +13,16 @@ const CONFIG_PATH = getWebSearchConfigPath();
 const SEARCH_TIMEOUT_MS = 60_000;
 
 // The selected model runs the server-side web_search call and writes the cited summary.
-// Prefer the newest mid-tier ("terra") model, then the newest bare mainline id; price
+// Prefer the newest mid-tier ("terra") model, then the newest bare mainline id, then any
+// other versioned GPT id (gateway providers such as opencode-go list only suffixed GPT
+// ids next to non-OpenAI models; unversioned ids such as gpt-oss-* are skipped); price
 // tiers ("pro"/"ultra" id segments) are excluded, and the numeric-aware sort keeps
 // e.g. gpt-5.10 ahead of gpt-5.9.
 const EXCLUDED_MODEL_SEGMENTS = new Set(["pro", "ultra"]);
 const MODEL_PREFERENCE = [
 	(id: string) => id.includes("terra"),
 	(id: string) => /^gpt-\d+(\.\d+)?$/.test(id),
+	(id: string) => /^gpt-\d/.test(id),
 ];
 const DEFAULT_SEARCH_PROVIDERS: readonly string[] = ["openai-codex", "openai"];
 
@@ -182,6 +185,9 @@ function resolveConfiguredResponsesUrl(value: unknown): string {
 	if (url.protocol !== "https:" && url.protocol !== "http:") {
 		throw new Error(`openaiResponsesUrl in ${CONFIG_PATH} must use http or https`);
 	}
+	if (url.hostname === "opencode.ai" && url.protocol !== "https:") {
+		throw new Error(`openaiResponsesUrl in ${CONFIG_PATH} must use HTTPS for opencode.ai`);
+	}
 	return url.toString();
 }
 
@@ -204,6 +210,9 @@ function resolveProviderResponsesUrl(baseUrl: unknown, useCodexEndpoint: boolean
 	} catch {
 		throw new CustomOpenAIBaseUrlError("OpenAI search configuration: openaiUseProviderBaseUrl requires an absolute http(s) provider baseUrl");
 	}
+	if (url.hostname === "opencode.ai" && url.protocol !== "https:") {
+		throw new CustomOpenAIBaseUrlError("OpenAI search configuration: opencode.ai provider baseUrl must use HTTPS");
+	}
 	const path = url.pathname.replace(/\/+$/u, "");
 	if (path.endsWith("/responses")) {
 		url.pathname = path;
@@ -239,6 +248,19 @@ function toRequestHeaders(headers: ProviderHeaders): Record<string, string> {
 	return requestHeaders;
 }
 
+function applyOpenCodeDestinationHeaders(headers: HeadersInit, requestUrl: string, ctx?: Pick<ExtensionContext, "sessionManager">): Headers {
+	const requestHeaders = new Headers(headers);
+	requestHeaders.delete("x-opencode-session");
+	requestHeaders.delete("x-opencode-client");
+	const url = new URL(requestUrl);
+	const sessionId = ctx?.sessionManager?.getSessionId?.();
+	if (url.protocol === "https:" && url.hostname === "opencode.ai" && sessionId) {
+		requestHeaders.set("x-opencode-session", sessionId);
+		requestHeaders.set("x-opencode-client", "pi");
+	}
+	return requestHeaders;
+}
+
 async function resolvePiAuth(ctx: ExtensionContext, responsesUrl: string, providers: readonly string[], modelOverride?: string, hasExplicitResponsesUrl = false, useProviderBaseUrl = false): Promise<OpenAIAuth | undefined> {
 	let models: ReturnType<typeof ctx.modelRegistry.getAll>;
 	let invalidProviderUrlError: CustomOpenAIBaseUrlError | undefined;
@@ -643,6 +665,7 @@ async function runOpenAISearch(
 	query: string,
 	options: SearchOptions,
 	auth: OpenAIAuth,
+	ctx?: Pick<ExtensionContext, "sessionManager">,
 ): Promise<SearchResponse> {
 	const useAlphaSearch = isAlphaSearchEnabled();
 	if (useAlphaSearch) options.signal?.throwIfAborted();
@@ -672,16 +695,21 @@ async function runOpenAISearch(
 		if (accountId) headers["chatgpt-account-id"] = accountId;
 		headers.originator = "pi";
 	}
+	const requestHeaders = applyOpenCodeDestinationHeaders(
+		useAlphaSearch ? buildAlphaSearchHeaders(headers, auth.apiKey) : headers,
+		requestUrl,
+		ctx,
+	);
 
 	try {
-		const response = await fetch(requestUrl, {
+		const response = await fetchWithCredentialRedirects(requestUrl, {
 			method: "POST",
-			headers: useAlphaSearch ? buildAlphaSearchHeaders(headers, auth.apiKey) : headers,
+			headers: requestHeaders,
 			body: JSON.stringify(body),
 			signal: options.signal
 				? AbortSignal.any([AbortSignal.timeout(SEARCH_TIMEOUT_MS), options.signal])
 				: AbortSignal.timeout(SEARCH_TIMEOUT_MS),
-		});
+		}, ["Authorization", "x-opencode-session", "x-opencode-client", "chatgpt-account-id", ...Object.keys(auth.headers)]);
 
 		if (!response.ok) {
 			activityMonitor.logError(activityId, `HTTP ${response.status}`);
@@ -738,7 +766,7 @@ export async function searchWithOpenAI(
 			"  3. Set OPENAI_API_KEY environment variable",
 		);
 	}
-	return runOpenAISearch(query, options, auth);
+	return runOpenAISearch(query, options, auth, ctx);
 }
 
 export async function searchWithCurrentModelOpenAI(
@@ -748,5 +776,5 @@ export async function searchWithCurrentModelOpenAI(
 ): Promise<SearchResponse> {
 	if (!ctx) throw new Error("OpenAI current-model search requires an extension context");
 	const auth = await resolveCurrentModelAuth(ctx, options.signal);
-	return runOpenAISearch(query, options, auth);
+	return runOpenAISearch(query, options, auth, ctx);
 }

package/node_modules/pi-web-access/package.json

@@ -1,10 +1,10 @@
 {
   "name": "pi-web-access",
-  "version": "0.31.0",
-  "description": "Web search, URL fetching, GitHub repo cloning, PDF extraction, YouTube video understanding, and local video analysis for Pi coding agent. Supports OpenAI, Brave, Parallel, TinyFish, Search1API, Searchinfinity, Querit, Tavily, Firecrawl, Crawl4AI, Jina, SERPdive, Kagi, Ollama, AnySearch, Bright Data SERP, SerpBase, SerpApi, Serply, SearXNG, Exa, Perplexity, Gemini, Kimi, and Mistral.",
+  "version": "0.34.0",
+  "description": "Web search, URL fetching, GitHub repo cloning, PDF extraction, YouTube video understanding, and local video analysis for Pi coding agent. Supports OpenAI, Brave, Parallel, TinyFish, Search1API, Searchinfinity, Querit, Tavily, Firecrawl, Crawl4AI, Jina, SERPdive, Kagi, Ollama, AnySearch, Bright Data SERP, SerpBase, SerpApi, Serply, You.com, SearXNG, Exa, Perplexity, Gemini, Kimi, and Mistral.",
   "type": "module",
   "scripts": {
-    "test": "node --test",
+    "test": "node --import ./test/isolate-env.mjs --test",
     "typecheck": "tsc",
     "audit:runtime": "npm audit --omit=dev --omit=peer",
     "build": "node scripts/build.js",
@@ -50,6 +50,7 @@
     "@earendil-works/pi-tui": "0.86.1",
     "@types/turndown": "^5.0.6",
     "esbuild": "^0.28.1",
+    "typebox": "1.3.27",
     "typescript": "^7.0.2"
   },
   "dependencies": {
@@ -60,8 +61,8 @@
     "p-limit": "^6.1.0",
     "promise.try": "^2.0.1",
     "turndown": "^7.2.0",
-    "unpdf": "^1.6.2",
-    "undici": "^8.9.0"
+    "undici": "^8.11.2",
+    "unpdf": "^1.6.2"
   },
   "peerDependencies": {
     "@earendil-works/pi-ai": "*",

package/node_modules/pi-web-access/page-query.ts

@@ -1,7 +1,7 @@
 import type { complete, Api, Message, Model } from "@earendil-works/pi-ai/compat";
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { existsSync, readFileSync } from "node:fs";
-import { findModelWithProviderRouting, loadEnabledModelPatterns, modelMatchesEnabledPatterns } from "./summary-model-scope.ts";
+import { findModelWithProviderRouting, isModelInScope } from "./summary-model-scope.ts";
 import { getWebSearchConfigPath } from "./utils.ts";
 import { awaitWithAbort } from "./abortable.ts";
 import { openCodeSessionHeaders } from "./opencode-session-headers.ts";
@@ -84,7 +84,7 @@ function resolveModel(ctx: ExtensionContext, override?: string, configured?: Ans
 		throw new Error("No current model available for page answering");
 	}
 	if (!model.input.includes("text")) throw new Error(`Answer model does not support text input: ${model.provider}/${model.id}`);
-	if (!modelMatchesEnabledPatterns(model, loadEnabledModelPatterns(ctx))) {
+	if (!isModelInScope(model, ctx.scopedModels)) {
 		throw new Error(`Answer model is not enabled: ${model.provider}/${model.id}`);
 	}
 	return model;

package/node_modules/pi-web-access/query-rewrite.ts

@@ -1,16 +1,15 @@
 import type { complete, Api, Model, ProviderHeaders } from "@earendil-works/pi-ai/compat";
 import type { SummaryGenerationContext } from "./summary-review.ts";
 import { awaitWithAbort } from "./abortable.ts";
-import { findModelWithProviderRouting, loadEnabledModelPatterns, modelMatchesEnabledPatterns } from "./summary-model-scope.ts";
+import { findModelWithProviderRouting, isModelInScope } from "./summary-model-scope.ts";
 
 async function resolveFirstAvailableModel(
 	ctx: SummaryGenerationContext,
 	candidates: Array<{ provider: string; id: string }>,
 ): Promise<{ model: Model<Api>; apiKey: string; headers?: ProviderHeaders }> {
-	const enabledModelPatterns = loadEnabledModelPatterns(ctx);
 	for (const { provider, id } of candidates) {
 		const model = findModelWithProviderRouting(ctx.modelRegistry, provider, id);
-		if (!model || !modelMatchesEnabledPatterns(model, enabledModelPatterns)) continue;
+		if (!model || !isModelInScope(model, ctx.scopedModels)) continue;
 		const auth = await ctx.modelRegistry.getApiKeyAndHeaders(model);
 		if (auth.ok && auth.apiKey) return { model, apiKey: auth.apiKey, headers: auth.headers };
 	}

package/node_modules/pi-web-access/ssrf-protection.ts

@@ -1,11 +1,13 @@
 import { lookup as dnsLookup } from "node:dns/promises";
 import { existsSync, readFileSync, statSync } from "node:fs";
 import net from "node:net";
-import { getActiveProxy, getWebSearchConfigPath, hasScopedProxyDecision, isProxyBypassedUrl } from "./utils.ts";
+import { getActiveProxy, getWebSearchConfigPath, hasScopedProxyDecision, isProxyBypassedUrl, loadConfiguredProxy, normalizeProxyUrl } from "./utils.ts";
 
 const DEFAULT_MAX_REDIRECTS = 5;
 const REDIRECT_STATUSES = new Set([301, 302, 303, 307, 308]);
 const LOOPBACK_ALLOW_RANGES = ["127.0.0.0/8", "::1", "::ffff:127.0.0.0/104"];
+// Proxy schemes where the proxy, not curl, resolves the target hostname.
+const REMOTE_DNS_PROXY_PROTOCOLS = new Set(["http:", "https:", "socks4a:", "socks5h:"]);
 
 export type LookupAddress = { address: string; family: number };
 export type Lookup = (hostname: string) => Promise<LookupAddress[]>;
@@ -147,12 +149,15 @@ interface ValidationOptions {
 	 */
 	allowRanges?: string[];
 	/**
-	 * When true, trust an explicitly-configured HTTP(S) proxy for hostname
-	 * resolution instead of performing local DNS lookups inside the sandbox.
-	 * Literal IPs and localhost remain blocked, and NO_PROXY hosts still use
-	 * the local SSRF preflight. This does not configure proxy transport.
+	 * When true, let the proxy carrying the request resolve hostnames instead of
+	 * performing local DNS lookups: an HTTP(S) proxy from the environment, or the
+	 * `proxy` configured in web-search.json. A different per-call proxy never
+	 * qualifies. Literal IPs and localhost remain blocked, and NO_PROXY hosts still
+	 * use the local SSRF preflight. This does not configure proxy transport.
 	 */
 	trustEnvProxy?: boolean;
+	/** Proxy pinned on the request via `__proxy`; defaults to the scoped proxy, like the transport. */
+	proxy?: string;
 	/** Allow loopback URLs for explicit provider base endpoints, not fetched targets. */
 	allowLoopback?: boolean;
 }
@@ -207,14 +212,21 @@ export async function validateRemoteUrl(rawUrl: string | URL, options: Validatio
 		return url;
 	}
 
-	if (shouldTrustEnvProxy(url, options.trustEnvProxy === true)) return url;
+	const trustProxy = options.trustEnvProxy === true;
+	const proxy = options.proxy !== undefined
+		? normalizeProxyUrl(options.proxy, "proxy")
+		: hasScopedProxyDecision() ? getActiveProxy() : undefined;
+	if (proxy === undefined ? shouldTrustEnvProxy(url, trustProxy) : trustProxy && isConfiguredRemoteDnsProxy(url, proxy)) return url;
 
 	let addresses: LookupAddress[];
 	try {
 		addresses = await (options.lookup ?? defaultLookup)(hostname);
 	} catch (err) {
 		const message = err instanceof Error ? err.message : String(err);
-		throw new Error(`Failed to resolve ${hostname}: ${message}`);
+		const hint = !trustProxy && proxy && isConfiguredRemoteDnsProxy(url, proxy)
+			? ". If your configured proxy resolves hostnames, set ssrf.trustEnvProxy to true in web-search.json."
+			: "";
+		throw new Error(`Failed to resolve ${hostname}: ${message}${hint}`);
 	}
 
 	if (addresses.length === 0) throw new Error(`Failed to resolve ${hostname}: no addresses returned`);
@@ -333,15 +345,20 @@ function hostnameMatchesNoProxy(hostname: string, port: string, entry: string):
 
 function shouldTrustEnvProxy(url: URL, enabled: boolean): boolean {
 	if (!enabled || !getProxyForProtocol(url.protocol)) return false;
-	if (hasScopedProxyDecision()) return false;
-	const activeProxy = getActiveProxy();
-	if (activeProxy && !isProxyBypassedUrl(url)) return false;
 	const hostname = normalizeHostname(url.hostname);
 	const port = url.port || (url.protocol === "https:" ? "443" : "80");
 	const noProxy = process.env.NO_PROXY || process.env.no_proxy || "";
 	return !noProxy.split(",").some(entry => hostnameMatchesNoProxy(hostname, port, entry));
 }
 
+/** Only the operator's configured proxy qualifies: a model-supplied per-call proxy must not skip DNS validation. */
+function isConfiguredRemoteDnsProxy(url: URL, proxy: string | null): boolean {
+	return proxy !== null &&
+		REMOTE_DNS_PROXY_PROTOCOLS.has(new URL(proxy).protocol) &&
+		!isProxyBypassedUrl(url) &&
+		proxy === loadConfiguredProxy();
+}
+
 function assertPublicAddress(address: string, hostname: string, allowRanges: ParsedCidr[] = []): void {
 	const normalized = normalizeHostname(address);
 	const ipVersion = net.isIP(normalized);

package/node_modules/pi-web-access/storage.ts

@@ -74,7 +74,9 @@ export function generateId(): string {
 }
 
 export function getFetchCacheDir(): string {
-	return join(getWebSearchConfigDir(), FETCH_CACHE_DIR);
+	// Always append our own folder: pruning deletes stale *.json files, so the override must
+	// never point pruning at a directory that holds user files.
+	return join(process.env.PI_WEB_ACCESS_CACHE_ROOT || getWebSearchConfigDir(), FETCH_CACHE_DIR);
 }
 
 function fetchCachePath(key: string): string | null {
@@ -151,17 +153,9 @@ function cacheLimits(limits?: Partial<FetchCacheLimits>): FetchCacheLimits {
 	return resolved;
 }
 
-function enforceDirectoryMode(fd: number): void {
+function enforceMode(fd: number, mode: number): void {
 	try {
-		fchmodSync(fd, 0o700);
-	} catch (err) {
-		if (process.platform !== "win32") throw err;
-	}
-}
-
-function enforceFileMode(fd: number): void {
-	try {
-		fchmodSync(fd, 0o600);
+		fchmodSync(fd, mode);
 	} catch (err) {
 		if (process.platform !== "win32") throw err;
 	}
@@ -182,31 +176,23 @@ function safeFetchCacheDir(create: boolean): string | null {
 	if (before.isSymbolicLink() || !before.isDirectory()) {
 		throw new Error("Fetched content cache path is not a safe directory");
 	}
-	if (process.platform === "win32") {
-		const after = lstatSync(dir);
-		if (after.isSymbolicLink() || !after.isDirectory() || after.dev !== before.dev || after.ino !== before.ino) {
-			throw new Error("Fetched content cache directory changed while securing it");
+	if (process.platform !== "win32") {
+		const fd = openSync(dir, constants.O_RDONLY | O_DIRECTORY | O_NOFOLLOW);
+		try {
+			const opened = fstatSync(fd);
+			if (!opened.isDirectory() || opened.dev !== before.dev || opened.ino !== before.ino) {
+				throw new Error("Fetched content cache directory changed while opening");
+			}
+			enforceMode(fd, 0o700);
+		} finally {
+			closeSync(fd);
 		}
-		return dir;
 	}
-	let fd: number | null = null;
-	try {
-		fd = openSync(dir, constants.O_RDONLY | O_DIRECTORY | O_NOFOLLOW);
-		const opened = fstatSync(fd);
-		if (!opened.isDirectory() || opened.dev !== before.dev || opened.ino !== before.ino) {
-			throw new Error("Fetched content cache directory changed while opening");
-		}
-		enforceDirectoryMode(fd);
-		closeSync(fd);
-		fd = null;
-		const after = lstatSync(dir);
-		if (after.isSymbolicLink() || !after.isDirectory() || after.dev !== before.dev || after.ino !== before.ino) {
-			throw new Error("Fetched content cache directory changed while securing it");
-		}
-		return dir;
-	} finally {
-		if (fd !== null) try { closeSync(fd); } catch {}
+	const after = lstatSync(dir);
+	if (after.isSymbolicLink() || !after.isDirectory() || after.dev !== before.dev || after.ino !== before.ino) {
+		throw new Error("Fetched content cache directory changed while securing it");
 	}
+	return dir;
 }
 
 function openRegularFile(path: string): { fd: number; info: Stats } {
@@ -225,28 +211,22 @@ function openRegularFile(path: string): { fd: number; info: Stats } {
 	}
 }
 
-type CacheUnlinkResult = "removed" | "missing" | "changed" | "error";
-
-function unlinkCacheFile(dir: string, file: CacheFile): CacheUnlinkResult {
+// True once the entry is gone; false when the directory or entry changed underneath us or could not be removed.
+function unlinkCacheFile(dir: string, file: CacheFile): boolean {
 	try {
 		const root = lstatSync(dir);
-		if (root.isSymbolicLink() || !root.isDirectory()) return "changed";
-		const path = join(dir, file.name);
-		let current: Stats;
-		try {
-			current = lstatSync(path);
-		} catch (err) {
-			return (err as NodeJS.ErrnoException).code === "ENOENT" ? "missing" : "error";
-		}
-		if (current.isSymbolicLink() || !current.isFile() || current.dev !== file.dev || current.ino !== file.ino) return "changed";
-		try {
-			unlinkSync(path);
-			return "removed";
-		} catch (err) {
-			return (err as NodeJS.ErrnoException).code === "ENOENT" ? "missing" : "error";
-		}
+		if (root.isSymbolicLink() || !root.isDirectory()) return false;
 	} catch {
-		return "error";
+		return false;
+	}
+	try {
+		const path = join(dir, file.name);
+		const current = lstatSync(path);
+		if (current.isSymbolicLink() || !current.isFile() || current.dev !== file.dev || current.ino !== file.ino) return false;
+		unlinkSync(path);
+		return true;
+	} catch (err) {
+		return (err as NodeJS.ErrnoException).code === "ENOENT";
 	}
 }
 
@@ -269,24 +249,21 @@ function pruneFetchCache(now: number, limits: FetchCacheLimits, preferredKey?: s
 	const files: CacheFile[] = [];
 	for (const entry of entries) {
 		if (!CACHE_KEY_PATTERN.test(entry) && !CACHE_TMP_PATTERN.test(entry)) continue;
-		const path = join(dir, entry);
-		let opened: ReturnType<typeof openRegularFile>;
-		try {
-			opened = openRegularFile(path);
-		} catch {
-			continue;
-		}
+		let info: Stats;
 		try {
-			enforceFileMode(opened.fd);
+			const opened = openRegularFile(join(dir, entry));
+			info = opened.info;
+			try {
+				enforceMode(opened.fd, 0o600);
+			} finally {
+				closeSync(opened.fd);
+			}
 		} catch {
-			closeSync(opened.fd);
 			continue;
 		}
-		closeSync(opened.fd);
-		const file = { name: entry, size: opened.info.size, mtimeMs: opened.info.mtimeMs, dev: opened.info.dev, ino: opened.info.ino };
+		const file = { name: entry, size: info.size, mtimeMs: info.mtimeMs, dev: info.dev, ino: info.ino };
 		if (now - file.mtimeMs >= CACHE_TTL_MS) {
-			const removed = unlinkCacheFile(dir, file);
-			if (removed !== "removed" && removed !== "missing") return false;
+			if (!unlinkCacheFile(dir, file)) return false;
 			continue;
 		}
 		if (CACHE_KEY_PATTERN.test(entry)) files.push(file);
@@ -307,8 +284,7 @@ function pruneFetchCache(now: number, limits: FetchCacheLimits, preferredKey?: s
 		if (index < 0) break;
 		const file = files[index];
 		attempted.add(file.name);
-		const removed = unlinkCacheFile(dir, file);
-		if (removed === "removed" || removed === "missing") files.splice(index, 1);
+		if (unlinkCacheFile(dir, file)) files.splice(index, 1);
 		usage = projectedUsage();
 	}
 	return usage.entries <= limits.maxEntries && usage.bytes <= limits.maxBytes;
@@ -335,7 +311,7 @@ function writeFetchCache(data: StoredSearchData & { urls: ExtractedContent[] }):
 		fd = openSync(tmpPath, constants.O_CREAT | constants.O_EXCL | constants.O_WRONLY | O_NOFOLLOW, 0o600);
 		const tmpInfo = fstatSync(fd);
 		tmpFile = { name: tmpName, size: tmpInfo.size, mtimeMs: tmpInfo.mtimeMs, dev: tmpInfo.dev, ino: tmpInfo.ino };
-		enforceFileMode(fd);
+		enforceMode(fd, 0o600);
 		writeFileSync(fd, serialized, "utf8");
 		fsyncSync(fd);
 		closeSync(fd);
@@ -358,11 +334,6 @@ function writeFetchCache(data: StoredSearchData & { urls: ExtractedContent[] }):
 	return { version: FETCH_CACHE_VERSION, key, storedAt: Date.now() };
 }
 
-function cacheWriteError(err: unknown): string {
-	const message = err instanceof Error ? err.message : String(err);
-	return `Failed to write fetched content cache: ${message}`;
-}
-
 function createFetchSessionData(data: StoredSearchData & { urls: ExtractedContent[] }, ref: FetchCacheRef | null, cacheError?: string): StoredSearchData {
 	return {
 		id: data.id,
@@ -394,9 +365,9 @@ function unavailableFetchData(data: StoredSearchData, reason: string): StoredSea
 	};
 }
 
-function readCachedFetchData(data: StoredSearchData, now = Date.now()): StoredSearchData {
+function readCachedFetchData(data: StoredSearchData): StoredSearchData {
 	if (data.type !== "fetch") return data;
-	if (now - data.timestamp >= CACHE_TTL_MS) {
+	if (Date.now() - data.timestamp >= CACHE_TTL_MS) {
 		return unavailableFetchData(data, "Cached fetched content is missing or expired");
 	}
 	if (isInlineFetchData(data)) return data;
@@ -410,7 +381,7 @@ function readCachedFetchData(data: StoredSearchData, now = Date.now()): StoredSe
 		if (!safeFetchCacheDir(false)) return unavailableFetchData(data, "Cached fetched content is missing or expired");
 		const opened = openRegularFile(path);
 		fd = opened.fd;
-		enforceFileMode(fd);
+		enforceMode(fd, 0o600);
 		const parsed: unknown = JSON.parse(readFileSync(fd, "utf8"));
 		if (!isValidStoredData(parsed) || parsed.type !== "fetch" || parsed.id !== data.id || !isInlineFetchData(parsed)) {
 			return unavailableFetchData(data, "Cached fetched content is invalid");
@@ -452,7 +423,7 @@ export function storeFetchedContentResult(id: string, data: StoredSearchData & {
 	try {
 		ref = writeFetchCache(data);
 	} catch (err) {
-		cacheError = cacheWriteError(err);
+		cacheError = `Failed to write fetched content cache: ${err instanceof Error ? err.message : String(err)}`;
 	}
 	storedResults.set(id, ref ? { ...data, fetchCache: ref, urlMetadata: metadataForUrls(data.urls) } : { ...data, fetchCacheError: cacheError });
 	return createFetchSessionData(data, ref, cacheError);

package/node_modules/pi-web-access/summary-model-scope.ts

@@ -1,16 +1,7 @@
-import { existsSync, readFileSync } from "node:fs";
-import { homedir } from "node:os";
-import { join } from "node:path";
-
 const THINKING_LEVELS = new Set(["off", "minimal", "low", "medium", "high", "xhigh", "max"]);
 
 export type SummaryThinkingLevel = "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
 
-interface SummaryModelScopeContext {
-	cwd: string;
-	isProjectTrusted(): boolean;
-}
-
 export interface ModelLike {
 	provider: string;
 	id: string;
@@ -45,39 +36,12 @@ export function findModelWithProviderRouting<T extends ModelLike>(
 	return routed ?? registry.find(provider, id);
 }
 
-function getAgentDir(): string {
-	return process.env.PI_CODING_AGENT_DIR || join(homedir(), ".pi", "agent");
-}
-
-function readSettings(path: string): Record<string, unknown> {
-	if (!existsSync(path)) return {};
-	const raw = readFileSync(path, "utf8");
-	try {
-		return JSON.parse(raw) as Record<string, unknown>;
-	} catch (err) {
-		const message = err instanceof Error ? err.message : String(err);
-		throw new Error(`Failed to parse ${path}: ${message}`);
-	}
-}
-
-export function loadEnabledModelPatterns(ctx: SummaryModelScopeContext): string[] | null {
-	const globalSettings = readSettings(join(getAgentDir(), "settings.json"));
-	const projectSettings = ctx.isProjectTrusted()
-		? readSettings(join(ctx.cwd, ".pi", "settings.json"))
-		: {};
-	const value = Object.hasOwn(projectSettings, "enabledModels")
-		? projectSettings.enabledModels
-		: globalSettings.enabledModels;
-	if (value === undefined) return null;
-	if (!Array.isArray(value)) throw new Error("enabledModels must be an array");
-	return value
-		.filter((item): item is string => typeof item === "string")
-		.map(item => item.trim())
-		.filter(Boolean);
-}
-
-export function summaryModelValue(model: ModelLike): string {
-	return `${model.provider}/${model.id}`;
+/**
+ * Pi resolves `--models` and `enabledModels` against the available catalogue and exposes the
+ * result as `ctx.scopedModels`; an empty scope means every available model is allowed.
+ */
+export function isModelInScope(model: ModelLike, scopedModels: ReadonlyArray<{ model: ModelLike }>): boolean {
+	return scopedModels.length === 0 || scopedModels.some(scoped => scoped.model.provider === model.provider && scoped.model.id === model.id);
 }
 
 export function splitThinkingSuffix(value: string): { value: string; thinkingLevel?: SummaryThinkingLevel } {
@@ -88,38 +52,3 @@ export function splitThinkingSuffix(value: string): { value: string; thinkingLev
 		? { value: value.slice(0, index), thinkingLevel: suffix as SummaryThinkingLevel }
 		: { value };
 }
-
-function stripThinkingSuffix(pattern: string): string {
- return splitThinkingSuffix(pattern).value;
-}
-
-function globToRegExp(pattern: string): RegExp {
-	let source = "^";
-	for (const char of pattern) {
-		if (char === "*") {
-			source += ".*";
-		} else if (char === "?") {
-			source += ".";
-		} else {
-			source += char.replace(/[|\\{}()[\]^$+?.]/g, "\\$&");
-		}
-	}
-	return new RegExp(`${source}$`, "i");
-}
-
-export function modelMatchesEnabledPatterns(model: ModelLike, patterns: string[] | null): boolean {
-	if (patterns === null) return true;
-	const value = summaryModelValue(model).toLowerCase();
-	const id = model.id.toLowerCase();
-	for (const rawPattern of patterns) {
-		const pattern = stripThinkingSuffix(rawPattern.trim()).toLowerCase();
-		if (!pattern) continue;
-		if (pattern.includes("*") || pattern.includes("?")) {
-			const regex = globToRegExp(pattern);
-			if (regex.test(value) || regex.test(id)) return true;
-			continue;
-		}
-		if (pattern === value || pattern === id) return true;
-	}
-	return false;
-}

package/node_modules/pi-web-access/summary-review.ts

@@ -2,7 +2,7 @@ import type { ModelThinkingLevel, ThinkingLevel } from "@earendil-works/pi-ai";
 import type { complete, Api, Message, Model } from "@earendil-works/pi-ai/compat";
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { openCodeSessionHeaders } from "./opencode-session-headers.ts";
-import { findModelWithProviderRouting, loadEnabledModelPatterns, modelMatchesEnabledPatterns, splitThinkingSuffix, type SummaryThinkingLevel } from "./summary-model-scope.ts";
+import { findModelWithProviderRouting, isModelInScope, splitThinkingSuffix, type SummaryThinkingLevel } from "./summary-model-scope.ts";
 import type { QueryResultData } from "./storage.ts";
 
 type ProviderHeaders = Record<string, string | null>;
@@ -30,7 +30,7 @@ export interface SummaryMeta {
 	edited?: boolean;
 }
 
-export type SummaryGenerationContext = Pick<ExtensionContext, "model" | "modelRegistry" | "sessionManager" | "cwd" | "isProjectTrusted">;
+export type SummaryGenerationContext = Pick<ExtensionContext, "model" | "modelRegistry" | "sessionManager" | "scopedModels">;
 
 function estimateTokens(text: string): number {
 	const trimmed = text.trim();
@@ -215,7 +215,6 @@ async function resolveSummaryModelCandidates(
 	ctx: SummaryGenerationContext,
 	modelOverride?: string,
 ): Promise<{ candidates: Array<{ model: Model<Api>; apiKey?: string; headers?: ProviderHeaders; thinkingLevel?: SummaryThinkingLevel }>; errors: string[] }> {
-	const enabledModelPatterns = loadEnabledModelPatterns(ctx);
 	const specs: Array<{ provider: string; id: string; thinkingLevel?: SummaryThinkingLevel }> = [];
 	const normalizedOverride = typeof modelOverride === "string" ? modelOverride.trim() : "";
 	if (normalizedOverride.length > 0) specs.push(parseModelSelector(normalizedOverride));
@@ -234,7 +233,7 @@ async function resolveSummaryModelCandidates(
 			errors.push(`Summary model not found: ${value}`);
 			continue;
 		}
-		if (!modelMatchesEnabledPatterns(model, enabledModelPatterns)) {
+		if (!isModelInScope(model, ctx.scopedModels)) {
 			errors.push(`Summary model is not enabled: ${value}`);
 			continue;
 		}