@oh-my-pi/pi-coding-agent 15.10.10 → 15.10.12

package/src/tools/browser/launch.ts

@@ -2,9 +2,8 @@ import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 import { $which, getPuppeteerDir, logger } from "@oh-my-pi/pi-utils";
-import * as browsers from "@puppeteer/browsers";
+import type * as BrowsersNs from "@puppeteer/browsers";
 import type { Browser, CDPSession, Page, default as Puppeteer, Target } from "puppeteer-core";
-import { PUPPETEER_REVISIONS } from "puppeteer-core/internal/revisions.js";
 import stealthTamperingScript from "../puppeteer/00_stealth_tampering.txt" with { type: "text" };
 import stealthActivityScript from "../puppeteer/01_stealth_activity.txt" with { type: "text" };
 import stealthHairlineScript from "../puppeteer/02_stealth_hairline.txt" with { type: "text" };
@@ -78,6 +77,14 @@ export async function loadPuppeteerInWorker(safeDir: string): Promise<typeof Pup
 	}
 }
 
+let browsersModule: typeof BrowsersNs | undefined;
+async function loadBrowsers(): Promise<typeof BrowsersNs> {
+	if (!browsersModule) {
+		browsersModule = await import("@puppeteer/browsers");
+	}
+	return browsersModule;
+}
+
 /**
  * Lazily download Chromium on first browser launch via @puppeteer/browsers.
  * Skipped when a system Chromium (NixOS) or PUPPETEER_EXECUTABLE_PATH is set.
@@ -92,12 +99,14 @@ async function ensureChromiumExecutable(): Promise<string | undefined> {
 	if (chromiumExecutablePromise) return chromiumExecutablePromise;
 
 	chromiumExecutablePromise = (async () => {
+		const browsers = await loadBrowsers();
 		const platform = browsers.detectBrowserPlatform();
 		if (!platform) {
 			logger.warn("Could not detect browser platform; relying on puppeteer default resolution");
 			return undefined;
 		}
 		const cacheDir = getPuppeteerDir();
+		const { PUPPETEER_REVISIONS } = await import("puppeteer-core/internal/revisions.js");
 		const buildId = await browsers.resolveBuildId(browsers.Browser.CHROME, platform, PUPPETEER_REVISIONS.chrome);
 		const executablePath = browsers.computeExecutablePath({
 			browser: browsers.Browser.CHROME,

package/src/tools/browser/readable.ts

@@ -1,5 +1,5 @@
-import { Readability } from "@mozilla/readability";
-import { parseHTML } from "linkedom";
+import type * as ReadabilityNs from "@mozilla/readability";
+import type * as LinkedomNs from "linkedom";
 import { htmlToBasicMarkdown } from "../../web/scrapers/types";
 
 export type ReadableFormat = "text" | "markdown";
@@ -20,6 +20,22 @@ function normalize(text: string | null | undefined): string | undefined {
 	return trimmed || undefined;
 }
 
+let readabilityModule: typeof ReadabilityNs | undefined;
+async function loadReadability(): Promise<typeof ReadabilityNs> {
+	if (!readabilityModule) {
+		readabilityModule = await import("@mozilla/readability");
+	}
+	return readabilityModule;
+}
+
+let linkedomModule: typeof LinkedomNs | undefined;
+async function loadLinkedom(): Promise<typeof LinkedomNs> {
+	if (!linkedomModule) {
+		linkedomModule = await import("linkedom");
+	}
+	return linkedomModule;
+}
+
 /**
  * Extract readable content from raw HTML.
  * Tries Readability (article-isolation scoring) first, then falls back to a
@@ -31,6 +47,7 @@ export async function extractReadableFromHtml(
 	url: string,
 	format: ReadableFormat,
 ): Promise<ReadableResult | null> {
+	const [{ parseHTML }, { Readability }] = await Promise.all([loadLinkedom(), loadReadability()]);
 	const { document } = parseHTML(html);
 
 	// --- Primary: Readability article extraction ---

package/src/tools/browser/registry.ts

@@ -157,7 +157,10 @@ export function holdBrowser(handle: BrowserHandle): void {
 export async function releaseBrowser(handle: BrowserHandle, opts: { kill: boolean }): Promise<void> {
 	handle.refCount = Math.max(0, handle.refCount - 1);
 	if (handle.refCount === 0) {
-		browsers.delete(handle.key);
+		// Only evict if the registry still points at THIS handle. After a disconnect,
+		// `acquireBrowser` may have already replaced the entry with a fresh live handle
+		// under the same key; deleting blindly would orphan that new browser.
+		if (browsers.get(handle.key) === handle) browsers.delete(handle.key);
 		await disposeBrowserHandle(handle, opts);
 	}
 }

package/src/tools/browser/render.ts

@@ -66,7 +66,7 @@ function dropTrailingBlankLines(text: string): string {
 function appendLine(component: Component, line: string | undefined): Component {
 	if (!line) return component;
 	const wrapped = {
-		render: (width: number): string[] => {
+		render: (width: number): readonly string[] => {
 			const base = component.render(width);
 			return [...base, line];
 		},
@@ -95,7 +95,7 @@ function renderRunCell(
 
 	let cached: { key: bigint; width: number; lines: string[] } | undefined;
 	return markFramedBlockComponent({
-		render: (width: number): string[] => {
+		render: (width: number): readonly string[] => {
 			const expanded = options.renderContext?.expanded ?? options.expanded;
 			const previewLines = options.renderContext?.previewLines ?? BROWSER_DEFAULT_PREVIEW_LINES;
 			const key = new Hasher()

package/src/tools/browser/tab-supervisor.ts

@@ -1,4 +1,4 @@
-import { getPuppeteerDir, isCompiledBinary, logger, Snowflake } from "@oh-my-pi/pi-utils";
+import { getPuppeteerDir, logger, Snowflake, workerHostEntry } from "@oh-my-pi/pi-utils";
 import type { Page, Target } from "puppeteer-core";
 import { callSessionTool } from "../../eval/js/tool-bridge";
 import type { ToolSession } from "../../sdk";
@@ -18,14 +18,8 @@ import type {
 	WorkerOutbound,
 } from "./tab-protocol";
 
-// Worker entry. The literal string in `new Worker("./packages/coding-agent/src/tools/browser/tab-worker-entry.ts", …)`
-// below is what Bun's `--compile` static analyzer needs to bundle the worker
-// (registered as an additional entrypoint in `scripts/build-binary.ts`); in
-// dev we resolve the same source via `import.meta.url`. Replaces the older
-// `with { type: "file" }` pattern, which only copied the entry as a raw
-// asset and could not resolve the worker's relative imports inside a
-// compiled binary (issue #1011 was a false-positive fix — the regression
-// test only checked emission, not actual worker startup).
+// Coding-agent binary/bundle workers route through the CLI entrypoint with a
+// hidden argv mode, so compiled/npm builds only need one JavaScript entry.
 
 interface WorkerHandle {
 	send(msg: WorkerInbound, transferList?: Transferable[]): void;
@@ -84,21 +78,51 @@ export interface ReleaseTabOptions {
 }
 
 const tabs = new Map<string, TabSession>();
+// Per-name acquisition chain: serializes concurrent `acquireTab` calls for the
+// same tab name so the existence check and `tabs.set` (separated by several
+// awaits) cannot interleave and leak a worker + browser refCount.
+const acquireChains = new Map<string, Promise<void>>();
 const GRACE_MS = 750;
 
 export function getTab(name: string): TabSession | undefined {
 	return tabs.get(name);
 }
 
-export async function acquireTab(
+export function acquireTab(name: string, browser: BrowserHandle, opts: AcquireTabOptions): Promise<AcquireTabResult> {
+	const prior = acquireChains.get(name) ?? Promise.resolve();
+	const result = prior.then(() => acquireTabImpl(name, browser, opts));
+	const tail = result.then(
+		() => undefined,
+		() => undefined,
+	);
+	acquireChains.set(name, tail);
+	void tail.then(() => {
+		if (acquireChains.get(name) === tail) acquireChains.delete(name);
+	});
+	return result;
+}
+
+async function acquireTabImpl(
 	name: string,
 	browser: BrowserHandle,
 	opts: AcquireTabOptions,
 ): Promise<AcquireTabResult> {
+	// Serialized opens can sit behind a slow predecessor in the per-name
+	// chain; honor an abort at dequeue instead of spawning a worker and
+	// browser hold nobody is waiting for.
+	if (opts.signal?.aborted) {
+		throw new ToolAbortError("Browser tab open aborted");
+	}
+	// Temporary refCount hold so releasing an existing tab on the SAME browser
+	// below cannot drop it to refCount 0 and dispose the instance we are about
+	// to reuse (e.g. reopening the sole tab with a different dialogs policy).
+	let tempHold = false;
 	const existing = tabs.get(name);
 	if (existing) {
 		if (existing.browser === browser && existing.state === "alive") {
 			if (opts.dialogs !== undefined && opts.dialogs !== existing.dialogPolicy) {
+				holdBrowser(browser);
+				tempHold = true;
 				await releaseTab(name, { kill: false });
 			} else {
 				const reuseSteps: string[] = [];
@@ -127,12 +151,25 @@ export async function acquireTab(
 				return { tab: tabs.get(name)!, created: false };
 			}
 		} else {
+			if (existing.browser === browser) {
+				holdBrowser(browser);
+				tempHold = true;
+			}
 			await releaseTab(name, { kill: false });
 		}
 	}
 
-	const initPayload = await buildInitPayload(browser, opts);
-	let worker = await spawnTabWorker();
+	let initPayload: WorkerInitPayload;
+	let worker: WorkerHandle;
+	try {
+		initPayload = await buildInitPayload(browser, opts);
+		worker = await spawnTabWorker();
+	} catch (error) {
+		// Failing before the worker took its own hold must release the
+		// temporary one, or the browser's refCount never reaches 0 again.
+		if (tempHold || browser.refCount === 0) await releaseBrowser(browser, { kill: false });
+		throw error;
+	}
 	let info: ReadyInfo;
 	try {
 		info = await initializeTabWorker(worker, initPayload, opts.timeoutMs + GRACE_MS);
@@ -142,7 +179,7 @@ export async function acquireTab(
 		// the inline worker here so module-resolution failures don't poison every tab open.
 		await worker.terminate().catch(() => undefined);
 		if (worker.mode === "inline") {
-			if (browser.refCount === 0) await releaseBrowser(browser, { kill: false });
+			if (tempHold || browser.refCount === 0) await releaseBrowser(browser, { kill: false });
 			throw error;
 		}
 		logger.warn("Tab worker init failed; retrying with inline tab worker (no sync-loop guard)", {
@@ -153,7 +190,7 @@ export async function acquireTab(
 			info = await initializeTabWorker(worker, initPayload, opts.timeoutMs + GRACE_MS);
 		} catch (inlineError) {
 			await worker.terminate().catch(() => undefined);
-			if (browser.refCount === 0) await releaseBrowser(browser, { kill: false });
+			if (tempHold || browser.refCount === 0) await releaseBrowser(browser, { kill: false });
 			const finalError = new ToolError(
 				`Failed to start browser tab worker (inline fallback also failed): ${inlineError instanceof Error ? inlineError.message : String(inlineError)}`,
 			);
@@ -163,6 +200,7 @@ export async function acquireTab(
 	}
 
 	holdBrowser(browser);
+	if (tempHold) await releaseBrowser(browser, { kill: false });
 	const tab: TabSession = {
 		name,
 		browser,
@@ -474,8 +512,9 @@ async function raceWithTimeout<T>(
 
 async function spawnTabWorker(): Promise<WorkerHandle> {
 	try {
-		const worker = isCompiledBinary()
-			? new Worker("./packages/coding-agent/src/tools/browser/tab-worker-entry.ts", { type: "module" })
+		const hostEntry = workerHostEntry();
+		const worker = hostEntry
+			? new Worker(hostEntry, { type: "module", argv: ["__omp_tab_worker"] })
 			: new Worker(new URL("./tab-worker-entry.ts", import.meta.url).href, { type: "module" });
 		return wrapBunWorker(worker);
 	} catch (err) {

package/src/tools/conflict-detect.ts

@@ -68,7 +68,9 @@ export function scanConflictLines(lines: readonly string[], firstLineNumber: num
 	} | null = null;
 
 	for (let i = 0; i < lines.length; i++) {
-		const line = lines[i];
+		// Strip a trailing \r so CRLF checkouts match the same markers; stored
+		// section lines are LF-normalized (splice re-applies \r on write).
+		const line = stripTrailingCr(lines[i]);
 		const ln = firstLineNumber + i;
 
 		const oursLabel = matchMarker(line, OURS_PREFIX);
@@ -338,13 +340,22 @@ export function spliceConflict(originalText: string, entry: ConflictEntry, repla
 	}
 
 	const trimmed = normalizeTrailingNewline(replacement);
-	const replacementLines = trimmed.split("\n");
+	let replacementLines = trimmed.split("\n").map(stripTrailingCr);
+	// Round-trip fidelity for CRLF files: recorded sections are LF-normalized,
+	// so re-apply \r to spliced lines when the matched region used CRLF. The
+	// final replacement line only carries \r when another line follows it.
+	if (lines[match.startIdx]!.endsWith("\r")) {
+		const hasFollowingLine = match.endIdx + 1 < lines.length;
+		replacementLines = replacementLines.map((l, i) =>
+			i < replacementLines.length - 1 || hasFollowingLine ? `${l}\r` : l,
+		);
+	}
 	const next = [...lines.slice(0, match.startIdx), ...replacementLines, ...lines.slice(match.endIdx + 1)];
 	return next.join("\n");
 }
 
 /** Reconstruct the recorded marker block as it should appear in the file. */
-function buildRecordedRegion(entry: ConflictEntry): string[] {
+function buildRecordedRegion(entry: ConflictBlock): string[] {
 	const out: string[] = [];
 	out.push(entry.oursLabel ? `${OURS_PREFIX} ${entry.oursLabel}` : OURS_PREFIX);
 	out.push(...entry.oursLines);
@@ -358,6 +369,36 @@ function buildRecordedRegion(entry: ConflictEntry): string[] {
 	return out;
 }
 
+/**
+ * True when two registered blocks record the same marker-block content
+ * (labels and all sides). Out-of-band edits can shift a block's line
+ * numbers between reads, registering a fresh id while the stale one
+ * persists; callers use content identity to treat a locate-miss for the
+ * stale twin as "already resolved" instead of a hard failure.
+ */
+export function conflictRegionsEqual(a: ConflictBlock, b: ConflictBlock): boolean {
+	const ra = buildRecordedRegion(a);
+	const rb = buildRecordedRegion(b);
+	if (ra.length !== rb.length) return false;
+	for (let i = 0; i < ra.length; i++) {
+		if (ra[i] !== rb[i]) return false;
+	}
+	return true;
+}
+
+/**
+ * True when the entry's recorded marker block still occurs in `content`
+ * (LF-normalized — recorded sections are stored LF). Distinguishes a stale
+ * re-registration of a just-resolved region (no longer present) from a
+ * DISTINCT conflict block that happens to be byte-identical (still present
+ * elsewhere in the file and must stay addressable).
+ */
+export function conflictRegionPresent(content: string, entry: ConflictBlock): boolean {
+	const region = buildRecordedRegion(entry).join("\n");
+	const normalized = content.includes("\r") ? content.replace(/\r\n/g, "\n") : content;
+	return normalized.includes(region);
+}
+
 /**
  * Find a contiguous match of `expected` inside `lines`, preferring the
  * occurrence closest to `preferredIdx` to disambiguate when an identical
@@ -391,11 +432,16 @@ function locateRegion(
 function matchesAt(lines: readonly string[], startIdx: number, expected: readonly string[]): boolean {
 	if (startIdx < 0 || startIdx + expected.length > lines.length) return false;
 	for (let i = 0; i < expected.length; i++) {
-		if (lines[startIdx + i] !== expected[i]) return false;
+		// Recorded lines are LF-normalized; tolerate CRLF on-disk lines.
+		if (stripTrailingCr(lines[startIdx + i]!) !== expected[i]) return false;
 	}
 	return true;
 }
 
+function stripTrailingCr(line: string): string {
+	return line.endsWith("\r") ? line.slice(0, -1) : line;
+}
+
 function normalizeTrailingNewline(replacement: string): string {
 	if (replacement.endsWith("\r\n")) return replacement.slice(0, -2);
 	if (replacement.endsWith("\n")) return replacement.slice(0, -1);

package/src/tools/debug.ts

@@ -592,7 +592,7 @@ export const debugToolRenderer = {
 	): Component {
 		const outputBlock = new CachedOutputBlock();
 		return markFramedBlockComponent({
-			render(width: number): string[] {
+			render(width: number): readonly string[] {
 				const action = (args?.action ?? result.details?.action ?? "debug").replaceAll("_", " ");
 				const success = !options.isPartial && !result.isError;
 				const statusIcon = success

package/src/tools/eval-render.ts

@@ -455,7 +455,7 @@ function formatCellOutputLines(
 	previewLines: number,
 	theme: Theme,
 	width: number,
-): { lines: string[]; hiddenCount: number } {
+): { lines: readonly string[]; hiddenCount: number } {
 	if (!cell.output) {
 		return { lines: [], hiddenCount: 0 };
 	}
@@ -492,7 +492,7 @@ export const evalToolRenderer = {
 		let cached: { key: string; width: number; result: string[] } | undefined;
 
 		return markFramedBlockComponent({
-			render: (width: number): string[] => {
+			render: (width: number): readonly string[] => {
 				const key = `${options.expanded ? 1 : 0}|${cells.map(c => `${c.language}:${c.title ?? ""}:${c.code.length}`).join("|")}`;
 				if (cached && cached.key === key && cached.width === width) {
 					return cached.result;
@@ -573,7 +573,7 @@ export const evalToolRenderer = {
 			let cached: { key: string; width: number; result: string[] } | undefined;
 
 			return markFramedBlockComponent({
-				render: (width: number): string[] => {
+				render: (width: number): readonly string[] => {
 					const expanded = options.renderContext?.expanded ?? options.expanded;
 					const previewLines = options.renderContext?.previewLines ?? EVAL_DEFAULT_PREVIEW_LINES;
 					const key = `${expanded}|${previewLines}|${options.spinnerFrame}`;
@@ -697,12 +697,12 @@ export const evalToolRenderer = {
 		const textContent = `\n${styledOutput}`;
 
 		let cachedWidth: number | undefined;
-		let cachedLines: string[] | undefined;
+		let cachedLines: readonly string[] | undefined;
 		let cachedSkipped: number | undefined;
 		let cachedPreviewLines: number | undefined;
 
 		return {
-			render: (width: number): string[] => {
+			render: (width: number): readonly string[] => {
 				const previewLines = options.renderContext?.previewLines ?? EVAL_DEFAULT_PREVIEW_LINES;
 				if (cachedLines === undefined || cachedWidth !== width || cachedPreviewLines !== previewLines) {
 					const result = truncateToVisualLines(textContent, previewLines, width);

package/src/tools/eval.ts

@@ -358,8 +358,6 @@ export class EvalTool implements AgentTool<typeof evalSchema> {
 							session,
 							idleTimeoutMs,
 							reset: cell.reset,
-							artifactPath,
-							artifactId,
 							onChunk: chunk => {
 								outputSink!.push(chunk);
 							},

package/src/tools/fetch.ts

@@ -7,7 +7,6 @@ import type { FetchImpl, ImageContent, TextContent } from "@oh-my-pi/pi-ai";
 import { htmlToMarkdown } from "@oh-my-pi/pi-natives";
 import { type Component, Text } from "@oh-my-pi/pi-tui";
 import { $which, ptree, truncate } from "@oh-my-pi/pi-utils";
-import { parseHTML } from "linkedom";
 import { LRUCache } from "lru-cache/raw";
 import type { Settings } from "../config/settings";
 import { readEditableNotebookText } from "../edit/notebook";
@@ -23,7 +22,7 @@ import { ensureTool } from "../utils/tools-manager";
 import { extractWithParallel, findParallelApiKey, getParallelExtractContent } from "../web/parallel";
 import { specialHandlers } from "../web/scrapers";
 import type { RenderResult } from "../web/scrapers/types";
-import { finalizeOutput, loadPage, looksLikeHtml, MAX_OUTPUT_CHARS } from "../web/scrapers/types";
+import { finalizeOutput, loadPage, looksLikeHtml, MAX_BYTES, MAX_OUTPUT_CHARS } from "../web/scrapers/types";
 import { convertWithMarkit, fetchBinary } from "../web/scrapers/utils";
 import { type ArchiveFormat, listArchiveRoot, sniffArchiveFormat } from "./archive-reader";
 import { applyListLimit } from "./list-limit";
@@ -191,7 +190,7 @@ export interface ParsedReadUrlTarget {
 
 /** Recognize a single selector token (`raw` or one/many line ranges). */
 function isUrlSelectorToken(token: string): boolean {
-	if (token === "raw") return true;
+	if (token.toLowerCase() === "raw") return true;
 	try {
 		return parseLineRanges(token) !== null;
 	} catch {
@@ -213,7 +212,7 @@ export function parseReadUrlTarget(readPath: string): ParsedReadUrlTarget | null
 	let raw = false;
 	let ranges: readonly LineRange[] | undefined;
 	for (const sel of embedded?.sels ?? []) {
-		if (sel === "raw") {
+		if (sel.toLowerCase() === "raw") {
 			raw = true;
 			continue;
 		}
@@ -549,7 +548,8 @@ function cleanFeedText(text: string): string {
 /**
  * Parse RSS/Atom feed to markdown
  */
-function parseFeedToMarkdown(content: string, maxItems = 10): string {
+async function parseFeedToMarkdown(content: string, maxItems = 10): Promise<string> {
+	const { parseHTML } = await import("linkedom");
 	try {
 		const doc = parseHTML(content).document;
 
@@ -805,6 +805,21 @@ function isArchiveHint(mime: string, extensionHint: string): boolean {
 	return ARCHIVE_MIMES.has(mime) || ARCHIVE_EXTENSIONS.has(extensionHint);
 }
 
+/**
+ * Content types whose payload renderUrl always re-fetches via fetchBinary.
+ * Skipping the initial body read for them avoids downloading and
+ * string-decoding huge binaries (PDFs, archives, images) twice.
+ */
+function shouldSkipBodyDownload(contentType: string): boolean {
+	return (
+		CONVERTIBLE_MIMES.has(contentType) ||
+		NOTEBOOK_MIMES.has(contentType) ||
+		SQLITE_MIMES.has(contentType) ||
+		ARCHIVE_MIMES.has(contentType) ||
+		SUPPORTED_INLINE_IMAGE_MIME_TYPES.has(contentType)
+	);
+}
+
 function getArchiveFormatHint(mime: string, extensionHint: string): ArchiveFormat | undefined {
 	if (extensionHint === ".zip" || mime === "application/zip" || mime === "application/x-zip-compressed") {
 		return "zip";
@@ -901,6 +916,7 @@ async function tryRenderBinaryPayload(
 	mime: string,
 	extHint: string,
 	rawContent: string,
+	bodySkipped: boolean,
 	timeout: number,
 	signal: AbortSignal | undefined,
 	fetchedAt: string,
@@ -909,7 +925,7 @@ async function tryRenderBinaryPayload(
 	const hasNotebookHint = isNotebookHint(mime, extHint);
 	const hasSqliteHint = isSqliteHint(mime, extHint);
 	const hasArchiveHint = isArchiveHint(mime, extHint);
-	const rawLooksBinary = sampleLooksBinary(rawContent);
+	const rawLooksBinary = bodySkipped || sampleLooksBinary(rawContent);
 	if (!hasNotebookHint && !hasSqliteHint && !hasArchiveHint && !rawLooksBinary) {
 		return null;
 	}
@@ -1092,7 +1108,7 @@ async function renderUrl(
 	}
 
 	// Step 2: Fetch page
-	const response = await loadPage(url, { timeout, signal });
+	const response = await loadPage(url, { timeout, signal, skipBodyForContentType: shouldSkipBodyDownload });
 	if (signal?.aborted) {
 		throw new ToolAbortError();
 	}
@@ -1105,11 +1121,17 @@ async function renderUrl(
 			content: "",
 			fetchedAt,
 			truncated: false,
-			notes: [response.status ? `Failed to fetch URL (HTTP ${response.status})` : "Failed to fetch URL"],
+			notes: [
+				response.status ? `Failed to fetch URL (HTTP ${response.status})` : "Failed to fetch URL",
+				...(response.error ? [`Cause: ${response.error}`] : []),
+			],
 		};
 	}
 
 	const { finalUrl, content: rawContent } = response;
+	if (response.truncated) {
+		notes.push(`Response body exceeded ${formatBytes(MAX_BYTES)} and was cut mid-stream; content is incomplete`);
+	}
 	const mime = normalizeMime(response.contentType);
 	const extHint = getExtensionHint(finalUrl);
 
@@ -1276,6 +1298,7 @@ async function renderUrl(
 		mime,
 		extHint,
 		rawContent,
+		response.bodySkipped === true,
 		timeout,
 		signal,
 		fetchedAt,
@@ -1321,7 +1344,7 @@ async function renderUrl(
 	}
 
 	if (isFeed || (isXml && (rawContent.includes("<rss") || rawContent.includes("<feed")))) {
-		const parsed = parseFeedToMarkdown(rawContent);
+		const parsed = await parseFeedToMarkdown(rawContent);
 		const output = finalizeOutput(parsed);
 		return {
 			url,
@@ -1414,7 +1437,7 @@ async function renderUrl(
 			const altResult = await loadPage(resolved, { timeout, signal });
 			if (altResult.ok && altResult.content.trim().length > 200) {
 				notes.push(`Used feed alternate: ${resolved}`);
-				const parsed = parseFeedToMarkdown(altResult.content);
+				const parsed = await parseFeedToMarkdown(altResult.content);
 				const output = finalizeOutput(parsed);
 				return {
 					url,

package/src/tools/gh-cache-invalidation.ts

@@ -17,7 +17,7 @@
  * number, all auth_keys) because the upside of staleness elimination
  * dwarfs the cost of one cache miss.
  */
-import { invalidateAllForNumber } from "./github-cache";
+import { invalidateAllForNumber, invalidateAllForRepo } from "./github-cache";
 
 const PR_URL_PATTERN = /^https:\/\/github\.com\/([^/\s]+\/[^/\s]+)\/pull\/(\d+)(?:[/?#].*)?$/i;
 const ISSUE_URL_PATTERN = /^https:\/\/github\.com\/([^/\s]+\/[^/\s]+)\/issues\/(\d+)(?:[/?#].*)?$/i;
@@ -48,13 +48,60 @@ const MUTATING_PR_SUBCMDS: Record<string, true> = {
 	lock: true,
 	unlock: true,
 };
+
+/**
+ * Flags whose value is the next argv token (`--milestone 3`). The detector
+ * must skip those values so `gh pr edit --milestone 3 14` invalidates #14,
+ * not #3. Curated for the mutating issue/PR subcommands above; a few short
+ * flags are booleans for *some* subcommands (e.g. `-c` is `--comment` text
+ * for `pr close` but a boolean for `pr review`) — we bias toward value-taking
+ * because over-skipping at worst falls back to repo-wide invalidation, while
+ * under-skipping invalidates the wrong number.
+ */
+const VALUE_TAKING_FLAGS: ReadonlySet<string> = new Set([
+	"-m",
+	"--milestone",
+	"-t",
+	"--title",
+	"-b",
+	"--body",
+	"-F",
+	"--body-file",
+	"-a",
+	"--assignee",
+	"--add-assignee",
+	"--remove-assignee",
+	"-l",
+	"--label",
+	"--add-label",
+	"--remove-label",
+	"-p",
+	"--project",
+	"--add-project",
+	"--remove-project",
+	"--add-reviewer",
+	"--remove-reviewer",
+	"-B",
+	"--base",
+	"-c",
+	"--comment",
+	"-r",
+	"--reason",
+	"--branch",
+	"--subject",
+	"--match-head-commit",
+	"--author-email",
+]);
 /**
  * Walk a single shell command's token stream looking for a top-level
- * `gh (issue|pr) <subcmd> <id-or-url>` invocation and return the
- * invalidation key when one is found. Returns `null` for non-matching
- * commands so the caller can iterate cheaply.
+ * `gh (issue|pr) <subcmd> [<id-or-url>]` invocation and return the
+ * invalidation key when one is found. `number === undefined` means the
+ * subcommand mutates state but names no identifier (gh defaults to the
+ * current branch's PR), so the caller must fall back to repo-wide
+ * invalidation. Returns `null` for non-matching commands so the caller can
+ * iterate cheaply.
  */
-function detectGhMutation(tokens: readonly string[]): { number: number; repo?: string } | null {
+function detectGhMutation(tokens: readonly string[]): { number?: number; repo?: string } | null {
 	const ghIdx = tokens.indexOf("gh");
 	if (ghIdx === -1) return null;
 	const subject = tokens[ghIdx + 1];
@@ -82,7 +129,9 @@ function detectGhMutation(tokens: readonly string[]): { number: number; repo?: s
 	}
 	for (let i = ghIdx + 3; i < tokens.length; i++) {
 		const token = tokens[i];
-		if (token === "-R" || token === "--repo") {
+		if (token === "-R" || token === "--repo" || VALUE_TAKING_FLAGS.has(token)) {
+			// Skip the flag's value so it is never mistaken for the positional
+			// identifier (`--milestone 3 14` must invalidate #14, not #3).
 			i++;
 			continue;
 		}
@@ -100,7 +149,9 @@ function detectGhMutation(tokens: readonly string[]): { number: number; repo?: s
 			}
 		}
 	}
-	return null;
+	// Mutating subcommand with no identifier: gh operates on the current
+	// branch's PR, which we cannot resolve synchronously here.
+	return repo !== undefined ? { repo } : {};
 }
 
 /**
@@ -195,6 +246,10 @@ export function invalidateGithubCacheForBashCommand(command: string): void {
 	for (const segment of segments) {
 		const hit = detectGhMutation(segment);
 		if (!hit) continue;
-		invalidateAllForNumber(hit.number, hit.repo);
+		if (hit.number !== undefined) {
+			invalidateAllForNumber(hit.number, hit.repo);
+		} else {
+			invalidateAllForRepo(hit.repo);
+		}
 	}
 }

package/src/tools/gh-renderer.ts

@@ -163,7 +163,7 @@ function getJobStateVisual(
 ): { iconRaw: string; iconColor: ToolUIColor; textColor: ThemeColor } {
 	if (job.conclusion && SUCCESS_CONCLUSIONS.has(job.conclusion)) {
 		return {
-			iconRaw: theme.symbol("tool.gh"),
+			iconRaw: theme.status.success,
 			iconColor: "accent",
 			textColor: "success",
 		};