@sayknow-cli/coding-agent 0.3.11 → 0.3.13

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

@@ -89,11 +89,57 @@ export interface RunInTabOptions {
 
 export interface ReleaseTabOptions {
 	kill?: boolean;
+	/**
+	 * Absolute end-to-end deadline (`Date.now()`-based, ms) for the whole teardown chain.
+	 * Shared across a `releaseAllTabs` loop so close/close-all honors ONE aggregate budget.
+	 * Omitted (the GC/session-teardown callers) keeps the original unbounded behavior.
+	 */
+	deadlineAt?: number;
 }
 
 const tabs = new Map<string, TabSession>();
 const GRACE_MS = 750;
 
+/**
+ * Remaining time (ms) until an absolute teardown deadline, or +Infinity when no deadline
+ * is set (the GC / session-teardown callers). A non-positive result means the shared
+ * close budget is already spent.
+ */
+function remainingBudget(deadlineAt: number | undefined): number {
+	if (deadlineAt === undefined) return Number.POSITIVE_INFINITY;
+	return deadlineAt - Date.now();
+}
+
+/**
+ * Await `op` but never longer than `remainingMs` (#2027). On timeout — or when the budget
+ * is already exhausted — the operation is detached and kept alive best-effort with its
+ * rejection swallowed, so a dying CDP target cannot wedge the close teardown or leak an
+ * unhandled rejection. Returns true when `op` settled within budget, false when detached.
+ */
+async function awaitWithinBudget(op: Promise<unknown>, remainingMs: number, label: string): Promise<boolean> {
+	const settled = Promise.resolve(op).then(
+		() => true,
+		() => true,
+	);
+	if (remainingMs === Number.POSITIVE_INFINITY) return await settled;
+	if (remainingMs <= 0) {
+		void settled;
+		logger.debug("close teardown budget already spent; detaching step", { label });
+		return false;
+	}
+	let timer: ReturnType<typeof setTimeout> | undefined;
+	const timedOut = new Promise<boolean>(resolve => {
+		timer = setTimeout(() => resolve(false), remainingMs);
+	});
+	try {
+		const ok = await Promise.race([settled, timedOut]);
+		if (!ok) logger.debug("close teardown step exceeded deadline; detached", { label });
+		return ok;
+	} finally {
+		if (timer) clearTimeout(timer);
+	}
+}
+
 export function getTab(name: string): TabSession | undefined {
 	return tabs.get(name);
 }
@@ -316,17 +362,24 @@ export async function releaseTab(name: string, opts: ReleaseTabOptions = {}): Pr
 	}
 	tab.pending.clear();
 	let forced = false;
+	const deadlineAt = opts.deadlineAt;
 	if (wasAlive) {
 		try {
 			tab.worker.send({ type: "close" });
-			await waitForClosed(tab);
+			await waitForClosed(tab, remainingBudget(deadlineAt));
 		} catch {
 			forced = true;
 		}
 	}
-	await tab.worker.terminate().catch(() => undefined);
-	if (forced && tab.kindTag === "headless") await closeOrphanTarget(tab);
-	await releaseBrowser(tab.browser, { kill: opts.kill ?? false });
+	await awaitWithinBudget(tab.worker.terminate(), remainingBudget(deadlineAt), "worker.terminate");
+	if (forced && tab.kindTag === "headless") {
+		await awaitWithinBudget(closeOrphanTarget(tab), remainingBudget(deadlineAt), "closeOrphanTarget");
+	}
+	await awaitWithinBudget(
+		releaseBrowser(tab.browser, { kill: opts.kill ?? false }),
+		remainingBudget(deadlineAt),
+		"releaseBrowser",
+	);
 	// Only delete if the map still holds THIS tab: a same-name reacquire during our async
 	// teardown may have installed a fresh tab that we must not evict.
 	if (tabs.get(name) === tab) tabs.delete(name);
@@ -495,13 +548,17 @@ async function closeOrphanTarget(tab: TabSession): Promise<void> {
 	}
 }
 
-async function waitForClosed(tab: TabSession): Promise<void> {
+async function waitForClosed(tab: TabSession, remainingMs: number = Number.POSITIVE_INFINITY): Promise<void> {
 	const { promise, resolve } = Promise.withResolvers<void>();
 	const unsubscribe = tab.worker.onMessage(msg => {
 		if (msg.type === "closed") resolve();
 	});
 	try {
-		await raceWithTimeout(promise, GRACE_MS, "Timed out closing browser tab worker");
+		await raceWithTimeout(
+			promise,
+			Math.max(0, Math.min(GRACE_MS, remainingMs)),
+			"Timed out closing browser tab worker",
+		);
 	} finally {
 		unsubscribe();
 	}

package/src/tools/browser.ts

@@ -187,7 +187,7 @@ export class BrowserTool implements AgentTool<typeof browserSchema, BrowserToolD
 				case "open":
 					return await this.#open(name, params, details, timeoutMs, signal);
 				case "close":
-					return await this.#close(name, params, details, signal);
+					return await this.#close(name, params, details, timeoutMs, signal);
 				case "run":
 					return await this.#run(name, params, details, timeoutMs, signal);
 				case "act":
@@ -274,15 +274,20 @@ export class BrowserTool implements AgentTool<typeof browserSchema, BrowserToolD
 		name: string,
 		params: BrowserParams,
 		details: BrowserToolDetails,
+		timeoutMs: number,
 		signal?: AbortSignal,
 	): Promise<AgentToolResult<BrowserToolDetails>> {
 		const kill = !!params.kill;
+		// One end-to-end budget across the whole close/close-all teardown chain (#2027):
+		// releaseAllTabs → waitForClosed → worker.terminate → releaseBrowser stay bounded so
+		// a CDP target dying mid-teardown cannot hang the tool call or the agent turn.
+		const deadlineAt = Date.now() + timeoutMs;
 		if (params.all) {
-			const count = await untilAborted(signal, () => releaseAllTabs({ kill }));
+			const count = await untilAborted(signal, () => releaseAllTabs({ kill, deadlineAt }));
 			details.result = `Closed ${count} tab(s)`;
 			return toolResult(details).text(details.result).done();
 		}
-		const closed = await untilAborted(signal, () => releaseTab(name, { kill }));
+		const closed = await untilAborted(signal, () => releaseTab(name, { kill, deadlineAt }));
 		details.result = closed ? `Closed tab ${JSON.stringify(name)}` : `No tab named ${JSON.stringify(name)}`;
 		return toolResult(details).text(details.result).done();
 	}

package/src/tools/fetch.ts

@@ -5,7 +5,6 @@ import type { ImageContent, TextContent } from "@sayknow-cli/ai";
 import { htmlToMarkdown } from "@sayknow-cli/natives";
 import { type Component, Text } from "@sayknow-cli/tui";
 import { $which, ptree, truncate } from "@sayknow-cli/utils";
-import { parseHTML } from "linkedom";
 import type { Settings } from "../config/settings";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import { type Theme, theme } from "../modes/theme/theme";
@@ -15,6 +14,7 @@ import { DEFAULT_MAX_BYTES, truncateHead } from "../session/streaming-output";
 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";
@@ -483,9 +483,9 @@ 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> {
 	try {
-		const doc = parseHTML(content).document;
+		const doc = (await parseHtmlLazy(content)).document;
 
 		// Try RSS
 		const channel = doc.querySelector("channel");
@@ -1026,7 +1026,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,
@@ -1119,7 +1119,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/index.ts

@@ -122,16 +122,91 @@ export type {
 	DiscoverableToolSource,
 } from "../tool-discovery/tool-index";
 
+/** A typed remote action available to an ask answer source. */
+export type AskRemoteControlId = "navigation_forward";
+
+export interface AskRemoteControl {
+	id: AskRemoteControlId;
+	kind: "navigation";
+	label: "Next" | "Done";
+	enabled: boolean;
+}
+
+export interface AskAnswerRequest {
+	question: string;
+	options: string[];
+	interaction: "selector" | "custom_editor" | "clarification_editor";
+	controls: readonly AskRemoteControl[];
+}
+
+export type AskRemoteInteraction =
+	| { kind: "value"; value: string }
+	| { kind: "control"; controlId: AskRemoteControlId };
+
+export type AskSettlement =
+	| { kind: "commit" }
+	| {
+			kind: "resolve_without_commit";
+			reason:
+				| "toggle"
+				| "other_transition"
+				| "clarification_transition"
+				| "clarification_submitted"
+				| "empty_navigation"
+				| "back_navigation"
+				| "cancelled"
+				| "aborted"
+				| "timed_out"
+				| "exception"
+				| "shutdown";
+	  }
+	| {
+			kind: "invalid";
+			reason:
+				| "invalid_option"
+				| "invalid_control"
+				| "invalid_structured_answer"
+				| "empty_custom"
+				| "empty_clarification";
+	  };
+
+export type AskSelectedAckOutcome =
+	| { status: "delivered"; messageId: number }
+	| {
+			status: "failed";
+			reason:
+				| "unsupported"
+				| "no_participant"
+				| "ambiguous_participant"
+				| "route_missing"
+				| "expired"
+				| "cancelled"
+				| "telegram_rejected"
+				| "session_closed";
+	  }
+	| { status: "unknown"; reason: "transport_ambiguous" | "origin_disconnected" | "host_timeout" | "shutdown" };
+
+export type AskSettlementResult =
+	| { kind: "committed"; ack: AskSelectedAckOutcome }
+	| { kind: "resolved_without_commit" }
+	| { kind: "invalid_closed" };
+
+export interface AskRemoteReceipt {
+	source: "remote";
+	interaction: AskRemoteInteraction;
+	settle(value: AskSettlement): Promise<AskSettlementResult>;
+}
+
+export type AskAnswerSourceResult = AskRemoteReceipt | string | undefined;
+
 /**
- * Source of remote answers for interactive asks (e.g. a Telegram reply routed
- * through the notifications SDK). Lets a pending ask resolve without RPC mode.
+ * Source of remote answers. `awaitAnswer` remains the legacy wire for existing
+ * integrations; typed sources opt into `awaitAnswerRequest`. This keeps an old
+ * string-only source from accidentally acquiring acknowledgement authority.
  */
 export interface AskAnswerSource {
-	/**
-	 * Race a remote answer against the local UI for one question. Resolves with the
-	 * chosen option label or free-text answer, or `undefined` to defer to local UI.
-	 */
 	awaitAnswer(question: string, options: string[], signal?: AbortSignal): Promise<string | undefined>;
+	awaitAnswerRequest?(request: AskAnswerRequest, signal?: AbortSignal): Promise<AskAnswerSourceResult>;
 }
 
 /** Session context for tool factories */

package/src/tools/skill.ts

@@ -4,15 +4,16 @@
  * Lets the agent hand off to another available skill in the current turn. The
  * callee's SKILL.md is dispatched through the same custom-message path used by
  * `/skill:<name>` typing, as a user-attribution message delivered same-turn
- * (without `deliverAs: "nextTurn"`). Before dispatch, the tool calls
- * `skc state <caller> handoff --to <callee>` in-process via the state-runtime
- * function so caller and callee mode-states plus `skill-active-state.json`
- * transition atomically.
+ * (without `deliverAs: "nextTurn"`). When the caller is one of the canonical
+ * workflow skills, the tool first runs the native state handoff so workflow
+ * mode-state and `skill-active-state.json` transition atomically. Runtime
+ * project/user skills have no native workflow mode-state, so they are dispatched
+ * directly and tracked by the prompt observer instead.
  *
- * Chaining is refused unless the caller's `current_phase` is in
- * `{complete, completed, handoff, failed, cancelled, canceled, inactive}`. The
- * agent declares readiness either by writing `current_phase: "handoff"` to its
- * mode-state or by running the handoff verb directly.
+ * Canonical workflow chaining is refused unless the caller's `current_phase` is
+ * in `{complete, completed, handoff, failed, cancelled, canceled, inactive}`.
+ * The agent declares readiness either by writing `current_phase: "handoff"` to
+ * its mode-state or by running the handoff verb directly.
  */
 
 import type { AgentTool, AgentToolResult } from "@sayknow-cli/agent-core";
@@ -24,6 +25,7 @@ import { buildSkillPromptMessage } from "../extensibility/skills";
 import skillDescription from "../prompts/tools/skill.md" with { type: "text" };
 import { SKILL_PROMPT_MESSAGE_TYPE } from "../session/messages";
 import { runNativeStateCommand } from "../skc-runtime/state-runtime";
+import { isCanonicalSkcWorkflowSkill } from "../skill-state/active-state";
 import type { ToolSession } from ".";
 import { ToolError } from "./tool-errors";
 
@@ -130,9 +132,10 @@ export class SkillTool implements AgentTool<typeof skillSchema, SkillToolDetails
 				throw new ToolError(`skill tool: unknown skill "${requestedName}".${hint}`);
 			}
 
-			// Phase guard + atomic handoff. Only runs when transitioning between
-			// distinct skills (same-skill recursion was already refused above).
-			if (activeSkill) {
+			// Phase guard + atomic native handoff only apply to canonical workflow
+			// skills. Runtime project/user skills do not have a native mode-state,
+			// so there is no `skc state <skill>` command to run for them.
+			if (activeSkill && isCanonicalSkcWorkflowSkill(activeSkill)) {
 				const phase = (this.#session.getActiveSkillPhase?.() ?? "running").trim().toLowerCase();
 				if (!TERMINAL_PHASES.has(phase)) {
 					throw new ToolError(

package/src/tools/sqlite-reader.ts

@@ -150,13 +150,16 @@ function buildAsciiTable(columns: string[], rows: SqliteRow[]): string {
 	return lines.map(line => truncateToWidth(replaceTabs(line), MAX_RENDER_WIDTH)).join("\n");
 }
 
+const DECIMAL_INTEGER_PATTERN = /^[+-]?\d+$/;
+
 function parseLimit(value: string | null, fallback: number): number {
 	if (value === null || value.trim().length === 0) {
 		return fallback;
 	}
 
-	const parsed = Number.parseInt(value, 10);
-	if (!Number.isFinite(parsed) || parsed < 1) {
+	const normalizedValue = value.trim();
+	const parsed = Number(normalizedValue);
+	if (!DECIMAL_INTEGER_PATTERN.test(normalizedValue) || !Number.isFinite(parsed) || parsed < 1) {
 		throw new ToolError(`SQLite limit must be a positive integer; got '${value}'`);
 	}
 	return Math.min(parsed, MAX_QUERY_LIMIT);
@@ -167,8 +170,9 @@ function parseOffset(value: string | null): number {
 		return 0;
 	}
 
-	const parsed = Number.parseInt(value, 10);
-	if (!Number.isFinite(parsed) || parsed < 0) {
+	const normalizedValue = value.trim();
+	const parsed = Number(normalizedValue);
+	if (!DECIMAL_INTEGER_PATTERN.test(normalizedValue) || !Number.isFinite(parsed) || parsed < 0) {
 		throw new ToolError(`SQLite offset must be a non-negative integer; got '${value}'`);
 	}
 	return parsed;

package/src/tui/output-block.ts

@@ -1,9 +1,16 @@
 /**
  * Bordered output container with optional header and sections.
  */
-import { ImageProtocol, padding, TERMINAL, visibleWidth, wrapTextWithAnsi } from "@sayknow-cli/tui";
+import {
+	ImageProtocol,
+	isTerminalGraphicsFallbackActive,
+	padding,
+	TERMINAL,
+	visibleWidth,
+	wrapTextWithAnsi,
+} from "@sayknow-cli/tui";
 import type { Theme } from "../modes/theme/theme";
-import { getSixelLineMask } from "../utils/sixel";
+import { containsSixelSequence, getSixelLineMask } from "../utils/sixel";
 import type { State } from "./types";
 import type { RenderCache } from "./utils";
 import { getStateBgColor, Hasher, padToWidth, truncateToWidth } from "./utils";
@@ -81,13 +88,17 @@ export function renderOutputBlock(options: OutputBlockOptions, theme: Theme): st
 			);
 		}
 		const allLines = section.lines.flatMap(l => l.split("\n"));
-		const sixelLineMask = TERMINAL.imageProtocol === ImageProtocol.Sixel ? getSixelLineMask(allLines) : undefined;
+		const fallbackActive = isTerminalGraphicsFallbackActive();
+		const sixelLineMask =
+			fallbackActive || TERMINAL.imageProtocol === ImageProtocol.Sixel ? getSixelLineMask(allLines) : undefined;
 		for (let lineIndex = 0; lineIndex < allLines.length; lineIndex++) {
-			const line = allLines[lineIndex]!;
-			if (sixelLineMask?.[lineIndex]) {
-				lines.push(line);
+			const sixelLine = sixelLineMask?.[lineIndex] ?? false;
+			if (sixelLine && !fallbackActive) {
+				lines.push(allLines[lineIndex]!);
 				continue;
 			}
+			if (sixelLine && sixelLineMask?.[lineIndex - 1] && !containsSixelSequence(allLines[lineIndex]!)) continue;
+			const line = sixelLine ? "[SIXEL image hidden while IRC sidebar is visible]" : allLines[lineIndex]!;
 			const wrappedLines = wrapTextWithAnsi(line.trimEnd(), contentWidth);
 			for (const wrappedLine of wrappedLines) {
 				const innerPadding = padding(Math.max(0, contentWidth - visibleWidth(wrappedLine)));
@@ -137,6 +148,7 @@ export class CachedOutputBlock {
 		h.optional(options.headerMeta);
 		h.optional(options.state);
 		h.bool(options.applyBg ?? true);
+		h.bool(isTerminalGraphicsFallbackActive());
 		if (options.sections) {
 			for (const s of options.sections) {
 				h.optional(s.label);

package/src/utils/external-editor.ts

@@ -21,6 +21,11 @@ export interface OpenInEditorOptions {
 	trimTrailingNewline?: boolean;
 }
 
+/** Remove one platform-standard trailing line terminator from editor content. */
+export function trimEditorTrailingNewline(text: string): string {
+	return text.replace(/\r?\n$/, "");
+}
+
 /**
  * Opens `content` in the user's external editor and returns the edited text.
  * Returns `null` if the editor exits with a non-zero code.
@@ -52,7 +57,7 @@ export async function openInEditor(
 			if (options?.trimTrailingNewline === false) {
 				return text;
 			}
-			return text.replace(/\n$/, "");
+			return trimEditorTrailingNewline(text);
 		}
 		return null;
 	} finally {

package/src/utils/linkedom.ts

@@ -0,0 +1,14 @@
+type LinkedomModule = typeof import("linkedom");
+
+type ParseHtml = LinkedomModule["parseHTML"];
+
+let parseHtml: ParseHtml | undefined;
+let linkedomImport: Promise<LinkedomModule> | undefined;
+
+export async function parseHtmlLazy(markup: string): Promise<ReturnType<ParseHtml>> {
+	if (!parseHtml) {
+		linkedomImport ??= import("linkedom");
+		parseHtml = (await linkedomImport).parseHTML;
+	}
+	return parseHtml(markup);
+}

package/src/utils/pasted-image-path.ts

@@ -1,12 +1,12 @@
 /**
  * Resolve pasted editor text to an image file path.
  *
- * Terminals insert a shell-escaped filesystem path when a file is drag-dropped
- * onto them (e.g. macOS `Screenshot\ 2026-07-07\ at\ 11.06.38 PM.png`, where
- * the visible "space" before AM/PM is U+202F and stays unescaped). When the
- * entire paste is a single path to an existing image file, the interactive
- * editor attaches the image and inserts an `[image N]` placeholder instead of
- * leaving the raw path in the prompt.
+ * Some terminal/clipboard integrations paste a temporary filesystem path after a
+ * copied image is pasted into the editor (for example `/tmp/clipboard-...png`).
+ * Only those recognized clipboard temp files are auto-attached and replaced with
+ * an `[image N] source="/path"` reference so the model receives both the image
+ * payload and the raw temp file path. Ordinary image paths remain literal prompt
+ * text; users attach saved files explicitly with `@path/to/image.png`.
  */
 import * as fs from "node:fs";
 import * as os from "node:os";
@@ -14,6 +14,7 @@ import * as path from "node:path";
 import { fileURLToPath } from "node:url";
 
 const IMAGE_FILE_EXTENSION_PATTERN = /\.(?:png|jpe?g|gif|webp)$/i;
+const CLIPBOARD_TEMP_BASENAME_PATTERN = /^clipboard-\d{4}-\d{2}-\d{2}-\d{6}-[A-Za-z0-9-]+\.(?:png|jpe?g|gif|webp)$/i;
 
 export interface DecodePastedPathOptions {
 	/**
@@ -150,16 +151,25 @@ function hasSupportedImageMagic(filePath: string): boolean {
 	}
 }
 
+function isRecognizedClipboardTempPath(filePath: string): boolean {
+	const resolved = path.resolve(filePath);
+	const tempRoot = path.resolve(os.tmpdir());
+	if (resolved !== tempRoot && !resolved.startsWith(`${tempRoot}${path.sep}`)) return false;
+	return CLIPBOARD_TEMP_BASENAME_PATTERN.test(path.basename(resolved));
+}
+
 /**
- * Returns the resolved path when the whole pasted text is a single path to an
- * existing image file (verified by extension AND content signature),
- * otherwise `undefined` (the paste is inserted as text).
+ * Returns the resolved path when the whole pasted text is a recognized clipboard
+ * temp path to an existing image file, otherwise `undefined` (the paste is
+ * inserted as text). Arbitrary saved image paths are not auto-attached here;
+ * users attach them explicitly with `@path/to/image.png`.
  */
 export function resolvePastedImagePath(text: string, options?: ResolvePastedImagePathOptions): string | undefined {
 	const candidate = decodePastedPathCandidate(text, options);
 	if (!candidate || !IMAGE_FILE_EXTENSION_PATTERN.test(candidate)) return undefined;
 
 	const resolved = path.resolve(options?.cwd ?? process.cwd(), candidate);
+	if (!isRecognizedClipboardTempPath(resolved)) return undefined;
 	try {
 		if (!fs.statSync(resolved).isFile()) return undefined;
 	} catch {
@@ -168,3 +178,7 @@ export function resolvePastedImagePath(text: string, options?: ResolvePastedImag
 	if (!hasSupportedImageMagic(resolved)) return undefined;
 	return resolved;
 }
+
+export function formatPastedImageReference(placeholder: string, imagePath: string): string {
+	return `${placeholder} source=${JSON.stringify(imagePath)}`;
+}

package/src/web/scrapers/arxiv.ts

@@ -1,4 +1,4 @@
-import { parseHTML } from "linkedom";
+import { parseHtmlLazy } from "../../utils/linkedom";
 import type { RenderResult, SpecialHandler } from "./types";
 import { buildResult, loadPage } from "./types";
 import { convertWithMarkit, fetchBinary } from "./utils";
@@ -31,7 +31,7 @@ export const handleArxiv: SpecialHandler = async (
 		if (!result.ok) return null;
 
 		// Parse the Atom feed response
-		const doc = parseHTML(result.content).document;
+		const doc = (await parseHtmlLazy(result.content)).document;
 		const entry = doc.querySelector("entry");
 
 		if (!entry) return null;

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

@@ -1,5 +1,5 @@
 import { tryParseJson } from "@sayknow-cli/utils";
-import { parseHTML } from "linkedom";
+import { parseHtmlLazy } from "../../utils/linkedom";
 import type { RenderResult, SpecialHandler } from "./types";
 import { buildResult, htmlToBasicMarkdown, loadPage } from "./types";
 
@@ -97,7 +97,7 @@ export const handleGoPkg: SpecialHandler = async (
 			});
 		}
 
-		const doc = parseHTML(pageResult.content).document;
+		const doc = (await parseHtmlLazy(pageResult.content)).document;
 
 		// Extract actual module path from breadcrumb or header
 		const breadcrumb = doc.querySelector(".go-Breadcrumb");

package/src/web/scrapers/iacr.ts

@@ -1,4 +1,4 @@
-import { parseHTML } from "linkedom";
+import { parseHtmlLazy } from "../../utils/linkedom";
 import type { RenderResult, SpecialHandler } from "./types";
 import { buildResult, loadPage } from "./types";
 import { convertWithMarkit, fetchBinary } from "./utils";
@@ -30,7 +30,7 @@ export const handleIacr: SpecialHandler = async (
 
 		if (!result.ok) return null;
 
-		const doc = parseHTML(result.content).document;
+		const doc = (await parseHtmlLazy(result.content)).document;
 
 		// Extract metadata from the page
 		const title =

package/src/web/scrapers/readthedocs.ts

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

package/src/web/scrapers/twitter.ts

@@ -1,5 +1,6 @@
-import { type HTMLElement, parseHTML } from "linkedom";
+import type { HTMLElement } from "linkedom";
 import { ToolAbortError } from "../../tools/tool-errors";
+import { parseHtmlLazy } from "../../utils/linkedom";
 import type { RenderResult, SpecialHandler } from "./types";
 import { buildResult, loadPage } from "./types";
 
@@ -33,7 +34,7 @@ export const handleTwitter: SpecialHandler = async (
 
 			if (result.ok && result.content.length > 500) {
 				// Parse the Nitter HTML
-				const doc = parseHTML(result.content).document;
+				const doc = (await parseHtmlLazy(result.content)).document;
 
 				// Extract tweet content
 				const tweetContent = doc.querySelector(".tweet-content")?.textContent?.trim();

package/src/web/scrapers/wikipedia.ts

@@ -1,4 +1,4 @@
-import { parseHTML } from "linkedom";
+import { parseHtmlLazy } from "../../utils/linkedom";
 import type { RenderResult, SpecialHandler } from "./types";
 import { buildResult, loadPage } from "./types";
 
@@ -45,7 +45,7 @@ export const handleWikipedia: SpecialHandler = async (
 		const contentResult = await loadPage(contentUrl, { timeout, signal });
 
 		if (contentResult.ok) {
-			const doc = parseHTML(contentResult.content).document;
+			const doc = (await parseHtmlLazy(contentResult.content)).document;
 
 			// Extract main content sections
 			const sections = doc.querySelectorAll("section");

package/dist/types/append-only-mode.d.ts

@@ -1,31 +0,0 @@
-/**
- * Single source of truth for append-only context-mode resolution and manager
- * construction. Both the initial session build (`sdk.ts`) and the runtime
- * model/setting-change path (`agent-session.ts`), plus the status UI, resolve
- * through here so the auto allowlist and prefix-reset diagnostics never drift.
- */
-import { AppendOnlyContextManager } from "@sayknow-cli/agent-core";
-/**
- * Providers for which append-only context auto-enables. Exact provider-string
- * match only: `anthropic` reached via a gateway/aggregator provider string
- * (e.g. `openrouter`, a custom gateway) does NOT match and stays opt-in via
- * `provider.appendOnlyContext: "on"`, because those transports can rewrite or
- * renormalize the request in ways that have not been validated for append-only
- * prefix stability.
- */
-export declare function providerSupportsAppendOnlyAuto(provider: string): boolean;
-/**
- * Resolve whether to enable append-only context mode based on the setting and provider.
- *
- * - `"on"` → always enable
- * - `"off"` → never enable
- * - `"auto"` → enable for providers with strong prompt-prefix caching that this
- *   harness has validated (see {@link providerSupportsAppendOnlyAuto})
- */
-export declare function resolveAppendOnlyMode(setting: "auto" | "on" | "off" | undefined, provider: string): boolean;
-/**
- * Construct an {@link AppendOnlyContextManager} wired to emit per-session
- * stable-prefix reset diagnostics. Use this at every creation site so the
- * telemetry is uniform.
- */
-export declare function createAppendOnlyContextManager(provider: string | undefined): AppendOnlyContextManager;

package/dist/types/async/index.d.ts

@@ -1,2 +0,0 @@
-export * from "./job-manager";
-export * from "./support";