@oh-my-pi/pi-coding-agent 17.2.8 → 17.2.10

package/src/vibe/runtime.ts

@@ -25,7 +25,6 @@ import { MCPManager } from "../mcp/manager";
 import vibeTurnResultTemplate from "../prompts/tools/vibe-turn-result.md" with { type: "text" };
 import { AgentLifecycleManager } from "../registry/agent-lifecycle";
 import { type AgentRef, AgentRegistry, MAIN_AGENT_ID } from "../registry/agent-registry";
-import type { SessionEntry } from "../session/session-entries";
 import { SessionManager, SessionPersistenceIndeterminateError } from "../session/session-manager";
 import { getBundledAgent } from "../task/agents";
 import { type ExecutorOptions, runSubagentFollowUpTurn, runSubprocess } from "../task/executor";
@@ -70,8 +69,8 @@ const TRACE_LINE_MAX = 120;
 const DEFAULT_WAIT_TIMEOUT_MS = 30_000;
 /** Response text cap inside a delivered turn result; full output stays at agent://<id>. */
 const RESPONSE_PREVIEW_MAX = 6000;
-/** Grace period for abort-aware turns before teardown detaches a stuck provider/tool call. */
-const CANCELLED_TURN_SETTLE_GRACE_MS = 250;
+/** Grace period for Vibe cancellation/release cleanup before teardown detaches (ms). */
+const VIBE_TEARDOWN_GRACE_MS = 5_000;
 
 const VIBE_LIFECYCLE_CUSTOM_TYPE = "vibe-session-lifecycle";
 const VIBE_LIFECYCLE_VERSION = 1;
@@ -252,6 +251,48 @@ export interface VibeWaitOutcome {
 	timedOut: boolean;
 }
 
+type VibeTeardownStatus = "pending" | "settled" | "failed";
+
+interface TrackedVibeTeardown {
+	promise: Promise<void>;
+	status: () => VibeTeardownStatus;
+}
+
+/** Observe cleanup without propagating a detached late rejection. */
+function trackVibeTeardown(promise: Promise<unknown>, onError: (error: unknown) => void): TrackedVibeTeardown {
+	let status: VibeTeardownStatus = "pending";
+	return {
+		promise: promise.then(
+			() => {
+				status = "settled";
+			},
+			error => {
+				status = "failed";
+				onError(error);
+			},
+		),
+		status: () => status,
+	};
+}
+
+/** Wait for cleanup only until the caller's shared absolute deadline. */
+async function waitForVibeTeardown(tasks: readonly TrackedVibeTeardown[], deadline: number): Promise<boolean> {
+	if (tasks.length === 0 || tasks.every(task => task.status() !== "pending")) return true;
+	const remainingMs = deadline - Date.now();
+	if (remainingMs <= 0) return false;
+	const timeout = Promise.withResolvers<void>();
+	const timer = setTimeout(timeout.resolve, remainingMs);
+	timer.unref?.();
+	try {
+		return await Promise.race([
+			Promise.allSettled(tasks.map(task => task.promise)).then(() => true),
+			timeout.promise.then(() => false),
+		]);
+	} finally {
+		clearTimeout(timer);
+	}
+}
+
 /** Normalize a text fragment to one bounded roster/trace line. */
 function firstLine(text: string, max = 100): string {
 	return oneLineLabel(text, max);
@@ -321,11 +362,12 @@ function parseLifecycleEvent(value: unknown): VibeLifecycleEvent | undefined {
 	return undefined;
 }
 
-/** Child ids claimed by any valid Vibe spawn event, independent of current parent scope. */
-export function persistedVibeChildIds(entries: Iterable<SessionEntry>): Set<string> {
+/** Child ids claimed by valid Vibe spawn records from untrusted persisted JSON. */
+export function persistedVibeChildIds(entries: Iterable<unknown>): Set<string> {
 	const ids = new Set<string>();
-	for (const entry of entries) {
-		if (entry.type !== "custom" || entry.customType !== VIBE_LIFECYCLE_CUSTOM_TYPE) continue;
+	for (const value of entries) {
+		const entry = objectRecord(value);
+		if (entry?.type !== "custom" || entry.customType !== VIBE_LIFECYCLE_CUSTOM_TYPE) continue;
 		const event = parseLifecycleEvent(entry.data);
 		if (
 			event?.action === "spawn" &&
@@ -354,24 +396,6 @@ function mergeTrace(turn: VibeTurn, progress: AgentProgress): void {
 /** Thrown from a turn job body so the job manager marks the job failed while carrying the formatted result. */
 export class VibeTurnError extends Error {}
 
-async function awaitCancelledTurnJobs(jobs: ReadonlySet<AsyncJob>): Promise<void> {
-	if (jobs.size === 0) return;
-	const settled = Promise.allSettled([...jobs].map(job => job.promise)).then(() => true);
-	const timeout = Promise.withResolvers<false>();
-	const timer = setTimeout(() => timeout.resolve(false), CANCELLED_TURN_SETTLE_GRACE_MS);
-	timer.unref();
-	try {
-		if (!(await Promise.race([settled, timeout.promise]))) {
-			logger.warn("vibe: detached cancelled turn that did not settle within teardown grace period", {
-				jobCount: jobs.size,
-				graceMs: CANCELLED_TURN_SETTLE_GRACE_MS,
-			});
-		}
-	} finally {
-		clearTimeout(timer);
-	}
-}
-
 /**
  * Process-global registry of vibe worker sessions, scoped by both owner agent
  * id and stable parent session id. Persisted lifecycle events rebuild idle
@@ -419,6 +443,12 @@ export class VibeSessionRegistry {
 	readonly #records = new Map<string, VibeRecord>();
 	readonly #terminationTails = new Map<string, Promise<void>>();
 	readonly #terminatedScopes = new Set<string>();
+	#teardownGraceMs = VIBE_TEARDOWN_GRACE_MS;
+
+	/** Override the teardown grace period for deterministic lifecycle tests. */
+	setTeardownGraceForTesting(timeoutMs: number): void {
+		this.#teardownGraceMs = Math.max(1, timeoutMs);
+	}
 
 	ownerScope(session: VibeParentSession): VibeOwnerScope {
 		const parentSessionId = session.getSessionId?.();
@@ -709,11 +739,50 @@ export class VibeSessionRegistry {
 		}
 	}
 
+	#trackAgentRelease(id: string, ref: AgentRef, action: "detach" | "release"): TrackedVibeTeardown {
+		return trackVibeTeardown(AgentLifecycleManager.global().release(id, ref), error => {
+			logger.warn(`vibe: failed to ${action} worker session`, {
+				id,
+				error: error instanceof Error ? error.message : String(error),
+			});
+		});
+	}
+
+	#finishAgentRelease(id: string, ref: AgentRef, task: TrackedVibeTeardown, action: "detach" | "release"): void {
+		if (task.status() === "settled") return;
+		if (task.status() === "pending") {
+			logger.warn(`vibe: timed out waiting to ${action} worker session; detaching registry ref`, { id });
+		}
+		AgentRegistry.global().unregister(id, ref);
+	}
+
+	async #releaseRefWithinDeadline(
+		id: string,
+		ref: AgentRef,
+		deadline: number,
+		action: "detach" | "release",
+	): Promise<void> {
+		const task = this.#trackAgentRelease(id, ref, action);
+		await waitForVibeTeardown([task], deadline);
+		this.#finishAgentRelease(id, ref, task, action);
+	}
+
+	#trackJobSettlement(record: VibeRecord, job: AsyncJob): TrackedVibeTeardown {
+		return trackVibeTeardown(job.promise, error => {
+			logger.warn("vibe: cancelled worker turn cleanup failed", {
+				id: record.id,
+				jobId: job.id,
+				error: error instanceof Error ? error.message : String(error),
+			});
+		});
+	}
+
 	async #markTerminalRef(
 		id: string,
 		ownerId: string,
 		childSessionFile: string,
 		expected?: AgentRef | null,
+		teardownDeadline?: number,
 	): Promise<void> {
 		const registry = AgentRegistry.global();
 		const existing = registry.get(id);
@@ -726,7 +795,9 @@ export class VibeSessionRegistry {
 		}
 		if (existing?.status === "aborted" && !existing.session) return;
 		if (existing && !registry.setStatus(id, "aborted", existing)) return;
-		if (existing && AgentLifecycleManager.global().has(id, existing)) {
+		if (existing && teardownDeadline !== undefined) {
+			await this.#releaseRefWithinDeadline(id, existing, teardownDeadline, "release");
+		} else if (existing && AgentLifecycleManager.global().has(id, existing)) {
 			await AgentLifecycleManager.global().release(id, existing);
 		} else if (existing?.session) {
 			await existing.session.dispose();
@@ -1086,21 +1157,50 @@ export class VibeSessionRegistry {
 			this.#records.delete(scopeKey(scope, record.id));
 			if (record.turn && manager) manager.cancel(record.turn.jobId, { ownerId: record.ownerId });
 		}
-		for (const { record, ref } of teardown) {
-			if (!ref) continue;
-			try {
-				await AgentLifecycleManager.global().release(record.id, ref);
-			} catch (error) {
-				logger.warn("vibe: failed to detach worker session", {
+		const deadline = Date.now() + this.#teardownGraceMs;
+		const cleanup = teardown.map(entry => ({
+			...entry,
+			releaseTask: entry.ref ? this.#trackAgentRelease(entry.record.id, entry.ref, "detach") : undefined,
+			jobTask: entry.job ? this.#trackJobSettlement(entry.record, entry.job) : undefined,
+		}));
+		await waitForVibeTeardown(
+			cleanup.flatMap(entry => [entry.releaseTask, entry.jobTask].filter(task => task !== undefined)),
+			deadline,
+		);
+		for (const { record, ref, releaseTask, job, jobTask } of cleanup) {
+			if (ref && releaseTask) this.#finishAgentRelease(record.id, ref, releaseTask, "detach");
+			if (job && jobTask?.status() === "pending") {
+				logger.warn("vibe: timed out waiting for cancelled worker turn; cleanup continues in the background", {
 					id: record.id,
-					error: error instanceof Error ? error.message : String(error),
+					jobId: job.id,
 				});
+				this.#continueSuspendedCleanup(scope, record, jobTask);
+			}
+			if (this.#records.has(scopeKey(scope, record.id))) continue;
+			const lateRef = this.#registeredAgent(record);
+			if (lateRef && lateRef !== ref) {
+				await this.#releaseRefWithinDeadline(record.id, lateRef, deadline, "detach");
 			}
 		}
-		await awaitCancelledTurnJobs(new Set(teardown.flatMap(entry => (entry.job ? [entry.job] : []))));
 		return records.length;
 	}
 
+	#continueSuspendedCleanup(scope: VibeOwnerScope, record: VibeRecord, jobTask: TrackedVibeTeardown): void {
+		void jobTask.promise
+			.then(async () => {
+				if (this.#records.has(scopeKey(scope, record.id))) return;
+				const lateRef = this.#registeredAgent(record);
+				if (!lateRef) return;
+				await this.#releaseRefWithinDeadline(record.id, lateRef, Date.now() + this.#teardownGraceMs, "detach");
+			})
+			.catch(error => {
+				logger.warn("vibe: failed to finish suspended worker cleanup", {
+					id: record.id,
+					error: error instanceof Error ? error.message : String(error),
+				});
+			});
+	}
+
 	/** Terminate one worker; a tombstone failure still tears it down before reconciliation and error delivery. */
 	async kill(session: ToolSession, id: string): Promise<VibeKillOutcome> {
 		const scope = this.ownerScope(session);
@@ -1144,15 +1244,21 @@ export class VibeSessionRegistry {
 			await this.#persistModeExit(session, scope, records);
 		} catch (error) {
 			if (error instanceof SessionPersistenceIndeterminateError) {
-				for (const record of records) {
-					await this.#killRecord(record, session.asyncJobManager, session, "mode-exit", false);
-				}
+				const teardownDeadline = Date.now() + this.#teardownGraceMs;
+				await Promise.all(
+					records.map(record =>
+						this.#killRecord(record, session.asyncJobManager, session, "mode-exit", false, teardownDeadline),
+					),
+				);
 			}
 			throw error;
 		}
-		for (const record of records) {
-			await this.#killRecord(record, session.asyncJobManager, session, "mode-exit");
-		}
+		const teardownDeadline = Date.now() + this.#teardownGraceMs;
+		await Promise.all(
+			records.map(record =>
+				this.#killRecord(record, session.asyncJobManager, session, "mode-exit", true, teardownDeadline),
+			),
+		);
 		return records.length;
 	}
 
@@ -1162,6 +1268,7 @@ export class VibeSessionRegistry {
 		session: VibeParentSession,
 		reason: VibeTombstoneReason,
 		persistTerminal = true,
+		teardownDeadline?: number,
 	): Promise<VibeKillOutcome> {
 		const registered = this.#registeredAgent(record);
 		const settlingJobs = new Set<AsyncJob>();
@@ -1198,26 +1305,29 @@ export class VibeSessionRegistry {
 		record.state = "dead";
 		record.lastActivityAt = Date.now();
 		record.lastActivity = "killed";
-		if (registered) {
-			try {
-				await AgentLifecycleManager.global().release(record.id, registered);
-			} catch (error) {
-				logger.warn("vibe: failed to release worker session", {
-					id: record.id,
-					error: error instanceof Error ? error.message : String(error),
-				});
-			}
+		const deadline = teardownDeadline ?? Date.now() + this.#teardownGraceMs;
+		const releaseTask = registered ? this.#trackAgentRelease(record.id, registered, "release") : undefined;
+		const jobCleanup = [...settlingJobs].map(job => ({ job, task: this.#trackJobSettlement(record, job) }));
+		await waitForVibeTeardown(
+			[releaseTask, ...jobCleanup.map(entry => entry.task)].filter(task => task !== undefined),
+			deadline,
+		);
+		if (registered && releaseTask) this.#finishAgentRelease(record.id, registered, releaseTask, "release");
+		const pendingJobs = jobCleanup.filter(entry => entry.task.status() === "pending");
+		for (const { job } of pendingJobs) {
+			logger.warn("vibe: timed out waiting for cancelled worker turn; cleanup continues in the background", {
+				id: record.id,
+				jobId: job.id,
+			});
 		}
-		await awaitCancelledTurnJobs(settlingJobs);
 		const terminalRef = registered ?? this.#registeredAgent(record) ?? null;
-		if (record.childSessionFile) {
-			try {
-				const persisted = await SessionManager.peekSessionInit(record.childSessionFile);
-				if (persisted?.init)
-					await this.#markTerminalRef(record.id, record.ownerId, record.childSessionFile, terminalRef);
-			} catch {
-				// A turn killed before session initialization has no readable history to retain.
-			}
+		await this.#markTerminalRecord(record, terminalRef, deadline);
+		if (pendingJobs.length > 0) {
+			this.#continueKilledCleanup(
+				record,
+				pendingJobs.map(entry => entry.task),
+				registered,
+			);
 		}
 		if (persistenceError) {
 			let finalPersistenceError = persistenceError;
@@ -1246,6 +1356,40 @@ export class VibeSessionRegistry {
 		return { id: record.id, cancelledTurn };
 	}
 
+	async #markTerminalRecord(
+		record: VibeRecord,
+		expected: AgentRef | null | undefined,
+		teardownDeadline: number,
+	): Promise<void> {
+		if (!record.childSessionFile) return;
+		try {
+			const persisted = await SessionManager.peekSessionInit(record.childSessionFile);
+			if (persisted?.init) {
+				await this.#markTerminalRef(record.id, record.ownerId, record.childSessionFile, expected, teardownDeadline);
+			}
+		} catch (error) {
+			logger.warn("vibe: failed to retain terminal worker transcript", {
+				id: record.id,
+				error: error instanceof Error ? error.message : String(error),
+			});
+		}
+	}
+
+	#continueKilledCleanup(
+		record: VibeRecord,
+		jobTasks: readonly TrackedVibeTeardown[],
+		expected: AgentRef | undefined,
+	): void {
+		void Promise.allSettled(jobTasks.map(task => task.promise))
+			.then(() => this.#markTerminalRecord(record, expected, Date.now() + this.#teardownGraceMs))
+			.catch(error => {
+				logger.warn("vibe: failed to finish killed worker cleanup", {
+					id: record.id,
+					error: error instanceof Error ? error.message : String(error),
+				});
+			});
+	}
+
 	/** Build the ExecutorOptions for a first spawn, mirroring the `task`/eval-bridge plumbing. */
 	async #buildSpawnOptions(
 		session: ToolSession,

package/src/web/scrapers/arxiv.ts

@@ -30,7 +30,7 @@ export const handleArxiv: SpecialHandler = async (
 		if (!result.ok) return null;
 
 		// Parse the Atom feed response
-		const { parseHTML } = await import("linkedom");
+		const { parseHTML } = await import("@oh-my-pi/pi-utils/dom");
 		const doc = parseHTML(result.content).document;
 		const entry = doc.querySelector("entry");
 

package/src/web/scrapers/go-pkg.ts

@@ -96,7 +96,7 @@ export const handleGoPkg: SpecialHandler = async (
 			});
 		}
 
-		const { parseHTML } = await import("linkedom");
+		const { parseHTML } = await import("@oh-my-pi/pi-utils/dom");
 		const doc = parseHTML(pageResult.content).document;
 
 		// Extract actual module path from breadcrumb or header

package/src/web/scrapers/hackage.ts

@@ -1,4 +1,4 @@
-import { tryParseJson } from "@oh-my-pi/pi-utils";
+import { compareVersions, tryParseJson } from "@oh-my-pi/pi-utils";
 import type { RenderResult, SpecialHandler } from "./types";
 import { buildResult, loadPage } from "./types";
 
@@ -20,17 +20,6 @@ interface ParsedCabal {
 	stability?: string;
 }
 
-function compareVersions(a: string, b: string): number {
-	const aParts = a.split(".").map(part => Number.parseInt(part, 10) || 0);
-	const bParts = b.split(".").map(part => Number.parseInt(part, 10) || 0);
-	const max = Math.max(aParts.length, bParts.length);
-	for (let i = 0; i < max; i++) {
-		const delta = (aParts[i] || 0) - (bParts[i] || 0);
-		if (delta !== 0) return delta;
-	}
-	return 0;
-}
-
 function extractCabalField(content: string, fieldName: string): string | undefined {
 	const pattern = new RegExp(`^${fieldName}:\\s*(.*)$`, "im");
 	const match = content.match(pattern);

package/src/web/scrapers/iacr.ts

@@ -29,7 +29,7 @@ export const handleIacr: SpecialHandler = async (
 
 		if (!result.ok) return null;
 
-		const { parseHTML } = await import("linkedom");
+		const { parseHTML } = await import("@oh-my-pi/pi-utils/dom");
 		const doc = parseHTML(result.content).document;
 
 		// Extract metadata from the page

package/src/web/scrapers/readthedocs.ts

@@ -1,6 +1,7 @@
 /**
  * Read the Docs handler for web-fetch
  */
+import type { Element } from "@oh-my-pi/pi-utils/dom";
 import { buildResult, htmlToBasicMarkdown, loadPage, type RenderResult, type SpecialHandler } from "./types";
 
 export const handleReadTheDocs: SpecialHandler = async (
@@ -38,7 +39,7 @@ export const handleReadTheDocs: SpecialHandler = async (
 	}
 
 	// Parse HTML
-	const { parseHTML } = await import("linkedom");
+	const { parseHTML } = await import("@oh-my-pi/pi-utils/dom");
 	const root = parseHTML(result.content).document;
 
 	// Extract main content from common Read the Docs selectors

package/src/web/scrapers/twitter.ts

@@ -1,4 +1,4 @@
-import type { HTMLElement } from "linkedom";
+import type { HTMLElement } from "@oh-my-pi/pi-utils/dom";
 import { ToolAbortError } from "../../tools/tool-errors";
 import type { RenderResult, SpecialHandler } from "./types";
 import { buildResult, loadPage } from "./types";
@@ -33,7 +33,7 @@ export const handleTwitter: SpecialHandler = async (
 
 			if (result.ok && result.content.length > 500) {
 				// Parse the Nitter HTML
-				const { parseHTML } = await import("linkedom");
+				const { parseHTML } = await import("@oh-my-pi/pi-utils/dom");
 				const doc = parseHTML(result.content).document;
 
 				// Extract tweet content

package/src/web/scrapers/types.ts

@@ -3,7 +3,7 @@
  */
 import { scheduler } from "node:timers/promises";
 import { ptree } from "@oh-my-pi/pi-utils";
-import type TurndownService from "turndown";
+import type TurndownService from "@oh-my-pi/pi-utils/turndown";
 
 import type { AgentStorage } from "../../session/agent-storage";
 import { ToolAbortError } from "../../tools/tool-errors";

package/src/web/scrapers/wikipedia.ts

@@ -44,7 +44,7 @@ export const handleWikipedia: SpecialHandler = async (
 		const contentResult = await loadPage(contentUrl, { timeout, signal });
 
 		if (contentResult.ok) {
-			const { parseHTML } = await import("linkedom");
+			const { parseHTML } = await import("@oh-my-pi/pi-utils/dom");
 			const doc = parseHTML(contentResult.content).document;
 
 			// Extract main content sections

package/src/web/search/providers/browser-headers.ts

@@ -1,28 +1,13 @@
-import { HeaderGenerator } from "header-generator";
+import { HeaderGenerator } from "@oh-my-pi/pi-utils/headers";
 
-// Lazily instantiate the singleton header generator. Bun single-file binaries do not
-// bundle header-generator's fs-loaded data_files, so construction may throw when the
-// original build-time node_modules path is absent.
-let generator: HeaderGenerator | undefined;
-let generatorUnavailable = false;
-
-function getHeaderGenerator(): HeaderGenerator | undefined {
-	if (generatorUnavailable) return undefined;
-	try {
-		generator ??= new HeaderGenerator({
-			browserListQuery: "last 3 versions",
-			devices: ["desktop"],
-			operatingSystems: ["windows", "macos", "linux"],
-			locales: ["en-US", "en"],
-			httpVersion: "2",
-			strict: false,
-		});
-		return generator;
-	} catch {
-		generatorUnavailable = true;
-		return undefined;
-	}
-}
+const generator = new HeaderGenerator({
+	browserListQuery: "last 3 versions",
+	devices: ["desktop"],
+	operatingSystems: ["windows", "macos", "linux"],
+	locales: ["en-US", "en"],
+	httpVersion: "2",
+	strict: false,
+});
 
 // A fallback desktop Mac Chrome navigation fingerprint matching
 // the previous static default setup for deterministic or non-randomized calls.
@@ -84,9 +69,8 @@ function canonicalizeHeaderNames(headers: Record<string, string>): Record<string
 
 /**
  * Build a fresh, internally consistent desktop navigation fingerprint for one HTTP request.
- * By default, this randomizes across valid modern versions of Chrome, Firefox, Edge, and Safari
- * using real-world traffic data. Set `randomized` to `false` when a fetch must preserve a
- * stable Mac Chrome identity.
+ * By default, this randomizes across coherent modern Chrome, Firefox, and Safari profiles.
+ * Set `randomized` to `false` when a fetch must preserve a stable Mac Chrome identity.
  */
 export function buildBrowserNavigationHeaders(options?: { randomized?: boolean }): Record<string, string> {
 	const randomized = options?.randomized !== false;
@@ -94,16 +78,5 @@ export function buildBrowserNavigationHeaders(options?: { randomized?: boolean }
 		return { ...CHROME_FALLBACK_HEADERS };
 	}
 
-	const generator = getHeaderGenerator();
-	if (!generator) {
-		return { ...CHROME_FALLBACK_HEADERS };
-	}
-
-	try {
-		// Generate realistic, consistent headers with the Bayesian generator
-		return canonicalizeHeaderNames(generator.getHeaders());
-	} catch {
-		// Gracefully recover to the robust default profile on unexpected generator errors
-		return { ...CHROME_FALLBACK_HEADERS };
-	}
+	return canonicalizeHeaderNames(generator.getHeaders());
 }

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

@@ -13,11 +13,7 @@ import {
 	withAuth,
 	withOAuthAccess,
 } from "@oh-my-pi/pi-ai";
-import { applyCodexResponsesLiteShape } from "@oh-my-pi/pi-ai/providers/openai-codex/request-transformer";
-import {
-	createOpenAICodexCompatibilityMetadata,
-	resolveCodexResponsesUrl,
-} from "@oh-my-pi/pi-ai/providers/openai-codex-responses";
+import { resolveCodexResponsesUrl } from "@oh-my-pi/pi-ai/providers/openai-codex-responses";
 import { getBundledModels } from "@oh-my-pi/pi-catalog/models";
 import {
 	CODEX_BASE_URL,
@@ -447,7 +443,6 @@ async function callCodexSearch(
 		systemPrompt?: string;
 		searchContextSize?: "low" | "medium" | "high";
 		model: CodexModelCandidate;
-		sessionId?: string;
 		fetch?: FetchImpl;
 		transport: CodexSearchTransport;
 	},
@@ -455,7 +450,6 @@ async function callCodexSearch(
 	const headers = buildCodexHeaders(auth.accessToken, auth.accountId, options.transport.headers);
 
 	const requestedModel = options.model.modelId;
-	const usesResponsesLite = options.model.catalogModel?.useResponsesLite === true;
 
 	const body: Record<string, unknown> = {
 		model: requestedModel,
@@ -477,21 +471,6 @@ async function callCodexSearch(
 		tool_choice: { type: "web_search" },
 		instructions: options.systemPrompt ?? DEFAULT_INSTRUCTIONS,
 	};
-	if (usesResponsesLite) {
-		const metadata = createOpenAICodexCompatibilityMetadata({
-			sessionId: options.sessionId,
-			requestKind: "turn",
-			startNewTurn: true,
-		});
-		for (const name in metadata.headers) {
-			const value = metadata.headers[name];
-			if (value !== undefined) headers.set(name, value);
-		}
-		headers.set(OPENAI_HEADERS.RESPONSES_LITE, "true");
-		body.client_metadata = metadata.clientMetadata;
-		body.reasoning = { context: "all_turns" };
-		applyCodexResponsesLiteShape(body);
-	}
 
 	const fetchImpl = options.fetch ?? fetch;
 	const response = await fetchImpl(options.transport.url, {
@@ -519,9 +498,8 @@ async function callCodexSearch(
 	let model = requestedModel;
 	let requestId = "";
 	let usage: { inputTokens: number; outputTokens: number; totalTokens: number } | undefined;
-	// Evidence that the hosted web_search tool actually ran. Lite models get
-	// `tool_choice: "auto"` and may answer without searching (#6988); a search
-	// command must reject that rather than return a non-search completion.
+	// A search command must reject a completion that did not invoke the hosted
+	// tool rather than returning an answer from the model's own knowledge (#6988).
 	let webSearchInvoked = false;
 
 	for await (const rawEvent of readSseJson<Record<string, unknown>>(response.body, options.signal)) {
@@ -651,7 +629,6 @@ async function runCodexSearchCandidates(options: {
 				systemPrompt: options.params.systemPrompt,
 				searchContextSize: "high",
 				model: candidate,
-				sessionId: options.params.sessionId,
 				fetch: options.params.fetch,
 				transport: options.transport,
 			});

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

@@ -372,7 +372,7 @@ export class DuckDuckGoProvider extends SearchProvider {
 		return true;
 	}
 
-	isExplicitlyAvailable(_authStorage: AuthStorage): boolean {
+	override isExplicitlyAvailable(_authStorage: AuthStorage): boolean {
 		return true;
 	}
 

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

@@ -1,5 +1,5 @@
 import type { AuthStorage } from "@oh-my-pi/pi-ai";
-import { parseHTML } from "linkedom";
+import { parseHTML } from "@oh-my-pi/pi-utils/dom";
 import type { SearchResponse, SearchSource } from "../../../web/search/types";
 import { SearchProviderError } from "../../../web/search/types";
 import { formatScraperQuery } from "../query";
@@ -173,7 +173,7 @@ export class EcosiaProvider extends SearchProvider {
 		return true;
 	}
 
-	isExplicitlyAvailable(_authStorage: AuthStorage): boolean {
+	override isExplicitlyAvailable(_authStorage: AuthStorage): boolean {
 		return true;
 	}
 

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

@@ -458,7 +458,7 @@ export class ExaProvider extends SearchProvider {
 	 * still uses {@link isAvailable} so an unrelated configured provider
 	 * keeps priority over the public fallback.
 	 */
-	isExplicitlyAvailable(_authStorage: AuthStorage): boolean {
+	override isExplicitlyAvailable(_authStorage: AuthStorage): boolean {
 		return this.#settingsAllowSearch();
 	}
 

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

@@ -203,7 +203,7 @@ export class FirecrawlProvider extends SearchProvider {
 	 * Firecrawl supports keyless mode, so an explicit user selection
 	 * (`webSearch: firecrawl`) works without any credential configured.
 	 */
-	isExplicitlyAvailable(_authStorage: AuthStorage): boolean {
+	override isExplicitlyAvailable(_authStorage: AuthStorage): boolean {
 		return true;
 	}
 

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

@@ -1,5 +1,5 @@
 import type { AuthStorage } from "@oh-my-pi/pi-ai";
-import { parseHTML } from "linkedom";
+import { type Element, parseHTML } from "@oh-my-pi/pi-utils/dom";
 import type { SearchResponse, SearchSource } from "../../../web/search/types";
 import { SearchProviderError } from "../../../web/search/types";
 import { formatScraperQuery } from "../query";