@deepseek-insight/dsi 0.8.4 → 0.9.0

package/build/server/chunks/chunks/{registry.js-CZNJZ0C-.js → registry.js-CWnRQ4vx.js}

@@ -1,4 +1,4 @@
-import { d as readBrowserConfig } from './insight-config.js-Dp_2gB5J.js';
+import { d as readBrowserConfig } from './insight-config.js-C5-Rhh5A.js';
 import { mkdirSync, rmSync, readdirSync } from 'node:fs';
 import { join } from 'node:path';
 import { spawn, spawnSync } from 'node:child_process';
@@ -157,6 +157,29 @@ var BrowserRelay = class {
 	}
 };
 Number(process.env.DSI_MCP_PORT ?? 9515);
+/** Layout-scale zoom (ADR-0041 amendment, 2026-10-31): the zoom knob is
+*  LAYOUT SCALE — the emulated viewport is the panel box divided by the
+*  zoom, and the mirror's contain-fit does the visual shrinking. The page
+*  keeps ONE coordinate space (no CSS zoom), so every consumer's own
+*  geometry math — YouTube's seek preview included — stays truthful.
+*  Rejected: documentElement CSS zoom (the 2026-10-28..31 implementation) —
+*  Chromium hit-testing stayed correct but the PAGE's own width perception
+*  split in two, and YouTube's player computed seek previews at exactly
+*  the zoom factor off (54:58 vs 1:08:44 at 0.8). */
+function layoutViewport(width, height, zoom) {
+	const z = zoom > 0 ? zoom : 1;
+	return {
+		width: Math.max(200, Math.min(8192, Math.round(width / z))),
+		height: Math.max(120, Math.min(8192, Math.round(height / z)))
+	};
+}
+/** Live zoom slider (2026-10-28): the slider's wire bounds — null when the
+*  value is not a finite number in 0.5..1.25 (the route answers 400). */
+function clampZoom(z) {
+	if (typeof z !== "number" || !Number.isFinite(z)) return null;
+	if (z < .5 || z > 1.25) return null;
+	return z;
+}
 /** The reaper's ONLY test — pure: a session is reaper-eligible when nobody
 *  watches its stream AND its last MCP tool traffic is older than idleMs.
 *  An active agent (traffic younger than idleMs) is NEVER eligible (D2). */
@@ -164,6 +187,100 @@ function reaperEligible(e, idleMs, now) {
 	if (e.streamSubscribers > 0) return false;
 	return now - e.lastMcpActivity >= idleMs;
 }
+/** Mint the next ordinal for targetId (idempotent: an already-minted
+*  targetId returns its existing ordinal — lazy attach and heal re-enter). */
+function mintTabId(entry, targetId) {
+	const tabIds = entry.tabIds ??= /* @__PURE__ */ new Map();
+	for (const [ord, tid] of tabIds) if (tid === targetId) return ord;
+	entry.nextTabId ??= 1;
+	const ord = entry.nextTabId;
+	entry.nextTabId = ord + 1;
+	entry.tabIds.set(ord, targetId);
+	return ord;
+}
+/** ADR-0040 Amendment 4 (D-A5): the OWNER hand claims a newborn. Called
+*  from the entry's own context 'page' listener — a claimed targetId is
+*  owner-born no matter what the browser-level watcher saw first. Pure. */
+function claimOwnerBirth(entry, targetId) {
+	(entry.ownBirths ??= /* @__PURE__ */ new Set()).add(targetId);
+}
+/** ADR-0040 Amendment 4 (D-A6): a GUEST birth is a citizen without the
+*  throne — mint an ordinal, append tabOrder (lands LAST), and NEVER move
+*  the active pointer (appear without stealing focus). Guards: closed
+*  sessions refuse; a target the entry already knows (or the owner hand
+*  claimed) is a no-op. Pure. Returns true when the guest was admitted. */
+function admitGuestBirth(e, targetId) {
+	if (e.closed) return false;
+	if (e.ownBirths?.has(targetId)) return false;
+	if (e.tabOrder.includes(targetId) || e.tabs.has(targetId)) return false;
+	e.tabOrder.push(targetId);
+	mintTabId(e, targetId);
+	return true;
+}
+/** Retire a closed tab: drop both map sides. The ordinal itself is gone —
+*  mintTabId never hands it out again. */
+function retireTabId(entry, targetId) {
+	if (!entry.tabIds) return;
+	for (const [ord, tid] of entry.tabIds) if (tid === targetId) {
+		entry.tabIds.delete(ord);
+		return;
+	}
+}
+/** HEAL PRESERVES ORDINALS: healHandles swaps a dead CDP handle for a
+*  fresh session — the tab's ordinal must survive with its value
+*  rewritten to the new targetId. An unknown page (first sight during
+*  heal) falls back to a fresh mint. */
+function healPreserveOrdinal(entry, oldTargetId, newTargetId) {
+	const tabIds = entry.tabIds ??= /* @__PURE__ */ new Map();
+	for (const [ord, tid] of tabIds) if (tid === oldTargetId) {
+		entry.tabIds.set(ord, newTargetId);
+		return ord;
+	}
+	return mintTabId(entry, newTargetId);
+}
+/** Resolve a tab reference — ordinal (number / numeric string), the
+*  'active' pointer, or a raw targetId — to { targetId, tabId }. A
+*  retired or unknown ordinal is an EXPLICIT error: no silent
+*  nearest-match (glass-tab-ids global constraint). */
+function resolveTab(entry, ref) {
+	if (ref === "active") {
+		if (!entry.activeTargetId) return {
+			ok: false,
+			error: "no active tab"
+		};
+		for (const [ord, tid] of entry.tabIds ?? []) if (tid === entry.activeTargetId) return {
+			ok: true,
+			targetId: tid,
+			tabId: ord
+		};
+		return {
+			ok: false,
+			error: "active tab has no ordinal: " + entry.activeTargetId
+		};
+	}
+	if (typeof ref === "number" || /^\d+$/.test(ref)) {
+		const ord = Number(ref);
+		const tid = entry.tabIds?.get(ord);
+		if (tid === void 0) return {
+			ok: false,
+			error: "unknown or retired tab ordinal: " + ord
+		};
+		return {
+			ok: true,
+			targetId: tid,
+			tabId: ord
+		};
+	}
+	for (const [ord, tid] of entry.tabIds ?? []) if (tid === ref) return {
+		ok: true,
+		targetId: tid,
+		tabId: ord
+	};
+	return {
+		ok: false,
+		error: "unknown tab: " + ref
+	};
+}
 var BrowserRegistryRefusal = class extends Error {
 	code;
 	constructor(code, message) {
@@ -190,10 +307,52 @@ function state() {
 function sweepOrphanProfiles(keep) {
 	try {
 		const root = readBrowserConfig().profileRoot;
-		for (const name of readdirSync(root)) if (!keep.has(name)) rmSync(join(root, name), {
-			recursive: true,
-			force: true
-		});
+		for (const name of readdirSync(root)) {
+			if (keep.has(name)) continue;
+			if (!process.env.VITEST) killOrphanChrome(name, {
+				listPids: () => spawnSync("ps", ["axo", "pid=,command="], {
+					encoding: "utf8",
+					timeout: 5e3
+				}).stdout ?? "",
+				killPid: (pid, sig) => process.kill(pid, sig)
+			});
+			rmSync(join(root, name), {
+				recursive: true,
+				force: true
+			});
+		}
+	} catch {}
+}
+/** Ghost Glass Fix 3 (RCA 2026-10-31 Bug 3): PURE matcher — which process
+*  rows hold a Chrome --user-data-dir that ENDS at the swept profile name?
+*  The name must terminate the dir (path separator before it, end/space
+*  after it), so a PREFIX-sharing sibling profile never matches. */
+function orphanChromePids(psOutput, profileName) {
+	const needle = "--user-data-dir=";
+	const pids = [];
+	for (const line of psOutput.split("\n")) {
+		const at = line.indexOf(needle);
+		if (at === -1) continue;
+		const rest = line.slice(at + 16);
+		const end = rest.search(/[\s"']/);
+		if (!(end === -1 ? rest : rest.slice(0, end)).replace(/\/+$/, "").endsWith("/" + profileName)) continue;
+		const pid = Number.parseInt(line.trimStart(), 10);
+		if (Number.isFinite(pid)) pids.push(pid);
+	}
+	return pids;
+}
+/** Ghost Glass Fix 3: the sweep kill arm with the OS injected — SIGKILL
+*  every holder of the profile dir. Best-effort both ways: a failed ps
+*  listing or an already-dead pid (ESRCH) never blocks the dir sweep. */
+function killOrphanChrome(profileName, deps) {
+	let out;
+	try {
+		out = deps.listPids();
+	} catch {
+		return;
+	}
+	for (const pid of orphanChromePids(out, profileName)) try {
+		deps.killPid(pid, "SIGKILL");
 	} catch {}
 }
 /** Brain re-homing (BUGFIX 2026-10-25): release the stable brain port
@@ -313,6 +472,7 @@ var BrowserRegistry = class {
 			pid: e.pid,
 			profileDir: e.profileDir,
 			createdAt: e.createdAt,
+			ownerSessionId: e.ownerSessionId ?? null,
 			mcp: e.mcpChild ? "child" : e.mcpInProcess ? "in-process" : "none",
 			mcpHealth: e.mcpHealth,
 			mcpError: e.mcpError
@@ -366,7 +526,7 @@ var BrowserRegistry = class {
 			const now = Date.now();
 			for (const e of state().entries.values()) {
 				if (!reaperEligible(e, idleMs, now)) continue;
-				this.close(e.id).catch(() => void 0);
+				this.close(e.id, "reaped").catch(() => void 0);
 			}
 		}, Math.min(idleMs / 2, 3e4));
 		s.reaperTimer.unref?.();
@@ -378,6 +538,31 @@ var BrowserRegistry = class {
 		if (!h) throw new BrowserRegistryRefusal("CLOSED", "no active tab handle");
 		return h.relay;
 	}
+	/** D5 amendment 2026-10-27: watch the active pointer. The stream route
+	*  re-binds its relay on every fire so a brain-driven activate (creation
+	*  auto-focus) repoints the MIRROR, not just the strip highlight. */
+	/** Ghost Glass Fix 2 (RCA 2026-10-31): the death handshake's registry
+	*  side. Subscribers hear ONE reason ('closed' human, 'reaped' reaper);
+	*  subscribing to an already-dead id hears the truth immediately instead
+	*  of polling a ghost. Same shape as onActiveChange. */
+	onDeath(id, cb) {
+		const e = state().entries.get(id);
+		if (!e || e.closed) {
+			cb("closed");
+			return () => void 0;
+		}
+		(e.deathListeners ??= /* @__PURE__ */ new Set()).add(cb);
+		return () => {
+			e.deathListeners?.delete(cb);
+		};
+	}
+	onActiveChange(id, cb) {
+		const e = this.peek(id);
+		(e.activeListeners ??= /* @__PURE__ */ new Set()).add(cb);
+		return () => {
+			e.activeListeners?.delete(cb);
+		};
+	}
 	/** Resolve a verb's target handle: explicit targetId, else the active tab
 	*  (ADR-0040 D3 — one verb seam, optional pointer). An ENUMERATED but
 	*  not-yet-attached target attaches lazily here — attach is not stream
@@ -413,7 +598,12 @@ var BrowserRegistry = class {
 					relay: handle.relay,
 					page
 				}).catch(() => void 0);
-				e.tabs.set(tid, handle);
+				const ord = mintTabId(e, tid);
+				e.tabs.set(tid, {
+					...handle,
+					tabId: ord
+				});
+				(e.tabOrder ??= []).push(tid);
 				if (tid === key) break;
 			}
 		}
@@ -421,19 +611,137 @@ var BrowserRegistry = class {
 		if (!h) throw new BrowserRegistryRefusal("NO_TARGET", "no such tab: " + key);
 		return h;
 	}
+	/** BUG 2026-10-27 (brain churn leaves stale handles): the registry's
+	*  cached CDP sessions can DIE while the pages live on (brain re-home,
+	*  MCP client reconnect) — listTabs then answers empty, every verb
+	*  NO_TARGETs, and the mirror starves on one frozen frame. Heal: re-probe
+	*  every live page with a FRESH CDP session, replace dead handles, and
+	*  remap the pointer when its target is gone. Called from listTabs when
+	*  enumeration comes back empty — the panel's 2s poll then heals the
+	*  whole session without operator action. */
+	async healHandles(e) {
+		for (const page of e.context.pages()) {
+			let scdp = null;
+			let tid = null;
+			try {
+				scdp = await e.context.newCDPSession(page);
+				tid = (await scdp.send("Target.getTargetInfo")).targetInfo?.targetId ?? null;
+			} catch {
+				continue;
+			}
+			if (!tid || !scdp) {
+				await scdp?.detach().catch(() => void 0);
+				continue;
+			}
+			const old = e.tabs.get(tid);
+			if (old) {
+				if (!await old.cdp.send("Target.getTargetInfo").then(() => false).catch(() => true)) {
+					await scdp.detach().catch(() => void 0);
+					continue;
+				}
+				old.relay.stop();
+				await old.cdp.detach().catch(() => void 0);
+				const cfg = readBrowserConfig();
+				const ord = healPreserveOrdinal(e, tid, tid);
+				e.tabs.set(tid, {
+					targetId: tid,
+					tabId: ord,
+					cdp: scdp,
+					relay: new BrowserRelay(scdp, cfg.screencastQuality, cfg.screencastMaxFps),
+					page
+				});
+				if (!e.tabOrder.includes(tid)) e.tabOrder.push(tid);
+			} else await scdp.detach().catch(() => void 0);
+		}
+		if (e.activeTargetId && !e.tabs.has(e.activeTargetId)) e.activeTargetId = [...e.tabs.keys()][0] ?? null;
+	}
 	/** Enumerate the context's page targets (ADR-0040 D5 feed) — type:page
 	*  only; iframes/omnibox/service workers are chrome noise (wire capture
-	*  2026-10-24). Read-only: never attaches, never streams (D1). */
+	*  2026-10-24). Mirror-lifecycle (ADR "The Mirror Must Face a Living
+	*  Tab", D1/D2): enumeration ADOPTS unknown live pages (mint + lazy
+	*  seam — survivors' ordinals never move) and RE-POINTS the active
+	*  pointer when its target is gone, re-seeding the mirror through
+	*  activate's idiom — the panel never faces a corpse (the 2026-10-28
+	*  frozen-frame bug). */
 	async listTabs(id) {
 		const e = this.peek(id);
-		const src = (e.activeTargetId ? e.tabs.get(e.activeTargetId) : null)?.cdp ?? [...e.tabs.values()][0]?.cdp;
-		if (!src) return [];
-		return ((await src.send("Target.getTargets").catch(() => null))?.targetInfos ?? []).filter((t) => t.type === "page").map((t) => ({
+		const pickSrc = () => (e.activeTargetId ? e.tabs.get(e.activeTargetId) : null)?.cdp ?? [...e.tabs.values()][0]?.cdp ?? null;
+		const readTargets = async (h) => {
+			return (await h.send("Target.getTargets").catch(() => null))?.targetInfos ?? null;
+		};
+		let src = pickSrc();
+		let infos = (src ? await readTargets(src) : null) ?? [];
+		if (infos === null || infos.length === 0 && e.context.pages().length > 0) {
+			await this.healHandles(e);
+			src = pickSrc();
+			infos = (src ? await readTargets(src) : null) ?? [];
+		}
+		let pages = infos.filter((t) => t.type === "page");
+		if (pages.length === 0 && e.context.pages().length > 0) {
+			const probed = [];
+			for (const page of e.context.pages()) try {
+				const scdp = await e.context.newCDPSession(page);
+				const info = await scdp.send("Target.getTargetInfo");
+				await scdp.detach().catch(() => void 0);
+				if (info.targetInfo?.targetId) probed.push({
+					targetId: info.targetInfo.targetId,
+					type: "page",
+					url: info.targetInfo.url ?? page.url(),
+					title: info.targetInfo.title ?? ""
+				});
+			} catch {
+				continue;
+			}
+			pages = probed;
+		}
+		const known = new Set(e.tabs.keys());
+		const unknown = pages.filter((t) => !known.has(t.targetId));
+		if (unknown.length > 0) {
+			const cfg = readBrowserConfig();
+			for (const page of e.context.pages()) {
+				let tid = null;
+				let scdp = null;
+				try {
+					scdp = await e.context.newCDPSession(page);
+					tid = (await scdp.send("Target.getTargetInfo")).targetInfo?.targetId ?? null;
+				} catch {
+					continue;
+				}
+				if (!tid || !unknown.some((u) => u.targetId === tid)) {
+					await scdp.detach().catch(() => void 0);
+					continue;
+				}
+				const ord = mintTabId(e, tid);
+				if (!e.tabOrder.includes(tid)) e.tabOrder.push(tid);
+				e.tabs.set(tid, {
+					targetId: tid,
+					tabId: ord,
+					cdp: scdp,
+					relay: new BrowserRelay(scdp, cfg.screencastQuality, cfg.screencastMaxFps),
+					page
+				});
+			}
+		}
+		const out = pages.map((t) => ({
+			tabId: mintTabId(e, t.targetId),
 			targetId: t.targetId,
 			url: t.url,
 			title: t.title,
 			active: t.targetId === e.activeTargetId
-		}));
+		})).sort((a, b) => {
+			const order = e.tabOrder ?? [];
+			const ia = order.indexOf(a.targetId);
+			const ib = order.indexOf(b.targetId);
+			return (ia === -1 ? Infinity : ia) - (ib === -1 ? Infinity : ib);
+		});
+		if (e.activeTargetId && !out.some((r) => r.targetId === e.activeTargetId)) {
+			const survivor = out[0]?.targetId ?? null;
+			if (survivor) {
+				await this.activate(id, survivor).catch(() => void 0);
+				for (const r of out) r.active = r.targetId === e.activeTargetId;
+			} else e.activeTargetId = null;
+		}
+		return out;
 	}
 	/** Attach (lazily), seed the first frame, re-apply the viewport, and move
 	*  the active pointer (ADR-0040 D1/D2/D4). The OLD active relay pauses —
@@ -462,6 +770,9 @@ var BrowserRegistry = class {
 			});
 		}
 		e.activeTargetId = targetId;
+		for (const l of e.activeListeners ?? []) try {
+			l(targetId);
+		} catch {}
 		let url = "";
 		let title = "";
 		try {
@@ -483,22 +794,25 @@ var BrowserRegistry = class {
 		const port = freePort(options.port);
 		const profileDir = join(cfg.profileRoot, id.slice(0, 8));
 		mkdirSync(profileDir, { recursive: true });
-		const ignoreDefaultArgs = ["--enable-automation", "--mute-audio"];
+		const ignoreDefaultArgs = [
+			"--enable-automation",
+			"--mute-audio",
+			"--hide-scrollbars"
+		];
 		const launch = (useChrome) => chromium.launchPersistentContext(profileDir, {
 			...useChrome ? { channel: "chrome" } : {},
 			headless: options.headless ?? cfg.headless,
 			ignoreDefaultArgs,
 			args: [
-				"--remote-debugging-port=" + port,
 				"--no-first-run",
-				"--disable-blink-features=AutomationControlled",
-				"--disable-features=IsolateOrigins,site-per-process",
+				"--remote-debugging-port=" + port,
 				"--disable-dev-shm-usage",
-				"--disable-backgrounding-occluded-windows",
 				"--disable-renderer-backgrounding",
 				"--disable-background-timer-throttling",
+				"--disable-backgrounding-occluded-windows",
+				"--disable-blink-features=AutomationControlled",
+				"--disable-features=IsolateOrigins,site-per-process",
 				"--autoplay-policy=no-user-gesture-required",
-				"--window-position=-32000,-32000",
 				"--window-size=" + (Math.max(200, Math.min(1920, options.width ?? 730)) + 6) + "," + (Math.max(120, Math.min(1080, options.height ?? 830)) + 70)
 			],
 			viewport: options.headless ?? cfg.headless ? {
@@ -524,12 +838,19 @@ var BrowserRegistry = class {
 		try {
 			activeTargetId = (await cdp.send("Target.getTargetInfo")).targetInfo?.targetId ?? null;
 		} catch {}
-		if (activeTargetId) tabs.set(activeTargetId, {
-			targetId: activeTargetId,
-			cdp,
-			relay,
-			page: context.pages()[0]
-		});
+		const tabIds = /* @__PURE__ */ new Map();
+		let nextTabId = 1;
+		if (activeTargetId) {
+			tabIds.set(1, activeTargetId);
+			nextTabId = 2;
+			tabs.set(activeTargetId, {
+				targetId: activeTargetId,
+				tabId: 1,
+				cdp,
+				relay,
+				page: context.pages()[0]
+			});
+		}
 		await relay.start();
 		const start = options.url ?? "data:text/html,<title>Glass Browser</title><body style=\"font-family:system-ui;color:gray;display:grid;place-items:center;height:100vh;margin:0\">Glass Browser — waiting for the agent</body>";
 		await cdp.send("Page.enable").catch(() => void 0);
@@ -547,6 +868,20 @@ var BrowserRegistry = class {
 				metadata: { seeded: true }
 			});
 		}
+		if (options.headless ?? cfg.headless) {
+			const birth = context.pages()[0];
+			if (birth && typeof birth.evaluate === "function") {
+				if (await birth.evaluate(() => {
+					const d = document.createElement("div");
+					d.style.cssText = "position:fixed;left:-100px;top:0;width:50px;height:50px;overflow:auto";
+					d.innerHTML = "<div style=\"width:200px;height:200px\"></div>";
+					document.body.appendChild(d);
+					const f = d.offsetHeight - d.clientHeight;
+					d.remove();
+					return f;
+				}).catch(() => null) === 0) throw new Error("glass scrollbar gate: bar footprint is 0 in a headless launch — --hide-scrollbars leaked past ignoreDefaultArgs (RCA 2026-10-28)");
+			}
+		}
 		const brainPort = Number(process.env.DSI_MCP_PORT ?? cfg.brainPort);
 		if (cfg.enabled) this.ensureReaper(cfg.idleMs);
 		const entry = {
@@ -554,10 +889,14 @@ var BrowserRegistry = class {
 			context,
 			tabs,
 			activeTargetId,
+			tabOrder: activeTargetId ? [activeTargetId] : [],
+			tabIds,
+			nextTabId,
 			viewport: {
 				width: Math.max(200, Math.min(1920, options.width ?? 730)),
 				height: Math.max(120, Math.min(1080, options.height ?? 830))
 			},
+			zoom: cfg.contentZoom,
 			headless: options.headless ?? cfg.headless,
 			port,
 			pid,
@@ -570,9 +909,70 @@ var BrowserRegistry = class {
 			mcpHealth: "up",
 			mcpError: null,
 			closed: false,
+			ownerSessionId: options.ownerSessionId ?? null,
+			ownBirths: /* @__PURE__ */ new Set(),
 			createdAt: (/* @__PURE__ */ new Date()).toISOString()
 		};
 		state().entries.set(id, entry);
+		if (typeof context.on === "function") context.on("page", (page) => {
+			(async () => {
+				for (let i = 0; i < 10; i += 1) {
+					await new Promise((r) => setTimeout(r, 300));
+					try {
+						const scdp = await context.newCDPSession(page);
+						const info = await scdp.send("Target.getTargetInfo").catch(() => null);
+						await scdp.detach().catch(() => void 0);
+						const tid = info?.targetInfo?.targetId;
+						if (!tid) continue;
+						if (!entry.tabOrder.includes(tid)) entry.tabOrder.push(tid);
+						mintTabId(entry, tid);
+						claimOwnerBirth(entry, tid);
+						if (entry.activeTargetId !== tid && !entry.closed && !entry.tabs.has(tid)) await this.activate(id, tid);
+						return;
+					} catch {}
+				}
+			})();
+		});
+		try {
+			const browser = context.browser?.();
+			if (browser && typeof browser.newBrowserCDPSession === "function") {
+				const bcdp = await browser.newBrowserCDPSession();
+				entry.browserCdp = bcdp;
+				await bcdp.send("Target.setDiscoverTargets", { discover: true }).catch(() => void 0);
+				bcdp.on("Target.targetCreated", (evt) => {
+					const tid = evt?.targetInfo?.targetId;
+					if (!tid || evt.targetInfo?.type !== "page") return;
+					if (entry.tabOrder.includes(tid) || entry.tabs.has(tid)) return;
+					(async () => {
+						for (let g = 0; g < 10; g += 1) {
+							await new Promise((r) => setTimeout(r, 300));
+							if (entry.closed) return;
+							if (entry.ownBirths?.has(tid)) return;
+							if (entry.tabOrder.includes(tid) || entry.tabs.has(tid)) return;
+						}
+						admitGuestBirth(entry, tid);
+					})();
+				});
+			}
+		} catch {}
+		if (!entry.headless) {
+			await this.applyPanelViewport(entry, {
+				cdp,
+				relay
+			}).catch(() => void 0);
+			const birthShot = await cdp.send("Page.captureScreenshot", {
+				format: "jpeg",
+				quality: cfg.screencastQuality
+			}).catch(() => null);
+			if (birthShot?.data) relay.reseed({
+				seq: 0,
+				jpeg: birthShot.data,
+				metadata: {
+					seeded: true,
+					birth: true
+				}
+			});
+		}
 		if (options.spawnMcp ?? true) {
 			if (process.env.DSI_MCP_IN_PROCESS === "1") {
 				evictBrainPort(brainPort, id);
@@ -592,6 +992,7 @@ var BrowserRegistry = class {
 			pid,
 			profileDir,
 			createdAt: entry.createdAt,
+			ownerSessionId: entry.ownerSessionId,
 			mcp: entry.mcpChild ? "child" : entry.mcpInProcess ? "in-process" : "none",
 			mcpHealth: entry.mcpHealth,
 			mcpError: entry.mcpError
@@ -621,7 +1022,7 @@ var BrowserRegistry = class {
 		});
 	}
 	/** D8 owner-release. Idempotent: closing a closed id resolves cleanly. */
-	async close(id) {
+	async close(id, reason = "closed") {
 		const entry = state().entries.get(id);
 		if (!entry) return {
 			ok: true,
@@ -636,6 +1037,10 @@ var BrowserRegistry = class {
 		}
 		entry.closed = true;
 		state().closed.add(id);
+		for (const cb of entry.deathListeners ?? []) try {
+			cb(reason);
+		} catch {}
+		await entry.browserCdp?.detach().catch(() => void 0);
 		if (state().closed.size > 256) state().closed.delete(state().closed.values().next().value);
 		const errs = [];
 		if (entry.mcpInProcess) try {
@@ -731,24 +1136,244 @@ var BrowserRegistry = class {
 		await handle.cdp.send("Page.enable").catch(() => void 0);
 		const prevSeq = handle.relay.latestFrame()?.seq ?? -1;
 		await this.applyPanelViewport(e, handle);
-		await this.seedAfterResize(handle, prevSeq).catch(() => void 0);
-	}
-	/** ADR-0041 D3: a resize must REPAINT, not wait for the next page
-	*  change — the screencast speaks only on change, so a static page
-	*  keeps the old-aspect frame letterboxed on the panel forever (the
-	*  operator's black bands, 2026-10-25). Bounded grace for a FRESH
-	*  frame (seq past prevSeq); silence answers with the deterministic
-	*  captureScreenshot seed — activate()'s first-frame idiom re-fired
-	*  for the resize path. Never hangs the verb past the grace. */
-	async seedAfterResize(handle, prevSeq) {
-		for (let i = 0; i < 10 && (handle.relay.latestFrame()?.seq ?? -1) === prevSeq; i += 1) await new Promise((r) => setTimeout(r, 100));
-		if ((handle.relay.latestFrame()?.seq ?? -1) !== prevSeq) return;
+		await this.repairSurfaceAfterResize(e, handle, prevSeq).catch(() => void 0);
+	}
+	/** Layout-scale zoom (ADR-0041 amendment, 2026-10-31): store the session
+	*  scale and re-apply the panel viewport — the emulation is box/zoom, so
+	*  the slider's LIVE effect rides the resize. Bad input (clampZoom null)
+	*  KEEPS the current zoom and returns silently: unreachable from the wire
+	*  (the route's clampZoom already answered 400) — documented keep. */
+	async setZoom(id, zoom) {
+		const e = this.peek(id);
+		if (e.closed) throw new BrowserRegistryRefusal("CLOSED", "session is closing");
+		const clamped = clampZoom(zoom);
+		if (clamped === null) return;
+		e.zoom = clamped;
+		const handle = await this.handleOf(e);
+		await this.applyPanelViewport(e, handle);
+	}
+	/** The window id, retried — Target.getWindowForTarget on a Playwright
+	*  page session races out on a COLD headed launch (measured in the
+	*  surface-lag test: both resizes skipped, the birth window kept its
+	*  size). Three bounded tries; the caller's race caps still apply. */
+	async windowIdOf(anyCdp, race, targetId) {
+		for (let i = 0; i < 3; i += 1) {
+			const t = await race(anyCdp.send("Target.getWindowForTarget"), null);
+			if (t && t.windowId) return t;
+			const b = await race(anyCdp.send("Browser.getWindowForTarget", targetId ? { targetId } : {}), null);
+			if (b && b.windowId) return b;
+			await new Promise((r) => setTimeout(r, 500));
+		}
+		return null;
+	}
+	/** ADR-0041 D3 + the surface-lag repair (BUG 2026-10-26): a resize must
+	*  REPAINT at the REQUESTED size, not just emit SOME fresh frame. Two
+	*  failure shapes live here:
+	*  1. the SILENT page — the screencast speaks only on change, so a
+	*     static page never repaints (the 2026-10-25 black bands);
+	*  2. the STALE SURFACE — a headed off-screen window takes the new
+	*     RENDERER size but macOS never reallocates the compositor surface:
+	*     every frame (even captureScreenshot) keeps arriving at the OLD
+	*     height, and the panel letterboxes it (the operator's top/bottom
+	*     bands at every height grow). Measured: 53 frames over 6s all at
+	*     the old 832 while innerHeight was 919; captureScreenshot agreed
+	*     with the stale surface. A window-state BOUNCE (minimize ->
+	*     normal — invisible at -32000,-32000) forces the window server to
+	*     reallocate; frames then arrive at the requested size.
+	*  Ladder: grace for a frame whose JPEG dims MATCH the request ->
+	*  bounce (headed only) -> second grace -> deterministic
+	*  captureScreenshot reseed (reseed: a stale REAL frame may sit atop
+	*  the ring, and seed() refuses to cover one). Capped throughout —
+	*  nothing here may hang the verb (the 2.5s rule). */
+	async repairSurfaceAfterResize(e, handle, prevSeq) {
+		const want0 = {
+			w: e.viewport.width,
+			h: e.viewport.height
+		};
+		const lvw = layoutViewport(want0.w, want0.h, e.zoom ?? readBrowserConfig().contentZoom);
+		const want = {
+			w: lvw.width,
+			h: lvw.height
+		};
+		const dimsOf = (f) => {
+			if (!f) return null;
+			const md = f.metadata;
+			const mw = Number(md?.deviceWidth);
+			const mh = Number(md?.deviceHeight);
+			if (Number.isFinite(mw) && Number.isFinite(mh) && mw > 0 && mh > 0) return {
+				w: mw,
+				h: mh
+			};
+			const b = Buffer.from(f.jpeg, "base64");
+			let i = 2;
+			while (i < b.length - 9) {
+				if (b[i] !== 255) {
+					i += 1;
+					continue;
+				}
+				const marker = b[i + 1];
+				if (marker >= 192 && marker <= 207 && marker !== 196 && marker !== 200 && marker !== 204) return {
+					h: b.readUInt16BE(i + 5),
+					w: b.readUInt16BE(i + 7)
+				};
+				i += Math.max(2, b.readUInt16BE(i + 2));
+			}
+			return null;
+		};
+		const matched = () => {
+			const f = handle.relay.latestFrame();
+			if (!f || f.seq === prevSeq) return false;
+			const d = dimsOf(f);
+			return d !== null && Math.abs(d.w - want.w) < 3 && Math.abs(d.h - want.h) < 3;
+		};
+		for (let i = 0; i < 10 && !matched(); i += 1) await new Promise((r) => setTimeout(r, 100));
+		if (matched()) return;
+		if (e.headless) {
+			const raceH = async (p, fb) => {
+				const timeout = new Promise((res) => setTimeout(() => res(fb), 2500));
+				return await Promise.race([p.catch(() => fb), timeout]);
+			};
+			if (handle.page) await raceH(handle.page.setViewportSize({
+				width: want.w,
+				height: want.h
+			}).catch(() => void 0).then(() => null), null);
+			await new Promise((r) => setTimeout(r, 400));
+			const shotH = await raceH(handle.cdp.send("Page.captureScreenshot", {
+				format: "jpeg",
+				quality: readBrowserConfig().screencastQuality
+			}).catch(() => null), null);
+			if (shotH?.data) handle.relay.reseed({
+				seq: 0,
+				jpeg: shotH.data,
+				metadata: {
+					seeded: true,
+					resize: true
+				}
+			});
+			return;
+		}
+		if (!e.headless) {
+			const race = async (p, fb) => {
+				const timeout = new Promise((res) => setTimeout(() => res(fb), 2500));
+				return await Promise.race([p.catch(() => fb), timeout]);
+			};
+			const anyCdp = handle.cdp;
+			const win = await this.windowIdOf(anyCdp, race, e.activeTargetId ?? void 0);
+			if (win?.windowId) {
+				let cw = e.chrome?.w ?? 0;
+				let ch = e.chrome?.h ?? 0;
+				console.log("[surface] ladder start want", want.w + "x" + want.h, "learned chrome", cw + "/" + ch);
+				for (let i = 0; i < 3; i += 1) {
+					await race(anyCdp.send("Browser.setWindowBounds", {
+						windowId: win.windowId,
+						bounds: {
+							width: Math.max(200, want.w + cw),
+							height: Math.max(120, want.h + ch),
+							windowState: "normal"
+						}
+					}), null);
+					await new Promise((r) => setTimeout(r, 350));
+					const shot = await race(anyCdp.send("Page.captureScreenshot", {
+						format: "jpeg",
+						quality: 60
+					}), null);
+					let d = shot?.data ? dimsOf({
+						jpeg: shot.data,
+						metadata: {}
+					}) : null;
+					if (!d) d = dimsOf(handle.relay.latestFrame());
+					if (d && Math.abs(d.w - want.w) < 3 && Math.abs(d.h - want.h) < 3) {
+						console.log("[surface] iter", i, "converged: capture", d.w + "x" + d.h, "chrome", cw + "/" + ch);
+						e.chrome = {
+							w: cw,
+							h: ch
+						};
+						if (shot?.data) handle.relay.reseed({
+							seq: 0,
+							jpeg: shot.data,
+							metadata: {
+								seeded: true,
+								resize: true
+							}
+						});
+						return;
+					}
+					console.log("[surface] iter", i, "miss: capture", d ? d.w + "x" + d.h : "null", "at bounds", want.w + cw + "x" + (want.h + ch));
+					if (!d) continue;
+					const cur = await race(anyCdp.send("Browser.getWindowForTarget", { targetId: e.activeTargetId }), null);
+					if (cur?.bounds?.width && cur?.bounds?.height) {
+						cw = Math.max(0, cur.bounds.width - d.w);
+						ch = Math.max(0, cur.bounds.height - d.h);
+					} else {
+						cw += Math.max(0, want.w - d.w);
+						ch += Math.max(0, want.h - d.h);
+					}
+				}
+				e.chrome = {
+					w: cw,
+					h: ch
+				};
+				await race(anyCdp.send("Browser.setWindowBounds", {
+					windowId: win.windowId,
+					bounds: { windowState: "minimized" }
+				}), null);
+				await race(anyCdp.send("Browser.setWindowBounds", {
+					windowId: win.windowId,
+					bounds: { windowState: "normal" }
+				}), null);
+				await race(anyCdp.send("Browser.setWindowBounds", {
+					windowId: win.windowId,
+					bounds: {
+						width: Math.max(200, want.w + cw),
+						height: Math.max(120, want.h + ch),
+						windowState: "normal"
+					}
+				}), null);
+				await new Promise((r) => setTimeout(r, 300));
+				for (let i = 0; i < 10 && !matched(); i += 1) await new Promise((r) => setTimeout(r, 100));
+				if (matched()) return;
+				const parked = {
+					width: Math.max(200, want.w + cw),
+					height: Math.max(120, want.h + ch),
+					windowState: "normal"
+				};
+				await race(anyCdp.send("Browser.setWindowBounds", {
+					windowId: win.windowId,
+					bounds: {
+						...parked,
+						left: 10,
+						top: 10
+					}
+				}), null);
+				await new Promise((r) => setTimeout(r, 400));
+				await race(anyCdp.send("Browser.setWindowBounds", {
+					windowId: win.windowId,
+					bounds: {
+						...parked,
+						left: -32e3,
+						top: -32e3
+					}
+				}), null);
+				await new Promise((r) => setTimeout(r, 300));
+				for (let i = 0; i < 10 && !matched(); i += 1) await new Promise((r) => setTimeout(r, 100));
+				if (matched()) return;
+				console.log("[surface] ladder exhausted: bounce+flash ran, stream frames still", (() => {
+					const d = dimsOf(handle.relay.latestFrame());
+					return d ? d.w + "x" + d.h : "unknown";
+				})());
+			}
+		}
 		const cfg = readBrowserConfig();
 		const shot = await handle.cdp.send("Page.captureScreenshot", {
 			format: "jpeg",
 			quality: cfg.screencastQuality
 		}).catch(() => null);
-		if (shot?.data) handle.relay.seed({
+		const fd = shot?.data ? dimsOf({
+			jpeg: shot.data,
+			metadata: {}
+		}) : null;
+		console.log("[surface] final reseed capture:", fd ? fd.w + "x" + fd.h : "null", "want", want.w + "x" + want.h);
+		if (shot?.data) handle.relay.reseed({
 			seq: 0,
 			jpeg: shot.data,
 			metadata: {
@@ -790,6 +1415,44 @@ var BrowserRegistry = class {
 			entryCount: hist.entries.length
 		};
 	}
+	/** The FULL navigation history of one tab (long-press dropdown,
+	*  operator-approved 2026-10-28): the attached CDP session's
+	*  Page.getNavigationHistory, entries as { index, url, title } — index
+	*  is the LIST position the UI filters by, id is the CDP entryId the
+	*  travel verb needs. Read-only; the same handleOf refusals as navInfo. */
+	async navEntries(id, targetId) {
+		const e = this.peek(id);
+		const h = await this.handleOf(e, targetId);
+		await h.cdp.send("Page.enable").catch(() => void 0);
+		const hist = await h.cdp.send("Page.getNavigationHistory", {});
+		return {
+			currentIndex: hist.currentIndex,
+			entries: hist.entries.map((en, index) => ({
+				index,
+				url: en.url,
+				title: en.title
+			}))
+		};
+	}
+	/** TRUE history travel (long-press dropdown, operator-approved
+	*  2026-10-28): Page.navigateToHistoryEntry to the entry AT the list
+	*  position — never a fresh navigate, which would append a new entry
+	*  and desync the dropdown from Chrome's own back/forward list. A
+	*  position outside the list is an explicit refusal. */
+	async historyTravel(id, index, targetId) {
+		const e = this.peek(id);
+		const h = await this.handleOf(e, targetId);
+		await h.cdp.send("Page.enable").catch(() => void 0);
+		const hist = await h.cdp.send("Page.getNavigationHistory", {});
+		if (!Number.isInteger(index) || index < 0 || index >= hist.entries.length) throw new BrowserRegistryRefusal("NO_TARGET", "HISTORY_INDEX — no entry at index " + index + " of " + hist.entries.length);
+		const loaded = this.waitLoad(h);
+		await h.cdp.send("Page.navigateToHistoryEntry", { entryId: hist.entries[index].id });
+		await loaded;
+		return {
+			currentIndex: index,
+			entryCount: hist.entries.length
+		};
+	}
 	/** Reload the session's active page (ADR-0031 D4): Page.reload keeps
 	*  the history entry, unlike re-navigating the current URL. */
 	async reload(id, targetId) {
@@ -901,12 +1564,15 @@ var BrowserRegistry = class {
 			waitLoad: true,
 			targetId
 		});
+		const tabId = mintTabId(e, targetId);
 		if (opts?.activate ?? true) return {
 			...await this.activate(id, targetId),
-			targetId
+			targetId,
+			tabId
 		};
 		const h = e.tabs.get(targetId);
 		return {
+			tabId,
 			targetId,
 			seq: h?.relay.latestFrame()?.seq ?? 0,
 			jpeg: h?.relay.latestFrame()?.jpeg ?? null,
@@ -930,10 +1596,23 @@ var BrowserRegistry = class {
 	async applyPanelViewport(e, handle) {
 		await handle.cdp.send("Page.enable").catch(() => void 0);
 		if (e.headless && handle.page) {
-			await Promise.race([handle.page.setViewportSize({
-				width: e.viewport.width,
-				height: e.viewport.height
-			}).catch(() => void 0), new Promise((res) => setTimeout(res, 2500))]);
+			const lv = layoutViewport(e.viewport.width, e.viewport.height, e.zoom ?? readBrowserConfig().contentZoom);
+			const resized = handle.page.setViewportSize({
+				width: lv.width,
+				height: lv.height
+			}).catch(() => void 0);
+			await Promise.race([resized, new Promise((res) => setTimeout(res, 2500))]);
+			await Promise.race([resized, new Promise((res) => setTimeout(res, 5e3))]);
+			try {
+				const cdp = await handle.page.context().newCDPSession(handle.page);
+				const dprEval = await Promise.race([handle.page.evaluate("devicePixelRatio").catch(() => 1), new Promise((res) => setTimeout(() => res(1), 500))]);
+				await cdp.send("Emulation.setDeviceMetricsOverride", {
+					width: lv.width,
+					height: lv.height,
+					deviceScaleFactor: typeof dprEval === "number" && dprEval > 0 ? dprEval : 1,
+					mobile: false
+				}).catch(() => void 0);
+			} catch {}
 			return;
 		}
 		const race = async (p, fb) => await Promise.race([p.catch(() => fb), new Promise((res) => setTimeout(() => res(fb), 2500))]);
@@ -942,25 +1621,35 @@ var BrowserRegistry = class {
 			expression: "JSON.stringify({ oh: window.outerHeight - window.innerHeight, ow: window.outerWidth - window.innerWidth })",
 			returnByValue: true
 		}), null);
-		let chromeH = 0, chromeW = 0;
+		let chromeH = e.chrome?.h ?? 0;
+		let chromeW = e.chrome?.w ?? 0;
 		try {
 			const d = JSON.parse(dims && dims.result && dims.result.value || "{}");
-			chromeH = Number(d.oh) || 0;
-			chromeW = Number(d.ow) || 0;
+			const oh = Number(d.oh) || 0;
+			const ow = Number(d.ow) || 0;
+			if (oh > 0 || ow > 0) {
+				chromeH = oh;
+				chromeW = ow;
+			}
 		} catch {}
 		const anyCdp2 = handle.cdp;
-		const win = await race(anyCdp2.send("Target.getWindowForTarget"), null);
+		const win = await this.windowIdOf(anyCdp2, race);
 		if (win && win.windowId) {
+			const lv = layoutViewport(e.viewport.width, e.viewport.height, e.zoom ?? readBrowserConfig().contentZoom);
 			await race(anyCdp2.send("Browser.setWindowBounds", {
 				windowId: win.windowId,
 				bounds: {
-					width: Math.max(200, e.viewport.width + chromeW),
-					height: Math.max(120, e.viewport.height + chromeH),
+					width: Math.max(200, lv.width + chromeW),
+					height: Math.max(120, lv.height + chromeH),
 					windowState: "normal"
 				}
 			}), null);
+			if (chromeW > 0 || chromeH > 0) e.chrome = {
+				w: chromeW,
+				h: chromeH
+			};
 			const check = await race(anyCdp2.send("Browser.getWindowForTarget", { targetId: e.activeTargetId }), null);
-			console.log("[window] resized ->", JSON.stringify(check && check.bounds ? check.bounds : check), "want", e.viewport.width + chromeW, "x", e.viewport.height + chromeH);
+			console.log("[window] resized ->", JSON.stringify(check && check.bounds ? check.bounds : check), "want", lv.width + chromeW, "x", lv.height + chromeH);
 		} else console.log("[window] no windowId — resize skipped (raced out)");
 		await race(anyCdp2.send("Emulation.clearDeviceMetricsOverride"), null);
 	}
@@ -969,14 +1658,23 @@ var BrowserRegistry = class {
 	*  to the first surviving tab (re-activated, first-frame contract
 	*  re-fired). Closing the LAST tab is refused: the kill ladder owns
 	*  session death (the trash is the operator-facing kill). */
-	async closeTab(id, targetId) {
+	async closeTab(id, ref) {
 		const e = this.peek(id);
 		if (e.closed) throw new BrowserRegistryRefusal("CLOSED", "session is closing");
+		let targetId = ref;
+		if (typeof ref === "number" || /^\d+$/.test(ref)) {
+			const r = resolveTab(e, ref);
+			if (!r.ok) throw new BrowserRegistryRefusal("NO_TARGET", r.error);
+			targetId = r.targetId;
+		}
 		if (e.tabs.size <= 1) throw new BrowserRegistryRefusal("NO_TARGET", "cannot close the last tab — use the trash to close the glass");
 		const victim = e.tabs.get(targetId);
 		if (!victim) throw new BrowserRegistryRefusal("NO_TARGET", "no such tab: " + targetId);
 		victim.relay.stop();
 		e.tabs.delete(targetId);
+		retireTabId(e, targetId);
+		const ordIdx = (e.tabOrder ?? []).indexOf(targetId);
+		if (ordIdx !== -1) e.tabOrder.splice(ordIdx, 1);
 		await victim.cdp.send("Target.closeTarget", { targetId }).catch(() => void 0);
 		await victim.cdp.detach().catch(() => void 0);
 		if (e.activeTargetId === targetId) {
@@ -999,5 +1697,5 @@ var BrowserRegistry = class {
 };
 var browserRegistry = new BrowserRegistry();
 
-export { BrowserRegistryRefusal as B, browserRegistry as b };
-//# sourceMappingURL=registry.js-CZNJZ0C-.js.map
+export { BrowserRegistryRefusal as B, browserRegistry as b, clampZoom as c };
+//# sourceMappingURL=registry.js-CWnRQ4vx.js.map