@gajae-code/coding-agent 0.11.5 → 0.11.7

package/src/session/yield-queue.ts

@@ -107,6 +107,26 @@ export class YieldQueue {
 		this.#idleFlushPending = false;
 	}
 
+	/** Drop only the queued entries of a single kind, leaving other kinds intact. */
+	clearKind(kind: string): void {
+		this.#entries.delete(kind);
+	}
+
+	/**
+	 * Re-schedule an idle flush if work remains and the session is idle. Used after
+	 * a transition (e.g. handoff) releases a delivery fence so entries queued while
+	 * fenced are not stranded until an unrelated enqueue or agent yield.
+	 */
+	rearmIdle(): void {
+		if (this.#options.isStreaming()) return;
+		for (const entries of this.#entries.values()) {
+			if (entries.length > 0) {
+				this.#scheduleIdleFlush();
+				return;
+			}
+		}
+	}
+
 	#scheduleIdleFlush(): void {
 		if (this.#idleFlushPending) return;
 		this.#idleFlushPending = true;

package/src/setup/credential-import.ts

@@ -391,7 +391,7 @@ export function formatCredentialSummary(credential: ImportableCredential): strin
 	const identityPart = identity ? ` ${identity}` : "";
 	let expiry = "";
 	if (credential.kind === "oauth" && credential.expiresAt !== undefined) {
-		expiry = credential.expiresAt < Date.now() ? " [expired]" : "";
+		expiry = credential.expiresAt <= Date.now() ? " [expired]" : "";
 	}
 	return `${provider} · ${kind}${identityPart} · token ${credential.redactedToken}${expiry} (from ${credential.source})`;
 }
@@ -413,7 +413,10 @@ export function formatDiscoverySummary(result: CredentialDiscoveryResult): strin
 	return lines;
 }
 
-export function isAutoImportOAuthCredential(credential: ImportableCredential): boolean {
+/** Reason shown when automatic OAuth import rejects an unusable discovery record. */
+export const INVALID_AUTO_IMPORT_OAUTH_EXPIRY_REASON = "OAuth credential has no valid future expiry";
+
+function hasAutoImportOAuthProviderOrigin(credential: ImportableCredential): boolean {
 	return (
 		AUTO_IMPORT_OAUTH_PROVIDER_ORIGINS[credential.provider]?.has(credential.origin) === true &&
 		credential.kind === "oauth" &&
@@ -421,8 +424,30 @@ export function isAutoImportOAuthCredential(credential: ImportableCredential): b
 	);
 }
 
+export function isAutoImportOAuthCredential(credential: ImportableCredential, now: number = Date.now()): boolean {
+	return (
+		hasAutoImportOAuthProviderOrigin(credential) &&
+		typeof credential.expiresAt === "number" &&
+		Number.isFinite(credential.expiresAt) &&
+		credential.expiresAt > now
+	);
+}
+
+/** Keep rejected OAuth discoveries visible to operators without offering them for automatic import. */
+export function getAutoImportOAuthCredentialSkips(
+	credentials: readonly ImportableCredential[],
+	now: number = Date.now(),
+): SkippedCredential[] {
+	return credentials.flatMap(credential =>
+		hasAutoImportOAuthProviderOrigin(credential) && !isAutoImportOAuthCredential(credential, now)
+			? [{ origin: credential.origin, source: credential.source, reason: INVALID_AUTO_IMPORT_OAUTH_EXPIRY_REASON }]
+			: [],
+	);
+}
+
 export function filterAutoImportOAuthCredentials(credentials: readonly ImportableCredential[]): ImportableCredential[] {
-	return credentials.filter(isAutoImportOAuthCredential);
+	const now = Date.now();
+	return credentials.filter(credential => isAutoImportOAuthCredential(credential, now));
 }
 
 /**

package/src/setup/provider-onboarding.ts

@@ -49,6 +49,7 @@ interface ProviderPreset {
 	baseUrl: string;
 	apiKeyEnv: string;
 	models: readonly string[];
+	modelApi?: Readonly<Record<string, ProviderSetupApi>>;
 	compat?: ProviderCompatConfig;
 }
 
@@ -113,6 +114,7 @@ function resolvePresetInput(input: ProviderSetupInput): {
 	apiKey?: string;
 	apiKeyEnv?: string;
 	models: readonly string[];
+	modelApi?: Readonly<Record<string, ProviderSetupApi>>;
 	api: ProviderSetupApi;
 	compat?: ProviderCompatConfig;
 } {
@@ -152,11 +154,32 @@ function resolvePresetInput(input: ProviderSetupInput): {
 		apiKey: input.apiKey,
 		apiKeyEnv: input.apiKeyEnv ?? preset?.apiKeyEnv,
 		models: input.models && input.models.length > 0 ? input.models : (preset?.models ?? []),
+		modelApi: preset?.modelApi,
 		api: preset?.api ?? apiForCompatibility(compatibility),
 		compat: preset?.compat,
 	};
 }
 
+export function validateModelApi(
+	modelApi: Readonly<Record<string, string>> | undefined,
+	models: readonly string[],
+	presetId: string,
+): void {
+	if (!modelApi) return;
+	const modelSet = new Set(models);
+	const validApis: readonly string[] = ["openai-responses", "openai-completions", "anthropic-messages"];
+	for (const [key, value] of Object.entries(modelApi)) {
+		if (!modelSet.has(key)) {
+			throw new Error(`Provider preset '${presetId}' declares modelApi for unknown model '${key}'.`);
+		}
+		if (!validApis.includes(value)) {
+			throw new Error(
+				`Provider preset '${presetId}' declares invalid modelApi value '${value}' for model '${key}'.`,
+			);
+		}
+	}
+}
+
 function validateSetupInput(input: ProviderSetupInput): {
 	providerId: string;
 	baseUrl: string;
@@ -166,6 +189,7 @@ function validateSetupInput(input: ProviderSetupInput): {
 	compatibility: ProviderCompatibility;
 	api: ProviderSetupApi;
 	compat?: ProviderCompatConfig;
+	modelApi?: Readonly<Record<string, ProviderSetupApi>>;
 	preset?: ProviderPreset;
 } {
 	const resolved = resolvePresetInput(input);
@@ -201,6 +225,7 @@ function validateSetupInput(input: ProviderSetupInput): {
 
 	const models = parseModelList(resolved.models);
 	if (models.length === 0) throw new Error("At least one model id is required.");
+	validateModelApi(resolved.modelApi, models, resolved.preset?.id ?? resolved.providerId);
 
 	return {
 		providerId,
@@ -210,6 +235,7 @@ function validateSetupInput(input: ProviderSetupInput): {
 		models,
 		compatibility: resolved.compatibility,
 		api: resolved.api,
+		modelApi: resolved.modelApi,
 		compat: resolved.compat,
 		preset: resolved.preset,
 	};
@@ -275,7 +301,10 @@ export async function addApiCompatibleProvider(input: ProviderSetupInput): Promi
 		baseUrl: validated.baseUrl,
 		api: validated.api,
 		auth: "apiKey",
-		models: validated.models.map(id => ({ id })),
+		models: validated.models.map(id => {
+			const api = validated.modelApi?.[id];
+			return api ? { id, api } : { id };
+		}),
 	};
 	if (validated.compat) provider.compat = validated.compat;
 	if (validated.credentialSource === "env") {

package/src/setup/provider-presets.json

@@ -1,5 +1,6 @@
 [
   {"id":"minimax","aliases":["minimax-code"],"name":"MiniMax Coding Plan","description":"OpenAI-compatible MiniMax Coding Plan endpoint","compatibility":"openai","api":"openai-completions","providerId":"minimax-code","baseUrl":"https://api.minimax.io/v1","apiKeyEnv":"MINIMAX_CODE_API_KEY","models":["minimax-m3"],"compat":{"supportsStore":false,"supportsDeveloperRole":false,"supportsReasoningEffort":false,"reasoningContentField":"reasoning_content"}},
   {"id":"minimax-cn","aliases":["minimax-code-cn","minimaxi"],"name":"MiniMax Coding Plan (China)","description":"OpenAI-compatible MiniMax China endpoint","compatibility":"openai","api":"openai-completions","providerId":"minimax-code-cn","baseUrl":"https://api.minimaxi.com/v1","apiKeyEnv":"MINIMAX_CODE_CN_API_KEY","models":["minimax-m3"],"compat":{"supportsStore":false,"supportsDeveloperRole":false,"supportsReasoningEffort":false,"reasoningContentField":"reasoning_content"}},
-  {"id":"glm","aliases":["zai","z-ai","bigmodel"],"name":"GLM / zAI","description":"OpenAI-compatible GLM endpoint from zAI/BigModel","compatibility":"openai","api":"openai-completions","providerId":"glm-proxy","baseUrl":"https://api.z.ai/api/paas/v4","apiKeyEnv":"ZAI_API_KEY","models":["glm-4.6"],"compat":{"supportsDeveloperRole":false,"supportsReasoningEffort":false,"thinkingFormat":"zai","reasoningContentField":"reasoning_content"}}
+  {"id":"glm","aliases":["zai","z-ai","bigmodel"],"name":"GLM / zAI","description":"OpenAI-compatible GLM endpoint from zAI/BigModel","compatibility":"openai","api":"openai-completions","providerId":"glm-proxy","baseUrl":"https://api.z.ai/api/paas/v4","apiKeyEnv":"ZAI_API_KEY","models":["glm-4.6"],"compat":{"supportsDeveloperRole":false,"supportsReasoningEffort":false,"thinkingFormat":"zai","reasoningContentField":"reasoning_content"}},
+  {"id":"alibaba-token-plan","aliases":["alibaba","token-plan"],"name":"Alibaba Token Plan","description":"OpenAI-compatible Alibaba Token Plan endpoint","compatibility":"openai","api":"openai-completions","providerId":"alibaba-token-plan","baseUrl":"https://token-plan.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1","apiKeyEnv":"ALIBABA_TOKEN_PLAN_API_KEY","models":["qwen3.8-max-preview","glm-5.2","deepseek-v4-pro"],"modelApi":{"qwen3.8-max-preview":"openai-responses","glm-5.2":"openai-completions","deepseek-v4-pro":"openai-completions"},"compat":{"supportsDeveloperRole":false}}
 ]

package/src/slash-commands/builtin-registry.ts

@@ -1435,6 +1435,42 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<SlashCommandSpec> = [
 			await runtime.ctx.handleCompactCommand(customInstructions);
 		},
 	},
+	{
+		name: "handoff",
+		priority: 71,
+		description: "Generate a handoff and continue in a new session",
+		acpDescription: "Generate a handoff document and start a new session",
+		inlineHint: "[focus instructions]",
+		acpInputHint: "[focus instructions]",
+		allowArgs: true,
+		handle: async (command, runtime) => {
+			let result: Awaited<ReturnType<typeof runtime.session.handoff>>;
+			try {
+				result = await runtime.session.handoff(command.args || undefined);
+			} catch (err) {
+				// Handoff precondition failures (nothing to hand off, streaming),
+				// cancellation, and provider errors propagate as plain Errors; the
+				// switch is non-destructive so the current session is unchanged.
+				return usage(`Handoff failed: ${errorMessage(err)}; current session is unchanged.`, runtime);
+			}
+			if (!result) {
+				return usage(
+					"Handoff not created (cancelled or nothing to hand off); current session is unchanged.",
+					runtime,
+				);
+			}
+			await runtime.output(
+				result.savedPath
+					? `Handoff created; new session started. Handoff document saved to: ${result.savedPath}`
+					: "Handoff created; new session started with handoff context.",
+			);
+			return commandConsumed();
+		},
+		handleTui: async (command, runtime) => {
+			runtime.ctx.editor.setText("");
+			await runtime.ctx.handleHandoffCommand(command.args || undefined);
+		},
+	},
 	{
 		name: "contribute-pr",
 		aliases: ["contribution-prep"],
@@ -1479,7 +1515,7 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<SlashCommandSpec> = [
 	},
 	{
 		name: "btw",
-		description: "Ask an ephemeral side question using the current session context",
+		description: "Start an ephemeral multi-turn side chat using the current session context",
 		inlineHint: "<question>",
 		allowArgs: true,
 		handleTui: async (command, runtime) => {

package/src/ssh/utils.ts

@@ -3,6 +3,20 @@ export function sanitizeHostName(name: string): string {
 	return sanitized.length > 0 ? sanitized : "remote";
 }
 
+export function validateSshDestination(username: string | undefined, host: string): string | undefined {
+	if (host.startsWith("-") || username?.startsWith("-")) {
+		return "username and host must not begin with '-'";
+	}
+	if (/\0|\r|\n/.test(host) || (username !== undefined && /\0|\r|\n/.test(username))) {
+		return "username and host must not contain NUL or line breaks";
+	}
+	return undefined;
+}
+
 export function buildSshTarget(username: string | undefined, host: string): string {
+	const validationError = validateSshDestination(username, host);
+	if (validationError) {
+		throw new Error(`Invalid SSH destination: ${validationError}`);
+	}
 	return username ? `${username}@${host}` : host;
 }

package/src/task/discovery.ts

@@ -14,6 +14,7 @@ import * as path from "node:path";
 import { logger } from "@gajae-code/utils";
 import { isProviderEnabled } from "../capability";
 import { findAllNearestProjectConfigDirs, getConfigDirs } from "../config";
+import type { Settings } from "../config/settings";
 import { listClaudePluginRoots } from "../discovery/helpers";
 import { rootContainsGjcManifest } from "../extensibility/gjc-plugins/paths";
 import { loadBundledAgents, parseAgent } from "./agents";
@@ -57,8 +58,13 @@ async function loadAgentsFromDir(dir: string, source: AgentSource): Promise<Agen
  * Precedence (highest wins): .gjc project, .gjc user, GJC plugins, then bundled
  *
  * @param cwd - Current working directory for project agent discovery
+ * @param activeSettings - Settings used to resolve enabled providers.
  */
-export async function discoverAgents(cwd: string, home: string = os.homedir()): Promise<DiscoveryResult> {
+export async function discoverAgents(
+	cwd: string,
+	home: string = os.homedir(),
+	activeSettings?: Settings,
+): Promise<DiscoveryResult> {
 	const resolvedCwd = path.resolve(cwd);
 	const agentSources = Array.from(new Set(getConfigDirs("", { project: false }).map(entry => entry.source)));
 
@@ -91,7 +97,7 @@ export async function discoverAgents(cwd: string, home: string = os.homedir()):
 	}
 
 	// Load agents from GJC marketplace plugins.
-	const { roots: pluginRoots } = isProviderEnabled("claude-plugins")
+	const { roots: pluginRoots } = isProviderEnabled("claude-plugins", activeSettings)
 		? await listClaudePluginRoots(home, resolvedCwd)
 		: { roots: [] };
 	const nonGjcPluginRoots = [];

package/src/tools/ask-answer-registry.ts

@@ -7,6 +7,7 @@
  * source; registering returns a disposer.
  */
 
+import { logger } from "@gajae-code/utils";
 import type { WorkflowGateEmitter } from "../modes/shared/agent-wire/workflow-gate-broker";
 import type { AskAnswerSource } from "./index";
 
@@ -31,7 +32,20 @@ export function getAskAnswerSource(sessionId: string): AskAnswerSource | undefin
 export function notifyWorkflowGateEmitterChanged(sessionId: string, emitter: WorkflowGateEmitter | undefined): void {
 	if (emitter) workflowGateEmitters.set(sessionId, emitter);
 	else workflowGateEmitters.delete(sessionId);
-	for (const listener of workflowGateListeners.get(sessionId) ?? []) listener(emitter);
+	for (const listener of workflowGateListeners.get(sessionId) ?? []) {
+		// Isolate each listener: a throwing observer must never escape into an
+		// emitter suspend/bind/restore step, which runs inside session-transition
+		// transactions (e.g. handoff) whose rollback/commit correctness depends on
+		// this notification being no-throw.
+		try {
+			listener(emitter);
+		} catch (error) {
+			logger.warn("Workflow-gate emitter listener threw during notification", {
+				sessionId,
+				error: error instanceof Error ? error.message : String(error),
+			});
+		}
+	}
 }
 
 /** Observe workflow-gate emitter installation even when it occurs after session_start. */

package/src/tools/ask.ts

@@ -317,7 +317,7 @@ function isRoundZeroRecoveryCandidate(value: unknown): boolean {
 		const question = parseEncodedContainer(rawQuestion);
 		if (typeof question !== "object" || question === null || !Object.hasOwn(question, "deepInterview")) return false;
 		const deepInterview = parseEncodedContainer((question as Record<string, unknown>).deepInterview);
-		if (typeof deepInterview !== "object" || deepInterview === null) return deepInterview === null;
+		if (typeof deepInterview !== "object" || deepInterview === null) return false;
 		const metadata = deepInterview as Record<string, unknown>;
 		return Object.hasOwn(metadata, "intent_contract") || Object.hasOwn(metadata, "intent_review");
 	});

package/src/tools/fetch.ts

@@ -4,7 +4,7 @@ import type { AgentToolResult } from "@gajae-code/agent-core";
 import type { ImageContent, TextContent } from "@gajae-code/ai";
 import { htmlToMarkdown } from "@gajae-code/natives";
 import { type Component, Text } from "@gajae-code/tui";
-import { $which, ptree, truncate } from "@gajae-code/utils";
+import { ptree, truncate } from "@gajae-code/utils";
 import type { Settings } from "../config/settings";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import { type Theme, theme } from "../modes/theme/theme";
@@ -15,10 +15,8 @@ import { renderStatusLine } from "../tui";
 import { CachedOutputBlock } from "../tui/output-block";
 import { formatDimensionNote, resizeImage } from "../utils/image-resize";
 import { parseHtmlLazy } from "../utils/linkedom";
-import { ensureTool } from "../utils/tools-manager";
-import { INSANE_NOTES, tryInsaneFetch } from "../web/insane/bridge";
-import { validatePublicHttpUrl, validatePublicHttpUrlForInsane } from "../web/insane/url-guard";
-import { extractWithParallel, findParallelApiKey, getParallelExtractContent } from "../web/parallel";
+import { INSANE_NOTES } from "../web/insane/bridge";
+import { validatePublicHttpUrl } from "../web/insane/url-guard";
 import { specialHandlers } from "../web/scrapers";
 import type { RenderResult } from "../web/scrapers/types";
 import { finalizeOutput, loadPage, looksLikeHtml, MAX_OUTPUT_CHARS } from "../web/scrapers/types";
@@ -93,13 +91,6 @@ const MAX_INLINE_IMAGE_OUTPUT_BYTES = 300 * 1024;
 // Utilities
 // =============================================================================
 
-/**
- * Check if a command exists (cross-platform)
- */
-function hasCommand(cmd: string): boolean {
-	return Boolean($which(cmd));
-}
-
 /**
  * Build llms.txt candidates scoped to the requested URL
  */
@@ -537,96 +528,18 @@ async function parseFeedToMarkdown(content: string, maxItems = 10): Promise<stri
 	return content; // Fall back to raw content
 }
 
-/**
- * Render HTML to markdown using Parallel, jina, trafilatura, lynx (in order of preference)
- */
-async function renderHtmlToText(
-	url: string,
+export async function renderHtmlToText(
 	html: string,
-	timeout: number,
-	settings: Settings,
-	userSignal: AbortSignal | undefined,
-	storage: AgentStorage | null,
+	signal?: AbortSignal,
 ): Promise<{ content: string; ok: boolean; method: string }> {
-	const signal = ptree.combineSignals(userSignal, timeout * 1000);
-	const execOptions = {
-		mode: "group" as const,
-		allowNonZero: true,
-		allowAbort: true,
-		stderr: "full" as const,
-		signal,
-	};
-
-	// Try Parallel extract first when credentials are configured
-	if (settings.get("providers.parallelFetch") && findParallelApiKey(storage)) {
-		try {
-			const parallelResult = await extractWithParallel(
-				[url],
-				{
-					objective: "Extract the main content",
-					excerpts: true,
-					fullContent: false,
-					signal,
-				},
-				storage,
-			);
-			const firstDocument = parallelResult.results[0];
-			if (firstDocument) {
-				const content = getParallelExtractContent(firstDocument);
-				if (content.trim().length > 100 && !isLowQualityOutput(content)) {
-					return { content, ok: true, method: "parallel" };
-				}
-			}
-		} catch {
-			// Parallel extract failed, continue to next method
-			signal?.throwIfAborted();
-		}
-	}
-
-	// Try jina first (reader API)
 	try {
-		const jinaUrl = `https://r.jina.ai/${url}`;
-		const response = await fetch(jinaUrl, {
-			headers: { Accept: "text/markdown" },
-			signal,
-		});
-		if (response.ok) {
-			const content = await response.text();
-			if (content.trim().length > 100 && !isLowQualityOutput(content)) {
-				return { content, ok: true, method: "jina" };
-			}
-		}
-	} catch {
-		// Jina failed, continue to next method
 		signal?.throwIfAborted();
-	}
-
-	// Try trafilatura (auto-install via uv/pip)
-	const trafilatura = await ensureTool("trafilatura", { signal, silent: true });
-	if (trafilatura) {
-		const result = await ptree.exec([trafilatura, "-u", url, "--output-format", "markdown"], execOptions);
-		if (result.ok && result.stdout.trim().length > 100) {
-			return { content: result.stdout, ok: true, method: "trafilatura" };
-		}
-	}
-
-	// Try lynx (can't auto-install, system package)
-	const lynx = hasCommand("lynx");
-	if (lynx) {
-		const result = await ptree.exec(["lynx", "-dump", "-nolist", "-width", "250", url], execOptions);
-		if (result.ok) {
-			return { content: result.stdout, ok: true, method: "lynx" };
-		}
-	}
-
-	// Fall back to native converter (fastest, no network/subprocess)
-	try {
 		const content = await htmlToMarkdown(html, { cleanContent: true });
 		if (content.trim().length > 100 && !isLowQualityOutput(content)) {
 			return { content, ok: true, method: "native" };
 		}
 	} catch {
-		// Native converter failed, continue to next method
+		// Native conversion failed; the caller returns its bounded raw HTML.
 		signal?.throwIfAborted();
 	}
 	return { content: "", ok: false, method: "none" };
@@ -707,14 +620,6 @@ async function handleSpecialUrls(
 // Main Render Function
 // =============================================================================
 
-/**
- * Opt-in insane-search fallback for blocked / degraded public URL reads.
- *
- * Returns a finalized `method: "insane"` result on success, or null (so the
- * caller continues with its normal degraded behavior). Fail-closed: no note,
- * guard DNS, dependency probe, or subprocess when raw mode or the opt-in
- * setting is off. The public-URL guard runs BEFORE any probe/spawn.
- */
 export async function tryInsaneFallback(args: {
 	url: string;
 	finalUrl: string;
@@ -727,32 +632,7 @@ export async function tryInsaneFallback(args: {
 }): Promise<FetchRenderResult | null> {
 	if (args.raw) return null;
 	if (args.settings.get("web.insaneFallback") !== true) return null;
-
-	const target = args.finalUrl || args.url;
-	const guard = await validatePublicHttpUrlForInsane(target);
-	if (!guard.ok) {
-		args.notes.push(INSANE_NOTES.guardBlocked(guard.reason));
-		return null;
-	}
-
-	const result = await tryInsaneFetch(guard.url.toString(), {
-		timeoutMs: args.timeout * 1000,
-		signal: args.signal,
-	});
-	if (result.ok) {
-		const output = finalizeOutput(result.content);
-		return {
-			url: args.url,
-			finalUrl: target,
-			contentType: "text/markdown",
-			method: "insane",
-			content: output.content,
-			fetchedAt: args.fetchedAt,
-			truncated: output.truncated,
-			notes: [...args.notes, ...result.notes],
-		};
-	}
-	for (const note of result.notes) args.notes.push(note);
+	args.notes.push(INSANE_NOTES.securityDisabled);
 	return null;
 }
 
@@ -772,6 +652,7 @@ async function renderUrl(
 	if (signal?.aborted) {
 		throw new ToolAbortError();
 	}
+	const preflightSignal = ptree.combineSignals(signal, timeout * 1000);
 
 	// Handle internal protocol URLs (e.g., pi-internal://) - return empty
 	if (url.startsWith("pi-internal://")) {
@@ -789,7 +670,8 @@ async function renderUrl(
 
 	// Step 0: Normalize URL (ensure scheme for special handlers)
 	url = normalizeUrl(url);
-	const publicUrl = await validatePublicHttpUrl(url);
+	const publicUrl = await validatePublicHttpUrl(url, { signal: preflightSignal });
+	if (signal?.aborted) throw new ToolAbortError();
 	if (!publicUrl.ok) {
 		notes.push(`Blocked URL fetch: target URL is not public HTTP(S): ${publicUrl.reason}`);
 		return {
@@ -1138,10 +1020,10 @@ async function renderUrl(
 			throw new ToolAbortError();
 		}
 
-		// 5E: Render HTML with lynx or html2text
-		const htmlResult = await renderHtmlToText(finalUrl, rawContent, timeout, settings, signal, storage);
+		// 5E: Render only the bytes already fetched above.
+		const htmlResult = await renderHtmlToText(rawContent, signal);
 		if (!htmlResult.ok) {
-			notes.push("html rendering failed (lynx/html2text unavailable)");
+			notes.push("native HTML rendering failed");
 			const insane = await tryInsaneFallback({ url, finalUrl, timeout, raw, settings, signal, fetchedAt, notes });
 			if (insane) return insane;
 			const output = finalizeOutput(rawContent);