@mind-harness/mh-browser 0.1.1 → 0.1.3

package/lib/index.js

@@ -5,12 +5,12 @@ import { isDeepStrictEqual } from "node:util";
 import { HarnessError, createUserMessage } from "@deepseek-ai/dsh-llm";
 import { z as z$1 } from "zod";
 import { createHash, randomUUID } from "node:crypto";
+import { constants, readFileSync } from "node:fs";
 import { lstat, mkdir, open, readFile, realpath, unlink, writeFile } from "node:fs/promises";
 import { parse } from "yaml";
+import { assertSupportedJsonSchema, defineTool, validateJsonSchemaValue } from "@deepseek-ai/dsh-tools";
 import { Remote, TypertRemoteService } from "@deepseek-ai/dsh-typert-protocol";
 import { chromium } from "playwright";
-import { constants, readFileSync } from "node:fs";
-import { assertSupportedJsonSchema, defineTool, validateJsonSchemaValue } from "@deepseek-ai/dsh-tools";
 import { fileURLToPath } from "node:url";
 import { UserQuestionError } from "@deepseek-ai/dsh-user-questions";
 //#region lib/types/config.js
@@ -127,7 +127,7 @@ function presenceSet(state) {
 }
 /** The text of a reminder, as `shown` records it. */
 function textDigest(message) {
-	return createHash("sha256").update(textOf$2(message)).digest("hex");
+	return createHash("sha256").update(textOf$3(message)).digest("hex");
 }
 function applySplice(state, event) {
 	const data = record$3(event.data);
@@ -254,7 +254,7 @@ function entryOf$1(value) {
 		...reason === void 0 ? {} : { reason }
 	}];
 }
-function textOf$2(value) {
+function textOf$3(value) {
 	const content = record$3(value).content;
 	if (!Array.isArray(content)) return "";
 	return content.map((block) => record$3(block).text).filter((text) => typeof text === "string").join("\n");
@@ -279,6 +279,8 @@ var MhBrowserError = class extends Error {
 		if (page !== void 0) this.page = page;
 	}
 };
+/** Owner of the person's own window. It belongs to no Session. */
+const PERSON_OWNER = "person";
 const UNKNOWN_TAB = "UNKNOWN_TAB";
 const UNKNOWN_TAB_REASON = "no such tab in this session";
 /**
@@ -384,6 +386,65 @@ async function filesInWorkspace(cwd, files) {
 	}
 	return resolved;
 }
+/** Refuse a filename that leaves the session's write root, without creating it. */
+async function assertInside(target, filename) {
+	await place(target, filename);
+}
+/**
+* Write `filename` under the session's write root. A path that leaves the
+* root is refused, through a symbolic link as well: the deepest existing
+* directory is checked before any is created, and the file itself is not
+* followed if it is a link.
+*/
+async function writeInside(target, filename, data) {
+	const file = await place(target, filename);
+	assertUnder(file.root, await realpath(await deepestExisting(dirname(file.file))), filename);
+	await mkdir(dirname(file.file), { recursive: true });
+	const parent = await realpath(dirname(file.file));
+	assertUnder(file.root, parent, filename);
+	const placed = resolve(parent, basename(file.file));
+	let handle;
+	try {
+		handle = await open(placed, constants.O_WRONLY | constants.O_CREAT | constants.O_TRUNC | constants.O_NOFOLLOW);
+	} catch (error) {
+		if (error.code === "ELOOP") throw new BrowserToolError("OUTSIDE_WORKSPACE", `${filename} is outside the session workspace`);
+		throw error;
+	}
+	try {
+		await handle.writeFile(data);
+	} finally {
+		await handle.close();
+	}
+	const bytes = typeof data === "string" ? Buffer.byteLength(data) : data.byteLength;
+	return {
+		path: relative(file.root, placed),
+		bytes
+	};
+}
+function assertUnder(root, path, filename) {
+	const fromRoot = relative(root, path);
+	if (fromRoot.startsWith("..") || isAbsolute(fromRoot)) throw new BrowserToolError("OUTSIDE_WORKSPACE", `${filename} is outside the session workspace`);
+}
+async function deepestExisting(path) {
+	for (let current = path;; current = dirname(current)) try {
+		await lstat(current);
+		return current;
+	} catch {
+		if (dirname(current) === current) return current;
+	}
+}
+async function place(target, filename) {
+	if ("denied" in target) throw new BrowserToolError(target.code, target.denied);
+	if (filename.trim() === "") throw new BrowserToolError("INVALID_ARGS", "filename: give a path inside the workspace");
+	const root = await realpath(target.root).catch(() => target.root);
+	const abs = isAbsolute(filename) ? filename : resolve(root, filename);
+	const direct = relative(root, abs);
+	if (direct.startsWith("..") || isAbsolute(direct)) throw new BrowserToolError("OUTSIDE_WORKSPACE", `${filename} is outside the session workspace`);
+	return {
+		root,
+		file: abs
+	};
+}
 //#endregion
 //#region lib/types/tools/attachments.js
 function initAttachments() {
@@ -452,7 +513,12 @@ function visit(value, depth, found) {
 	}
 	for (const item of Object.values(row)) visit(item, depth + 1, found);
 }
+//#endregion
+//#region lib/types/representation/agent-view.js
+const AGENT_VIEW_VERSION = "0.1";
 const AGENT_VIEW_ACCEPT = "text/markdown; variant=agent-view";
+/** Accept on the page address when its origin is known to offer Agent Views. */
+const PAGE_ACCEPT = "text/markdown; variant=agent-view, text/html;q=0.9, */*;q=0.8";
 const FENCE_OPEN = /```agent-view\b/g;
 const HTTP_METHODS = /* @__PURE__ */ new Set([
 	"GET",
@@ -659,6 +725,208 @@ function isAbsoluteHttp(uri) {
 	}
 }
 //#endregion
+//#region lib/types/render/envelope.js
+/** Every element the service writes around site text. */
+const FRAMES = [
+	"system-reminder",
+	"page",
+	"page-error",
+	"added",
+	"changed",
+	"removed",
+	"absent",
+	"action-response",
+	"tabs",
+	"dialog",
+	"download",
+	"download-error"
+];
+const CLOSERS = new RegExp(`<\\s*/\\s*(${FRAMES.join("|")})(?![\\w-])`, "gi");
+const OPENERS = new RegExp(`<\\s*(${FRAMES.join("|")})(?![\\w-])`, "gi");
+/**
+* Escape a closer a site could use to end a frame the service opened, and an
+* opener it could use to pass its text off as one. Only `</name` and `<name`
+* are rewritten, so a tag cut off before `>` is caught and no site text is dropped.
+*/
+function escapeBody(text) {
+	return text.replace(CLOSERS, (_match, tag) => `<\\/${tag.toLowerCase()}`).replace(OPENERS, (_match, tag) => `<\\${tag.toLowerCase()}`);
+}
+/** Escape text the service writes into an attribute. */
+function escapeAttr(text) {
+	return text.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/\r/g, "&#13;").replace(/\n/g, "&#10;").replace(/\t/g, "&#9;");
+}
+/** Site text that must stay on one line, such as a title in `<tabs>`. */
+function oneLine(text) {
+	return text.replace(/[\u0000-\u001f\u007f\u2028\u2029]+/g, " ");
+}
+function incompleteText(incomplete) {
+	const pending = `${String(incomplete.pendingRequests)} requests pending`;
+	return incomplete.load ? pending : `load not fired; ${pending}`;
+}
+function waitedText(waited) {
+	const seconds = formatSeconds(waited.seconds);
+	if (waited.met === "text") return `text appeared after ${seconds} s`;
+	if (waited.met === "textGone") return `text gone after ${seconds} s`;
+	if (waited.met === "time") return `waited ${seconds} s`;
+	return `not met after ${seconds} s`;
+}
+/**
+* `withDigest` is for a page attached to a tool error: an error result has no
+* meta, so the digest in the header is what records the delivery.
+*/
+function renderPage(view, screenshot, omitBody = false, withDigest = false) {
+	const body = view.summary !== void 0 ? view.detail === void 0 || view.detail === "" ? view.summary : `${view.summary}\n${view.detail}` : view.headerOnly ? view.inPresence ? "" : "Open this page to read it or act on it." : omitBody ? "Content follows in the next presence reminder." : pageBody(view);
+	const dialog = view.dialog === void 0 ? "" : `\n${renderDialog(view.dialog.type, view.dialog.message)}`;
+	const digest = withDigest && !omitBody ? digestOf$1(view) : void 0;
+	const digestAttr = digest === void 0 ? "" : attr$1("digest", digest);
+	return `<page${pageAttrs(view, screenshot)}${digestAttr}>${escapeBody(body)}${dialog}</page>`;
+}
+function renderActionResponse(response) {
+	const body = response.lost ? "No response arrived after sending; the action may have taken effect." : response.body !== void 0 ? response.body : response.bytes !== void 0 ? `${response.mediaType ?? "application/octet-stream"} (${String(response.bytes)} bytes)` : "";
+	return `<action-response${attr$1("name", response.name)}${response.lost === true ? attr$1("lost", "true") : ""}${response.status === void 0 ? "" : attr$1("status", String(response.status))}${response.location === void 0 ? "" : attr$1("location", response.location)}>${escapeBody(body)}</action-response>`;
+}
+function renderPageError(error) {
+	const tab = error.tab === void 0 ? "" : attr$1("tab", error.tab);
+	return `<page-error${attr$1("url", error.url)}${tab}${attr$1("reason", error.reason)}></page-error>`;
+}
+function renderTabs(tabs, closed) {
+	const lines = tabs.map((tab) => {
+		const title = tab.title === "" ? "" : ` — ${oneLine(tab.title)}`;
+		const flags = [
+			tab.inPresence ? "in presence" : "",
+			tab.mayHaveChanged ? "may have changed" : "",
+			tab.occupied ? "in use" : ""
+		].filter((flag) => flag !== "");
+		const suffix = flags.length === 0 ? "" : ` ${flags.join(", ")}`;
+		return `${tab.tab} ${oneLine(tab.url)}${title}${suffix}`;
+	});
+	const closedLines = closed.map((note) => `closed: ${note}`);
+	return `<tabs>\n${escapeBody([...lines, ...closedLines].join("\n"))}\n</tabs>`;
+}
+function renderDialog(type, message) {
+	return `<dialog${attr$1("type", type)}>${escapeBody(message)}</dialog>`;
+}
+function renderDownload(download) {
+	if (download.kind === "error") {
+		const status = download.status === void 0 ? "" : attr$1("status", String(download.status));
+		return `<download-error${attr$1("url", download.url)}${status}${attr$1("reason", download.reason)}></download-error>`;
+	}
+	const media = download.mediaType === void 0 ? "" : attr$1("media-type", download.mediaType);
+	return `<download${attr$1("path", download.path)}${attr$1("url", download.url)}${media}${attr$1("bytes", String(download.bytes))}${attr$1("sha256", download.sha256)}${attr$1("observed", download.observed)}></download>`;
+}
+/**
+* `omitInPresence`: the page's body is the same one presence carries, so a
+* page in presence gets only its attributes.
+*/
+function renderOutcome(pages, screenshot, omitInPresence = false) {
+	return pages.map((page) => {
+		const main = "representation" in page ? renderPage(page, screenshot, omitInPresence && page.inPresence) : renderPageError(page);
+		if (!("representation" in page) || page.download === void 0) return main;
+		return `${main}\n${renderDownload(page.download)}`;
+	}).join("\n");
+}
+function tabSnap(tabs, closed) {
+	return {
+		tabs: tabs.map((tab) => ({
+			id: tab.tab,
+			url: tab.url,
+			presence: tab.inPresence,
+			changed: tab.mayHaveChanged,
+			inUse: tab.occupied
+		})),
+		closed: [...closed]
+	};
+}
+/**
+* Attach the full list when this session has not attached one yet, when the
+* tab key changed, or when this result closed something. Title is not a change.
+*/
+function tabsChanged(previous, next) {
+	if (next.closed.length > 0) return true;
+	if (previous === void 0) return next.tabs.length > 0;
+	return JSON.stringify(previous.tabs) !== JSON.stringify(next.tabs);
+}
+/** Reading fields persisted in tool meta. `by` marks the result as this plugin's. */
+function readingsOf(pages, action) {
+	return {
+		by: "mh-browser",
+		action,
+		pages: pages.map((page) => {
+			if (!("representation" in page)) return {
+				url: page.url,
+				...page.tab === void 0 ? {} : { tab: page.tab },
+				representation: "snapshot",
+				reason: page.reason
+			};
+			const version = versionOf$1(page);
+			const digest = page.headerOnly ? void 0 : digestOf$1(page);
+			const id = page.headerOnly ? void 0 : idOf(page);
+			return {
+				url: page.url,
+				...page.tab === void 0 ? {} : { tab: page.tab },
+				representation: page.headerOnly ? "header" : page.representation.kind,
+				...version === void 0 ? {} : { version },
+				...digest === void 0 ? {} : { digest },
+				...id === void 0 ? {} : { id },
+				...page.incomplete === void 0 ? {} : { incomplete: incompleteText(page.incomplete) }
+			};
+		})
+	};
+}
+function pageAttrs(view, screenshot) {
+	const representation = view.representation;
+	const version = versionOf$1(view);
+	const agentView = representation.kind === "snapshot" && representation.agentView !== void 0 ? attr$1("agent-view", "available") : "";
+	return [
+		attr$1("url", view.url),
+		view.tab === void 0 ? "" : attr$1("tab", view.tab),
+		view.headerOnly ? attr$1("title", view.title) : "",
+		attr$1("representation", representation.kind),
+		version === void 0 ? "" : attr$1("version", version),
+		attr$1("observed", view.observedAt),
+		view.fragment === void 0 ? "" : attr$1("fragment", view.fragment),
+		view.status === void 0 ? "" : attr$1("status", String(view.status)),
+		view.mediaType === void 0 ? "" : attr$1("media-type", view.mediaType),
+		view.incomplete === void 0 ? "" : attr$1("incomplete", incompleteText(view.incomplete)),
+		view.waited === void 0 ? "" : attr$1("waited", waitedText(view.waited)),
+		view.inPresence ? attr$1("in-presence", "true") : "",
+		agentView,
+		representation.kind === "snapshot" && representation.agentViewError !== void 0 ? attr$1("agent-view-error", representation.agentViewError) : "",
+		screenshot === void 0 ? "" : attr$1("screenshot", screenshot)
+	].join("");
+}
+const BODY_LIMIT = 2e5;
+function pageBody(view) {
+	const representation = view.representation;
+	if (view.mediaType === void 0 || representation.kind !== "snapshot") return representation.text;
+	if (view.body !== void 0) {
+		if (view.body.length <= BODY_LIMIT) return view.body;
+		return `${view.body.slice(0, BODY_LIMIT)}\nCut at ${String(BODY_LIMIT)} characters; use browser_download to save the whole file into the workspace.`;
+	}
+	if (view.status !== void 0) return `The site answered HTTP ${String(view.status)}; the ${view.mediaType} body is not shown.`;
+	return "Not an HTML page; use browser_download to save it into the workspace.";
+}
+function versionOf$1(view) {
+	const representation = view.representation;
+	if (representation.kind === "agent-view") return representation.version;
+	return representation.agentView?.version;
+}
+function digestOf$1(view) {
+	if (view.representation.kind !== "agent-view") return void 0;
+	return representationDigest(view.representation.text);
+}
+function idOf(view) {
+	if (view.representation.kind !== "agent-view") return void 0;
+	return agentViewId(view.representation.text, view.url);
+}
+function attr$1(name, value) {
+	return ` ${name}="${escapeAttr(value)}"`;
+}
+function formatSeconds(seconds) {
+	const rounded = Math.round(seconds * 10) / 10;
+	return Number.isInteger(rounded) ? String(rounded) : rounded.toFixed(1);
+}
+//#endregion
 //#region lib/types/tools/delivery.js
 /** Every mh-browser tool result's `meta.by`; a result without it is not a delivery. */
 const META_BY = "mh-browser";
@@ -670,81 +938,70 @@ function initDeliveries() {
 	};
 }
 /**
-* One event folded into the delivery record. A tool result shadowed by
-* `compaction/prune` or replaced on the surface is out of context, and its
-* replacement is not a new delivery; a summary puts everything before it out
-* of context, presence reminders included: the replacement baseline that
-* follows the summary is the delivery that counts.
+* One event folded into the delivery record. Compaction does not revoke a
+* delivery. A later result with the same call id is the replacement a prune
+* appends, so it does not replace the text the model was shown.
 */
 function applyDelivery(state, event) {
-	if (event.type === "compaction/summary") return markOut(state, (item) => item.seq < event.seq);
-	if (event.type === "compaction/prune") {
-		const shadowed = new Set(numberList(record$2(event.data).shadowedSeqs));
-		return markOut(state, (item) => shadowed.has(item.seq));
-	}
-	const replaced = replacedRange(event.surfaceOp);
-	if (replaced !== void 0) return markOut(state, (item) => item.seq >= replaced.start && item.seq <= replaced.end);
+	if (event.type === "compaction/summary" || event.type === "compaction/prune") return state;
 	if (event.type === "tool/result") return withShown(state, fromTool(event));
 	if (event.type === "user/message") return withShown(state, fromPresence(event));
 	return state;
 }
 /**
-* The Agent View of this address the model saw last, and whether it is still
-* in context. A page shown only as a snapshot has no Agent View digest.
-*/
-function latestSeen(state, url) {
-	const matches = state.deliveries.filter((item) => sameUrl(item.url, url));
-	if (matches.length === 0) return void 0;
-	const latest = matches.filter((item) => item.digest !== void 0).at(-1);
-	if (latest === void 0) return { digest: "" };
-	if (!latest.inContext) return "not-in-context";
-	return seenOf(latest);
-}
-function seenOf(item) {
-	return {
-		digest: item.digest ?? "",
-		...item.version === void 0 ? {} : { version: item.version }
-	};
-}
-/**
 * The document `page` names: the one shown at that address, else the one whose
 * Agent View declares that `id`. One `id` can name several documents, such as
-* the pages of a collection; when more than one is in context and they
-* differ, the caller must pick an address.
+* the pages of a collection; when they differ, the caller must pick an address.
+* `text` is the body the model was shown for that document.
 */
 function resolvePage(state, page) {
-	const atAddress = latestSeen(state, page);
-	if (atAddress !== void 0) return {
-		url: page,
-		seen: atAddress
-	};
+	const atAddress = documentOf(state.deliveries.filter((item) => sameUrl(item.url, page)));
+	if (atAddress !== void 0) return shownPage(atAddress);
 	const named = state.deliveries.filter((item) => item.id !== void 0 && sameUrl(item.id, page));
 	if (named.length === 0) return void 0;
 	const byUrl = /* @__PURE__ */ new Map();
 	for (const item of named) {
-		byUrl.delete(item.url);
-		byUrl.set(item.url, item);
+		const list = byUrl.get(item.url) ?? [];
+		list.push(item);
+		byUrl.set(item.url, list);
 	}
-	const latest = [...byUrl.values()];
-	const current = latest.filter((item) => {
-		const seen = latestSeen(state, item.url);
-		return seen !== void 0 && seen !== "not-in-context" && seen.digest === item.digest;
+	const latest = [...byUrl.values()].flatMap((list) => {
+		const doc = documentOf(list);
+		return doc === void 0 ? [] : [doc];
 	});
-	const last = latest.at(-1);
-	if (current.length === 0) return last === void 0 ? void 0 : {
-		url: last.url,
-		seen: "not-in-context"
-	};
-	if (new Set(current.map((item) => item.digest)).size > 1) return { ambiguous: current.map((item) => item.url) };
-	const chosen = current.at(-1);
+	if (new Set(latest.map((item) => item.digest)).size > 1) return { ambiguous: latest.map((item) => item.url) };
+	const chosen = latest.reduce((best, item) => best === void 0 || item.seq >= best.seq ? item : best, void 0);
 	if (chosen === void 0) return void 0;
+	return shownPage(chosen);
+}
+function shownPage(item) {
 	return {
-		url: chosen.url,
-		seen: seenOf(chosen)
+		url: item.url,
+		text: item.text ?? ""
 	};
 }
+/**
+* The last Agent View shown at these deliveries, else the last delivery. A
+* result that left the body to presence carries the same digest without the
+* body; the body comes from the latest delivery with that digest that has one.
+*/
+function documentOf(matches) {
+	const views = matches.filter((item) => item.digest !== void 0);
+	const last = views.at(-1);
+	if (last === void 0) return matches.at(-1);
+	if (last.text !== void 0) return last;
+	for (let index = views.length - 1; index >= 0; index -= 1) {
+		const item = views[index];
+		if (item !== void 0 && item.digest === last.digest && item.text !== void 0) return {
+			...last,
+			text: item.text
+		};
+	}
+	return last;
+}
 function withShown(state, shown) {
 	if (shown === void 0 || shown.deliveries.length === 0) return state;
+	if (shown.callId !== void 0 && state.deliveries.some((item) => item.callId === shown.callId)) return state;
 	const known = new Set(state.tokens);
 	const fresh = urlsIn(shown.text).filter((token) => {
 		if (known.has(token)) return false;
@@ -756,16 +1013,6 @@ function withShown(state, shown) {
 		tokens: fresh.length === 0 ? state.tokens : [...state.tokens, ...fresh]
 	};
 }
-function markOut(state, out) {
-	if (!state.deliveries.some((item) => item.inContext && out(item))) return state;
-	return {
-		...state,
-		deliveries: state.deliveries.map((item) => item.inContext && out(item) ? {
-			...item,
-			inContext: false
-		} : item)
-	};
-}
 const URL_TOKEN = /https?:\/\/[^\s"'<>`]+/gi;
 function urlsIn(text) {
 	const found = [];
@@ -783,8 +1030,8 @@ function fromTool(event) {
 	const data = record$2(event.data);
 	const message = record$2(data.message);
 	const callId = readString(message.toolCallId);
-	const text = textOf$1(message.content);
-	if (message.isError === true) return attachedPage(event.seq, data, text, callId);
+	const text = textOf$2(message.content);
+	if (message.isError === true) return void 0;
 	const meta = record$2(data.meta);
 	if (meta.by !== "mh-browser") return void 0;
 	const pages = meta.pages;
@@ -792,25 +1039,28 @@ function fromTool(event) {
 	const deliveries = [];
 	for (const page of pages) {
 		const row = record$2(page);
+		if (row.representation === "header" || readString(row.reason) !== void 0) continue;
 		const url = readString(row.url);
 		if (url === void 0) continue;
 		const digest = readString(row.digest);
 		const version = readString(row.version);
 		const id = readString(row.id);
+		const body = digest === void 0 ? void 0 : shownBody(text, url);
 		deliveries.push({
 			url,
 			seq: event.seq,
 			kind: "tool",
-			inContext: true,
 			...callId === void 0 ? {} : { callId },
 			...digest === void 0 ? {} : { digest },
 			...version === void 0 ? {} : { version },
-			...id === void 0 ? {} : { id }
+			...id === void 0 ? {} : { id },
+			...body === void 0 ? {} : { text: body }
 		});
 	}
 	return {
 		deliveries,
-		text
+		text,
+		...callId === void 0 ? {} : { callId }
 	};
 }
 function fromPresence(event) {
@@ -828,76 +1078,65 @@ function fromPresence(event) {
 		const digest = readString(row.digest);
 		const version = readString(row.version);
 		const id = readString(row.id);
+		const body = digest === void 0 ? void 0 : shownBody(textOf$2(message.content), url);
 		deliveries.push({
 			url,
 			seq: event.seq,
 			kind: "presence",
-			inContext: true,
 			...digest === void 0 ? {} : { digest },
 			...version === void 0 ? {} : { version },
-			...id === void 0 ? {} : { id }
+			...id === void 0 ? {} : { id },
+			...body === void 0 ? {} : { text: body }
 		});
 	}
 	return {
 		deliveries,
-		text: textOf$1(message.content)
+		text: textOf$2(message.content)
 	};
 }
+const OMITTED_BODY = /* @__PURE__ */ new Set([
+	"",
+	"Content follows in the next presence reminder.",
+	"Open this page to read it or act on it."
+]);
 /**
-* An error result carries no meta. Only `STALE_VIEW` attaches a page that
-* counts as delivered, and the service writes that page's header, with its
-* Agent View digest, before any site text: so only the first `<page` header
-* of this tool's own error counts.
+* The `<page>` body the model was shown for this address. Site text cannot
+* open or close a frame (`escapeBody`), so every frame tag here is the
+* Service's. A spill can still cut out the closer and whatever follows it up
+* to a later closer; the body ends at the spill gap or at the next frame the
+* Service opened, whichever comes first.
 */
-function attachedPage(seq, data, text, callId) {
-	const error = record$2(data.error);
-	if (error.name !== "BrowserToolError" || error.code !== "STALE_VIEW") return void 0;
-	const start = text.indexOf("<page ");
-	if (start < 0) return void 0;
-	const end = text.indexOf(">", start);
-	if (end < 0) return void 0;
-	const header = text.slice(start, end);
-	const url = attrOf(header, "url");
-	const digest = attrOf(header, "digest");
-	const version = attrOf(header, "version");
-	if (url === void 0 || digest === void 0) return void 0;
-	const close = text.indexOf("</page>", end);
-	const id = agentViewId(text.slice(end + 1, close < 0 ? void 0 : close), url);
-	return {
-		deliveries: [{
-			url,
-			seq,
-			kind: "tool",
-			digest,
-			...version === void 0 ? {} : { version },
-			inContext: true,
-			...callId === void 0 ? {} : { callId },
-			...id === void 0 ? {} : { id }
-		}],
-		text
-	};
+function shownBody(text, url) {
+	for (const match of text.matchAll(/<(page|added|changed)(?=[\s>])([^>]*)>([\s\S]*?)<\/\1>/g)) {
+		const found = attrOf(match[2] ?? "", "url");
+		if (found === void 0 || !sameUrl(found, url)) continue;
+		const body = unescapeBody(upToBoundary(withoutDialog(match[3] ?? "")));
+		if (OMITTED_BODY.has(body.trim())) return void 0;
+		return body;
+	}
+}
+const SPILL_GAP = "\n\n[...]\n\n";
+const FRAME_OPENER = new RegExp(`<(${FRAMES.join("|")})(?=[\\s>/])`);
+function upToBoundary(body) {
+	const gap = body.indexOf(SPILL_GAP);
+	const kept = gap === -1 ? body : body.slice(0, gap);
+	const opener = FRAME_OPENER.exec(kept);
+	return opener === null ? kept : kept.slice(0, opener.index);
+}
+const DIALOG_SUFFIX = /\n<dialog(?=[\s>])[^>]*>[\s\S]*?<\/dialog>$/;
+function withoutDialog(body) {
+	return body.replace(DIALOG_SUFFIX, "");
+}
+const ESCAPED_TAG = new RegExp(`<\\\\(/?)(${FRAMES.join("|")})(?![\\w-])`, "g");
+function unescapeBody(body) {
+	return body.replace(ESCAPED_TAG, "<$1$2");
 }
 function attrOf(header, name) {
 	const value = new RegExp(`\\s${name}="([^"]*)"`).exec(header)?.[1];
 	if (value === void 0 || value === "") return void 0;
 	return value.replace(/&quot;/g, "\"").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&#10;/g, "\n").replace(/&#13;/g, "\r").replace(/&#9;/g, "	").replace(/&amp;/g, "&");
 }
-function replacedRange(op) {
-	const row = record$2(op);
-	if (row.op !== "replace") return void 0;
-	const start = row.startSeq;
-	const end = row.endSeq;
-	if (typeof start !== "number" || typeof end !== "number" || end < start) return void 0;
-	return {
-		start,
-		end
-	};
-}
-function numberList(value) {
-	if (!Array.isArray(value)) return [];
-	return value.filter((item) => typeof item === "number");
-}
-function textOf$1(content) {
+function textOf$2(content) {
 	if (!Array.isArray(content)) return "";
 	const parts = [];
 	for (const block of content) {
@@ -931,16 +1170,38 @@ function initTabLog() {
 	return { open: [] };
 }
 function applyTabLog(state, event) {
-	if (event.type !== "tool/result") return state;
+	const cleared = event.type === "compaction/summary" || event.type === "compaction/prune" || event.surfaceOp === "replace";
+	if (event.type !== "tool/result") return cleared ? withoutSnap(state) : state;
 	const meta = record$1(record$1(event.data).meta);
-	if (meta.by !== "mh-browser") return state;
+	if (meta.by !== "mh-browser") return cleared ? withoutSnap(state) : state;
 	const named = Array.isArray(meta.pages) ? meta.pages.map((page) => record$1(page).tab).filter(isTabId) : [];
 	const closed = Array.isArray(meta.closed) ? meta.closed.filter((note) => typeof note === "string").map(tabOfNote) : [];
-	if (named.length === 0 && closed.length === 0) return state;
 	const next = new Set(state.open);
 	for (const tab of named) next.add(tab);
 	for (const tab of closed) next.delete(tab);
-	return { open: [...next] };
+	const keptSnap = (cleared ? void 0 : snapOf(meta.tabs)) ?? (cleared ? void 0 : state.snap);
+	const lastTab = Array.isArray(meta.pages) ? named[named.length - 1] : state.lastTab;
+	return {
+		open: [...next],
+		...lastTab === void 0 ? {} : { lastTab },
+		...keptSnap === void 0 ? {} : { snap: keptSnap }
+	};
+}
+/** The `<tabs>` suffix for this result, and the snap to store when it is attached. */
+function tabBlock(ctx, reader, session) {
+	const closed = closedNotes(ctx, reader, session);
+	const live = ctx.mhBrowser.tabs(session.id);
+	const snap = tabSnap(live, closed);
+	const previous = reader.tabs(session.session).snap;
+	if (!tabsChanged(previous, snap)) return {
+		suffix: "",
+		closed
+	};
+	return {
+		suffix: `\n${renderTabs(live, closed)}`,
+		closed,
+		snap
+	};
 }
 /**
 * The closed notes for this result: the service's own, then each tab an
@@ -959,6 +1220,28 @@ function tabOfNote(note) {
 function isTabId(value) {
 	return typeof value === "string" && /^t\d+$/.test(value);
 }
+function withoutSnap(state) {
+	const { snap: _snap, ...rest } = state;
+	return rest;
+}
+function snapOf(value) {
+	const snap = record$1(value);
+	if (!Array.isArray(snap.tabs)) return void 0;
+	return {
+		tabs: snap.tabs.flatMap((item) => {
+			const row = record$1(item);
+			if (typeof row.id !== "string" || typeof row.url !== "string") return [];
+			return [{
+				id: row.id,
+				url: row.url,
+				presence: row.presence === true,
+				changed: row.changed === true,
+				inUse: row.inUse === true
+			}];
+		}),
+		closed: Array.isArray(snap.closed) ? snap.closed.filter((note) => typeof note === "string") : []
+	};
+}
 function record$1(value) {
 	return value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
 }
@@ -968,7 +1251,7 @@ function record$1(value) {
 function registerProjections(ctx) {
 	ctx.sessionProjections.register({
 		key: "mhBrowserDeliveries",
-		stateVersion: 1,
+		stateVersion: 2,
 		stateSchema: plainObject(["deliveries", "tokens"]),
 		init: initDeliveries,
 		apply: (state, event) => applyDelivery(state, {
@@ -1000,7 +1283,7 @@ function registerProjections(ctx) {
 	});
 	ctx.sessionProjections.register({
 		key: "mhBrowserTabs",
-		stateVersion: 1,
+		stateVersion: 2,
 		stateSchema: plainObject(["open"]),
 		init: initTabLog,
 		apply: (state, event) => applyTabLog(state, event)
@@ -1024,23 +1307,676 @@ function plainObject(keys) {
 	return z$1.custom((value) => value !== null && typeof value === "object" && keys.every((key) => key in value));
 }
 //#endregion
-//#region lib/types/presence/notice.js
-/** The sentence a session sees after the person hands the browser back. */
-function takeoverText(taken) {
-	const tabs = taken.tabs.length === 0 ? "none" : taken.tabs.join(", ");
-	return [
-		"<system-reminder>",
-		`The person took over the browser and handed it back (${String(taken.operations)} operations, ${taken.from}–${taken.to}). Tabs that may have changed: ${tabs}. Look at them again before acting on them.`,
-		"</system-reminder>"
-	].join("\n");
-}
-//#endregion
-//#region lib/types/presence/register.js
-const BROWSER_TOOLS = /* @__PURE__ */ new Set([
-	"browser_open",
-	"browser_act",
+//#region lib/types/tools/page-ops.js
+const IMAGE_VALUE = {
+	type: "object",
+	additionalProperties: false,
+	properties: {
+		attachmentId: {
+			type: "string",
+			required: true
+		},
+		mediaType: {
+			type: "string",
+			enum: [
+				"image/png",
+				"image/jpeg",
+				"image/webp",
+				"image/gif"
+			],
+			required: true
+		},
+		bytes: {
+			type: "integer",
+			required: true
+		},
+		width: {
+			type: "integer",
+			required: true
+		},
+		height: {
+			type: "integer",
+			required: true
+		},
+		name: { type: "string" },
+		originalDimensions: {
+			type: "object",
+			additionalProperties: false,
+			properties: {
+				width: {
+					type: "integer",
+					required: true
+				},
+				height: {
+					type: "integer",
+					required: true
+				}
+			}
+		}
+	}
+};
+const TAB$1 = "Tab id copied from the latest result in this session: a tabs list, or a page element's tab attribute. Omit it to use the tab of that latest result; if it has no tab, the call fails with INVALID_ARGS. An idle tab may be closed, and a closed id fails with UNKNOWN_TAB: open the address again with browser_open. A tab with unsubmitted input is marked in use and is not closed, and opening or a declared action does not reload it. Tabs are gone after a restart. A page with an Agent View has no tab until you open it with snapshot.";
+const TARGET = "A ref copied from this tab's latest snapshot, such as e3, or a selector that matches one element. A ref that is not in the current snapshot fails with STALE_REF.";
+const ELEMENT = "What the person sees in the log. It does not locate the element.";
+const FILENAME = "A path inside the workspace. The result is saved there and the reply is the path and the byte count. Omit it and the result stays in the reply.";
+const OUTPUT = {
+	schema: {
+		type: "object",
+		additionalProperties: false,
+		properties: {
+			text: {
+				type: "string",
+				required: true
+			},
+			meta: {
+				type: "json",
+				required: true
+			},
+			image: IMAGE_VALUE
+		}
+	},
+	render: (_args, value) => {
+		const text = {
+			type: "text",
+			text: value.text
+		};
+		if (value.image === void 0) return [text];
+		return [text, {
+			type: "image",
+			attachment: imageRef(value.image)
+		}];
+	},
+	presentationMeta: (_args, value) => value.meta
+};
+const TARGET_FIELDS = {
+	target: {
+		type: "string",
+		required: true,
+		description: TARGET
+	},
+	element: {
+		type: "string",
+		description: ELEMENT
+	}
+};
+const PAGE_OPERATION_NAMES = [
+	"browser_click",
+	"browser_hover",
+	"browser_select_option",
+	"browser_drag",
+	"browser_type",
+	"browser_fill_form",
+	"browser_press_key",
+	"browser_file_upload",
+	"browser_handle_dialog",
+	"browser_navigate_back",
+	"browser_wait_for",
+	"browser_snapshot",
+	"browser_find",
+	"browser_take_screenshot",
+	"browser_evaluate"
+];
+const OPS = [
+	{
+		name: "browser_click",
+		description: "Click an element.",
+		properties: {
+			...TARGET_FIELDS,
+			doubleClick: {
+				type: "boolean",
+				description: "Double-click instead of click."
+			},
+			button: {
+				type: "string",
+				enum: [
+					"left",
+					"right",
+					"middle"
+				],
+				description: "Mouse button. Defaults to left."
+			},
+			modifiers: {
+				type: "array",
+				description: "Modifier keys held during the click.",
+				items: {
+					type: "string",
+					enum: [
+						"Alt",
+						"Control",
+						"ControlOrMeta",
+						"Meta",
+						"Shift"
+					]
+				}
+			}
+		},
+		build: async (args) => ({
+			kind: "click",
+			target: string(args.target),
+			...optionalString(args, "element"),
+			...args.doubleClick === true ? { doubleClick: true } : {},
+			...args.button === "left" || args.button === "right" || args.button === "middle" ? { button: args.button } : {},
+			...Array.isArray(args.modifiers) ? { modifiers: args.modifiers.filter(isModifier) } : {}
+		})
+	},
+	{
+		name: "browser_hover",
+		description: "Hover over an element.",
+		properties: { ...TARGET_FIELDS },
+		build: async (args) => ({
+			kind: "hover",
+			target: string(args.target),
+			...optionalString(args, "element")
+		})
+	},
+	{
+		name: "browser_select_option",
+		description: "Choose options on a list element. This does not submit.",
+		properties: {
+			...TARGET_FIELDS,
+			values: {
+				type: "array",
+				required: true,
+				description: "Option values copied from the control. At least one.",
+				items: { type: "string" }
+			}
+		},
+		build: async (args) => ({
+			kind: "select_option",
+			target: string(args.target),
+			values: stringList$1(args.values),
+			...optionalString(args, "element")
+		})
+	},
+	{
+		name: "browser_drag",
+		description: "Drag from one element to another.",
+		properties: {
+			startTarget: {
+				type: "string",
+				required: true,
+				description: TARGET
+			},
+			startElement: {
+				type: "string",
+				description: ELEMENT
+			},
+			endTarget: {
+				type: "string",
+				required: true,
+				description: TARGET
+			},
+			endElement: {
+				type: "string",
+				description: ELEMENT
+			}
+		},
+		build: async (args) => ({
+			kind: "drag",
+			startTarget: string(args.startTarget),
+			endTarget: string(args.endTarget),
+			...optional("startElement", args.startElement),
+			...optional("endElement", args.endElement)
+		})
+	},
+	{
+		name: "browser_type",
+		description: "Type into an element. submit presses Enter afterwards; otherwise this does not submit. Do not type into a login form or a form that issues credentials; call browser_handover.",
+		properties: {
+			...TARGET_FIELDS,
+			text: {
+				type: "string",
+				required: true,
+				description: "Text to type into the element."
+			},
+			submit: {
+				type: "boolean",
+				description: "Press Enter after typing."
+			},
+			slowly: {
+				type: "boolean",
+				description: "Type one character at a time. Otherwise the whole text is filled at once."
+			}
+		},
+		build: async (args) => ({
+			kind: "type",
+			target: string(args.target),
+			text: string(args.text),
+			...optionalString(args, "element"),
+			...args.submit === true ? { submit: true } : {},
+			...args.slowly === true ? { slowly: true } : {}
+		})
+	},
+	{
+		name: "browser_fill_form",
+		description: "Fill fields. This does not submit. Do not fill a login form or a form that issues credentials; call browser_handover.",
+		properties: { fields: {
+			type: "array",
+			required: true,
+			description: "Fields to write in one step. At least one. This does not submit.",
+			items: {
+				type: "object",
+				additionalProperties: false,
+				properties: {
+					...TARGET_FIELDS,
+					name: {
+						type: "string",
+						required: true,
+						description: "Field name, for the person reading the log."
+					},
+					type: {
+						type: "string",
+						required: true,
+						enum: [
+							"textbox",
+							"checkbox",
+							"radio",
+							"combobox",
+							"slider"
+						],
+						description: "textbox, checkbox, radio, combobox, or slider."
+					},
+					value: {
+						type: "string",
+						required: true,
+						description: "Text to write. A checkbox or radio is 'true' or 'false'. A combobox is the option text."
+					}
+				}
+			}
+		} },
+		build: async (args) => ({
+			kind: "fill_form",
+			fields: fieldsOf(args.fields)
+		})
+	},
+	{
+		name: "browser_press_key",
+		description: "Press a key on this tab. Enter returns a snapshot; any other key returns a sentence.",
+		properties: { key: {
+			type: "string",
+			required: true,
+			description: "Key name, such as Enter or ArrowDown, or one character."
+		} },
+		build: async (args) => ({
+			kind: "press_key",
+			key: string(args.key)
+		})
+	},
+	{
+		name: "browser_file_upload",
+		description: "Give files to the open file chooser. Omit paths to cancel it.",
+		properties: { paths: {
+			type: "array",
+			description: "Attachment references from this session, or paths inside the workspace. Omit it to cancel the chooser.",
+			items: { type: "string" }
+		} },
+		build: async (args, ctx, reader, session) => {
+			const values = Array.isArray(args.paths) ? args.paths : void 0;
+			const paths = values === void 0 ? void 0 : await uploadPaths(ctx, reader.attachments(session.session), session.cwd, values);
+			return {
+				kind: "file_upload",
+				...paths === void 0 ? {} : { paths }
+			};
+		}
+	},
+	{
+		name: "browser_handle_dialog",
+		description: "Accept or dismiss the dialog open on this tab.",
+		properties: {
+			accept: {
+				type: "boolean",
+				required: true,
+				description: "True accepts. False dismisses."
+			},
+			promptText: {
+				type: "string",
+				description: "Text to enter when accepting a prompt."
+			}
+		},
+		build: async (args) => ({
+			kind: "handle_dialog",
+			accept: args.accept === true,
+			...typeof args.promptText === "string" ? { promptText: args.promptText } : {}
+		})
+	},
+	{
+		name: "browser_navigate_back",
+		description: "Go back one step in this tab's history.",
+		properties: {},
+		build: async () => ({ kind: "navigate_back" })
+	},
+	{
+		name: "browser_wait_for",
+		description: "Wait for text to appear or disappear, or for a number of seconds, then return the snapshot.",
+		properties: {
+			text: {
+				type: "string",
+				description: "Text to wait for. The snapshot is returned even if it never appears."
+			},
+			textGone: {
+				type: "string",
+				description: "Text to wait until it disappears. With text set too, the first one wins."
+			},
+			time: {
+				type: "number",
+				description: "Seconds to wait, or the limit for text and textGone. Capped at 30. Default 30."
+			}
+		},
+		build: async (args) => ({
+			kind: "wait_for",
+			...typeof args.text === "string" ? { text: args.text } : {},
+			...typeof args.textGone === "string" ? { textGone: args.textGone } : {},
+			...typeof args.time === "number" ? { time: args.time } : {}
+		})
+	},
+	{
+		name: "browser_snapshot",
+		description: "Return this tab's aria snapshot. A page that also has an Agent View still returns the snapshot; the agent-view attribute says one is available, and its text is not included.",
+		properties: {
+			target: {
+				type: "string",
+				description: "Limit the snapshot to this ref or selector."
+			},
+			depth: {
+				type: "number",
+				description: "Limit how deep the snapshot tree goes."
+			},
+			boxes: {
+				type: "boolean",
+				description: "Include each element's box."
+			},
+			filename: {
+				type: "string",
+				description: FILENAME
+			}
+		},
+		filename: true,
+		build: async (args) => ({
+			kind: "snapshot",
+			...typeof args.target === "string" ? { target: args.target } : {},
+			...typeof args.depth === "number" ? { depth: args.depth } : {},
+			...args.boxes === true ? { boxes: true } : {}
+		})
+	},
+	{
+		name: "browser_find",
+		description: "Search this tab's snapshot and return the matching lines with a little context.",
+		properties: {
+			text: {
+				type: "string",
+				description: "Plain text to find. Case-insensitive. Give text or regex, not both."
+			},
+			regex: {
+				type: "string",
+				description: "Regular expression to find. Wrap it in slashes to add flags, such as /error/i."
+			},
+			maxResults: {
+				type: "number",
+				description: "Maximum number of matches to return. A positive integer."
+			},
+			filename: {
+				type: "string",
+				description: FILENAME
+			}
+		},
+		filename: true,
+		build: async (args) => ({
+			kind: "find",
+			...typeof args.text === "string" ? { text: args.text } : {},
+			...typeof args.regex === "string" ? { regex: args.regex } : {},
+			...typeof args.maxResults === "number" ? { maxResults: args.maxResults } : {}
+		})
+	},
+	{
+		name: "browser_take_screenshot",
+		description: "Take a screenshot of this tab. Use browser_snapshot to read the page and get refs.",
+		properties: {
+			element: {
+				type: "string",
+				description: ELEMENT
+			},
+			target: {
+				type: "string",
+				description: "Screenshot this ref or selector instead of the viewport."
+			},
+			type: {
+				type: "string",
+				enum: [
+					"png",
+					"jpeg",
+					"webp"
+				],
+				description: "Image format. Defaults to png."
+			},
+			fullPage: {
+				type: "boolean",
+				description: "Capture the full scrollable page. Not with a target."
+			},
+			scale: {
+				type: "string",
+				enum: ["css", "device"],
+				description: "css sizes the image in CSS pixels. device uses device pixels. Defaults to css."
+			},
+			filename: {
+				type: "string",
+				description: FILENAME
+			}
+		},
+		filename: true,
+		image: true,
+		build: async (args) => ({
+			kind: "take_screenshot",
+			...typeof args.element === "string" ? { element: args.element } : {},
+			...typeof args.target === "string" ? { target: args.target } : {},
+			...args.type === "png" || args.type === "jpeg" || args.type === "webp" ? { type: args.type } : {},
+			...args.fullPage === true ? { fullPage: true } : {},
+			...args.scale === "css" || args.scale === "device" ? { scale: args.scale } : {}
+		})
+	},
+	{
+		name: "browser_evaluate",
+		description: "Run a function in this tab's page, with the page's login. Write requests made while it runs are listed after the return value.",
+		properties: {
+			element: {
+				type: "string",
+				description: ELEMENT
+			},
+			target: {
+				type: "string",
+				description: "Pass this ref or selector as the function's element argument."
+			},
+			function: {
+				type: "string",
+				required: true,
+				description: "A function, () => { ... } or (element) => { ... } when target is set."
+			},
+			filename: {
+				type: "string",
+				description: FILENAME
+			}
+		},
+		filename: true,
+		build: async (args, _ctx, _reader, _session, exec) => ({
+			kind: "evaluate",
+			function: string(args.function),
+			callId: callIdOf(exec),
+			...typeof args.element === "string" ? { element: args.element } : {},
+			...typeof args.target === "string" ? { target: args.target } : {}
+		})
+	}
+];
+function pageOperationTools(ctx) {
+	const reader = logReader(ctx);
+	return OPS.map((spec) => defineOperation(ctx, reader, spec));
+}
+function defineOperation(ctx, reader, spec) {
+	return defineTool({
+		name: spec.name,
+		description: spec.description,
+		parameters: {
+			tab: {
+				type: "string",
+				description: TAB$1
+			},
+			...spec.properties
+		},
+		output: OUTPUT,
+		isConcurrencySafe: () => false,
+		timeoutMs: 6e4,
+		presentCall: (args) => ({
+			card: "generic",
+			kind: "other",
+			title: `${spec.name} ${typeof args.tab === "string" ? args.tab : ""}`.trim()
+		}),
+		presentResult: (args) => ({
+			card: "generic",
+			title: `${spec.name} ${typeof args.tab === "string" ? args.tab : ""}`.trim()
+		}),
+		async execute(args, exec) {
+			const session = sessionFor(ctx, exec);
+			const target = writeTarget(ctx, session);
+			ctx.mhBrowser.noteWorkspace(session.id, target);
+			const input = args;
+			const filename = spec.filename === true && typeof input.filename === "string" ? input.filename : void 0;
+			if (filename !== void 0) await assertInside(target, filename);
+			try {
+				const tab = tabOf(reader, session, args.tab);
+				const op = await spec.build(input, ctx, reader, session, exec);
+				const view = await ctx.mhBrowser.act(session.id, tab, op, exec.signal);
+				const saved = filename === void 0 ? void 0 : await saveResult(target, filename, view);
+				if (saved !== void 0) {
+					view.summary = `${saved.path}\n${String(saved.bytes)} bytes`;
+					if (view.writes === void 0) delete view.detail;
+					delete view.shot;
+				}
+				const image = spec.image === true && filename === void 0 && view.shot !== void 0 ? await saveShot(ctx, view) : void 0;
+				const block = tabBlock(ctx, reader, session);
+				return {
+					text: `${renderOutcome([view], image?.attachmentId)}${block.suffix}`,
+					meta: JSON.parse(JSON.stringify({
+						...readingsOf([view], spec.name.slice(8)),
+						...view.writes === void 0 ? {} : { writes: view.writes },
+						closed: block.closed,
+						...block.snap === void 0 ? {} : { tabs: block.snap }
+					})),
+					...image === void 0 ? {} : { image: imageValue(image) }
+				};
+			} catch (error) {
+				if (error instanceof MhBrowserError && error.code === "UNKNOWN_TAB") {
+					const block = tabBlock(ctx, reader, session);
+					rethrow(new MhBrowserError(UNKNOWN_TAB, `${UNKNOWN_TAB_REASON} ${typeof args.tab === "string" ? args.tab : ""}`.trim()), `${renderOutcome([])}${block.suffix}`);
+				}
+				if (error instanceof MhBrowserError && (error.code === "STALE_REF" || error.code === "TAKEN_OVER" || error.code === "MODAL_STATE" || error.code === "PERSON_IN_CONTROL") && error.page !== void 0) {
+					const block = tabBlock(ctx, reader, session);
+					rethrow(error, `${renderOutcome([error.page])}${block.suffix}`);
+				}
+				rethrow(error);
+			}
+		}
+	});
+}
+/** Probe the path before the action, then write the result the model would have been shown. */
+async function saveResult(target, filename, view) {
+	return writeInside(target, filename, view.shot?.bytes ?? textOf$1(view));
+}
+function textOf$1(view) {
+	if (view.summary !== void 0 && view.summary !== "") return view.detail === void 0 || view.detail === "" ? view.summary : `${view.summary}\n${view.detail}`;
+	return view.representation.text;
+}
+function tabOf(reader, session, tab) {
+	if (typeof tab === "string" && tab !== "") return tab;
+	const last = reader.tabs(session.session).lastTab;
+	if (last === void 0) throw new BrowserToolError("INVALID_ARGS", "tab: give a tab, or open the page with snapshot first");
+	return last;
+}
+function string(value) {
+	return typeof value === "string" ? value : "";
+}
+function stringList$1(value) {
+	return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+}
+function optionalString(args, key) {
+	return typeof args[key] === "string" ? { element: args[key] } : {};
+}
+function optional(key, value) {
+	return typeof value === "string" ? { [key]: value } : {};
+}
+function fieldsOf(value) {
+	if (!Array.isArray(value)) return [];
+	return value.flatMap((item) => {
+		if (item === null || typeof item !== "object") return [];
+		const row = item;
+		const type = row.type;
+		if (type !== "textbox" && type !== "checkbox" && type !== "radio" && type !== "combobox" && type !== "slider") return [];
+		return [{
+			target: string(row.target),
+			...typeof row.element === "string" ? { element: row.element } : {},
+			name: string(row.name),
+			type,
+			value: string(row.value)
+		}];
+	});
+}
+function callIdOf(exec) {
+	return String(exec.callId);
+}
+function imageValue(ref) {
+	return {
+		attachmentId: ref.attachmentId,
+		mediaType: ref.mediaType,
+		bytes: ref.bytes,
+		width: ref.width,
+		height: ref.height,
+		...ref.name === void 0 ? {} : { name: ref.name },
+		...ref.originalDimensions === void 0 ? {} : { originalDimensions: { ...ref.originalDimensions } }
+	};
+}
+function imageRef(value) {
+	return {
+		attachmentId: value.attachmentId,
+		mediaType: value.mediaType,
+		bytes: value.bytes,
+		width: value.width,
+		height: value.height,
+		...value.name === void 0 ? {} : { name: value.name },
+		...value.originalDimensions === void 0 ? {} : { originalDimensions: { ...value.originalDimensions } }
+	};
+}
+async function saveShot(ctx, view) {
+	const shot = view.shot;
+	if (shot === void 0) return void 0;
+	try {
+		return await ctx.attachments.saveImage({
+			data: shot.bytes,
+			mediaType: shot.mediaType,
+			name: `${view.tab ?? "page"}.${shot.mediaType.slice(6)}`
+		});
+	} catch (error) {
+		ctx.logger.warn("saving the screenshot failed: %o", error);
+		return;
+	}
+}
+function isModifier(value) {
+	return value === "Alt" || value === "Control" || value === "ControlOrMeta" || value === "Meta" || value === "Shift";
+}
+//#endregion
+//#region lib/types/presence/notice.js
+/** The sentence a session sees after the person hands the browser back. */
+function takeoverText(taken) {
+	const tabs = taken.tabs.length === 0 ? "none" : taken.tabs.join(", ");
+	return [
+		"<system-reminder>",
+		`The person took over the browser and handed it back (${String(taken.operations)} operations, ${taken.from}–${taken.to}). Tabs that may have changed: ${tabs}. Look at them again before acting on them.`,
+		"</system-reminder>"
+	].join("\n");
+}
+//#endregion
+//#region lib/types/presence/register.js
+const BROWSER_TOOLS = /* @__PURE__ */ new Set([
+	"browser_open",
 	"browser_invoke",
-	"browser_presence"
+	"browser_presence",
+	...PAGE_OPERATION_NAMES
 ]);
 /**
 * Track browser touches, check the pages they named after the step, and merge
@@ -1266,13 +2202,7 @@ function touchedUrls(service, exec, result) {
 		const args = record(exec.arguments);
 		return [...stringList(args.put), ...stringList(args.remove)].map(canonical$1);
 	}
-	if (result.isError) {
-		if (exec.name !== "browser_invoke" || errorCode(result) !== "STALE_VIEW") return [];
-		const page = record(exec.arguments).page;
-		if (typeof page !== "string") return [];
-		const key = canonical$1(page);
-		return known.has(key) ? [key] : [];
-	}
+	if (result.isError) return [];
 	const value = result.value;
 	const pages = record(record(value).meta).pages;
 	if (!Array.isArray(pages)) return [];
@@ -1283,11 +2213,6 @@ function touchedUrls(service, exec, result) {
 		return known.has(key) ? [key] : [];
 	});
 }
-function errorCode(result) {
-	if (!result.isError) return void 0;
-	const code = record(record(record(result).error).info).code;
-	return typeof code === "string" ? code : void 0;
-}
 function stringList(value) {
 	if (!Array.isArray(value)) return [];
 	return value.filter((item) => typeof item === "string" && item !== "");
@@ -1439,183 +2364,6 @@ var PresenceBook = class {
 	}
 };
 //#endregion
-//#region lib/types/render/envelope.js
-const CLOSERS = new RegExp(`<\\s*/\\s*(${[
-	"system-reminder",
-	"page",
-	"page-error",
-	"added",
-	"changed",
-	"removed",
-	"absent",
-	"action-response",
-	"tabs",
-	"dialog",
-	"download",
-	"download-error"
-].join("|")})(?![\\w-])`, "gi");
-/**
-* Escape a closer a site could use to end a frame the service opened. Only
-* its opening `</name` is rewritten, so a closer cut off before `>` is caught
-* and no site text is dropped.
-*/
-function escapeBody(text) {
-	return text.replace(CLOSERS, (_match, tag) => `<\\/${tag.toLowerCase()}`);
-}
-/** Escape text the service writes into an attribute. */
-function escapeAttr(text) {
-	return text.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/\r/g, "&#13;").replace(/\n/g, "&#10;").replace(/\t/g, "&#9;");
-}
-/** Site text that must stay on one line, such as a title in `<tabs>`. */
-function oneLine(text) {
-	return text.replace(/[\u0000-\u001f\u007f\u2028\u2029]+/g, " ");
-}
-function incompleteText(incomplete) {
-	const pending = `${String(incomplete.pendingRequests)} requests pending`;
-	return incomplete.load ? pending : `load not fired; ${pending}`;
-}
-function waitedText(waited) {
-	const seconds = formatSeconds(waited.seconds);
-	if (waited.met === "text") return `text appeared after ${seconds} s`;
-	if (waited.met === "textGone") return `text gone after ${seconds} s`;
-	if (waited.met === "time") return `waited ${seconds} s`;
-	return `not met after ${seconds} s`;
-}
-/**
-* `withDigest` is for a page attached to a tool error: an error result has no
-* meta, so the digest in the header is what records the delivery.
-*/
-function renderPage(view, screenshot, omitBody = false, withDigest = false) {
-	const body = omitBody ? "Content follows in the next presence reminder." : pageBody(view);
-	const dialog = view.dialog === void 0 ? "" : `\n${renderDialog(view.dialog.type, view.dialog.message)}`;
-	const digest = withDigest && !omitBody ? digestOf$1(view) : void 0;
-	const digestAttr = digest === void 0 ? "" : attr$1("digest", digest);
-	return `<page${pageAttrs(view, screenshot)}${digestAttr}>${escapeBody(body)}${dialog}</page>`;
-}
-function renderActionResponse(response) {
-	const body = response.lost ? "No response arrived after sending; the action may have taken effect." : response.body !== void 0 ? response.body : response.bytes !== void 0 ? `${response.mediaType ?? "application/octet-stream"} (${String(response.bytes)} bytes)` : "";
-	return `<action-response${attr$1("name", response.name)}${response.lost === true ? attr$1("lost", "true") : ""}${response.status === void 0 ? "" : attr$1("status", String(response.status))}${response.location === void 0 ? "" : attr$1("location", response.location)}>${escapeBody(body)}</action-response>`;
-}
-function renderPageError(error) {
-	const tab = error.tab === void 0 ? "" : attr$1("tab", error.tab);
-	return `<page-error${attr$1("url", error.url)}${tab}${attr$1("reason", error.reason)}></page-error>`;
-}
-function renderTabs(tabs, closed) {
-	const lines = tabs.map((tab) => {
-		const title = tab.title === "" ? "" : ` — ${oneLine(tab.title)}`;
-		const flags = [
-			tab.inPresence ? "in presence" : "",
-			tab.mayHaveChanged ? "may have changed" : "",
-			tab.occupied ? "in use" : ""
-		].filter((flag) => flag !== "");
-		const suffix = flags.length === 0 ? "" : ` ${flags.join(", ")}`;
-		return `${tab.tab} ${oneLine(tab.url)}${title}${suffix}`;
-	});
-	const closedLines = closed.map((note) => `closed: ${note}`);
-	return `<tabs>\n${escapeBody([...lines, ...closedLines].join("\n"))}\n</tabs>`;
-}
-function renderDialog(type, message) {
-	return `<dialog${attr$1("type", type)}>${escapeBody(message)}</dialog>`;
-}
-function renderDownload(download) {
-	if (download.kind === "error") {
-		const status = download.status === void 0 ? "" : attr$1("status", String(download.status));
-		return `<download-error${attr$1("url", download.url)}${status}${attr$1("reason", download.reason)}></download-error>`;
-	}
-	const media = download.mediaType === void 0 ? "" : attr$1("media-type", download.mediaType);
-	return `<download${attr$1("path", download.path)}${attr$1("url", download.url)}${media}${attr$1("bytes", String(download.bytes))}${attr$1("sha256", download.sha256)}${attr$1("observed", download.observed)}></download>`;
-}
-/**
-* `omitInPresence`: the page's body is the same one presence carries, so a
-* page in presence gets only its attributes.
-*/
-function renderOutcome(pages, tabs, closed, screenshot, omitInPresence = false) {
-	return `${pages.map((page) => {
-		const main = "representation" in page ? renderPage(page, screenshot, omitInPresence && page.inPresence) : renderPageError(page);
-		if (!("representation" in page) || page.download === void 0) return main;
-		return `${main}\n${renderDownload(page.download)}`;
-	}).join("\n")}\n${renderTabs(tabs, closed)}`;
-}
-/** Reading fields persisted in tool meta. `by` marks the result as this plugin's. */
-function readingsOf(pages, action) {
-	return {
-		by: "mh-browser",
-		action,
-		pages: pages.map((page) => {
-			if (!("representation" in page)) return {
-				url: page.url,
-				...page.tab === void 0 ? {} : { tab: page.tab },
-				representation: "snapshot",
-				reason: page.reason
-			};
-			const version = versionOf$1(page);
-			const digest = digestOf$1(page);
-			const id = idOf(page);
-			return {
-				url: page.url,
-				tab: page.tab,
-				representation: page.representation.kind,
-				...version === void 0 ? {} : { version },
-				...digest === void 0 ? {} : { digest },
-				...id === void 0 ? {} : { id },
-				...page.incomplete === void 0 ? {} : { incomplete: incompleteText(page.incomplete) }
-			};
-		})
-	};
-}
-function pageAttrs(view, screenshot) {
-	const representation = view.representation;
-	const version = versionOf$1(view);
-	const agentView = representation.kind === "snapshot" && representation.agentView !== void 0 ? attr$1("agent-view", "available") : "";
-	return [
-		attr$1("url", view.url),
-		attr$1("tab", view.tab),
-		attr$1("representation", representation.kind),
-		version === void 0 ? "" : attr$1("version", version),
-		attr$1("observed", view.observedAt),
-		view.fragment === void 0 ? "" : attr$1("fragment", view.fragment),
-		view.status === void 0 ? "" : attr$1("status", String(view.status)),
-		view.mediaType === void 0 ? "" : attr$1("media-type", view.mediaType),
-		view.incomplete === void 0 ? "" : attr$1("incomplete", incompleteText(view.incomplete)),
-		view.waited === void 0 ? "" : attr$1("waited", waitedText(view.waited)),
-		view.inPresence ? attr$1("in-presence", "true") : "",
-		agentView,
-		representation.kind === "snapshot" && representation.agentViewError !== void 0 ? attr$1("agent-view-error", representation.agentViewError) : "",
-		screenshot === void 0 ? "" : attr$1("screenshot", screenshot)
-	].join("");
-}
-const BODY_LIMIT = 2e5;
-function pageBody(view) {
-	const representation = view.representation;
-	if (view.mediaType === void 0 || representation.kind !== "snapshot") return representation.text;
-	if (view.body !== void 0) {
-		if (view.body.length <= BODY_LIMIT) return view.body;
-		return `${view.body.slice(0, BODY_LIMIT)}\nCut at ${String(BODY_LIMIT)} characters; use browser_download to save the whole file into the workspace.`;
-	}
-	if (view.status !== void 0) return `The site answered HTTP ${String(view.status)}; the ${view.mediaType} body is not shown.`;
-	return "Not an HTML page; use browser_download to save it into the workspace.";
-}
-function versionOf$1(view) {
-	const representation = view.representation;
-	if (representation.kind === "agent-view") return representation.version;
-	return representation.agentView?.version;
-}
-function digestOf$1(view) {
-	if (view.representation.kind !== "agent-view") return void 0;
-	return representationDigest(view.representation.text);
-}
-function idOf(view) {
-	if (view.representation.kind !== "agent-view") return void 0;
-	return agentViewId(view.representation.text, view.url);
-}
-function attr$1(name, value) {
-	return ` ${name}="${escapeAttr(value)}"`;
-}
-function formatSeconds(seconds) {
-	const rounded = Math.round(seconds * 10) / 10;
-	return Number.isInteger(rounded) ? String(rounded) : rounded.toFixed(1);
-}
-//#endregion
 //#region lib/types/presence/plan.js
 const SOURCE_ORDER = [
 	"person via sidebar",
@@ -2083,10 +2831,14 @@ async function loadShown(input) {
 		base.mediaType = input.main.mediaType;
 		if (isTextual(input.main.mediaType)) base.body = input.main.body;
 	}
-	if (input.main !== void 0 && isAgentViewContentType(input.main.mediaType, input.main.body) && samePage(input.main.finalUrl, input.pageUrl)) return fromDocument({
-		...base,
-		href: input.pageUrl
-	}, input.main.body, input.pageUrl);
+	if (input.main !== void 0 && isAgentViewContentType(input.main.mediaType, input.main.body) && samePage(input.main.finalUrl, input.pageUrl)) {
+		const shown = fromDocument({
+			...base,
+			href: input.pageUrl
+		}, input.main.body, input.pageUrl);
+		if (input.main.etag !== void 0) shown.etag = input.main.etag;
+		return shown;
+	}
 	if (input.relocate) {
 		const html = await input.fetch(input.pageUrl, "text/html");
 		if (html.kind === "error") return failed(base, html.reason);
@@ -2225,27 +2977,43 @@ async function launchBrowser(options) {
 //#endregion
 //#region lib/types/service/control.js
 /**
-* Who holds the browser for one session. Person input outside a service
-* dispatch moves it to the person and aborts the action still waiting.
-* A model handover keeps the hold until hand-back or a stopped call.
+* Who holds each tab of one session. Person input outside a service dispatch
+* moves that tab to the person and aborts the action still waiting on it.
+* A handover that names no tab holds every tab until hand-back.
 */
 var Control = class {
 	who = /* @__PURE__ */ new Map();
 	holding = /* @__PURE__ */ new Set();
+	/** A handover that named no tab: every tab of the session is the person's. */
+	blanket = /* @__PURE__ */ new Set();
 	inflight = /* @__PURE__ */ new Map();
 	operations = /* @__PURE__ */ new Map();
 	tabs = /* @__PURE__ */ new Map();
 	since = /* @__PURE__ */ new Map();
 	named = /* @__PURE__ */ new Map();
+	/** Whether the person holds any tab, or a handover is waiting. */
 	of(owner) {
 		return this.who.get(owner) ?? "model";
 	}
-	/** Abort this session's waiting action when the caller aborts or the person takes over. */
-	link(owner, caller) {
+	/** The person holds this tab until they hand it back. */
+	ofTab(owner, tab) {
+		if (this.blanket.has(owner)) return "person";
+		if (this.tabs.get(owner)?.has(tab) === true) return "person";
+		return "model";
+	}
+	/**
+	* Abort this waiting action when the caller aborts, or when the person
+	* takes the tab it is running on. A call with no tab (the request channel)
+	* ends only when its caller aborts.
+	*/
+	link(owner, caller, tab) {
 		const ctrl = new AbortController();
-		const set = this.inflight.get(owner) ?? /* @__PURE__ */ new Set();
+		const byTab = this.inflight.get(owner) ?? /* @__PURE__ */ new Map();
+		const key = tab ?? "";
+		const set = byTab.get(key) ?? /* @__PURE__ */ new Set();
 		set.add(ctrl);
-		this.inflight.set(owner, set);
+		byTab.set(key, set);
+		this.inflight.set(owner, byTab);
 		const onCaller = () => ctrl.abort();
 		if (caller?.aborted === true) ctrl.abort();
 		else caller?.addEventListener("abort", onCaller, { once: true });
@@ -2272,7 +3040,7 @@ var Control = class {
 		}
 		this.operations.set(owner, (this.operations.get(owner) ?? 0) + 1);
 		if (tab !== void 0) this.tabs.get(owner)?.add(tab);
-		for (const ctrl of this.inflight.get(owner) ?? []) ctrl.abort();
+		this.abort(owner, tab);
 	}
 	/** A handover is waiting for the person to hand the browser back. */
 	holds(owner) {
@@ -2285,8 +3053,12 @@ var Control = class {
 	/** The model hands the browser to the person and waits for the card. */
 	handover(owner, tab) {
 		this.holding.add(owner);
-		if (tab !== void 0) this.named.set(owner, tab);
-		if (this.who.get(owner) === "person") return;
+		if (tab === void 0) this.blanket.add(owner);
+		else this.named.set(owner, tab);
+		if (this.who.get(owner) === "person") {
+			if (tab !== void 0) this.tabs.get(owner)?.add(tab);
+			return;
+		}
 		this.who.set(owner, "person");
 		this.since.set(owner, (/* @__PURE__ */ new Date()).toISOString());
 		this.operations.set(owner, 0);
@@ -2320,13 +3092,23 @@ var Control = class {
 	}
 	/** The Session is gone. Its in-flight calls are aborted. */
 	forget(owner) {
-		for (const ctrl of this.inflight.get(owner) ?? []) ctrl.abort();
+		this.abort(owner, void 0);
 		this.inflight.delete(owner);
 		this.clear(owner);
 		this.who.delete(owner);
 	}
+	abort(owner, tab) {
+		const byTab = this.inflight.get(owner);
+		if (byTab === void 0) return;
+		if (tab === void 0) {
+			for (const set of byTab.values()) for (const ctrl of set) ctrl.abort();
+			return;
+		}
+		for (const ctrl of byTab.get(tab) ?? []) ctrl.abort();
+	}
 	clear(owner) {
 		this.holding.delete(owner);
+		this.blanket.delete(owner);
 		this.who.set(owner, "model");
 		this.operations.delete(owner);
 		this.tabs.delete(owner);
@@ -2441,75 +3223,65 @@ const KEPT_KEYWORDS = /* @__PURE__ */ new Set([
 	"default",
 	"examples"
 ]);
-async function runInvoke(host, pageUrl, call) {
-	const view = await host.idleView(pageUrl) ?? await host.open(pageUrl);
-	if (!("representation" in view)) throw new MhBrowserError("NOT_DECLARED", view.reason);
-	const action = declaredAction(view, call.name);
-	if (call.seen === "not-in-context") throw new MhBrowserError("STALE_VIEW", "not-in-context", view);
-	if (viewChanged(call.seen, view)) throw new MhBrowserError("STALE_VIEW", "changed", view);
-	const doc = readableDoc(view);
-	const origin = view.url === "" ? pageUrl : view.url;
-	const plan = planAction(doc, action, origin, call);
+async function runInvoke(host, call) {
+	const origin = call.shown.url;
+	const read = readAgentView(call.shown.text, origin);
+	if (!read.ok) throw new MhBrowserError("NOT_DECLARED", read.reason);
+	const action = read.doc.actions[call.name];
+	if (action === void 0) throw new MhBrowserError("NOT_DECLARED", `no declared action named ${call.name}`);
+	const plan = planAction(read.doc, action, origin, call);
 	if (plan.method === "GET") {
-		const landed = await host.navigate(view.tab, withQuery(plan.url, plan.query));
+		const landed = await land(host, withQuery(plan.url, plan.query));
 		return {
 			schemaRejected: plan.schemaRejected,
 			page: landed
 		};
-	}
-	const target = plan.method === "DELETE" ? withQuery(plan.url, plan.query) : plan.url;
-	const sent = await host.send(await requestOf(host, plan, target));
-	if (sent.kind === "lost") return {
-		schemaRejected: plan.schemaRejected,
-		response: {
-			name: call.name,
-			lost: true
-		},
-		page: view
-	};
-	const response = actionResponse(call.name, sent, plan.url);
-	if (response.location !== void 0 && sameOrigin(response.location, origin)) {
-		const landed = await host.navigate(view.tab, response.location);
+	}
+	const target = plan.method === "DELETE" ? withQuery(plan.url, plan.query) : plan.url;
+	const sent = await host.send(await requestOf(host, plan, target));
+	if (sent.kind === "lost") {
+		const page = header(await landAfterSend(host, origin));
 		return {
 			schemaRejected: plan.schemaRejected,
-			response,
-			page: landed
+			response: {
+				name: call.name,
+				lost: true
+			},
+			page
 		};
 	}
-	if (response.location !== void 0) return {
-		schemaRejected: plan.schemaRejected,
-		response,
-		page: view
-	};
-	const reloaded = await host.reload(pageUrl, view.tab);
+	const response = actionResponse(call.name, sent, plan.url);
+	const follows = response.location !== void 0 && sameOrigin(response.location, origin) ? response.location : origin;
 	return {
 		schemaRejected: plan.schemaRejected,
 		response,
-		page: reloaded
+		page: header(await landAfterSend(host, follows))
 	};
 }
-/**
-* A page that declares a `version` changed only when that version did: bytes
-* that are not the resource, such as links to the rest of the site, move
-* without making the model's choice stale. The site's own version precondition
-* in `request` rejects a choice made on an old version.
-*/
-function viewChanged(seen, view) {
-	const version = view.representation.kind === "agent-view" ? view.representation.version : void 0;
-	if (seen.version !== void 0 || version !== void 0) return seen.version !== version;
-	return seen.digest !== representationDigest(view.representation.text);
-}
-function declaredAction(view, name) {
-	if (view.representation.kind !== "agent-view") throw new MhBrowserError("NOT_DECLARED", (view.representation.kind === "snapshot" ? view.representation.agentViewError : void 0) ?? "this page has no readable Agent View", view);
-	const action = readableDoc(view).actions[name];
-	if (action === void 0) throw new MhBrowserError("NOT_DECLARED", `no declared action named ${name}`, view);
-	return action;
-}
-function readableDoc(view) {
-	if (view.representation.kind !== "agent-view") throw new MhBrowserError("NOT_DECLARED", "this page has no readable Agent View", view);
-	const read = readAgentView(view.representation.text, view.url);
-	if (!read.ok) throw new MhBrowserError("NOT_DECLARED", read.reason, view);
-	return read.doc;
+/** The request already went out, so a failed landing is reported on the page and the response is kept. */
+async function landAfterSend(host, url) {
+	try {
+		return await land(host, url);
+	} catch (error) {
+		return {
+			url,
+			reason: error instanceof Error ? error.message : String(error)
+		};
+	}
+}
+/** Open the address, then reload any other idle tab still showing it. */
+async function land(host, url) {
+	const page = await host.open(url);
+	await host.refreshIdle(url, "tab" in page ? page.tab : void 0);
+	return page;
+}
+/** A non-GET action shows the landing page's header and does not deliver it. */
+function header(page) {
+	if (!("representation" in page)) return page;
+	return {
+		...page,
+		headerOnly: true
+	};
 }
 function planAction(doc, action, pageUrl, call) {
 	const input = objectInput(call.input);
@@ -2731,84 +3503,386 @@ function isRecord(value) {
 }
 //#endregion
 //#region lib/types/service/actions.js
-/** Run one snapshot action. Dialog, wait, and look are handled by the service. */
-async function runAction(page, action, signal) {
+const REF = /^(?:f\d+)?e\d+$/;
+const TIMEOUT = 1e4;
+/** A page operation returns a snapshot after it. The rest return one sentence. */
+function showsSnapshot(op) {
+	if (op.kind === "press_key") return op.key === "Enter";
+	if (op.kind === "type") return op.slowly === true || op.submit === true;
+	return op.kind === "click" || op.kind === "hover" || op.kind === "drag" || op.kind === "select_option" || op.kind === "file_upload" || op.kind === "navigate_back" || op.kind === "wait_for" || op.kind === "snapshot" || op.kind === "take_screenshot";
+}
+/** The sentence for an operation whose result has no snapshot. */
+function summaryOf(op) {
+	if (op.kind === "fill_form") return `Filled ${String(op.fields.length)} fields.`;
+	if (op.kind === "type") return `Typed into ${op.element ?? op.target}.`;
+	if (op.kind === "press_key") return `Pressed ${op.key}.`;
+	if (op.kind === "handle_dialog") return op.accept ? "Dialog accepted." : "Dialog dismissed.";
+}
+/** Run one snapshot action. Dialog, wait, upload, find, and evaluate are handled by the service. */
+async function runAction(page, op, snapshot, signal) {
 	let navigated = false;
 	const onNav = (frame) => {
 		if (frame.parentFrame() === null) navigated = true;
 	};
 	page.on("framenavigated", onNav);
 	try {
-		await dispatch(page, action, signal);
+		await dispatch(page, op, snapshot, signal);
 		return navigated;
+	} catch (error) {
+		if (error instanceof MhBrowserError) throw error;
+		const message = error instanceof Error ? error.message : String(error);
+		const first = message.split("\n")[0] ?? message;
+		if (first.includes("strict mode violation")) throw new MhBrowserError("INVALID_ARGS", first);
+		throw error;
 	} finally {
 		page.off("framenavigated", onNav);
 	}
 }
-async function dispatch(page, action, signal) {
+async function locate(page, target, snapshot) {
+	if (REF.test(target)) {
+		if (!snapshot.includes(`[ref=${target}]`)) throw new MhBrowserError("STALE_REF", `Ref ${target} not found in the current page snapshot. Try capturing new snapshot.`);
+		return page.getByRef(target);
+	}
+	const found = await page.$(target);
+	if (found === null) throw new MhBrowserError("STALE_REF", `"${target}" does not match any elements.`);
+	await found.dispose();
+	return page.locator(target);
+}
+async function dispatch(page, op, snapshot, signal) {
 	const options = signal === void 0 ? {} : { signal };
-	if (action.kind === "click") {
-		await page.getByRef(action.ref).click({
-			button: action.button ?? "left",
-			clickCount: action.double === true ? 2 : 1,
-			...action.modifiers !== void 0 ? { modifiers: action.modifiers } : {},
-			timeout: 1e4,
+	if (op.kind === "click") {
+		await (await locate(page, op.target, snapshot)).click({
+			button: op.button ?? "left",
+			clickCount: op.doubleClick === true ? 2 : 1,
+			...op.modifiers !== void 0 ? { modifiers: op.modifiers } : {},
+			timeout: TIMEOUT,
 			...options
 		});
 		return;
 	}
-	if (action.kind === "select") {
-		if (action.values.length === 0) throw new MhBrowserError("INVALID_ARGS", "select needs at least one value");
-		await page.getByRef(action.ref).selectOption(action.values, {
-			timeout: 1e4,
+	if (op.kind === "hover") {
+		await (await locate(page, op.target, snapshot)).hover({
+			timeout: TIMEOUT,
 			...options
 		});
 		return;
 	}
-	if (action.kind === "press") {
-		if (action.ref === void 0) await page.keyboard.press(action.key);
-		else await page.getByRef(action.ref).press(action.key, {
-			timeout: 1e4,
+	if (op.kind === "select_option") {
+		if (op.values.length === 0) throw new MhBrowserError("INVALID_ARGS", "select_option needs at least one value");
+		await (await locate(page, op.target, snapshot)).selectOption(op.values, {
+			timeout: TIMEOUT,
 			...options
 		});
 		return;
 	}
-	if (action.kind === "fill") {
-		if (action.fields.length === 0) throw new MhBrowserError("INVALID_ARGS", "fill needs at least one field");
-		for (const field of action.fields) {
-			const locator = page.getByRef(field.ref);
-			if (await locator.evaluate((element) => element.tagName === "INPUT" ? element.getAttribute("type") ?? "text" : "") === "checkbox") {
-				if (field.value === "true") await locator.check({
-					timeout: 1e4,
-					...options
-				});
-				else if (field.value === "false") await locator.uncheck({
-					timeout: 1e4,
+	if (op.kind === "drag") {
+		const start = await locate(page, op.startTarget, snapshot);
+		const end = await locate(page, op.endTarget, snapshot);
+		await start.dragTo(end, {
+			timeout: TIMEOUT,
+			...options
+		});
+		return;
+	}
+	if (op.kind === "type") {
+		const locator = await locate(page, op.target, snapshot);
+		if (op.slowly === true) await locator.pressSequentially(op.text, {
+			timeout: TIMEOUT,
+			...options
+		});
+		else await locator.fill(op.text, {
+			timeout: TIMEOUT,
+			...options
+		});
+		if (op.submit === true) await locator.press("Enter", {
+			timeout: TIMEOUT,
+			...options
+		});
+		return;
+	}
+	if (op.kind === "fill_form") {
+		if (op.fields.length === 0) throw new MhBrowserError("INVALID_ARGS", "fill_form needs at least one field");
+		for (const field of op.fields) {
+			const locator = await locate(page, field.target, snapshot);
+			if (field.type === "checkbox" || field.type === "radio") {
+				if (field.value !== "true" && field.value !== "false") throw new MhBrowserError("INVALID_ARGS", "a checkbox value is true or false");
+				await locator.setChecked(field.value === "true", {
+					timeout: TIMEOUT,
 					...options
 				});
-				else throw new MhBrowserError("INVALID_ARGS", "a checkbox value is true or false");
-			} else await locator.fill(field.value, {
-				timeout: 1e4,
+			} else if (field.type === "combobox") await locator.selectOption({ label: field.value }, {
+				timeout: TIMEOUT,
+				...options
+			});
+			else await locator.fill(field.value, {
+				timeout: TIMEOUT,
 				...options
 			});
 		}
 		return;
 	}
-	if (action.kind === "upload") {
-		if (action.files.length === 0) throw new MhBrowserError("INVALID_ARGS", "upload needs at least one file");
-		await page.getByRef(action.ref).setInputFiles(action.files, {
-			timeout: 1e4,
-			...options
-		});
+	if (op.kind === "press_key") {
+		await page.keyboard.press(op.key);
 		return;
 	}
-	await page.goBack({
+	if (op.kind === "navigate_back") await page.goBack({
 		waitUntil: "commit",
-		timeout: 1e4,
+		timeout: TIMEOUT,
 		...options
 	});
 }
 //#endregion
+//#region lib/types/service/evaluate.js
+/** How long requests the function started are still collected after it returns. */
+const SETTLE_MS$1 = 50;
+/**
+* Run the expression in the page and collect write requests.
+* A request is from this call when its initiator stack, including parents,
+* has a frame from the sourceURL marker. Anything else is contemporaneous.
+* GET, HEAD, and OPTIONS are not writes. A dialog, a stop, or a navigation
+* ends the wait; requests already sent are reported either way.
+*/
+async function evaluateMarked(page, source, target, callId, signal, dialog) {
+	const marker = `mh-evaluate-${callId}-${randomUUID().slice(0, 8)}`;
+	const client = await page.context().newCDPSession(page);
+	const notes = /* @__PURE__ */ new Map();
+	const onRequest = (event) => {
+		const method = event.request?.method?.toUpperCase();
+		const url = event.request?.url;
+		if (method === void 0 || url === void 0) return;
+		if (method === "GET" || method === "HEAD" || method === "OPTIONS") return;
+		const id = event.requestId ?? `${String(notes.size)}`;
+		if (notes.has(id)) return;
+		notes.set(id, {
+			method,
+			origin: originOf(url),
+			fromCall: stackHas(event.initiator?.stack, marker)
+		});
+	};
+	const writes = () => countWrites([...notes.values()]);
+	client.on("Network.requestWillBeSent", onRequest);
+	const stop = whenAborted(signal);
+	let dialogOpen = false;
+	try {
+		await client.send("Network.enable");
+		await client.send("Debugger.enable");
+		await client.send("Debugger.setSkipAllPauses", { skip: true });
+		await client.send("Debugger.setAsyncCallStackDepth", { maxDepth: 32 });
+		const evaluation = (target === void 0 ? page.evaluate(runSource, {
+			expr: source,
+			marker
+		}) : target.evaluate(runSourceOn, {
+			expr: source,
+			marker
+		})).then((raw) => ({
+			kind: "value",
+			raw
+		}), (error) => ({
+			kind: "error",
+			error
+		}));
+		const winner = await Promise.race([
+			evaluation,
+			stop.promise.then(() => ({ kind: "stopped" })),
+			dialog.then((shown) => ({
+				kind: "dialog",
+				dialog: shown
+			}))
+		]);
+		if (winner.kind === "stopped") return {
+			kind: "stopped",
+			writes: writes()
+		};
+		if (winner.kind === "dialog") {
+			dialogOpen = true;
+			return {
+				kind: "dialog",
+				dialog: winner.dialog,
+				writes: writes()
+			};
+		}
+		if (winner.kind === "error") {
+			if (!contextGone(winner.error)) throw winner.error;
+			await delay(SETTLE_MS$1);
+			return {
+				kind: "navigated",
+				writes: writes()
+			};
+		}
+		await delay(SETTLE_MS$1);
+		return {
+			kind: "value",
+			value: JSON.stringify(winner.raw, null, 2) ?? "undefined",
+			writes: writes()
+		};
+	} finally {
+		stop.dispose();
+		client.off("Network.requestWillBeSent", onRequest);
+		const detached = client.detach().catch(() => void 0);
+		if (!dialogOpen) await detached;
+	}
+}
+/** One line per group: `POST https://site × 2 (this call)`. */
+function formatWrites(writes) {
+	return writes.map((note) => `${note.method} ${note.origin} × ${String(note.count)} (${note.fromCall ? "this call" : "contemporaneous"})`).join("\n");
+}
+function countWrites(notes) {
+	const counts = /* @__PURE__ */ new Map();
+	for (const note of notes) {
+		const key = `${note.method} ${note.origin} ${note.fromCall ? "call" : "page"}`;
+		const found = counts.get(key);
+		if (found === void 0) counts.set(key, {
+			...note,
+			count: 1
+		});
+		else found.count += 1;
+	}
+	return [...counts.values()];
+}
+function whenAborted(signal) {
+	if (signal === void 0) return {
+		promise: new Promise(() => void 0),
+		dispose: () => {}
+	};
+	if (signal.aborted) return {
+		promise: Promise.resolve(),
+		dispose: () => {}
+	};
+	let onAbort = () => {};
+	return {
+		promise: new Promise((resolve) => {
+			onAbort = () => resolve();
+			signal.addEventListener("abort", onAbort, { once: true });
+		}),
+		dispose: () => signal.removeEventListener("abort", onAbort)
+	};
+}
+function contextGone(error) {
+	return (error instanceof Error ? error.message : String(error)).includes("Execution context was destroyed");
+}
+function delay(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function runSource(input) {
+	const value = eval(`(${input.expr})\n//# sourceURL=${input.marker}`);
+	return typeof value === "function" ? value() : value;
+}
+function runSourceOn(element, input) {
+	const value = eval(`(${input.expr})\n//# sourceURL=${input.marker}`);
+	return typeof value === "function" ? value(element) : value;
+}
+function stackHas(stack, marker) {
+	for (let cursor = stack; cursor !== void 0; cursor = cursor.parent) for (const frame of cursor.callFrames ?? []) if (frame.url === marker) return true;
+	return false;
+}
+function originOf(url) {
+	try {
+		return new URL(url).origin;
+	} catch {
+		return url;
+	}
+}
+//#endregion
+//#region lib/types/service/find.js
+const CONTEXT_LINES = 3;
+/** Search one snapshot. The header and the miss sentence are what the model reads. */
+function findInSnapshot(snapshot, query) {
+	if (query.text === void 0 && query.regex === void 0 || query.text !== void 0 && query.regex !== void 0) throw new MhBrowserError("INVALID_ARGS", query.text !== void 0 && query.regex !== void 0 ? "Provide only one of \"text\" or \"regex\", not both." : "Provide either \"text\" or \"regex\" to search for.");
+	if (query.maxResults !== void 0 && (!Number.isInteger(query.maxResults) || query.maxResults <= 0)) throw new MhBrowserError("INVALID_ARGS", "\"maxResults\" must be a positive integer.");
+	const matched = matcher(query.text, query.regex);
+	const lines = snapshot.split("\n");
+	const indents = lines.map(indentOf);
+	const hits = [];
+	for (let index = 0; index < lines.length; index += 1) {
+		const line = lines[index];
+		if (line !== void 0 && matched.test(line)) hits.push(index);
+	}
+	const label = matched.label;
+	if (hits.length === 0) return `No matches found for ${label}.`;
+	const shown = query.maxResults === void 0 ? hits : hits.slice(0, query.maxResults);
+	const windows = mergeWindows(shown, lines.length);
+	const onPath = /* @__PURE__ */ new Set();
+	for (const hit of shown) {
+		onPath.add(hit);
+		for (const ancestor of ancestorIndices(lines, indents, hit)) onPath.add(ancestor);
+	}
+	const snippets = windows.map((window) => {
+		const indices = ancestorIndices(lines, indents, window.start);
+		for (let index = window.start; index <= window.end; index += 1) indices.push(index);
+		const out = [];
+		for (let index = 0; index < indices.length; index += 1) {
+			const lineNo = indices[index];
+			const previous = indices[index - 1];
+			if (lineNo !== void 0 && previous !== void 0 && lineNo > previous + 1 && !onPath.has(lineNo) && !onPath.has(previous)) out.push(`${" ".repeat(indents[lineNo] ?? 0)}...`);
+			const line = lineNo === void 0 ? void 0 : lines[lineNo];
+			if (line !== void 0) out.push(line);
+		}
+		return out.join("\n");
+	});
+	return `${shown.length < hits.length ? `Found ${String(hits.length)} matches for ${label} (showing first ${String(shown.length)}):` : `Found ${String(hits.length)} matches for ${label}:`}\n\n${snippets.join("\n\n----\n\n")}`;
+}
+function matcher(text, regex) {
+	if (regex !== void 0) {
+		let pattern;
+		try {
+			pattern = compileRegex(regex);
+		} catch {
+			throw new MhBrowserError("INVALID_ARGS", "Invalid regular expression");
+		}
+		return {
+			label: String(pattern),
+			test(line) {
+				pattern.lastIndex = 0;
+				return pattern.test(line);
+			}
+		};
+	}
+	const needle = (text ?? "").toLowerCase();
+	return {
+		label: `"${text ?? ""}"`,
+		test(line) {
+			return line.toLowerCase().includes(needle);
+		}
+	};
+}
+function compileRegex(source) {
+	const literal = /^\/(.*)\/([a-z]*)$/.exec(source);
+	const pattern = literal?.[1] ?? source;
+	const flags = literal?.[2]?.replace(/g/g, "") ?? "";
+	return new RegExp(pattern, flags);
+}
+function indentOf(line) {
+	return line.length - line.trimStart().length;
+}
+function ancestorIndices(lines, indents, index) {
+	const found = [];
+	let indent = indents[index] ?? 0;
+	for (let cursor = index - 1; cursor >= 0 && indent > 0; cursor -= 1) {
+		const line = lines[cursor];
+		if (line === void 0 || line.trim() === "") continue;
+		const next = indents[cursor] ?? 0;
+		if (next < indent) {
+			found.push(cursor);
+			indent = next;
+		}
+	}
+	return found.reverse();
+}
+function mergeWindows(hits, length) {
+	const windows = [];
+	for (const hit of hits) {
+		const start = Math.max(0, hit - CONTEXT_LINES);
+		const end = Math.min(length - 1, hit + CONTEXT_LINES);
+		const last = windows[windows.length - 1];
+		if (last !== void 0 && start <= last.end + 1) last.end = Math.max(last.end, end);
+		else windows.push({
+			start,
+			end
+		});
+	}
+	return windows;
+}
+//#endregion
 //#region lib/types/service/waits.js
 const LOAD_MS = 5e3;
 const WAIT_CAP_MS = 3e4;
@@ -3309,6 +4383,7 @@ var Windows = class {
 		tab.inputHeld = false;
 		tab.mayHaveChanged = false;
 		tab.occupied = tab.dialogHeld || tab.handoverHeld;
+		tab.fileChooser = void 0;
 	}
 	markMayHaveChanged(tab) {
 		tab.mayHaveChanged = true;
@@ -3442,11 +4517,16 @@ var Windows = class {
 		await this.arm(page, owner, tab.id);
 		return tab;
 	}
-	/** Close one tab the service opened for a presence check. */
+	/**
+	* Close one tab. `note` is listed in the next `<tabs>` block. A tab the
+	* model was never shown (an Agent View discovered on a new tab) omits it.
+	*/
 	async closeTab(tab, note) {
-		const notes = this.closedNotes.get(tab.owner) ?? [];
-		notes.push(note);
-		this.closedNotes.set(tab.owner, notes);
+		if (note !== void 0) {
+			const notes = this.closedNotes.get(tab.owner) ?? [];
+			notes.push(note);
+			this.closedNotes.set(tab.owner, notes);
+		}
 		await this.closePage(tab);
 	}
 	async closeOwner(owner) {
@@ -3845,6 +4925,7 @@ function idleTab() {
 		handoverHeld: false,
 		inPresence: false,
 		mayHaveChanged: false,
+		fileChooser: void 0,
 		pendingDialog: void 0,
 		dialogWaiters: [],
 		pendingDownload: void 0,
@@ -3919,6 +5000,8 @@ const RELAUNCH_LIMIT = 3;
 const RELAUNCH_WINDOW_MS = 6e4;
 const STOP_WAIT_MS = 5e3;
 const WAITING_STOPPED = "stopped while waiting";
+const STOPPED = Symbol("stopped");
+const NAVIGATED_DURING_EVALUATE = "The page navigated before the function returned.";
 const MAY_HAVE_TAKEN_EFFECT = "taken over by the person; the action may have partly taken effect";
 const NO_WORKSPACE_REASON = "this session has no working directory";
 /**
@@ -3970,6 +5053,10 @@ let MhBrowserService = (() => {
 		workspaces = /* @__PURE__ */ new Map();
 		control = new Control();
 		personTouch = /* @__PURE__ */ new Set();
+		/** Origins that have served a readable Agent View. Memory only; a restart clears it. */
+		agentViewOrigins = /* @__PURE__ */ new Set();
+		/** The last Agent View read for a page address, so a later read can send If-None-Match. */
+		documents = /* @__PURE__ */ new Map();
 		constructor(ctx, config) {
 			super(ctx, "mhBrowser");
 			this.maxBytes = config.presence.maxBytes;
@@ -4002,28 +5089,30 @@ let MhBrowserService = (() => {
 				await this.stop();
 			});
 		}
+		/** Remember an origin whose pages offer Agent Views. A missing page does not remove it. */
+		declareAgentViewOrigin(origin) {
+			try {
+				const parsed = new URL(origin);
+				if (parsed.protocol !== "http:" && parsed.protocol !== "https:") return;
+				this.agentViewOrigins.add(parsed.origin);
+			} catch {}
+		}
 		async open(owner, items, signal) {
 			return this.exclusive(owner, async () => {
 				await this.ready;
-				this.refuseIfPerson(owner);
-				const linked = this.control.link(owner, signal);
 				const views = [];
-				try {
-					for (const item of items) {
-						if (signal?.aborted) {
-							views.push({
-								url: item.url,
-								reason: WAITING_STOPPED
-							});
-							continue;
-						}
-						views.push(await this.openOne(owner, item.url, item.waitFor, linked.signal));
+				for (const item of items) {
+					if (signal?.aborted) {
+						views.push({
+							url: item.url,
+							reason: WAITING_STOPPED
+						});
+						continue;
 					}
-					await this.enforceCap(owner);
-					return views;
-				} finally {
-					linked.release();
+					views.push(await this.openAddress(owner, item, signal));
 				}
+				await this.enforceCap(owner);
+				return views;
 			});
 		}
 		async view(owner, tab, signal) {
@@ -4137,7 +5226,8 @@ let MhBrowserService = (() => {
 				if (opts?.ifNoneMatch !== void 0) headers["if-none-match"] = opts.ifNoneMatch;
 				const response = await context.request.get(url, {
 					headers,
-					failOnStatusCode: false
+					failOnStatusCode: false,
+					...opts?.signal !== void 0 ? { signal: opts.signal } : {}
 				});
 				const headerMap = response.headers();
 				const body = {
@@ -4181,24 +5271,32 @@ let MhBrowserService = (() => {
 				page: (owner, tab) => this.windows.get(owner, tab)?.page
 			};
 		}
-		async act(owner, tab, action, signal) {
+		async act(owner, tab, op, signal) {
 			return this.exclusive(owner, async () => {
 				await this.ready;
-				this.refuseIfPerson(owner);
+				this.refuseIfPerson(owner, tab);
 				const live = this.windows.get(owner, tab);
 				if (live === void 0) throw new MhBrowserError(UNKNOWN_TAB, UNKNOWN_TAB_REASON);
 				if (signal?.aborted) throw new MhBrowserError(INTERRUPTED, WAITING_STOPPED);
-				const linked = this.control.link(owner, signal);
+				const linked = this.control.link(owner, signal, tab);
 				try {
-					if (live.dialogHeld && action.kind !== "dialog" && action.kind !== "look") throw new MhBrowserError("INVALID_ARGS", "this page has a dialog open; accept or dismiss it with dialog first", await this.blockedView(live));
-					if (missingRef(this.shown.get(live.id)?.snapshot ?? "", action) !== void 0) throw new MhBrowserError("STALE_REF", "the ref is not in this page's current snapshot", await this.pageFromShown(live, this.shown.get(live.id), { surface: "snapshot" }));
-					const outcome = await this.perform(live, action, linked.signal);
-					if (action.kind === "fill" || action.kind === "select" || action.kind === "upload") {
+					if (live.dialogHeld && op.kind !== "handle_dialog") throw new MhBrowserError("MODAL_STATE", "a dialog is open; use browser_handle_dialog", await this.blockedView(live));
+					if (live.fileChooser !== void 0 && op.kind !== "file_upload") {
+						const blocked = await this.pageFromShown(live, this.shown.get(live.id), { surface: "snapshot" });
+						blocked.dialog = {
+							type: "filechooser",
+							message: live.fileChooser.isMultiple() ? "choose files (several allowed) with browser_file_upload" : "choose one file with browser_file_upload"
+						};
+						throw new MhBrowserError("MODAL_STATE", "a file chooser is open; use browser_file_upload", blocked);
+					}
+					const outcome = await this.perform(live, op, linked.signal);
+					if (op.kind === "fill_form" || op.kind === "select_option" || op.kind === "type" || op.kind === "file_upload") {
 						if (outcome.navigated) this.windows.onNavigated(live);
 						else this.windows.holdInput(live);
 					} else if (outcome.navigated) this.windows.onNavigated(live);
 					this.windows.touch(live);
 					const shown = outcome.navigated ? await this.discover(live, live.page.url(), null) : await this.refreshSnapshot(live);
+					const scoped = op.kind === "snapshot" && (op.target !== void 0 || op.depth !== void 0 || op.boxes === true) ? await this.scopedSnapshot(live, op) : void 0;
 					this.shown.set(live.id, shown);
 					this.windows.noteUrl(live, live.page.url());
 					const view = await this.pageFromShown(live, shown, {
@@ -4207,9 +5305,23 @@ let MhBrowserService = (() => {
 						...outcome.incomplete !== void 0 ? { incomplete: outcome.incomplete } : {},
 						...outcome.waited !== void 0 ? { waited: outcome.waited } : {}
 					});
+					if (scoped !== void 0 && view.representation.kind === "snapshot") view.representation = {
+						...view.representation,
+						text: scoped
+					};
+					if (!showsSnapshot(op)) {
+						const summary = outcome.summary ?? summaryOf(op);
+						if (summary !== void 0) view.summary = summary;
+						if (outcome.detail !== void 0 && outcome.detail !== "") view.detail = outcome.detail;
+					}
+					if (op.kind === "take_screenshot") view.summary = "";
+					if (outcome.shot !== void 0) view.shot = outcome.shot;
+					if (outcome.writes !== void 0) view.writes = outcome.writes;
 					return this.attachDownload(live, view, false);
 				} catch (error) {
-					if (this.control.of(owner) === "person") throw await this.takenOver(live);
+					if (error instanceof MhBrowserError && error.code === "TAKEN_OVER") throw error;
+					if (this.control.ofTab(owner, tab) === "person") throw await this.takenOver(live);
+					if (error instanceof MhBrowserError && error.code === "STALE_REF" && error.page === void 0) throw new MhBrowserError(error.code, error.message, await this.pageFromShown(live, this.shown.get(live.id), { surface: "snapshot" }));
 					throw error;
 				} finally {
 					linked.release();
@@ -4242,50 +5354,30 @@ let MhBrowserService = (() => {
 				}
 			});
 		}
-		invoke(owner, page, call, opts) {
+		invoke(owner, _page, call, opts) {
 			return this.exclusive(owner, async () => {
 				await this.ready;
-				this.refuseIfPerson(owner);
 				if (opts?.signal?.aborted) throw new MhBrowserError(INTERRUPTED, WAITING_STOPPED);
-				const linked = this.control.link(owner, opts?.signal);
-				const signal = linked.signal;
-				try {
-					const sent = await runInvoke({
-						idleView: (url) => this.idleView(owner, url),
-						open: (url) => this.openOne(owner, url, void 0, signal),
-						navigate: (tab, url) => this.navigateOwned(owner, tab, url, signal),
-						reload: (url, tab) => this.reloadSame(owner, url, tab, signal),
-						send: (request) => this.sendAction(request, signal),
-						readFile: opts?.readFile ?? (async () => {
-							throw new MhBrowserError("NO_WORKSPACE", NO_WORKSPACE_REASON);
-						})
-					}, page, call);
-					await this.enforceCap(owner);
-					return sent;
-				} catch (error) {
-					if (this.control.of(owner) === "person") throw new MhBrowserError("TAKEN_OVER", MAY_HAVE_TAKEN_EFFECT);
-					throw error;
-				} finally {
-					linked.release();
-				}
+				const signal = opts?.signal;
+				const sent = await runInvoke({
+					open: (url) => this.openAddress(owner, { url }, signal),
+					refreshIdle: (url, except) => this.refreshIdle(owner, url, except, signal),
+					send: (request) => this.sendAction(request, signal),
+					readFile: opts?.readFile ?? (async () => {
+						throw new MhBrowserError("NO_WORKSPACE", NO_WORKSPACE_REASON);
+					})
+				}, call);
+				await this.enforceCap(owner);
+				return sent;
 			});
 		}
 		/**
 		* Not queued: it opens no tab, and a long body must not hold up the
 		* Session's other calls. `root` is the directory the session may write.
 		*/
-		async download(owner, url, root, signal) {
+		async download(_owner, url, root, signal) {
 			await this.ready;
-			this.refuseIfPerson(owner);
-			const linked = this.control.link(owner, signal);
-			try {
-				return await this.saveResponse(url, root, linked.signal);
-			} catch (error) {
-				if (this.control.of(owner) === "person") throw new MhBrowserError("TAKEN_OVER", MAY_HAVE_TAKEN_EFFECT);
-				throw error;
-			} finally {
-				linked.release();
-			}
+			return this.saveResponse(url, root, signal);
 		}
 		controlOf(owner) {
 			return this.control.of(owner);
@@ -4376,9 +5468,185 @@ let MhBrowserService = (() => {
 				urls: this.presenceUrls(owner, taken.tabs)
 			};
 		}
-		async openOne(owner, url, waitFor, signal) {
+		/**
+		* Read one address. A known origin is tried on the request channel first.
+		* A readable Agent View found on a tab this call opened is returned without
+		* the tab, and that tab is not listed as closed.
+		*/
+		async openAddress(owner, item, signal) {
+			const wantsTab = owner === "person" || item.snapshot === true || item.waitFor !== void 0;
+			if (!wantsTab && this.knownOrigin(item.url)) {
+				const via = await this.readKnown(owner, item.url, signal);
+				if (via === STOPPED) return {
+					url: item.url,
+					reason: WAITING_STOPPED
+				};
+				if (via !== void 0) return via;
+			}
+			const opened = await this.openOne(owner, item.url, item.waitFor, signal, item.snapshot === true);
+			this.keepAgentView(opened);
+			if (!wantsTab && opened.fresh && this.closable(owner, opened.live) && "representation" in opened.view && opened.view.representation.kind === "agent-view") {
+				await this.windows.closeTab(opened.live);
+				const view = { ...opened.view };
+				delete view.tab;
+				return view;
+			}
+			return opened.view;
+		}
+		/** A tab this call opened can be closed again unless the person took it or it holds input. */
+		closable(owner, live) {
+			return this.control.ofTab(owner, live.id) !== "person" && !live.occupied;
+		}
+		knownOrigin(url) {
+			try {
+				return this.agentViewOrigins.has(new URL(url).origin);
+			} catch {
+				return false;
+			}
+		}
+		rememberOrigin(url) {
+			try {
+				this.agentViewOrigins.add(new URL(url).origin);
+			} catch {}
+		}
+		/** A readable Agent View puts its origin on the list and keeps the document for the next read. */
+		keepAgentView(opened) {
+			if (!("representation" in opened.view)) return;
+			const representation = opened.view.representation;
+			if (!(representation.kind === "agent-view" || representation.kind === "snapshot" && representation.agentView !== void 0)) return;
+			this.rememberOrigin(opened.view.url);
+			const shown = this.shown.get(opened.live.id);
+			if (shown?.kind === "agent-view") this.documents.set(canonical(shown.pageUrl), shown);
+		}
+		/**
+		* Read a known origin without a tab. `undefined` means this page has to be
+		* opened in a tab: nothing declared, the declaration could not be read, or
+		* the request failed. The origin stays on the list either way. A stop
+		* ends the read without falling back to a tab.
+		*/
+		async readKnown(owner, url, signal) {
+			const key = canonical(url);
+			const previous = this.documents.get(key);
+			const servedAtPage = previous?.kind === "agent-view" && previous.href !== void 0 && canonical(previous.href) === canonical(previous.pageUrl);
+			let response;
+			try {
+				const got = await this.fetchSameOrigin(url, PAGE_ACCEPT, servedAtPage ? previous.etag : void 0, signal);
+				if (signal?.aborted === true) return STOPPED;
+				if (got === void 0) return void 0;
+				response = got;
+			} catch {
+				return signal?.aborted === true ? STOPPED : void 0;
+			}
+			if (response.status === 304 && previous?.kind === "agent-view") return this.pageOfShown(owner, previous);
+			const text = new TextDecoder().decode(response.body);
+			const pageUrl = canonical(response.finalUrl === "" ? url : response.finalUrl);
+			const cached = this.documents.get(pageUrl);
+			const shown = await loadShown({
+				pageUrl,
+				...optionalFragment(response.finalUrl === "" ? url : response.finalUrl),
+				snapshot: "",
+				main: {
+					status: response.status,
+					...response.mediaType !== void 0 ? { mediaType: response.mediaType } : {},
+					finalUrl: response.finalUrl === "" ? url : response.finalUrl,
+					...response.link !== void 0 ? { link: response.link } : {},
+					...response.etag !== void 0 ? { etag: response.etag } : {},
+					body: text
+				},
+				domLinks: linksInHtml(text, response.finalUrl === "" ? url : response.finalUrl),
+				...cached !== void 0 ? { previous: cached } : {},
+				relocate: false,
+				fetch: (target, accept, ifNoneMatch) => this.fetchForRead(target, accept, ifNoneMatch, signal)
+			});
+			if (stopped(signal)) return STOPPED;
+			if (shown.kind !== "agent-view") return void 0;
+			this.documents.set(pageUrl, shown);
+			this.rememberOrigin(pageUrl);
+			return this.pageOfShown(owner, shown);
+		}
+		/** One page from a document, with no tab. */
+		pageOfShown(owner, shown) {
+			const view = {
+				url: shown.pageUrl,
+				title: "",
+				observedAt: (/* @__PURE__ */ new Date()).toISOString(),
+				representation: shown.kind === "agent-view" ? {
+					kind: "agent-view",
+					text: shown.text,
+					...shown.version !== void 0 ? { version: shown.version } : {},
+					...shown.href !== void 0 ? { href: shown.href } : {}
+				} : {
+					kind: "snapshot",
+					text: shown.snapshot,
+					...shown.agentViewError !== void 0 ? { agentViewError: shown.agentViewError } : {}
+				},
+				inPresence: this.book.isShown(owner, canonical(shown.pageUrl))
+			};
+			if (shown.fragment !== void 0) view.fragment = shown.fragment;
+			if (shown.status !== void 0) view.status = shown.status;
+			if (shown.mediaType !== void 0) view.mediaType = shown.mediaType;
+			if (shown.body !== void 0) view.body = shown.body;
+			return view;
+		}
+		/**
+		* GET that follows same-origin redirects only. `undefined` when it cannot.
+		* A body that is neither text nor an Agent View is not read: the page then
+		* goes to a tab, which loads it anyway.
+		*/
+		async fetchSameOrigin(url, accept, ifNoneMatch, signal) {
+			const context = this.context;
+			if (context === void 0) return void 0;
+			let current = url;
+			let origin;
+			try {
+				origin = new URL(url).origin;
+			} catch {
+				return;
+			}
+			for (let hop = 0; hop < 10; hop += 1) {
+				const headers = { accept };
+				if (ifNoneMatch !== void 0 && hop === 0) headers["if-none-match"] = ifNoneMatch;
+				const response = await context.request.get(current, {
+					headers,
+					maxRedirects: 0,
+					failOnStatusCode: false,
+					...signal !== void 0 ? { signal } : {}
+				});
+				const status = response.status();
+				const location = response.headers().location;
+				if (status >= 300 && status < 400 && location !== void 0 && location !== "") {
+					let next;
+					try {
+						next = new URL(location, current);
+					} catch {
+						return;
+					}
+					if (next.origin !== origin) return void 0;
+					current = next.href;
+					continue;
+				}
+				const headerMap = response.headers();
+				const mediaType = headerMap["content-type"];
+				const body = {
+					kind: "response",
+					finalUrl: current,
+					status,
+					body: readsAsText(mediaType) ? new Uint8Array(await response.body()) : /* @__PURE__ */ new Uint8Array()
+				};
+				const etag = headerMap.etag;
+				const link = headerMap.link;
+				if (mediaType !== void 0) body.mediaType = mediaType;
+				if (etag !== void 0) body.etag = etag;
+				if (link !== void 0) body.link = link;
+				return body;
+			}
+		}
+		async openOne(owner, url, waitFor, signal, snapshot = false) {
 			assertWaitFor(waitFor);
-			const live = this.idleTabOn(owner, url) ?? await this.windows.openBlank(owner);
+			const reused = this.idleTabOn(owner, url);
+			const live = reused ?? await this.windows.openBlank(owner);
+			const fresh = reused === void 0;
+			const linked = this.control.link(owner, signal, live.id);
 			const nextDialog = this.windows.nextDialog(live);
 			try {
 				let seenDialog;
@@ -4388,7 +5656,7 @@ let MhBrowserService = (() => {
 				});
 				let navigationError;
 				let response = null;
-				const raced = this.goto(live.page, url, signal).then((value) => {
+				const raced = this.goto(live.page, url, linked.signal).then((value) => {
 					response = value;
 					return "navigated";
 				}, (error) => {
@@ -4402,14 +5670,22 @@ let MhBrowserService = (() => {
 						const view = await this.pageFromShown(live, this.shown.get(live.id));
 						if (view.url === "" || view.url === "about:blank") view.url = canonical(url);
 						this.applyDocumentType(live, view);
-						return this.attachDownload(live, view, true);
+						return {
+							view: await this.attachDownload(live, view, true),
+							fresh,
+							live
+						};
 					}
 					throw navigationError;
 				}
-				if (signal?.aborted) return {
-					tab: live.id,
-					url,
-					reason: WAITING_STOPPED
+				if (linked.signal.aborted) return {
+					view: {
+						tab: live.id,
+						url,
+						reason: WAITING_STOPPED
+					},
+					fresh,
+					live
 				};
 				const current = live.page.url();
 				const address = current === "about:blank" ? url : current;
@@ -4425,11 +5701,11 @@ let MhBrowserService = (() => {
 					load: false,
 					pendingRequests: 0,
 					dialog
-				} : await waitForLoad(live.page, signal);
+				} : await waitForLoad(live.page, linked.signal);
 				if (load.dialog !== void 0) this.windows.holdDialog(live);
 				let waited;
 				if (waitFor !== void 0 && load.dialog === void 0) {
-					const text = await waitForText(live.page, waitFor, signal);
+					const text = await waitForText(live.page, waitFor, linked.signal);
 					waited = {
 						met: text.met,
 						seconds: text.seconds
@@ -4446,6 +5722,7 @@ let MhBrowserService = (() => {
 				}) : await this.discover(live, address, response);
 				this.shown.set(live.id, shown);
 				const view = await this.pageFromShown(live, shown, {
+					...snapshot ? { surface: "snapshot" } : {},
 					...load.load ? {} : { incomplete: {
 						load: load.load,
 						pendingRequests: load.pendingRequests
@@ -4453,26 +5730,51 @@ let MhBrowserService = (() => {
 					...load.dialog !== void 0 ? { dialog: load.dialog } : {},
 					...waited !== void 0 ? { waited } : {}
 				});
-				return this.attachDownload(live, view, false);
+				return {
+					view: await this.attachDownload(live, view, false),
+					fresh,
+					live
+				};
 			} catch (error) {
 				nextDialog.cancel();
-				if (this.control.of(owner) === "person") throw await this.takenOver(live);
-				if (signal?.aborted || error instanceof MhBrowserError && error.code === "INTERRUPTED") return {
-					tab: live.id,
-					url,
-					reason: WAITING_STOPPED
+				if (this.control.ofTab(owner, live.id) === "person") throw await this.takenOver(live);
+				if (linked.signal.aborted || error instanceof MhBrowserError && error.code === "INTERRUPTED") return {
+					view: {
+						tab: live.id,
+						url,
+						reason: WAITING_STOPPED
+					},
+					fresh,
+					live
 				};
 				return {
-					tab: live.id,
-					url,
-					reason: error instanceof Error ? error.message : String(error)
+					view: {
+						tab: live.id,
+						url,
+						reason: error instanceof Error ? error.message : String(error)
+					},
+					fresh,
+					live
 				};
+			} finally {
+				linked.release();
 			}
 		}
-		async perform(live, action, signal) {
-			if (action.kind === "look") return { navigated: false };
-			if (action.kind === "wait") {
-				const waitFor = waitFrom(action);
+		async perform(live, op, signal) {
+			if (op.kind === "snapshot") return { navigated: false };
+			if (op.kind === "find") return {
+				navigated: false,
+				summary: findInSnapshot(await this.aria(live), op)
+			};
+			if (op.kind === "evaluate") {
+				const snapshot = this.shown.get(live.id)?.snapshot ?? "";
+				const target = op.target === void 0 ? void 0 : await locate(live.page, op.target, snapshot);
+				return this.evaluateOn(live, op, target, signal);
+			}
+			if (op.kind === "take_screenshot") return this.shoot(live, op, signal);
+			if (op.kind === "file_upload") return this.uploadHeld(live, op, signal);
+			if (op.kind === "wait_for") {
+				const waitFor = waitFrom(op);
 				assertWaitFor(waitFor);
 				const text = await waitForText(live.page, waitFor, signal);
 				if (text.dialog !== void 0) this.windows.holdDialog(live);
@@ -4485,11 +5787,11 @@ let MhBrowserService = (() => {
 					...text.dialog !== void 0 ? { dialog: text.dialog } : {}
 				};
 			}
-			if (action.kind === "dialog") {
+			if (op.kind === "handle_dialog") {
 				const dialog = live.pendingDialog;
 				if (dialog === void 0) throw new MhBrowserError("INVALID_ARGS", "this page has no dialog");
 				const before = live.page.url();
-				if (action.accept) await (action.promptText !== void 0 ? dialog.accept(action.promptText) : dialog.accept());
+				if (op.accept) await (op.promptText !== void 0 ? dialog.accept(op.promptText) : dialog.accept());
 				else await dialog.dismiss();
 				this.windows.clearDialog(live);
 				const navigated = live.page.url() !== before;
@@ -4501,9 +5803,10 @@ let MhBrowserService = (() => {
 			const requests = trackActionRequests(live.page);
 			const nextDialog = this.windows.nextDialog(live);
 			const chooser = watchFileChooser(live.page);
+			const snapshot = this.shown.get(live.id)?.snapshot ?? "";
 			this.windows.beginDispatch(live.page);
 			try {
-				const finished = runAction(live.page, action, signal).then((navigated) => ({
+				const finished = runAction(live.page, op, snapshot, signal).then((navigated) => ({
 					kind: "done",
 					navigated
 				}));
@@ -4511,9 +5814,9 @@ let MhBrowserService = (() => {
 					kind: "dialog",
 					dialog
 				}));
-				const chose = chooser.opened.then((multiple) => ({
+				const chose = chooser.opened.then((opened) => ({
 					kind: "chooser",
-					multiple
+					opened
 				}));
 				const winner = await Promise.race([
 					finished,
@@ -4537,13 +5840,13 @@ let MhBrowserService = (() => {
 					finished.catch(() => void 0);
 					return {
 						navigated: false,
-						dialog: this.chooserHeld(live, winner.multiple)
+						dialog: this.chooserHeld(live, winner.opened)
 					};
 				}
-				const settledLoad = await Promise.race([settleAction(live.page, winner.navigated, requests, signal), chooser.opened.then((multiple) => ({
+				const settledLoad = await Promise.race([settleAction(live.page, winner.navigated, requests, signal), chooser.opened.then((opened) => ({
 					load: true,
 					pendingRequests: 0,
-					dialog: this.chooserHeld(live, multiple)
+					dialog: this.chooserHeld(live, opened)
 				}))]);
 				return {
 					navigated: winner.navigated,
@@ -4555,12 +5858,121 @@ let MhBrowserService = (() => {
 				chooser.stop();
 			}
 		}
+		/**
+		* `browser_evaluate`. A dialog the function opens is held like any other; a
+		* stop or a takeover ends the wait and still reports the writes already sent.
+		*/
+		async evaluateOn(live, op, target, signal) {
+			const nextDialog = this.windows.nextDialog(live);
+			let navigated = false;
+			const onNav = (frame) => {
+				if (frame.parentFrame() === null) navigated = true;
+			};
+			live.page.on("framenavigated", onNav);
+			try {
+				const evaluated = await evaluateMarked(live.page, op.function, target, op.callId, signal, nextDialog.dialog);
+				const writes = formatWrites(evaluated.writes);
+				const counted = evaluated.writes.length === 0 ? {} : { writes: evaluated.writes };
+				if (evaluated.kind === "stopped") {
+					const note = writes === "" ? "" : `\n${writes}`;
+					if (this.control.ofTab(live.owner, live.id) === "person") throw await this.takenOver(live, note);
+					throw new MhBrowserError(INTERRUPTED, `${WAITING_STOPPED}${note}`);
+				}
+				if (evaluated.kind === "dialog") {
+					this.windows.holdDialog(live, evaluated.dialog);
+					return {
+						navigated: false,
+						dialog: {
+							type: evaluated.dialog.type(),
+							message: evaluated.dialog.message()
+						},
+						summary: "",
+						detail: writes,
+						...counted
+					};
+				}
+				if (evaluated.kind === "navigated") return {
+					navigated: true,
+					summary: NAVIGATED_DURING_EVALUATE,
+					detail: writes,
+					...counted
+				};
+				return {
+					navigated,
+					summary: evaluated.value,
+					detail: writes,
+					...counted
+				};
+			} finally {
+				live.page.off("framenavigated", onNav);
+				nextDialog.cancel();
+			}
+		}
+		async uploadHeld(live, op, signal) {
+			const chooser = live.fileChooser;
+			if (chooser === void 0) throw new MhBrowserError("INVALID_ARGS", "No file chooser visible");
+			const paths = op.paths;
+			if (paths === void 0 || paths.length === 0) {
+				live.fileChooser = void 0;
+				return { navigated: false };
+			}
+			const requests = trackActionRequests(live.page);
+			let navigated = false;
+			const onNav = (frame) => {
+				if (frame.parentFrame() === null) navigated = true;
+			};
+			live.page.on("framenavigated", onNav);
+			this.windows.beginDispatch(live.page);
+			try {
+				await chooser.setFiles(paths, signal === void 0 ? {} : { signal });
+				live.fileChooser = void 0;
+				await settleAction(live.page, navigated, requests, signal);
+				return { navigated };
+			} finally {
+				live.page.off("framenavigated", onNav);
+				this.windows.endDispatch(live.page);
+				requests.stop();
+			}
+		}
+		async shoot(live, op, signal) {
+			if (op.fullPage === true && op.target !== void 0) throw new MhBrowserError("INVALID_ARGS", "fullPage cannot be used with element screenshots.");
+			const type = op.type ?? "png";
+			const snapshot = this.shown.get(live.id)?.snapshot ?? "";
+			const locator = op.target === void 0 ? void 0 : await locate(live.page, op.target, snapshot);
+			const options = {
+				type,
+				...type === "jpeg" ? { quality: 90 } : {},
+				...op.scale !== void 0 ? { scale: op.scale } : {},
+				...op.fullPage === true ? { fullPage: true } : {},
+				...signal !== void 0 ? { signal } : {}
+			};
+			const bytes = locator === void 0 ? await live.page.screenshot(options) : await locator.screenshot(options);
+			return {
+				navigated: false,
+				shot: {
+					mediaType: `image/${type}`,
+					bytes: new Uint8Array(bytes)
+				}
+			};
+		}
+		/** A snapshot limited to a target, a depth, or boxes. Refs still resolve against the full one. */
+		async scopedSnapshot(tab, op) {
+			const options = {
+				mode: "ai",
+				...op.depth !== void 0 ? { depth: op.depth } : {},
+				...op.boxes === true ? { boxes: true } : {}
+			};
+			const snapshot = this.shown.get(tab.id)?.snapshot ?? "";
+			if (op.target !== void 0) return (await locate(tab.page, op.target, snapshot)).ariaSnapshot(options);
+			return tab.page.ariaSnapshot(options);
+		}
 		/** A file chooser the action opened. The tab stays in use until it navigates. */
-		chooserHeld(live, multiple) {
+		chooserHeld(live, chooser) {
+			live.fileChooser = chooser;
 			this.windows.holdInput(live);
 			return {
 				type: "filechooser",
-				message: multiple ? "choose files (several allowed) with upload" : "choose one file with upload"
+				message: chooser.isMultiple() ? "choose files (several allowed) with browser_file_upload" : "choose one file with browser_file_upload"
 			};
 		}
 		async refreshSnapshot(tab) {
@@ -4616,10 +6028,11 @@ let MhBrowserService = (() => {
 				fetch: (target, accept, ifNoneMatch) => this.fetchForRead(target, accept, ifNoneMatch)
 			});
 		}
-		fetchForRead(url, accept, ifNoneMatch) {
+		fetchForRead(url, accept, ifNoneMatch, signal) {
 			return this.fetch(url, {
 				accept,
-				...ifNoneMatch !== void 0 ? { ifNoneMatch } : {}
+				...ifNoneMatch !== void 0 ? { ifNoneMatch } : {},
+				...signal !== void 0 ? { signal } : {}
 			});
 		}
 		async aria(tab) {
@@ -4663,13 +6076,36 @@ let MhBrowserService = (() => {
 			if (extra?.waited !== void 0) view.waited = extra.waited;
 			return view;
 		}
-		/** Read one presence page. A tab opened only for this read is closed again. */
+		/**
+		* Read one presence page. A known origin is read on the request channel,
+		* with If-None-Match when the document was read before. Anything else uses
+		* a tab already on the address, or opens one and closes it again.
+		*/
 		async observePresence(owner, url, signal) {
+			if (this.knownOrigin(url)) {
+				const via = await this.readKnown(owner, url, signal);
+				if (via === STOPPED) return observationOf(url, {
+					url,
+					reason: WAITING_STOPPED
+				});
+				if (via !== void 0) return observationOf(url, via);
+			}
 			const existing = this.tabOn(owner, url);
-			const view = existing !== void 0 ? await this.refreshView(existing) : await this.openOne(owner, url, void 0, signal);
-			if (existing === void 0 && "tab" in view && view.tab !== void 0) {
-				const opened = this.windows.get(owner, view.tab);
-				if (opened !== void 0) await this.windows.closeTab(opened, `${opened.id} (idle)`);
+			if (existing !== void 0) return observationOf(url, await this.refreshView(existing));
+			const opened = await this.openOne(owner, url, void 0, signal, false);
+			this.keepAgentView(opened);
+			const view = opened.view;
+			if (opened.fresh && "tab" in view && view.tab !== void 0) {
+				const live = this.windows.get(owner, view.tab);
+				if (live !== void 0 && this.closable(owner, live)) {
+					const agent = "representation" in view && view.representation.kind === "agent-view";
+					await this.windows.closeTab(live, agent ? void 0 : `${live.id} (idle)`);
+					if (agent) {
+						const shown = { ...view };
+						delete shown.tab;
+						return observationOf(url, shown);
+					}
+				}
 			}
 			return observationOf(url, view);
 		}
@@ -4694,17 +6130,12 @@ let MhBrowserService = (() => {
 			});
 			this.shown.set(live.id, shown);
 			this.windows.noteUrl(live, address);
-			return this.pageFromShown(live, shown);
-		}
-		async idleView(owner, url) {
-			const live = this.idleTabOn(owner, url);
-			if (live === void 0) return void 0;
-			return this.refreshView(live);
+			return this.pageFromShown(live, shown);
 		}
-		/** The most recently touched idle tab on this address. */
+		/** The most recently touched idle tab on this address. A tab the person holds is left alone. */
 		idleTabOn(owner, url) {
 			const pageUrl = canonical(url);
-			const tabs = this.windows.list(owner).map((info) => this.windows.get(owner, info.tab)).filter((tab) => tab !== void 0 && canonical(tab.url) === pageUrl && !tab.occupied);
+			const tabs = this.windows.list(owner).map((info) => this.windows.get(owner, info.tab)).filter((tab) => tab !== void 0 && canonical(tab.url) === pageUrl && !tab.occupied && this.control.ofTab(owner, tab.id) !== "person");
 			tabs.sort((left, right) => right.touchedAt - left.touchedAt);
 			return tabs[0];
 		}
@@ -4713,10 +6144,15 @@ let MhBrowserService = (() => {
 			if (owner === "person") return;
 			await this.windows.enforceCap(owner);
 		}
-		async navigateOwned(owner, tab, url, signal) {
-			const live = this.windows.get(owner, tab);
-			if (live === void 0) return unknownTab();
-			return this.navigateTab(live, url, signal);
+		/** Other tabs on this address: idle ones reload, occupied or taken ones are marked. */
+		async refreshIdle(owner, url, except, signal) {
+			const pageUrl = canonical(url);
+			const tabs = this.windows.list(owner).map((info) => this.windows.get(owner, info.tab)).filter((item) => item !== void 0 && canonical(item.url) === pageUrl);
+			for (const item of tabs) {
+				if (item.id === except) continue;
+				if (item.occupied || this.control.ofTab(owner, item.id) === "person") this.windows.markMayHaveChanged(item);
+				else await this.navigateTab(item, item.page.url(), signal);
+			}
 		}
 		async navigateTab(live, url, signal) {
 			try {
@@ -4751,18 +6187,6 @@ let MhBrowserService = (() => {
 				};
 			}
 		}
-		async reloadSame(owner, url, tab, signal) {
-			const pageUrl = canonical(url);
-			const current = this.windows.get(owner, tab);
-			if (current === void 0) return unknownTab();
-			const tabs = this.windows.list(owner).map((info) => this.windows.get(owner, info.tab)).filter((item) => item !== void 0 && canonical(item.url) === pageUrl);
-			for (const item of tabs) {
-				if (item.id === current.id) continue;
-				if (item.occupied) this.windows.markMayHaveChanged(item);
-				else await this.navigateTab(item, item.page.url(), signal);
-			}
-			return this.navigateTab(current, current.page.url(), signal);
-		}
 		async sendAction(request, signal) {
 			const context = this.context;
 			if (context === void 0) return { kind: "lost" };
@@ -4926,16 +6350,16 @@ let MhBrowserService = (() => {
 			(browser?.process?.())?.kill("SIGKILL");
 			this.context = void 0;
 		}
-		refuseIfPerson(owner) {
-			if (this.control.of(owner) !== "person") return;
-			throw new MhBrowserError("PERSON_IN_CONTROL", "the person is using the browser; call browser_handover to wait until they hand it back");
+		refuseIfPerson(owner, tab) {
+			if (this.control.ofTab(owner, tab) !== "person") return;
+			throw new MhBrowserError("PERSON_IN_CONTROL", "the person is using this tab; call browser_handover with this tab to wait until they hand it back, or work in another tab");
 		}
-		async takenOver(live) {
+		async takenOver(live, note = "") {
 			try {
 				const page = await this.pageFromShown(live, this.shown.get(live.id), { surface: "snapshot" });
-				return new MhBrowserError("TAKEN_OVER", MAY_HAVE_TAKEN_EFFECT, page);
+				return new MhBrowserError("TAKEN_OVER", `${MAY_HAVE_TAKEN_EFFECT}${note}`, page);
 			} catch {
-				return new MhBrowserError("TAKEN_OVER", MAY_HAVE_TAKEN_EFFECT);
+				return new MhBrowserError("TAKEN_OVER", `${MAY_HAVE_TAKEN_EFFECT}${note}`);
 			}
 		}
 		presenceUrls(owner, tabs) {
@@ -5116,7 +6540,7 @@ function watchFileChooser(page) {
 	let onChooser;
 	return {
 		opened: new Promise((resolve) => {
-			onChooser = (chooser) => resolve(chooser.isMultiple());
+			onChooser = (chooser) => resolve(chooser);
 			page.on("filechooser", onChooser);
 		}),
 		stop: () => {
@@ -5124,15 +6548,6 @@ function watchFileChooser(page) {
 		}
 	};
 }
-function missingRef(snapshot, action) {
-	return refsOf(action).find((ref) => !snapshot.includes(`[ref=${ref}]`));
-}
-function refsOf(action) {
-	if (action.kind === "click" || action.kind === "select" || action.kind === "upload") return [action.ref];
-	if (action.kind === "press") return action.ref === void 0 ? [] : [action.ref];
-	if (action.kind === "fill") return action.fields.map((field) => field.ref);
-	return [];
-}
 function snapshotSurface(current) {
 	const agentView = current.kind === "agent-view" ? current.version !== void 0 ? { version: current.version } : {} : void 0;
 	return {
@@ -5142,478 +6557,15 @@ function snapshotSurface(current) {
 		...agentView !== void 0 ? { agentView } : {}
 	};
 }
-//#endregion
-//#region lib/types/tools/act.js
-/** The saved screenshot as a plain value; `render` re-brands it into the block's reference. */
-const IMAGE_VALUE = {
-	type: "object",
-	additionalProperties: false,
-	properties: {
-		attachmentId: {
-			type: "string",
-			required: true
-		},
-		mediaType: {
-			type: "string",
-			enum: [
-				"image/png",
-				"image/jpeg",
-				"image/webp",
-				"image/gif"
-			],
-			required: true
-		},
-		bytes: {
-			type: "integer",
-			required: true
-		},
-		width: {
-			type: "integer",
-			required: true
-		},
-		height: {
-			type: "integer",
-			required: true
-		},
-		name: { type: "string" },
-		originalDimensions: {
-			type: "object",
-			additionalProperties: false,
-			properties: {
-				width: {
-					type: "integer",
-					required: true
-				},
-				height: {
-					type: "integer",
-					required: true
-				}
-			}
-		}
-	}
-};
-function imageValue(ref) {
-	return {
-		attachmentId: ref.attachmentId,
-		mediaType: ref.mediaType,
-		bytes: ref.bytes,
-		width: ref.width,
-		height: ref.height,
-		...ref.name === void 0 ? {} : { name: ref.name },
-		...ref.originalDimensions === void 0 ? {} : { originalDimensions: { ...ref.originalDimensions } }
-	};
-}
-/** `dsh-llm` types its block against the hoisted `dsh-attachment`, so the id is re-branded through that type. */
-function imageRef(value) {
-	return {
-		attachmentId: value.attachmentId,
-		mediaType: value.mediaType,
-		bytes: value.bytes,
-		width: value.width,
-		height: value.height,
-		...value.name === void 0 ? {} : { name: value.name },
-		...value.originalDimensions === void 0 ? {} : { originalDimensions: { ...value.originalDimensions } }
-	};
-}
-const ACT = [
-	"Do one thing on a tab's human page and return its aria snapshot.",
-	"Use it for a page without an Agent View, or to work the human page of one; to read a page use browser_open, and to call a declared action use browser_invoke.",
-	"A page with an Agent View still returns a snapshot (agent-view=\"available\"); use look first when you need refs for it.",
-	"A tab is in use while it has unsubmitted input, an open dialog, or a handover; an idle tab may be closed (UNKNOWN_TAB), and browser_open of its address opens it again.",
-	"Do not fill or submit a login form or a form that issues credentials; call browser_handover."
-].join(" ");
-const TAB$1 = "Tab id copied from the latest browser result. An unknown id fails with UNKNOWN_TAB and returns the current tabs list.";
-const ACTION = [
-	"The one action to perform.",
-	"ref is an element ref copied from this tab's latest snapshot, such as e3; one that is not in that snapshot fails with STALE_REF and returns the current snapshot.",
-	"element is an optional short label for the person reading the log; it does not locate anything.",
-	"press without a ref goes to the focused element."
-].join(" ");
-const REF = "Element ref, such as e3.";
-const ELEMENT = "Label for the person.";
-function browserActTool(ctx) {
-	const reader = logReader(ctx);
-	return defineTool({
-		name: "browser_act",
-		description: ACT,
-		parameters: {
-			tab: {
-				type: "string",
-				required: true,
-				description: TAB$1
-			},
-			action: {
-				required: true,
-				description: ACTION,
-				oneOf: [
-					{
-						type: "object",
-						additionalProperties: false,
-						description: "Click an element.",
-						properties: {
-							kind: {
-								type: "string",
-								const: "click",
-								required: true,
-								description: "click"
-							},
-							ref: {
-								type: "string",
-								required: true,
-								description: REF
-							},
-							element: {
-								type: "string",
-								description: ELEMENT
-							},
-							double: {
-								type: "boolean",
-								description: "Double-click instead of click."
-							},
-							button: {
-								type: "string",
-								enum: [
-									"left",
-									"right",
-									"middle"
-								],
-								description: "Defaults to left."
-							},
-							modifiers: {
-								type: "array",
-								description: "Modifier keys held during the click.",
-								items: {
-									type: "string",
-									enum: [
-										"Alt",
-										"Control",
-										"Meta",
-										"Shift"
-									]
-								}
-							}
-						}
-					},
-					{
-						type: "object",
-						additionalProperties: false,
-						description: "Choose options on a list element; this does not submit.",
-						properties: {
-							kind: {
-								type: "string",
-								const: "select",
-								required: true,
-								description: "select"
-							},
-							ref: {
-								type: "string",
-								required: true,
-								description: REF
-							},
-							element: {
-								type: "string",
-								description: ELEMENT
-							},
-							values: {
-								type: "array",
-								required: true,
-								description: "Option values copied from the control; at least one.",
-								items: { type: "string" }
-							}
-						}
-					},
-					{
-						type: "object",
-						additionalProperties: false,
-						description: "Press a key.",
-						properties: {
-							kind: {
-								type: "string",
-								const: "press",
-								required: true,
-								description: "press"
-							},
-							key: {
-								type: "string",
-								required: true,
-								description: "Key name, such as Enter or ArrowDown."
-							},
-							ref: {
-								type: "string",
-								description: REF
-							},
-							element: {
-								type: "string",
-								description: ELEMENT
-							}
-						}
-					},
-					{
-						type: "object",
-						additionalProperties: false,
-						description: "Fill fields; this does not submit.",
-						properties: {
-							kind: {
-								type: "string",
-								const: "fill",
-								required: true,
-								description: "fill"
-							},
-							fields: {
-								type: "array",
-								required: true,
-								description: "Fields to write in one step; at least one.",
-								items: {
-									type: "object",
-									additionalProperties: false,
-									properties: {
-										ref: {
-											type: "string",
-											required: true,
-											description: REF
-										},
-										element: {
-											type: "string",
-											description: ELEMENT
-										},
-										value: {
-											type: "string",
-											required: true,
-											description: "Text to write; for a checkbox, true or false."
-										}
-									}
-								}
-							}
-						}
-					},
-					{
-						type: "object",
-						additionalProperties: false,
-						description: "Set files on a file input.",
-						properties: {
-							kind: {
-								type: "string",
-								const: "upload",
-								required: true,
-								description: "upload"
-							},
-							ref: {
-								type: "string",
-								required: true,
-								description: REF
-							},
-							element: {
-								type: "string",
-								description: ELEMENT
-							},
-							files: {
-								type: "array",
-								required: true,
-								description: "Attachment ids shown in this session, or paths inside the session cwd; at least one.",
-								items: { type: "string" }
-							}
-						}
-					},
-					{
-						type: "object",
-						additionalProperties: false,
-						description: "Accept or dismiss the open dialog.",
-						properties: {
-							kind: {
-								type: "string",
-								const: "dialog",
-								required: true,
-								description: "dialog"
-							},
-							accept: {
-								type: "boolean",
-								required: true,
-								description: "True accepts, false dismisses."
-							},
-							promptText: {
-								type: "string",
-								description: "Text to enter when accepting a prompt."
-							}
-						}
-					},
-					{
-						type: "object",
-						additionalProperties: false,
-						description: "Go back one step in this tab's history.",
-						properties: { kind: {
-							type: "string",
-							const: "back",
-							required: true,
-							description: "back"
-						} }
-					},
-					{
-						type: "object",
-						additionalProperties: false,
-						description: "Wait for text to appear or disappear, or for time seconds, then return the snapshot.",
-						properties: {
-							kind: {
-								type: "string",
-								const: "wait",
-								required: true,
-								description: "wait"
-							},
-							text: {
-								type: "string",
-								description: "Text to wait for; the snapshot is returned even if it never appears."
-							},
-							textGone: {
-								type: "string",
-								description: "Text to wait until it disappears; with text set too, the first one wins."
-							},
-							time: {
-								type: "number",
-								description: "Seconds to wait, or the limit for text and textGone; capped at 30, default 30."
-							}
-						}
-					},
-					{
-						type: "object",
-						additionalProperties: false,
-						description: "Return the current snapshot without acting; use it to obtain refs.",
-						properties: { kind: {
-							type: "string",
-							const: "look",
-							required: true,
-							description: "look"
-						} }
-					}
-				]
-			},
-			screenshot: {
-				type: "boolean",
-				description: "True adds a PNG of this tab after the page; none is taken while a dialog is open."
-			}
-		},
-		output: {
-			schema: {
-				type: "object",
-				additionalProperties: false,
-				properties: {
-					text: {
-						type: "string",
-						required: true
-					},
-					meta: {
-						type: "json",
-						required: true
-					},
-					image: IMAGE_VALUE
-				}
-			},
-			render: (_args, value) => {
-				const text = {
-					type: "text",
-					text: value.text
-				};
-				if (value.image === void 0) return [text];
-				return [text, {
-					type: "image",
-					attachment: imageRef(value.image)
-				}];
-			},
-			presentationMeta: (_args, value) => value.meta
-		},
-		isConcurrencySafe: () => false,
-		timeoutMs: 6e4,
-		presentCall: (args) => ({
-			card: "generic",
-			kind: "other",
-			title: `browser_act ${args.tab} ${args.action.kind}`
-		}),
-		presentResult: (args) => ({
-			card: "generic",
-			title: `browser_act ${args.tab} ${args.action.kind}`
-		}),
-		async execute(args, exec) {
-			const session = sessionFor(ctx, exec);
-			ctx.mhBrowser.noteWorkspace(session.id, writeTarget(ctx, session));
-			try {
-				const action = await toAction(args.action, (files) => uploadPaths(ctx, reader.attachments(session.session), session.cwd, files));
-				const view = await ctx.mhBrowser.act(session.id, args.tab, action, exec.signal);
-				const image = args.screenshot === true ? await screenshot(ctx, session.id, args.tab, exec.signal) : void 0;
-				const closed = closedNotes(ctx, reader, session);
-				const tabs = ctx.mhBrowser.tabs(session.id);
-				return {
-					text: renderOutcome([view], tabs, closed, image === void 0 ? void 0 : image.attachmentId),
-					meta: JSON.parse(JSON.stringify({
-						...readingsOf([view], action.kind),
-						closed
-					})),
-					...image === void 0 ? {} : { image: imageValue(image) }
-				};
-			} catch (error) {
-				if (error instanceof MhBrowserError && error.code === "UNKNOWN_TAB") rethrow(new MhBrowserError(UNKNOWN_TAB, `${UNKNOWN_TAB_REASON} ${args.tab}`), renderOutcome([], ctx.mhBrowser.tabs(session.id), closedNotes(ctx, reader, session)));
-				if (error instanceof MhBrowserError && (error.code === "STALE_REF" || error.code === "TAKEN_OVER") && error.page !== void 0) rethrow(error, renderOutcome([error.page], ctx.mhBrowser.tabs(session.id), closedNotes(ctx, reader, session)));
-				rethrow(error);
-			}
-		}
-	});
-}
-/** The action already happened, so a screenshot that cannot be taken or saved is left out, not an error. */
-async function screenshot(ctx, owner, tab, signal) {
-	const data = await ctx.mhBrowser.capture(owner, tab, signal);
-	if (data === void 0) return void 0;
-	try {
-		return await ctx.attachments.saveImage({
-			data,
-			mediaType: "image/png",
-			name: `${tab}.png`
-		});
-	} catch (error) {
-		ctx.logger.warn("saving the screenshot of %s failed: %o", tab, error);
-		return;
-	}
+/** Text and Agent View bodies are read on the request channel; anything else is left to a tab. */
+function readsAsText(mediaType) {
+	if (mediaType === void 0) return true;
+	const type = mediaType.split(";")[0]?.trim().toLowerCase() ?? "";
+	return type.startsWith("text/") || type === "application/xhtml+xml";
 }
-async function toAction(action, resolveFiles) {
-	if (action.kind === "click" && action.ref !== void 0) return {
-		kind: "click",
-		ref: action.ref,
-		...action.double !== void 0 ? { double: action.double } : {},
-		...action.button !== void 0 ? { button: action.button } : {},
-		...action.modifiers !== void 0 ? { modifiers: [...action.modifiers] } : {}
-	};
-	if (action.kind === "select" && action.ref !== void 0 && action.values !== void 0) return {
-		kind: "select",
-		ref: action.ref,
-		values: [...action.values]
-	};
-	if (action.kind === "press" && action.key !== void 0) return {
-		kind: "press",
-		key: action.key,
-		...action.ref !== void 0 ? { ref: action.ref } : {}
-	};
-	if (action.kind === "fill" && action.fields !== void 0) return {
-		kind: "fill",
-		fields: action.fields.map((field) => ({
-			ref: field.ref,
-			value: field.value
-		}))
-	};
-	if (action.kind === "upload" && action.ref !== void 0 && action.files !== void 0) return {
-		kind: "upload",
-		ref: action.ref,
-		files: await resolveFiles(action.files)
-	};
-	if (action.kind === "dialog" && action.accept !== void 0) return {
-		kind: "dialog",
-		accept: action.accept,
-		...action.promptText !== void 0 ? { promptText: action.promptText } : {}
-	};
-	if (action.kind === "back") return { kind: "back" };
-	if (action.kind === "wait") return {
-		kind: "wait",
-		...action.text !== void 0 ? { text: action.text } : {},
-		...action.textGone !== void 0 ? { textGone: action.textGone } : {},
-		...action.time !== void 0 ? { time: action.time } : {}
-	};
-	if (action.kind === "look") return { kind: "look" };
-	throw new Error(`unknown action ${action.kind}`);
+/** Read after an await: an earlier check does not narrow it. */
+function stopped(signal) {
+	return signal?.aborted === true;
 }
 //#endregion
 //#region lib/types/tools/download.js
@@ -5667,8 +6619,8 @@ function browserDownloadTool(ctx) {
 			ctx.mhBrowser.noteWorkspace(session.id, target);
 			if ("denied" in target) throw new BrowserToolError(target.code, target.denied);
 			const saved = await ctx.mhBrowser.download(session.id, args.url, target.root, exec.signal);
-			const closed = closedNotes(ctx, reader, session);
-			const text = `${renderDownload(saved)}\n${renderTabs(ctx.mhBrowser.tabs(session.id), closed)}`;
+			const block = tabBlock(ctx, reader, session);
+			const text = `${renderDownload(saved)}${block.suffix}`;
 			const download = saved.kind === "saved" ? {
 				path: saved.path,
 				bytes: saved.bytes,
@@ -5684,8 +6636,9 @@ function browserDownloadTool(ctx) {
 					by: META_BY,
 					action: "download",
 					pages: [],
-					closed,
-					download
+					closed: block.closed,
+					download,
+					...block.snap === void 0 ? {} : { tabs: block.snap }
 				}))
 			};
 		}
@@ -5695,11 +6648,11 @@ function browserDownloadTool(ctx) {
 //#region lib/types/tools/handover.js
 const HANDOVER = [
 	"Hand the browser to the person and wait until they hand it back.",
-	"Call it instead of filling or submitting a login form or a form that issues credentials, and whenever only the person can continue.",
-	"The result is the note the person wrote, if any, how many operations they performed, and a snapshot of the tab you named."
+	"The person can take over a tab at any time; that stops the action in progress on that tab, and a tab they have touched stays with them until they hand it back. Other tabs keep working.",
+	"Call it instead of filling or submitting a login form, a Memory login or consent form, or any form that issues credentials, and whenever only the person can continue."
 ].join(" ");
 const REASON = "The sentence the person sees on the handover card, unchanged.";
-const TAB = "Tab id copied from the latest browser result; it stays in use until the person hands it back. Omit it to hand over without naming a tab.";
+const TAB = "Tab id of the human page to show the person, copied from a page element's tab attribute. Omit it to hand over without naming a tab; that does not pick the latest result. A page with an Agent View has no tab until you open it with snapshot.";
 const ABORT = Symbol("abort");
 function browserHandoverTool(ctx) {
 	const reader = logReader(ctx);
@@ -5762,23 +6715,23 @@ function browserHandoverTool(ctx) {
 				const back = await ctx.mhBrowser.handBack(session.id, note);
 				const page = back.page;
 				const pages = page === void 0 ? [] : [page];
-				const closed = closedNotes(ctx, reader, session);
-				const tabs = ctx.mhBrowser.tabs(session.id);
+				const block = tabBlock(ctx, reader, session);
 				return {
 					text: `${[
 						...note === void 0 || note === "" ? [] : [note],
 						`${String(back.operations)} operations`,
 						takeoverText(back)
-					].join("\n")}\n${renderOutcome(pages, tabs, closed)}`,
+					].join("\n")}\n${renderOutcome(pages)}${block.suffix}`,
 					meta: JSON.parse(JSON.stringify({
 						...readingsOf(pages, "handover"),
-						closed,
-						operations: back.operations
+						closed: block.closed,
+						operations: back.operations,
+						...block.snap === void 0 ? {} : { tabs: block.snap }
 					}))
 				};
 			} catch (error) {
 				if (exec.signal.aborted || isAskAborted(error)) return quiet();
-				if (error instanceof MhBrowserError && error.code === "UNKNOWN_TAB") rethrow(new MhBrowserError(UNKNOWN_TAB, `${UNKNOWN_TAB_REASON} ${args.tab ?? ""}`.trim()), renderOutcome([], ctx.mhBrowser.tabs(session.id), closedNotes(ctx, reader, session)));
+				if (error instanceof MhBrowserError && error.code === "UNKNOWN_TAB") rethrow(new MhBrowserError(UNKNOWN_TAB, `${UNKNOWN_TAB_REASON} ${args.tab ?? ""}`.trim()), `${renderOutcome([])}${tabBlock(ctx, reader, session).suffix}`);
 				rethrow(error);
 			} finally {
 				ctx.mhBrowser.releaseIfHeld(session.id);
@@ -5828,10 +6781,10 @@ function isAskAborted(error) {
 //#endregion
 //#region lib/types/tools/invoke.js
 const INVOKE = [
-	"Call one action an Agent View declares, as the principal on that site, and return the resulting page.",
-	"You name the page and the action; the service builds and sends the page's request, so you never supply a URL or a pinned field.",
-	"If the result is STALE_VIEW, read the attached current page before choosing again.",
-	"An action declared by a document in requires is called on that document, not on the page that requires it.",
+	"Call one action an Agent View declares, in the principal's name on that site. The call uses the page address and does not need a tab.",
+	"A declared GET returns the resulting page the way browser_open does; any other action returns only the header of the page it lands on, so open that page to read it or act on it.",
+	"The call uses the Agent View you were shown; if the page has changed, the site refuses and the result says so.",
+	"An action declared by a document in requires is called with that document's address as page.",
 	"Do not submit a login form or a form that issues credentials; call browser_handover."
 ].join(" ");
 const PAGE = "The url attribute of a page element in a tool result or a presence reminder, or the id in that page's Agent View. When one id names several pages shown to you, use the url of the one you mean.";
@@ -5906,7 +6859,10 @@ function browserInvokeTool(ctx) {
 			try {
 				const sent = await ctx.mhBrowser.invoke(session.id, resolved.url, {
 					name: args.name,
-					seen: resolved.seen,
+					shown: {
+						url: resolved.url,
+						text: resolved.text
+					},
 					...args.item === void 0 ? {} : { item: args.item },
 					...input === void 0 ? {} : { input }
 				}, {
@@ -5914,20 +6870,20 @@ function browserInvokeTool(ctx) {
 					readFile: (value) => resolveBinary(ctx, reader.attachments(session.session), session.cwd, value)
 				});
 				const pages = [sent.page];
-				const closed = closedNotes(ctx, reader, session);
+				const block = tabBlock(ctx, reader, session);
 				return {
-					text: `${sent.response === void 0 ? "" : `${renderActionResponse(sent.response)}\n`}${"representation" in sent.page ? renderPage(sent.page, void 0, sent.page.inPresence) : renderPageError(sent.page)}\n${renderTabs(ctx.mhBrowser.tabs(session.id), closed)}`,
+					text: `${sent.response === void 0 ? "" : `${renderActionResponse(sent.response)}\n`}${"representation" in sent.page ? renderPage(sent.page, void 0, sent.page.inPresence && !sent.page.headerOnly) : renderPageError(sent.page)}${block.suffix}`,
 					meta: JSON.parse(JSON.stringify({
 						...readingsOf(pages, `invoke:${args.name}`),
-						closed,
+						closed: block.closed,
+						...block.snap === void 0 ? {} : { tabs: block.snap },
 						...sent.schemaRejected ? { schemaRejected: true } : {}
 					}))
 				};
 			} catch (error) {
 				if (error instanceof MhBrowserError && error.page !== void 0) {
-					const stale = error.code === "STALE_VIEW";
-					const omit = stale && error.page.inPresence;
-					rethrow(error, `${renderPage(error.page, void 0, omit, stale)}\n${renderTabs(ctx.mhBrowser.tabs(session.id), closedNotes(ctx, reader, session))}`);
+					const block = tabBlock(ctx, reader, session);
+					rethrow(error, `${renderPage(error.page, void 0, error.page.inPresence)}${block.suffix}`);
 				}
 				rethrow(error);
 			}
@@ -5947,14 +6903,14 @@ async function resolveBinary(ctx, seen, cwd, value) {
 //#endregion
 //#region lib/types/tools/open.js
 const OPEN = [
-	"Read 1 to 8 pages: a page with an Agent View returns that document, any other page returns an aria snapshot.",
-	"This is how you read a page once; browser_presence keeps a page in context, browser_invoke calls a declared action, browser_act works a human page.",
-	"A page lists what it depends on in requires; those documents are not fetched with it, so open them to read them or to call their actions.",
-	"An address with no version attribute is one observation; agent-view-error means the Agent View could not be read and the page has no declared actions."
+	"Read 1 to 8 pages. A page with an Agent View returns that document; any other page returns an aria snapshot.",
+	"A page with no version attribute is one observation. agent-view-error means the Agent View could not be read, so this page is a snapshot and has no declared actions.",
+	"A page lists documents in requires; those are not fetched with it, so open their addresses to read them or to call their actions."
 ].join(" ");
 const PAGES = "The pages to read, 1 to 8, each returned in order as its own element.";
 const URL$1 = "The address to read: from a page shown to you, from the principal, or one you composed; opening a composed address is how it is checked before you use it elsewhere.";
 const WAIT = "Optional wait after the document loads for text to appear or disappear, or for time seconds; at least one must be set. If not met, the page is still returned and waited says so.";
+const SNAPSHOT = "Ask for the human page: open a tab and return its snapshot, for page operations and handover. A page without an Agent View already does.";
 function browserOpenTool(ctx) {
 	const reader = logReader(ctx);
 	return defineTool({
@@ -5973,6 +6929,10 @@ function browserOpenTool(ctx) {
 						required: true,
 						description: URL$1
 					},
+					snapshot: {
+						type: "boolean",
+						description: SNAPSHOT
+					},
 					waitFor: {
 						type: "object",
 						additionalProperties: false,
@@ -6038,14 +6998,16 @@ function browserOpenTool(ctx) {
 			try {
 				const pages = await ctx.mhBrowser.open(session.id, args.pages.map((page) => ({
 					url: page.url,
+					...page.snapshot === true ? { snapshot: true } : {},
 					...page.waitFor === void 0 ? {} : { waitFor: compactWait(page.waitFor) }
 				})), exec.signal);
-				const closed = closedNotes(ctx, reader, session);
+				const block = tabBlock(ctx, reader, session);
 				return {
-					text: renderOutcome(pages, ctx.mhBrowser.tabs(session.id), closed, void 0, true),
+					text: `${renderOutcome(pages, void 0, true)}${block.suffix}`,
 					meta: JSON.parse(JSON.stringify({
 						...readingsOf(pages, "open"),
-						closed
+						closed: block.closed,
+						...block.snap === void 0 ? {} : { tabs: block.snap }
 					}))
 				};
 			} catch (error) {
@@ -6124,7 +7086,6 @@ function browserPresenceTool(ctx) {
 		}),
 		async execute(args, exec) {
 			const session = sessionFor(ctx, exec);
-			if (ctx.mhBrowser.controlOf(session.id) === "person") throw new BrowserToolError("PERSON_IN_CONTROL", "the person is using the browser; call browser_handover to wait until they hand it back");
 			const put = args.put ?? [];
 			const remove = args.remove ?? [];
 			if (put.length + remove.length === 0) throw new BrowserToolError("INVALID_ARGS", "give put, remove, or both");
@@ -6133,15 +7094,16 @@ function browserPresenceTool(ctx) {
 			const added = ctx.mhBrowser.presencePut(session.id, put, "model");
 			const removed = ctx.mhBrowser.presenceRemove(session.id, remove);
 			const receipts = [...added, ...removed];
-			const closed = closedNotes(ctx, reader, session);
+			const block = tabBlock(ctx, reader, session);
 			return {
-				text: `${receipts.map(line).join("\n")}\n${renderTabs(ctx.mhBrowser.tabs(session.id), closed)}`,
+				text: `${receipts.map(line).join("\n")}${block.suffix}`,
 				meta: JSON.parse(JSON.stringify({
 					by: META_BY,
 					action: "presence",
 					pages: [],
-					closed,
-					receipts
+					closed: block.closed,
+					receipts,
+					...block.snap === void 0 ? {} : { tabs: block.snap }
 				}))
 			};
 		}
@@ -6155,7 +7117,7 @@ function line(receipt) {
 function registerBrowserTools(ctx) {
 	followSessionTitles(ctx);
 	ctx.tools.register(browserOpenTool(ctx));
-	ctx.tools.register(browserActTool(ctx));
+	for (const tool of pageOperationTools(ctx)) ctx.tools.register(tool);
 	ctx.tools.register(browserInvokeTool(ctx));
 	ctx.tools.register(browserDownloadTool(ctx));
 	ctx.tools.register(browserPresenceTool(ctx));