lsd-pi 1.2.4 → 1.3.6

package/src/resources/extensions/ask-user-questions.ts

@@ -51,6 +51,14 @@ const OptionSchema = Type.Object({
 	description: Type.String({ description: "One short sentence explaining impact/tradeoff if selected" }),
 });
 
+const ShowWhenSchema = Type.Object({
+	questionId: Type.String({ description: "Earlier question id this question depends on" }),
+	selectedAnyOf: Type.Array(Type.String(), {
+		description: "Show this question only when the earlier question selection includes one of these labels",
+		minItems: 1,
+	}),
+});
+
 const QuestionSchema = Type.Object({
 	id: Type.String({ description: "Stable identifier for mapping answers (snake_case)" }),
 	header: Type.String({ description: "Short header label shown in the UI (12 or fewer chars)" }),
@@ -65,6 +73,7 @@ const QuestionSchema = Type.Object({
 				"If true, the user can select multiple options using SPACE to toggle and ENTER to confirm. No 'None of the above' option is added. Default: false.",
 		}),
 	),
+	showWhen: Type.Optional(ShowWhenSchema),
 });
 
 const AskUserQuestionsParams = Type.Object({
@@ -88,6 +97,40 @@ function errorResult(
 }
 
 /** Convert the shared RoundResult into the JSON the LLM expects. */
+function selectedLabels(answer: { answers: string[] } | undefined): string[] {
+	if (!answer) return [];
+	return answer.answers.filter((item) => typeof item === "string" && !item.startsWith("user_note:"));
+}
+
+function shouldAskQuestion(
+	question: Question,
+	answers: Record<string, { answers: string[] }>,
+): boolean {
+	if (!question.showWhen) return true;
+	const controlling = answers[question.showWhen.questionId];
+	if (!controlling) return false;
+	const selected = selectedLabels(controlling);
+	return selected.some((label) => question.showWhen?.selectedAnyOf.includes(label));
+}
+
+function selectedRoundLabels(answer: { selected: string | string[]; notes: string } | undefined): string[] {
+	if (!answer) return [];
+	return (Array.isArray(answer.selected) ? answer.selected : [answer.selected]).filter(
+		(item): item is string => typeof item === "string" && item.length > 0,
+	);
+}
+
+function shouldRenderRoundQuestion(
+	question: Question,
+	answers: RoundResult["answers"],
+): boolean {
+	if (!question.showWhen) return true;
+	const controlling = answers[question.showWhen.questionId];
+	if (!controlling) return false;
+	const selected = selectedRoundLabels(controlling);
+	return selected.some((label) => question.showWhen?.selectedAnyOf.includes(label));
+}
+
 function formatForLLM(result: RoundResult): string {
 	const answers: Record<string, { answers: string[] }> = {};
 	for (const [id, answer] of Object.entries(result.answers)) {
@@ -118,6 +161,7 @@ export default function AskUserQuestions(pi: ExtensionAPI) {
 			"Keep questions to 1 when possible; never exceed 3.",
 			"For single-select: each question must have 2-3 options. Put the recommended option first with '(Recommended)' suffix. Do not include an 'Other' or 'None of the above' option - the client adds one automatically.",
 			"For multi-select: set allowMultiple: true. The user can pick any number of options. No 'None of the above' is added.",
+			"For conditional follow-ups, use showWhen.questionId and showWhen.selectedAnyOf on a later question so it only appears after the matching earlier answer.",
 		],
 		parameters: AskUserQuestionsParams,
 
@@ -136,6 +180,45 @@ export default function AskUserQuestions(pi: ExtensionAPI) {
 				}
 			}
 
+			for (let i = 0; i < params.questions.length; i++) {
+				const q = params.questions[i];
+				if (!q.showWhen) continue;
+				const controllerIndex = params.questions.findIndex((candidate) => candidate.id === q.showWhen?.questionId);
+				if (controllerIndex < 0 || controllerIndex >= i) {
+					return errorResult(
+						`Error: question "${q.id}" has invalid showWhen.questionId "${q.showWhen.questionId}" (must reference an earlier question id)`,
+						params.questions,
+					);
+				}
+				if (!q.showWhen.selectedAnyOf || q.showWhen.selectedAnyOf.length === 0) {
+					return errorResult(
+						`Error: question "${q.id}" showWhen.selectedAnyOf must include at least one option label`,
+						params.questions,
+					);
+				}
+				const controller = params.questions[controllerIndex];
+				const validLabels = [
+					...controller.options.map((option) => option.label),
+					...(!controller.allowMultiple ? [OTHER_OPTION_LABEL] : []),
+				];
+				const invalidLabels = q.showWhen.selectedAnyOf.filter((label) => !validLabels.includes(label));
+				if (invalidLabels.length > 0) {
+					return errorResult(
+						`Error: question "${q.id}" showWhen.selectedAnyOf contains unknown option labels: ${invalidLabels.join(", ")}`,
+						params.questions,
+					);
+				}
+			}
+
+			// Subagents have no human to respond — fail fast and tell the model to decide autonomously.
+			if (process.argv.includes('--subagent-name')) {
+				return errorResult(
+					"Error: ask_user_questions cannot be used inside a subagent. " +
+					"There is no human available. Make a reasonable autonomous decision and proceed.",
+					params.questions,
+				);
+			}
+
 			if (!ctx.hasUI) {
 				return errorResult("Error: UI not available (non-interactive mode)", params.questions);
 			}
@@ -149,6 +232,9 @@ export default function AskUserQuestions(pi: ExtensionAPI) {
 			if (!result) {
 				const answers: Record<string, { answers: string[] }> = {};
 				for (const q of params.questions) {
+					if (!shouldAskQuestion(q, answers)) {
+						continue;
+					}
 					const options = q.options.map((o) => o.label);
 					if (!q.allowMultiple) {
 						options.push(OTHER_OPTION_LABEL);
@@ -262,6 +348,7 @@ export default function AskUserQuestions(pi: ExtensionAPI) {
 				lines.push(theme.fg("dim", details.channel));
 				if (details.response) {
 					for (const q of questions) {
+						if (!shouldAskQuestion(q, details.response.answers)) continue;
 						const answer = details.response.answers[q.id];
 						if (!answer) {
 							lines.push(`${theme.fg("accent", q.header)}: ${theme.fg("dim", "(no answer)")}`);
@@ -284,6 +371,7 @@ export default function AskUserQuestions(pi: ExtensionAPI) {
 
 			const lines: string[] = [];
 			for (const q of details.questions) {
+				if (!shouldRenderRoundQuestion(q, details.response.answers)) continue;
 				const answer = (details.response as RoundResult).answers[q.id];
 				if (!answer) {
 					lines.push(`${theme.fg("accent", q.header)}: ${theme.fg("dim", "(no answer)")}`);

package/src/resources/extensions/bg-shell/bg-shell-tool.ts

@@ -44,22 +44,12 @@ export function registerBgShellTool(pi: ExtensionAPI, state: BgShellSharedState)
 			"group_status (health of a process group), highlights (significant output lines only).",
 
 		promptGuidelines: [
-			"Use bg_shell to start long-running processes (servers, watchers, builds) that should not block the agent.",
-			"After starting a server, use 'wait_for_ready' to efficiently block until it's listening — avoids polling loops entirely.",
-			"Use 'digest' instead of 'output' when you just need status — it returns a structured ~30-token summary instead of ~2000 tokens of raw output.",
-			"Use 'highlights' to see only significant output (errors, URLs, results) — typically 5-15 lines instead of hundreds.",
-			"Use 'output' only when you need raw lines for debugging — add filter:'error|warning' to narrow results.",
-			"The 'output' action returns only new output since the last check (incremental). Repeated calls are cheap on context.",
-			"Set type:'server' and ready_port:3000 for dev servers so readiness detection is automatic.",
-			"Set group:'my-stack' on related processes to manage them together with 'group_status'.",
-			"Use 'run' to execute a command on a persistent shell session and block until it completes — returns structured output + exit code. Shell state (env vars, cwd, virtualenvs) persists across runs.",
-			"Use 'send_and_wait' for interactive CLIs: send input and wait for expected output pattern.",
-			"Use 'env' to check the current working directory and active environment variables of a shell session — useful after cd, source, or export commands.",
-			"Background processes are session-scoped by default: a new session reaps them unless you set persist_across_sessions:true.",
-			"Use 'restart' to kill and relaunch with the same config — preserves restart count.",
-			"Background processes are auto-classified (server/build/test/watcher) based on the command.",
-			"Process crashes and errors are automatically surfaced as alerts at the start of your next turn — you don't need to poll.",
-			"To create a persistent shell session: bg_shell start with type:'shell'. The session stays alive for interactive use with 'send', 'send_and_wait', or 'run'.",
+			"Use bg_shell for long-running processes (servers, watchers, builds). Set type:'server' and ready_port for dev servers.",
+			"Use 'digest' for status (~30 tokens), 'highlights' for key output, 'output' only for raw debugging. All are incremental.",
+			"Use 'run' to execute a command on a persistent shell (state persists). Use 'send_and_wait' for interactive CLIs.",
+			"Use 'wait_for_ready' after starting a server — blocks until the port/pattern matches.",
+			"Use group:'name' to manage related processes together; 'group_status' for health.",
+			"Crashes are auto-surfaced next turn. Use persist_across_sessions:true to survive session restarts.",
 		],
 
 		parameters: Type.Object({

package/src/resources/extensions/browser-tools/tools/codegen.ts

@@ -84,9 +84,10 @@ export function registerCodegenTools(pi: ExtensionAPI, deps: ToolDeps): void {
 							break;
 						}
 
-						case "browser_click_ref": {
+						case "browser_ref": {
 							// Refs are session-specific — add comment
-							testLines.push(`    // browser_click_ref: ${entry.paramsSummary} — replace with stable selector`);
+							const refAction = params.action ?? "click";
+							testLines.push(`    // browser_ref (${refAction}): ${entry.paramsSummary} — replace with stable selector`);
 							actionCount++;
 							break;
 						}
@@ -101,9 +102,8 @@ export function registerCodegenTools(pi: ExtensionAPI, deps: ToolDeps): void {
 							break;
 						}
 
-						case "browser_fill_ref": {
-							testLines.push(`    // browser_fill_ref: ${entry.paramsSummary} — replace with stable selector`);
-							actionCount++;
+						case "browser_fill_ref_handled": {
+							// Already handled by browser_ref above
 							break;
 						}
 

package/src/resources/extensions/browser-tools/tools/navigation.ts

@@ -17,216 +17,138 @@ export function registerNavigationTools(pi: ExtensionAPI, deps: ToolDeps): void
 		name: "browser_navigate",
 		label: "Browser Navigate",
 		description:
-			"Open the browser (if not already open) and navigate to a URL. Waits for network idle. Returns page title and current URL. Use ONLY for visually verifying locally-running web apps (e.g. http://localhost:3000). Do NOT use for documentation sites, GitHub, search results, or any external URL — use web_search instead. Screenshots are only captured when the `screenshot` parameter is set to true.",
+			"Navigate to a URL, go back/forward in history, or reload the page. " +
+			"Use ONLY for locally-running web apps (e.g. http://localhost:3000). " +
+			"Do NOT use for documentation sites, GitHub, or external URLs — use web_search instead.",
 		parameters: Type.Object({
-			url: Type.String({ description: "URL to navigate to, e.g. http://localhost:3000" }),
+			action: Type.Union([
+				Type.Literal("goto"),
+				Type.Literal("go_back"),
+				Type.Literal("go_forward"),
+				Type.Literal("reload"),
+			], { description: "'goto' — navigate to url (default), 'go_back'/'go_forward' — history, 'reload' — refresh page" }),
+			url: Type.Optional(Type.String({ description: "URL to navigate to (required for goto action)." })),
 			screenshot: Type.Optional(Type.Boolean({ description: "Capture and return a screenshot (default: false)", default: false })),
 		}),
 
 		async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
-			let actionId: number | null = null;
-			let beforeState: CompactPageState | null = null;
-			try {
-				const { page: p } = await deps.ensureBrowser();
-				beforeState = await deps.captureCompactPageState(p, { includeBodyText: true });
-				actionId = deps.beginTrackedAction("browser_navigate", params, beforeState.url).id;
-				await p.goto(params.url, { waitUntil: "domcontentloaded", timeout: 30000 });
-				await p.waitForLoadState("networkidle", { timeout: 5000 }).catch(() => { /* networkidle timeout — non-fatal, page may still be usable */ });
-				await new Promise(resolve => setTimeout(resolve, 300));
-
-				const title = await p.title();
-				const url = p.url();
-				const viewport = p.viewportSize();
-				const vpText = viewport ? `${viewport.width}x${viewport.height}` : "unknown";
-				const afterState = await deps.captureCompactPageState(p, { includeBodyText: true });
-				const summary = deps.formatCompactStateSummary(afterState);
-				const jsErrors = deps.getRecentErrors(p.url());
-				const diff = diffCompactStates(beforeState, afterState);
-				setLastActionBeforeState(beforeState);
-				setLastActionAfterState(afterState);
-				deps.finishTrackedAction(actionId, {
-					status: "success",
-					afterUrl: afterState.url,
-					warningSummary: jsErrors.trim() || undefined,
-					diffSummary: diff.summary,
-					changed: diff.changed,
-					beforeState,
-					afterState,
-				});
-
-				let screenshotContent: any[] = [];
-				if (params.screenshot) {
-					try {
-						let buf = await p.screenshot({ type: "jpeg", quality: 80, scale: "css" });
-						buf = await deps.constrainScreenshot(p, buf, "image/jpeg", 80);
-						screenshotContent = [{ type: "image", data: buf.toString("base64"), mimeType: "image/jpeg" }];
-					} catch { /* non-fatal — screenshot is optional, navigation result is still valid */ }
-				}
-
-				return {
-					content: [
-						{ type: "text", text: `Navigated to: ${url}\nTitle: ${title}\nViewport: ${vpText}\nAction: ${actionId}${jsErrors}\n\nDiff:\n${deps.formatDiffText(diff)}\n\nPage summary:\n${summary}` },
-						...screenshotContent,
-					],
-					details: { title, url, status: "loaded", viewport: vpText, actionId, diff },
-				};
-			} catch (err: any) {
-				if (actionId !== null) {
-					deps.finishTrackedAction(actionId, { status: "error", afterUrl: deps.getActivePageOrNull()?.url() ?? "", error: err.message, beforeState: beforeState ?? undefined });
-				}
-				const errorShot = await deps.captureErrorScreenshot(deps.getActivePageOrNull());
-				const content: any[] = [{ type: "text", text: `Navigation failed: ${err.message}` }];
-				if (errorShot) {
-					content.push({ type: "image", data: errorShot.data, mimeType: errorShot.mimeType });
-				}
-				return {
-					content,
-					details: { status: "error", error: err.message, actionId },
-					isError: true,
-				};
-			}
-		},
-	});
-
-	// -------------------------------------------------------------------------
-	// browser_go_back
-	// -------------------------------------------------------------------------
-	pi.registerTool({
-		name: "browser_go_back",
-		label: "Browser Go Back",
-		description: "Navigate back in browser history. Returns a compact page summary after navigation.",
-		parameters: Type.Object({}),
-
-		async execute(_toolCallId, _params, _signal, _onUpdate, _ctx) {
-			try {
-				const { page: p } = await deps.ensureBrowser();
-				const response = await p.goBack({ waitUntil: "domcontentloaded", timeout: 10000 });
-
-				if (!response) {
-					return {
-						content: [{ type: "text", text: "No previous page in history." }],
-						details: {},
-						isError: true,
-					};
-				}
-
-				await p.waitForLoadState("networkidle", { timeout: 5000 }).catch(() => { /* networkidle timeout — non-fatal, page may still be usable */ });
-
-				const title = await p.title();
-				const url = p.url();
-				const summary = await deps.postActionSummary(p);
-				const jsErrors = deps.getRecentErrors(p.url());
-
-				return {
-					content: [{ type: "text", text: `Navigated back to: ${url}\nTitle: ${title}${jsErrors}\n\nPage summary:\n${summary}` }],
-					details: { title, url },
-				};
-			} catch (err: any) {
-				const errorShot = await deps.captureErrorScreenshot(deps.getActivePageOrNull());
-				const content: any[] = [{ type: "text", text: `Go back failed: ${err.message}` }];
-				if (errorShot) {
-					content.push({ type: "image", data: errorShot.data, mimeType: errorShot.mimeType });
-				}
-				return { content, details: { error: err.message }, isError: true };
-			}
-		},
-	});
-
-	// -------------------------------------------------------------------------
-	// browser_go_forward
-	// -------------------------------------------------------------------------
-	pi.registerTool({
-		name: "browser_go_forward",
-		label: "Browser Go Forward",
-		description: "Navigate forward in browser history. Returns a compact page summary after navigation.",
-		parameters: Type.Object({}),
+			const action = params.action ?? "goto";
 
-		async execute(_toolCallId, _params, _signal, _onUpdate, _ctx) {
 			try {
-				const { page: p } = await deps.ensureBrowser();
-				const response = await p.goForward({ waitUntil: "domcontentloaded", timeout: 10000 });
-
-				if (!response) {
-					return {
-						content: [{ type: "text", text: "No forward page in history." }],
-						details: {},
-						isError: true,
-					};
+				if (action === "goto") {
+					return await gotoAction(params);
+				} else if (action === "go_back") {
+					return await goBackForward("back");
+				} else if (action === "go_forward") {
+					return await goBackForward("forward");
+				} else {
+					return await reloadAction();
 				}
-
-				await p.waitForLoadState("networkidle", { timeout: 5000 }).catch(() => { /* networkidle timeout — non-fatal, page may still be usable */ });
-
-				const title = await p.title();
-				const url = p.url();
-				const summary = await deps.postActionSummary(p);
-				const jsErrors = deps.getRecentErrors(p.url());
-
-				return {
-					content: [{ type: "text", text: `Navigated forward to: ${url}\nTitle: ${title}${jsErrors}\n\nPage summary:\n${summary}` }],
-					details: { title, url },
-				};
 			} catch (err: any) {
 				const errorShot = await deps.captureErrorScreenshot(deps.getActivePageOrNull());
-				const content: any[] = [{ type: "text", text: `Go forward failed: ${err.message}` }];
-				if (errorShot) {
-					content.push({ type: "image", data: errorShot.data, mimeType: errorShot.mimeType });
-				}
+				const content: any[] = [{ type: "text" as const, text: `Navigation '${action}' failed: ${err.message}` }];
+				if (errorShot) content.push({ type: "image" as const, data: errorShot.data, mimeType: errorShot.mimeType });
 				return { content, details: { error: err.message }, isError: true };
 			}
 		},
 	});
 
-	// -------------------------------------------------------------------------
-	// browser_reload
-	// -------------------------------------------------------------------------
-	pi.registerTool({
-		name: "browser_reload",
-		label: "Browser Reload",
-		description: "Reload the current page. Returns a screenshot, compact page summary, and page metadata (same shape as browser_navigate).",
-		parameters: Type.Object({}),
-
-		async execute(_toolCallId, _params, _signal, _onUpdate, _ctx) {
+	// ── action implementations ──
+
+	async function gotoAction(params: { url?: string; screenshot?: boolean }) {
+		if (!params.url) {
+			return { content: [{ type: "text" as const, text: "Goto requires a 'url' parameter." }], details: { error: "missing_url" }, isError: true };
+		}
+		let actionId: number | null = null;
+		let beforeState: CompactPageState | null = null;
+		const { page: p } = await deps.ensureBrowser();
+		beforeState = await deps.captureCompactPageState(p, { includeBodyText: true });
+		actionId = deps.beginTrackedAction("browser_navigate", params, beforeState.url).id;
+		await p.goto(params.url, { waitUntil: "domcontentloaded", timeout: 30000 });
+		await p.waitForLoadState("networkidle", { timeout: 5000 }).catch(() => { /* non-fatal */ });
+		await new Promise(resolve => setTimeout(resolve, 300));
+
+		const title = await p.title();
+		const url = p.url();
+		const viewport = p.viewportSize();
+		const vpText = viewport ? `${viewport.width}x${viewport.height}` : "unknown";
+		const afterState = await deps.captureCompactPageState(p, { includeBodyText: true });
+		const summary = deps.formatCompactStateSummary(afterState);
+		const jsErrors = deps.getRecentErrors(p.url());
+		const diff = diffCompactStates(beforeState, afterState);
+		setLastActionBeforeState(beforeState);
+		setLastActionAfterState(afterState);
+		deps.finishTrackedAction(actionId, {
+			status: "success", afterUrl: afterState.url, warningSummary: jsErrors.trim() || undefined,
+			diffSummary: diff.summary, changed: diff.changed, beforeState, afterState,
+		});
+
+		let screenshotContent: any[] = [];
+		if (params.screenshot) {
 			try {
-				const { page: p } = await deps.ensureBrowser();
-				await p.reload({ waitUntil: "domcontentloaded", timeout: 30000 });
-				await p.waitForLoadState("networkidle", { timeout: 5000 }).catch(() => { /* networkidle timeout — non-fatal, page may still be usable */ });
-
-				const title = await p.title();
-				const url = p.url();
-				const viewport = p.viewportSize();
-				const vpText = viewport ? `${viewport.width}x${viewport.height}` : "unknown";
-				const summary = await deps.postActionSummary(p);
-				const jsErrors = deps.getRecentErrors(p.url());
-
-				let screenshotContent: any[] = [];
-				try {
-					let buf = await p.screenshot({ type: "jpeg", quality: 80, scale: "css" });
-					buf = await deps.constrainScreenshot(p, buf, "image/jpeg", 80);
-					screenshotContent = [{
-						type: "image",
-						data: buf.toString("base64"),
-						mimeType: "image/jpeg",
-					}];
-				} catch { /* non-fatal — screenshot is optional, reload result is still valid */ }
-
-				return {
-					content: [
-						{
-							type: "text",
-							text: `Reloaded: ${url}\nTitle: ${title}\nViewport: ${vpText}${jsErrors}\n\nPage summary:\n${summary}`,
-						},
-						...screenshotContent,
-					],
-					details: { title, url, viewport: vpText },
-				};
-			} catch (err: any) {
-				const errorShot = await deps.captureErrorScreenshot(deps.getActivePageOrNull());
-				const content: any[] = [{ type: "text", text: `Reload failed: ${err.message}` }];
-				if (errorShot) {
-					content.push({ type: "image", data: errorShot.data, mimeType: errorShot.mimeType });
-				}
-				return { content, details: { error: err.message }, isError: true };
-			}
-		},
-	});
+				let buf = await p.screenshot({ type: "jpeg", quality: 80, scale: "css" });
+				buf = await deps.constrainScreenshot(p, buf, "image/jpeg", 80);
+				screenshotContent = [{ type: "image" as const, data: buf.toString("base64"), mimeType: "image/jpeg" }];
+			} catch { /* non-fatal */ }
+		}
+
+		return {
+			content: [
+				{ type: "text" as const, text: `Navigated to: ${url}\nTitle: ${title}\nViewport: ${vpText}\nAction: ${actionId}${jsErrors}\n\nDiff:\n${deps.formatDiffText(diff)}\n\nPage summary:\n${summary}` },
+				...screenshotContent,
+			],
+			details: { title, url, status: "loaded", viewport: vpText, actionId, diff },
+		};
+	}
+
+	async function goBackForward(direction: "back" | "forward") {
+		const { page: p } = await deps.ensureBrowser();
+		const response = direction === "back"
+			? await p.goBack({ waitUntil: "domcontentloaded", timeout: 10000 })
+			: await p.goForward({ waitUntil: "domcontentloaded", timeout: 10000 });
+
+		if (!response) {
+			return {
+				content: [{ type: "text" as const, text: `No ${direction} page in history.` }],
+				details: {},
+				isError: true,
+			};
+		}
+
+		await p.waitForLoadState("networkidle", { timeout: 5000 }).catch(() => { /* non-fatal */ });
+		const title = await p.title();
+		const url = p.url();
+		const summary = await deps.postActionSummary(p);
+		const jsErrors = deps.getRecentErrors(p.url());
+
+		return {
+			content: [{ type: "text" as const, text: `Navigated ${direction} to: ${url}\nTitle: ${title}${jsErrors}\n\nPage summary:\n${summary}` }],
+			details: { title, url },
+		};
+	}
+
+	async function reloadAction() {
+		const { page: p } = await deps.ensureBrowser();
+		await p.reload({ waitUntil: "domcontentloaded", timeout: 30000 });
+		await p.waitForLoadState("networkidle", { timeout: 5000 }).catch(() => { /* non-fatal */ });
+
+		const title = await p.title();
+		const url = p.url();
+		const viewport = p.viewportSize();
+		const vpText = viewport ? `${viewport.width}x${viewport.height}` : "unknown";
+		const summary = await deps.postActionSummary(p);
+		const jsErrors = deps.getRecentErrors(p.url());
+
+		let screenshotContent: any[] = [];
+		try {
+			let buf = await p.screenshot({ type: "jpeg", quality: 80, scale: "css" });
+			buf = await deps.constrainScreenshot(p, buf, "image/jpeg", 80);
+			screenshotContent = [{ type: "image" as const, data: buf.toString("base64"), mimeType: "image/jpeg" }];
+		} catch { /* non-fatal */ }
+
+		return {
+			content: [{ type: "text" as const, text: `Reloaded: ${url}\nTitle: ${title}\nViewport: ${vpText}${jsErrors}\n\nPage summary:\n${summary}` }, ...screenshotContent],
+			details: { title, url, viewport: vpText },
+		};
+	}
 }