@cmmd-center/forge 0.13.30 → 0.13.32

package/dist/bin.mjs

@@ -65937,7 +65937,7 @@ function normalizeNumberish(value) {
 }
 //#endregion
 //#region package.json
-var version$1 = "0.13.30";
+var version$1 = "0.13.32";
 //#endregion
 //#region src/sentry.ts
 const SERVER_APP_NAME = "forge-server";
@@ -100800,7 +100800,7 @@ var BrowserManager = class extends Service$1()("forge/browser/Services/Manager/B
 const DEFAULT_PORT_MIN = 5200;
 const DEFAULT_PORT_MAX = 5999;
 var ThreadDevRuntime = class extends Service$1()("forge/threadDevRuntime/ThreadDevRuntime") {};
-function nowIso$5() {
+function nowIso$7() {
 	return (/* @__PURE__ */ new Date()).toISOString();
 }
 function previewUrlForPort(port) {
@@ -100827,7 +100827,7 @@ const ThreadDevRuntimeLive = effect(ThreadDevRuntime, gen(function* () {
 				allocatedPort: port,
 				status: "allocated",
 				previewUrl: previewUrlForPort(port),
-				updatedAt: nowIso$5()
+				updatedAt: nowIso$7()
 			};
 			yield* update$4(byThreadId, (current) => {
 				const next = new Map(current);
@@ -100849,7 +100849,7 @@ const ThreadDevRuntimeLive = effect(ThreadDevRuntime, gen(function* () {
 				next.set(input.threadId, {
 					...existing,
 					status: "released",
-					updatedAt: nowIso$5()
+					updatedAt: nowIso$7()
 				});
 				return next;
 			});
@@ -100875,7 +100875,7 @@ const ThreadDevRuntimeLive = effect(ThreadDevRuntime, gen(function* () {
 				...patch.terminalId !== void 0 ? { terminalId: patch.terminalId } : {},
 				...patch.previewUrl !== void 0 ? { previewUrl: patch.previewUrl } : {},
 				...patch.tunnelId !== void 0 ? { tunnelId: patch.tunnelId } : {},
-				updatedAt: nowIso$5()
+				updatedAt: nowIso$7()
 			};
 			yield* update$4(byThreadId, (current) => {
 				const next = new Map(current);
@@ -230852,7 +230852,7 @@ const OpenCodeRuntimeLive = effect(OpenCodeRuntime, makeOpenCodeRuntime).pipe(pr
 //#endregion
 //#region src/provider/Layers/OpenCodeAdapter.ts
 const PROVIDER$5 = "opencode";
-const nowIso$4 = map$3(now, formatIso);
+const nowIso$6 = map$3(now, formatIso);
 /**
 * Map a tagged OpenCodeRuntimeError produced by {@link runOpenCodeSdk} into
 * the adapter-boundary `ProviderAdapterRequestError`. SDK-method-level call
@@ -230879,7 +230879,7 @@ const toProcessError = (threadId, cause) => new ProviderAdapterProcessError({
 });
 const buildEventBase = (input) => gen(function* () {
 	const uuid = yield* nextUUIDv4;
-	const createdAt = input.createdAt ?? (yield* nowIso$4);
+	const createdAt = input.createdAt ?? (yield* nowIso$6);
 	return {
 		eventId: EventId.make(uuid),
 		provider: PROVIDER$5,
@@ -231038,7 +231038,7 @@ function sessionErrorMessage(error) {
 }
 function updateProviderSession(context, patch, options) {
 	return gen(function* () {
-		const updatedAt = yield* nowIso$4;
+		const updatedAt = yield* nowIso$6;
 		const nextSession = {
 			...context.session,
 			...patch,
@@ -231160,7 +231160,7 @@ function makeOpenCodeAdapter(openCodeSettings, options) {
 			if (("properties" in event ? event.properties.sessionID : void 0) !== context.openCodeSessionId) return;
 			const turnId = context.activeTurnId;
 			yield* writeNativeEventBestEffort(context.session.threadId, {
-				observedAt: yield* nowIso$4,
+				observedAt: yield* nowIso$6,
 				event: {
 					provider: PROVIDER$5,
 					threadId: context.session.threadId,
@@ -231476,7 +231476,7 @@ function makeOpenCodeAdapter(openCodeSettings, options) {
 				yield* close(started.sessionScope, void_$3).pipe(ignore);
 				return raceWinner.session;
 			}
-			const createdAt = yield* nowIso$4;
+			const createdAt = yield* nowIso$6;
 			const session = {
 				provider: PROVIDER$5,
 				status: "ready",
@@ -238648,7 +238648,7 @@ function filterEvents(events, options) {
 	});
 	return options.limit === void 0 ? filtered : filtered.slice(-options.limit);
 }
-function nowIso$3() {
+function nowIso$5() {
 	return (/* @__PURE__ */ new Date()).toISOString();
 }
 //#endregion
@@ -238663,7 +238663,7 @@ var BrowserActionEventRecorder = class {
 			type: "browser.action",
 			action,
 			...this.sessionFields(),
-			timestamp: nowIso$3()
+			timestamp: nowIso$5()
 		});
 	}
 	async result(action) {
@@ -238672,7 +238672,7 @@ var BrowserActionEventRecorder = class {
 			action,
 			ok: true,
 			...this.sessionFields(),
-			timestamp: nowIso$3()
+			timestamp: nowIso$5()
 		});
 	}
 	async error(action, error) {
@@ -238681,7 +238681,7 @@ var BrowserActionEventRecorder = class {
 			action,
 			error: error instanceof Error ? error.message : String(error),
 			...this.sessionFields(),
-			timestamp: nowIso$3()
+			timestamp: nowIso$5()
 		});
 	}
 	sessionFields() {
@@ -239184,7 +239184,7 @@ var AgentBrowser = class {
 		await this.options.events?.record({
 			type: "browser.safety.confirmation.requested",
 			...request,
-			createdAt: nowIso$3()
+			createdAt: nowIso$5()
 		});
 		const result = await this.resolveConfirmation(request);
 		const approved = typeof result === "boolean" ? result : result.approved;
@@ -239192,7 +239192,7 @@ var AgentBrowser = class {
 			type: "browser.safety.confirmation.resolved",
 			approved,
 			requestId: request.requestId,
-			resolvedAt: nowIso$3(),
+			resolvedAt: nowIso$5(),
 			...this.events.sessionFields()
 		});
 		if (!approved) throw new BrowserSafetyError(decision.reason ?? "Browser action was not confirmed.", action, {
@@ -240322,6 +240322,1254 @@ function isPromiseLike(value) {
 	return !!value && typeof value.then === "function";
 }
 //#endregion
+//#region src/sprite/spriteTaskHold.ts
+/**
+* Keeps a Fly.io Sprite awake for the duration of an agent turn.
+*
+* ── why this exists ─────────────────────────────────────────────────────────
+* A sprite's container cgroup is frozen within ~1 second of the last inbound
+* request. Processes are paused mid-instruction, not killed, and resume when
+* traffic returns. Measured on a throwaway sprite with a 1 Hz ticker
+* (`pocs/sprite-lifecycle-spike/`):
+*
+*   detached, nothing connected      2 ticks / 121 s  =   1.7%
+*   with a task hold               90 ticks /  90 s  = 100%
+*
+* So an agent turn that nobody is watching effectively stops. fly.io names our
+* previous approach — relying on a running process after disconnection — as an
+* anti-pattern, and points at the Tasks API instead. See
+* https://docs.sprites.dev/keeping-sprites-running/ and
+* `docs/specs/2026-07-30-sprites-platform-ground-truth.md` §1.
+*
+* Note that Services (the platform supervisor) do NOT solve this: "a Sprite with
+* ten services defined still pauses when it goes idle." Supervision and
+* wakefulness are separate primitives, and this module is only the second one.
+*
+* ── why it lives in the guest ───────────────────────────────────────────────
+* The Tasks API is guest-only. `GET https://api.sprites.dev/v1/sprites/{n}/tasks`
+* answers 404; the socket at /.sprite/api.sock is the only surface. CMMD cannot
+* take this hold on our behalf, which is why the env vars below are exported by
+* CMMD's provider and consumed here.
+*
+* ── the ordering rules ──────────────────────────────────────────────────────
+* 1. The refresher MUST be stopped before the DELETE is issued. A refresher that
+*    outlives the delete re-acquires the hold on its next tick; that was
+*    previously measured leaking 37 renewals over 18 minutes, pinning a sprite
+*    running — and billing — 33 minutes after its work had ended.
+* 2. Stopping the interval only cancels FUTURE ticks. A PUT already on the wire
+*    must be JOINED before the DELETE, or it lands afterwards and recreates the
+*    hold for another full expiry window. fly.io's reference worker cancels and
+*    awaits its heartbeat for the same reason.
+* 3. `release` can arrive while `acquire` is still awaiting its own PUT —
+*    `releaseAll` runs from runtime drain and the shutdown finalizer,
+*    concurrently with the provider event stream. The hold is registered before
+*    that await (so a duplicate turn.started cannot double-acquire), so release
+*    can remove the map entry first; `acquire` must then NOT install a
+*    refresher. One attached to an unmapped hold is unreachable by release,
+*    releaseThread and releaseAll alike, and re-PUTs every 60 s for the life of
+*    the process — an unbounded pin.
+*
+* All three are pinned by tests.
+*
+* Pure and dependency-free on purpose, for the same reason as
+* `provider/claudeCredentialContainment.ts`: this rule is cost-critical and must
+* stay directly unit-testable without booting the Effect runtime.
+*/
+/** Set by CMMD's Sprites provider on every project sprite. Absent elsewhere. */
+const SPRITE_TASK_HOLD_SOCKET_ENV = "FORGE_CMMD_SPRITE_TASK_HOLD_SOCKET";
+const SPRITE_TASK_HOLD_REFRESH_MS = 6e4;
+/**
+* Per-request deadline for the guest-socket calls. Must stay strictly under
+* SPRITE_TASK_HOLD_REFRESH_MS: the manager serializes refreshes, so a PUT that
+* never settles turns every later tick into a no-op and the hold expires
+* mid-turn. Bounding the call means a hung socket settles as a rejection, the
+* next 60 s tick retries, and release is not wedged joining it. From the last
+* good refresh there are still four attempts (+60/+120/+180/+240 s) before the
+* 300 s expiry. 10 s matches the `-m 10` cap CMMD already puts on every curl in
+* its own hold preamble; the guest-side manager was the one path left unbounded.
+*/
+const SPRITE_TASK_HOLD_REQUEST_TIMEOUT_MS = 1e4;
+/**
+* Resolve the hold configuration from the process environment.
+*
+* Returns null on every runtime that is not a project sprite — desktop-local and
+* browser runtimes have no `/.sprite/api.sock`, so the whole feature no-ops
+* there rather than erroring.
+*/
+function resolveSpriteTaskHoldConfig(env = process.env) {
+	const socketPath = env[SPRITE_TASK_HOLD_SOCKET_ENV]?.trim();
+	if (socketPath === void 0 || socketPath.length === 0) return null;
+	return {
+		socketPath,
+		namePrefix: env["FORGE_CMMD_SPRITE_TASK_HOLD_PREFIX"]?.trim() ?? ""
+	};
+}
+/**
+* Hold names must be unique per turn: several git worktrees inside one sprite
+* can run turns concurrently, and each has to be released independently.
+*/
+function spriteTaskHoldName(namePrefix, turnId) {
+	return `${namePrefix}${turnId}`;
+}
+const DEFAULT_TIMER = {
+	setInterval: (handler, ms) => setInterval(handler, ms),
+	clearInterval: (handle) => {
+		clearInterval(handle);
+	}
+};
+/**
+* Tracks one hold per active turn.
+*
+* Every method is failure-tolerant by design. Acquiring a hold is an
+* optimisation, not a precondition: if it fails the turn still runs, just at the
+* degraded speed it has today. Failing the turn instead would convert a billing
+* inefficiency into an outage.
+*/
+var SpriteTaskHoldManager = class {
+	#config;
+	#transport;
+	#timer;
+	#onError;
+	#holds = /* @__PURE__ */ new Map();
+	constructor(options) {
+		this.#config = options.config;
+		this.#transport = options.transport;
+		this.#timer = options.timer ?? DEFAULT_TIMER;
+		this.#onError = options.onError ?? (() => {});
+	}
+	/** Turn ids that currently hold the sprite awake. Test/diagnostic surface. */
+	activeTurnIds() {
+		return [...this.#holds.keys()];
+	}
+	async acquire(turnId, threadId = null) {
+		if (this.#holds.has(turnId)) return;
+		const name = spriteTaskHoldName(this.#config.namePrefix, turnId);
+		const hold = {
+			name,
+			threadId,
+			refresher: null,
+			inFlight: /* @__PURE__ */ new Set(),
+			released: false
+		};
+		this.#holds.set(turnId, hold);
+		const put = this.#transport.put(name, 300);
+		const tracked = put.then(() => {}, () => {});
+		hold.inFlight.add(tracked);
+		try {
+			await put;
+		} catch (cause) {
+			hold.inFlight.delete(tracked);
+			this.#onError(`failed to acquire sprite task hold for turn ${turnId}`, cause);
+			if (hold.released || this.#holds.get(turnId) !== hold) return;
+		}
+		hold.inFlight.delete(tracked);
+		if (hold.released || this.#holds.get(turnId) !== hold) return;
+		hold.refresher = this.#timer.setInterval(() => {
+			if (hold.inFlight.size > 0) return;
+			const refresh = this.#transport.put(name, 300).catch((cause) => this.#onError(`failed to refresh sprite task hold for turn ${turnId}`, cause));
+			hold.inFlight.add(refresh);
+			refresh.finally(() => hold.inFlight.delete(refresh));
+		}, SPRITE_TASK_HOLD_REFRESH_MS);
+	}
+	async release(turnId) {
+		const hold = this.#holds.get(turnId);
+		if (!hold) return;
+		hold.released = true;
+		if (hold.refresher !== null) {
+			this.#timer.clearInterval(hold.refresher);
+			hold.refresher = null;
+		}
+		this.#holds.delete(turnId);
+		if (hold.inFlight.size > 0) await Promise.all(hold.inFlight);
+		try {
+			await this.#transport.delete(hold.name);
+		} catch (cause) {
+			this.#onError(`failed to release sprite task hold for turn ${turnId}`, cause);
+		}
+	}
+	/**
+	* Release every hold belonging to one thread.
+	*
+	* `session.exited` names only the thread whose provider process died, and a
+	* dead session's turn will never emit `turn.completed`. Releasing by thread —
+	* rather than releasing everything — is what keeps a crash in one worktree
+	* from silently dropping the holds of the other turns running beside it.
+	*/
+	async releaseThread(threadId) {
+		const turnIds = [...this.#holds.entries()].filter(([, hold]) => hold.threadId === threadId).map(([turnId]) => turnId);
+		await Promise.all(turnIds.map((turnId) => this.release(turnId)));
+	}
+	/**
+	* Release everything. Runtime drain and server shutdown must call this, or a
+	* drained sprite keeps billing until each hold expires.
+	*/
+	async releaseAll() {
+		await Promise.all([...this.#holds.keys()].map((turnId) => this.release(turnId)));
+	}
+};
+/**
+* HTTP-over-unix-socket transport for the guest API.
+*
+* Bun's fetch takes a `unix` option; the URL host is ignored by the socket but
+* still has to parse, which is why it is the literal `http://sprite` the
+* platform docs use.
+*/
+function makeSpriteTaskHoldTransport(config, fetchImpl = fetch) {
+	const call = async (path, init) => {
+		const controller = new AbortController();
+		const deadline = setTimeout(() => controller.abort(), SPRITE_TASK_HOLD_REQUEST_TIMEOUT_MS);
+		try {
+			const response = await fetchImpl(`http://sprite/v1/tasks${path}`, {
+				...init,
+				signal: controller.signal,
+				unix: config.socketPath
+			});
+			if (!response.ok) throw new Error(`sprite task API responded ${response.status}`);
+		} finally {
+			clearTimeout(deadline);
+		}
+	};
+	return {
+		put: (name, expireSeconds) => call(`/${encodeURIComponent(name)}`, {
+			method: "PUT",
+			headers: { "content-type": "application/json" },
+			body: JSON.stringify({ expire: `${expireSeconds}s` })
+		}),
+		delete: (name) => call(`/${encodeURIComponent(name)}`, { method: "DELETE" })
+	};
+}
+/**
+* Build a manager for this process, or null when the runtime is not a sprite.
+* Callers treat null as "this feature does not apply here".
+*/
+function makeSpriteTaskHoldManager(env = process.env, onError) {
+	const config = resolveSpriteTaskHoldConfig(env);
+	if (config === null) return null;
+	return new SpriteTaskHoldManager({
+		config,
+		transport: makeSpriteTaskHoldTransport(config),
+		...onError ? { onError } : {}
+	});
+}
+//#endregion
+//#region src/browser/AgentBrowserHostBridgeCommands.ts
+const DEFAULT_AGENT_BROWSER_VIEWPORT = {
+	width: 1280,
+	height: 720
+};
+const ABSOLUTE_WEB_URL_PATTERN = /^[a-z][a-z\d+\-.]*:\/\//i;
+const SPECIAL_URL_PATTERN = /^(about|blob|chrome|data|devtools|file):/i;
+const LOCAL_URL_LIKE_PATTERN = /^(localhost|127\.0\.0\.1|\[::1\]|::1|[a-z0-9.-]+\.localhost)(?::\d+)?(?:[/?#].*)?$/i;
+function nowIso$4() {
+	return (/* @__PURE__ */ new Date()).toISOString();
+}
+function normalizeUserVisibleBrowserUrl(url) {
+	const trimmed = url.trim();
+	if (trimmed.length === 0) return trimmed;
+	if (ABSOLUTE_WEB_URL_PATTERN.test(trimmed) || SPECIAL_URL_PATTERN.test(trimmed) || trimmed.startsWith("//")) return trimmed;
+	if (LOCAL_URL_LIKE_PATTERN.test(trimmed)) return `http://${trimmed}`;
+	return `https://${trimmed}`;
+}
+function isAgentBrowserBoundedControlCommand(command) {
+	switch (command.type) {
+		case "click":
+		case "clickPoint":
+		case "pressKey":
+		case "resetViewport":
+		case "scroll":
+		case "setViewport":
+		case "type":
+		case "typeText":
+		case "wheel": return true;
+		default: return false;
+	}
+}
+function snapshotAfterTimedOutControl(snapshot, command) {
+	switch (command.type) {
+		case "setViewport": return {
+			...snapshot,
+			viewport: command.viewport,
+			updatedAt: nowIso$4()
+		};
+		case "resetViewport": return {
+			...snapshot,
+			viewport: DEFAULT_AGENT_BROWSER_VIEWPORT,
+			updatedAt: nowIso$4()
+		};
+		default: return snapshot;
+	}
+}
+const HOST_COMMAND_MAPPERS = {
+	activateTab: (command) => ({
+		type: "activateTab",
+		tabId: command.tabId
+	}),
+	click: (command) => ({
+		type: "click",
+		tabId: command.tabId,
+		selector: command.selector
+	}),
+	clickPoint: (command) => ({
+		type: "clickPoint",
+		tabId: command.tabId,
+		x: command.x,
+		y: command.y,
+		...command.button !== void 0 ? { button: command.button } : {},
+		...command.clickCount !== void 0 ? { clickCount: command.clickCount } : {}
+	}),
+	closeTab: (command) => ({
+		type: "closeTab",
+		tabId: command.tabId
+	}),
+	consoleLogs: (command) => ({
+		type: "consoleLogs",
+		...command.tabId !== void 0 ? { tabId: command.tabId } : {},
+		...command.limit !== void 0 ? { limit: command.limit } : {},
+		...command.levels !== void 0 ? { levels: command.levels } : {}
+	}),
+	goBack: (command) => ({
+		type: "goBack",
+		tabId: command.tabId
+	}),
+	goForward: (command) => ({
+		type: "goForward",
+		tabId: command.tabId
+	}),
+	nameSession: (command) => ({
+		type: "nameSession",
+		name: command.name
+	}),
+	navigate: (command) => ({
+		type: "navigate",
+		url: normalizeUserVisibleBrowserUrl(command.url),
+		...command.tabId !== void 0 ? { tabId: command.tabId } : {}
+	}),
+	newTab: (command) => ({
+		type: "newTab",
+		...command.url !== void 0 ? { url: normalizeUserVisibleBrowserUrl(command.url) } : {},
+		...command.makeActive !== void 0 ? { makeActive: command.makeActive } : {}
+	}),
+	pressKey: (command) => ({
+		type: "pressKey",
+		tabId: command.tabId,
+		key: command.key
+	}),
+	reload: (command) => ({
+		type: "reload",
+		tabId: command.tabId
+	}),
+	resetViewport: () => ({ type: "resetViewport" }),
+	screenshot: (command) => ({
+		type: "screenshot",
+		tabId: command.tabId,
+		...command.fullPage !== void 0 ? { fullPage: command.fullPage } : {}
+	}),
+	scroll: (command) => ({
+		type: "scroll",
+		tabId: command.tabId,
+		scrollX: 0,
+		scrollY: command.toTop === true ? -900 : 900,
+		...command.x !== void 0 ? { x: command.x } : {},
+		...command.y !== void 0 ? { y: command.y } : {}
+	}),
+	setViewport: (command) => ({
+		type: "setViewport",
+		viewport: command.viewport
+	}),
+	setVisibility: (command) => ({
+		type: "setVisibility",
+		visibility: command.visibility
+	}),
+	snapshot: (command) => ({
+		type: "snapshot",
+		tabId: command.tabId
+	}),
+	type: (command) => ({
+		type: "type",
+		tabId: command.tabId,
+		selector: command.selector,
+		text: command.text,
+		...command.append !== void 0 ? { append: command.append } : {}
+	}),
+	typeText: (command) => ({
+		type: "typeText",
+		tabId: command.tabId,
+		text: command.text,
+		...command.pressEnter !== void 0 ? { pressEnter: command.pressEnter } : {}
+	}),
+	wheel: (command) => ({
+		type: "wheel",
+		tabId: command.tabId,
+		deltaX: command.deltaX,
+		deltaY: command.deltaY,
+		...command.x !== void 0 ? { x: command.x } : {},
+		...command.y !== void 0 ? { y: command.y } : {}
+	})
+};
+function toHostCommand(command) {
+	return HOST_COMMAND_MAPPERS[command.type](command);
+}
+function commandCaptureTabId(command) {
+	switch (command.type) {
+		case "snapshot":
+		case "screenshot": return command.tabId;
+		default: return;
+	}
+}
+//#endregion
+//#region src/browser/AgentBrowserHostBridgeDisplay.ts
+const REMOTE_WEBRTC_UNAVAILABLE_DETAIL = "Remote WebRTC browser display is not available: the current Agent Browser runtime exposes tab control but does not provide a media transport.";
+const REMOTE_WEBRTC_RELAY_REQUIRED_DETAIL = "Remote WebRTC browser display requires a TURN relay in cloud mode. Configure FORGE_BROWSER_WEBRTC_ICE_SERVERS with authenticated turn: or turns: URLs.";
+function remoteWebRtcUnavailableError(_input) {
+	return new BrowserError({ detail: REMOTE_WEBRTC_UNAVAILABLE_DETAIL });
+}
+function remoteWebRtcRelayRequiredError(_input) {
+	return new BrowserError({ detail: REMOTE_WEBRTC_RELAY_REQUIRED_DETAIL });
+}
+function agentBrowserDisplayForRuntimeMode(input) {
+	if (input.mode !== "desktop") {
+		const hasRelay = hasTurnRelay(input.iceServers ?? []);
+		return {
+			transport: "remote-webrtc",
+			status: "degraded",
+			reason: input.requiresRelay === true && !hasRelay ? "network_unreachable" : "transport_unavailable",
+			detail: input.requiresRelay === true && !hasRelay ? REMOTE_WEBRTC_RELAY_REQUIRED_DETAIL : "Remote WebRTC browser display is not attached yet.",
+			...input.viewport ? { viewport: input.viewport } : {},
+			...input.iceServers && input.iceServers.length > 0 ? { iceServers: input.iceServers } : {},
+			reconnect: {
+				status: "ready",
+				attempt: 0
+			}
+		};
+	}
+	return {
+		transport: "native-embedded",
+		status: "connected",
+		...input.viewport ? { viewport: input.viewport } : {},
+		reconnect: {
+			status: "ready",
+			attempt: 0
+		}
+	};
+}
+function hasTurnRelay(iceServers) {
+	return browserWebRtcIceServersIncludeRelay(iceServers);
+}
+async function resolveDisplayIceServers(options) {
+	return options?.resolveDisplayIceServers ? await options.resolveDisplayIceServers() : options?.displayIceServers ?? [];
+}
+function webRtcDisplayRequiresRelay(serverConfig) {
+	return serverConfig.mode === "web" && serverConfig.devUrl === void 0;
+}
+//#endregion
+//#region src/browser/AgentBrowserHostBridgeProjection.ts
+const DEFAULT_URL$1 = "about:blank";
+const DEFAULT_RENDER_MODE = "interactive";
+const DEFAULT_AGENT_BROWSER_DISPLAY = {
+	transport: "remote-webrtc",
+	status: "connected",
+	reconnect: {
+		status: "ready",
+		attempt: 0
+	}
+};
+function nowIso$3() {
+	return (/* @__PURE__ */ new Date()).toISOString();
+}
+function toForgeTab(input) {
+	return {
+		tabId: BrowserTabId.make(input.tab.id),
+		restoreKey: input.tab.id,
+		...input.tab.title ? { title: input.tab.title } : {},
+		url: input.tab.url ?? DEFAULT_URL$1,
+		isActive: input.tab.isActive,
+		canGoBack: input.tab.canGoBack ?? false,
+		canGoForward: input.tab.canGoForward ?? false,
+		renderMode: DEFAULT_RENDER_MODE,
+		status: "live",
+		...input.tab.navigationStatus !== void 0 ? { navigationStatus: input.tab.navigationStatus } : {},
+		...input.tab.requestedUrl !== void 0 ? { requestedUrl: input.tab.requestedUrl } : {},
+		...input.tab.navigationError !== void 0 ? { navigationError: input.tab.navigationError } : {},
+		updatedAt: input.updatedAt
+	};
+}
+function toForgeSession(input) {
+	return {
+		browserId: BrowserId.make(input.snapshot.browserId),
+		threadId: input.threadId,
+		environmentId: EnvironmentId.make(input.environmentId ?? DEFAULT_BROWSER_ENVIRONMENT_ID),
+		userId: BrowserUserId.make(input.userId ?? "local-user"),
+		agentId: input.agentId ?? null,
+		ownerRole: input.ownerRole ?? "lead",
+		name: input.snapshot.name,
+		visibility: input.snapshot.visibility,
+		viewport: input.snapshot.viewport,
+		display: input.display ?? DEFAULT_AGENT_BROWSER_DISPLAY,
+		sessionId: BrowserSessionId.make(input.snapshot.sessionId),
+		...input.controlState ? {
+			sessionEpoch: input.controlState.sessionEpoch,
+			lastAppliedControlSequence: input.controlState.lastAppliedControlSequence
+		} : {},
+		activeTabId: input.snapshot.activeTabId ? BrowserTabId.make(input.snapshot.activeTabId) : null,
+		tabs: input.snapshot.tabs.map((tab) => toForgeTab({
+			tab,
+			updatedAt: input.snapshot.updatedAt
+		})),
+		updatedAt: input.snapshot.updatedAt
+	};
+}
+function toStreamEvent(input) {
+	const base = {
+		eventId: EventId.make(crypto.randomUUID()),
+		browserId: input.browserId,
+		threadId: input.threadId,
+		environmentId: EnvironmentId.make(input.environmentId),
+		userId: BrowserUserId.make(input.userId),
+		agentId: input.agentId,
+		...input.controlState ? { sessionEpoch: input.controlState.sessionEpoch } : {},
+		createdAt: nowIso$3()
+	};
+	switch (input.event.type) {
+		case "session.started": return {
+			...base,
+			type: "session.started",
+			payload: { snapshot: toForgeSession({
+				snapshot: input.event.payload.snapshot,
+				threadId: input.threadId,
+				environmentId: input.environmentId,
+				userId: input.userId,
+				agentId: input.agentId,
+				ownerRole: input.ownerRole,
+				display: input.display,
+				controlState: input.controlState
+			}) }
+		};
+		case "session.updated": return {
+			...base,
+			type: input.event.type,
+			payload: { snapshot: toForgeSession({
+				snapshot: input.event.payload.snapshot,
+				threadId: input.threadId,
+				environmentId: input.environmentId,
+				userId: input.userId,
+				agentId: input.agentId,
+				ownerRole: input.ownerRole,
+				display: input.display,
+				controlState: input.controlState
+			}) }
+		};
+		case "session.closed": return {
+			...base,
+			type: "session.closed",
+			payload: { sessionId: BrowserSessionId.make(input.event.payload.sessionId) }
+		};
+		case "tab.closed": return {
+			...base,
+			type: "tab.closed",
+			payload: {
+				sessionId: BrowserSessionId.make(input.event.sessionId),
+				tabId: BrowserTabId.make(input.event.payload.tabId)
+			}
+		};
+		case "snapshot.ready": return {
+			...base,
+			type: "snapshot.ready",
+			payload: {
+				sessionId: BrowserSessionId.make(input.event.sessionId),
+				tabId: BrowserTabId.make(input.event.payload.tabId),
+				captureId: BrowserCaptureId.make(input.event.payload.captureId ?? crypto.randomUUID()),
+				capturedAt: input.event.payload.capturedAt,
+				url: input.event.payload.url ?? DEFAULT_URL$1,
+				viewport: input.event.payload.viewport,
+				content: input.event.payload.content
+			}
+		};
+		case "screenshot.ready": return {
+			...base,
+			type: "screenshot.ready",
+			payload: {
+				sessionId: BrowserSessionId.make(input.event.sessionId),
+				tabId: BrowserTabId.make(input.event.payload.tabId),
+				captureId: BrowserCaptureId.make(input.event.payload.captureId ?? crypto.randomUUID()),
+				capturedAt: input.event.payload.capturedAt,
+				url: input.event.payload.url ?? DEFAULT_URL$1,
+				viewport: input.event.payload.viewport,
+				imageDataUrl: input.event.payload.imageDataUrl
+			}
+		};
+		case "console.logs.ready": return {
+			...base,
+			type: "console.logs.ready",
+			payload: {
+				sessionId: BrowserSessionId.make(input.event.sessionId),
+				tabId: BrowserTabId.make(input.event.payload.tabId),
+				logs: input.event.payload.logs.map((log) => ({
+					level: log.level === "warn" ? "warning" : log.level === "log" ? "info" : log.level,
+					message: log.message,
+					createdAt: log.timestamp
+				}))
+			}
+		};
+		case "action.failed": return {
+			...base,
+			type: "action.failed",
+			payload: {
+				commandType: input.event.payload.commandType,
+				message: input.event.payload.message,
+				...input.event.payload.tabId ? { tabId: BrowserTabId.make(input.event.payload.tabId) } : {}
+			}
+		};
+		case "dom.visible.ready":
+		case "element.info.ready":
+		case "element.screenshot.ready":
+		case "clipboard.text.ready": return null;
+	}
+}
+function toCommandResult(input) {
+	return {
+		ok: input.result.ok,
+		snapshot: toForgeSession({
+			snapshot: input.result.snapshot,
+			threadId: input.command.threadId,
+			environmentId: input.command.environmentId,
+			userId: input.command.userId,
+			display: input.display,
+			controlState: input.controlState
+		}),
+		sessionEpoch: input.controlState.sessionEpoch,
+		acknowledgedControlSequence: input.acknowledgedControlSequence,
+		...input.result.detail ? { detail: input.result.detail } : {},
+		...input.latestCapture ? { latestCapture: input.latestCapture } : {}
+	};
+}
+function toCommandLatestCapture(input) {
+	const tabId = commandCaptureTabId(input.command.command);
+	if (tabId === void 0 || input.event.type !== "snapshot.ready" && input.event.type !== "screenshot.ready" || input.event.sessionId !== BrowserSessionId.make(input.command.threadId) || input.event.payload.tabId !== tabId) return;
+	const mapped = toStreamEvent({
+		event: input.event,
+		threadId: input.command.threadId,
+		browserId: input.browserId,
+		environmentId: input.command.environmentId ?? DEFAULT_BROWSER_ENVIRONMENT_ID,
+		userId: input.command.userId ?? "local-user",
+		agentId: null,
+		ownerRole: "lead",
+		display: input.display,
+		controlState: input.controlState
+	});
+	return mapped?.type === "snapshot.ready" || mapped?.type === "screenshot.ready" ? mapped : void 0;
+}
+//#endregion
+//#region src/browser/AgentBrowserHostBridgeShared.ts
+const DEFAULT_AGENT_BROWSER_ID = "embedded";
+const DEFAULT_URL = "about:blank";
+const isBrowserError = is$1(BrowserError);
+function nowIso$2() {
+	return (/* @__PURE__ */ new Date()).toISOString();
+}
+function sessionIdForThread(threadId) {
+	return BrowserSessionId.make(threadId);
+}
+function browserIdFrom(input) {
+	return BrowserId.make(input.browserId ?? "embedded");
+}
+function toBrowserError(error, fallback) {
+	console.warn("[browser] Agent Browser host bridge operation failed", {
+		operation: fallback,
+		error
+	});
+	if (isBrowserError(error)) return error;
+	if (error instanceof Error && error.message.trim().length > 0) return new BrowserError({ detail: error.message.trim() });
+	return new BrowserError({ detail: fallback });
+}
+//#endregion
+//#region src/browser/AgentBrowserHostBridgeTimeouts.ts
+const DEFAULT_AGENT_BROWSER_CONTROL_COMMAND_TIMEOUT_MS = 1500;
+const DEFAULT_AGENT_BROWSER_FAST_COMMAND_TIMEOUT_MS = 1e4;
+const DEFAULT_AGENT_BROWSER_NAVIGATION_COMMAND_TIMEOUT_MS = 9e4;
+const DEFAULT_AGENT_BROWSER_CAPTURE_COMMAND_TIMEOUT_MS = 9e4;
+const DEFAULT_AGENT_BROWSER_BRIDGE_OPEN_TIMEOUT_MS = 9e4;
+const DEFAULT_AGENT_BROWSER_BRIDGE_CLOSE_TIMEOUT_MS = 3e4;
+const DEFAULT_AGENT_BROWSER_PLAYWRIGHT_BACKEND_CLOSE_TIMEOUT_MS = 1e4;
+function positiveTimeoutMs(value) {
+	if (!value) return;
+	const parsed = Number.parseInt(value, 10);
+	return Number.isFinite(parsed) && parsed > 0 ? parsed : void 0;
+}
+function agentBrowserCommandTimeoutMs(command, env = process.env) {
+	const explicitCommandTimeout = positiveTimeoutMs(env.FORGE_AGENT_BROWSER_BRIDGE_COMMAND_TIMEOUT_MS);
+	if (explicitCommandTimeout !== void 0) return explicitCommandTimeout;
+	if (isAgentBrowserBoundedControlCommand(command)) return positiveTimeoutMs(env.FORGE_AGENT_BROWSER_BRIDGE_CONTROL_TIMEOUT_MS) ?? DEFAULT_AGENT_BROWSER_CONTROL_COMMAND_TIMEOUT_MS;
+	switch (command.type) {
+		case "screenshot":
+		case "snapshot": return positiveTimeoutMs(env.FORGE_AGENT_BROWSER_BRIDGE_CAPTURE_TIMEOUT_MS) ?? DEFAULT_AGENT_BROWSER_CAPTURE_COMMAND_TIMEOUT_MS;
+		case "newTab":
+		case "navigate":
+		case "goBack":
+		case "goForward":
+		case "reload": return DEFAULT_AGENT_BROWSER_NAVIGATION_COMMAND_TIMEOUT_MS;
+		default: return DEFAULT_AGENT_BROWSER_FAST_COMMAND_TIMEOUT_MS;
+	}
+}
+function agentBrowserCloseTimeoutMs(env = process.env) {
+	return positiveTimeoutMs(env.FORGE_AGENT_BROWSER_BRIDGE_CLOSE_TIMEOUT_MS) ?? DEFAULT_AGENT_BROWSER_BRIDGE_CLOSE_TIMEOUT_MS;
+}
+function agentBrowserOpenTimeoutMs(env = process.env) {
+	return positiveTimeoutMs(env.FORGE_AGENT_BROWSER_BRIDGE_OPEN_TIMEOUT_MS) ?? DEFAULT_AGENT_BROWSER_BRIDGE_OPEN_TIMEOUT_MS;
+}
+function agentBrowserFastTimeoutMs(env = process.env) {
+	return positiveTimeoutMs(env.FORGE_AGENT_BROWSER_BRIDGE_COMMAND_TIMEOUT_MS) ?? DEFAULT_AGENT_BROWSER_FAST_COMMAND_TIMEOUT_MS;
+}
+function agentBrowserPlaywrightBackendCloseTimeoutMs(env = process.env) {
+	return positiveTimeoutMs(env.FORGE_AGENT_BROWSER_PLAYWRIGHT_BACKEND_CLOSE_TIMEOUT_MS) ?? DEFAULT_AGENT_BROWSER_PLAYWRIGHT_BACKEND_CLOSE_TIMEOUT_MS;
+}
+async function withAgentBrowserBridgeTimeout(label, promise, timeoutMs) {
+	let timeout;
+	try {
+		return await Promise.race([promise, new Promise((_, reject) => {
+			timeout = setTimeout(() => {
+				reject(/* @__PURE__ */ new Error(`${label} timed out after ${Math.ceil(timeoutMs / 1e3)}s.`));
+			}, timeoutMs);
+		})]);
+	} finally {
+		if (timeout !== void 0) clearTimeout(timeout);
+	}
+}
+async function openAgentBrowserSessionReady(bridge, input) {
+	let resolveStarted;
+	const started = new Promise((resolve) => {
+		resolveStarted = resolve;
+	});
+	const unsubscribe = await bridge.subscribe({
+		sessionId: input.sessionId,
+		...input.browserId ? { browserId: input.browserId } : {}
+	}, (event) => {
+		if (event.type === "session.started" && event.sessionId === input.sessionId) resolveStarted(event.payload.snapshot);
+	});
+	try {
+		return await Promise.race([bridge.openSession(input), started]);
+	} finally {
+		unsubscribe();
+	}
+}
+function isAgentBrowserBridgeTimeoutError(error) {
+	const message = [
+		isBrowserError(error) ? error.detail : void 0,
+		error instanceof Error ? error.message : void 0,
+		error instanceof Error ? error.stack : void 0,
+		typeof error === "string" ? error : void 0,
+		(() => {
+			try {
+				return JSON.stringify(error);
+			} catch {
+				return;
+			}
+		})(),
+		String(error)
+	].filter((part) => typeof part === "string" && part.length > 0).join("\n");
+	return /timed out after \d+s\./.test(message);
+}
+async function closeAgentBrowserBackendWithTimeout(closeBackend, env = process.env) {
+	try {
+		await withAgentBrowserBridgeTimeout("Agent Browser Playwright backend close", closeBackend(), agentBrowserPlaywrightBackendCloseTimeoutMs(env));
+	} catch (error) {
+		if (!isAgentBrowserBridgeTimeoutError(error)) throw error;
+		console.warn("[browser] Agent Browser Playwright backend close timed out; continuing", { timeoutMs: agentBrowserPlaywrightBackendCloseTimeoutMs(env) });
+	}
+}
+//#endregion
+//#region src/browser/browserControlProtocol.ts
+function resolveBrowserControlDecision(state, metadata) {
+	const hasSessionEpoch = metadata.sessionEpoch !== void 0;
+	const hasControlSequence = metadata.controlSequence !== void 0;
+	const expectedControlSequence = state.lastAppliedControlSequence + 1;
+	if (!hasSessionEpoch && !hasControlSequence) return {
+		type: "apply",
+		controlSequence: expectedControlSequence
+	};
+	if (!hasSessionEpoch || !hasControlSequence) return {
+		type: "reject",
+		reason: "incomplete_metadata",
+		expectedSessionEpoch: state.sessionEpoch,
+		expectedControlSequence,
+		acknowledgedControlSequence: state.lastAppliedControlSequence
+	};
+	if (metadata.sessionEpoch !== state.sessionEpoch) return {
+		type: "reject",
+		reason: "stale_epoch",
+		expectedSessionEpoch: state.sessionEpoch,
+		acknowledgedControlSequence: state.lastAppliedControlSequence
+	};
+	if (metadata.controlSequence <= state.lastAppliedControlSequence) return {
+		type: "duplicate",
+		acknowledgedControlSequence: state.lastAppliedControlSequence
+	};
+	if (metadata.controlSequence !== expectedControlSequence) return {
+		type: "reject",
+		reason: "sequence_gap",
+		expectedControlSequence,
+		acknowledgedControlSequence: state.lastAppliedControlSequence
+	};
+	return {
+		type: "apply",
+		controlSequence: metadata.controlSequence
+	};
+}
+function browserControlRejectionDetail(decision) {
+	switch (decision.reason) {
+		case "stale_epoch": return `Browser session is stale. Expected epoch ${decision.expectedSessionEpoch}.`;
+		case "sequence_gap": return `Browser control sequence is out of order. Expected ${decision.expectedControlSequence}.`;
+		case "incomplete_metadata": return "Browser control ordering requires both sessionEpoch and controlSequence.";
+	}
+}
+//#endregion
+//#region src/browser/AgentBrowserHostBridgeManagerCommands.ts
+async function duplicateControlResult(input) {
+	const snapshot = await withAgentBrowserBridgeTimeout("Agent Browser duplicate command session read", input.bridge.getSession({
+		sessionId: input.hostSessionId,
+		...input.commandInput.browserId ? { browserId: input.commandInput.browserId } : {}
+	}), agentBrowserFastTimeoutMs());
+	if (!snapshot) throw new BrowserError({ detail: "Browser session not found." });
+	const controlState = input.state.controlStateFor(input.hostSessionId);
+	return {
+		ok: true,
+		snapshot: toForgeSession({
+			snapshot,
+			threadId: input.commandInput.threadId,
+			environmentId: input.commandInput.environmentId,
+			userId: input.commandInput.userId,
+			display: input.state.displayForSnapshot(snapshot),
+			controlState
+		}),
+		sessionEpoch: controlState.sessionEpoch,
+		acknowledgedControlSequence: input.acknowledgedControlSequence,
+		detail: "Browser control was already applied"
+	};
+}
+async function dispatchHostCommand(input) {
+	try {
+		return await withAgentBrowserBridgeTimeout(`Agent Browser command ${input.commandInput.command.type}`, input.bridge.command({
+			...input.hostIdentity,
+			command: toHostCommand(input.commandInput.command)
+		}), agentBrowserCommandTimeoutMs(input.commandInput.command));
+	} catch (error) {
+		if (!(isAgentBrowserBridgeTimeoutError(error) && isAgentBrowserBoundedControlCommand(input.commandInput.command) && input.preCommandSnapshot !== null)) throw error;
+		console.warn("[browser] Agent Browser control command timed out after dispatch", {
+			commandType: input.commandInput.command.type,
+			sessionId: input.hostIdentity.sessionId,
+			...input.commandInput.browserId ? { browserId: input.commandInput.browserId } : {}
+		});
+		return {
+			ok: true,
+			snapshot: snapshotAfterTimedOutControl(input.preCommandSnapshot, input.commandInput.command),
+			detail: "Agent Browser control command dispatch timed out before post-action observation completed."
+		};
+	}
+}
+async function executeHostCommand(input) {
+	const captureTabId = commandCaptureTabId(input.commandInput.command);
+	const hostIdentity = {
+		sessionId: input.hostSessionId,
+		...input.commandInput.browserId ? { browserId: input.commandInput.browserId } : {}
+	};
+	const preCommandSnapshot = isAgentBrowserBoundedControlCommand(input.commandInput.command) ? await withAgentBrowserBridgeTimeout(`Agent Browser command ${input.commandInput.command.type} preflight session read`, input.bridge.getSession(hostIdentity), agentBrowserCommandTimeoutMs(input.commandInput.command)).catch(() => null) : null;
+	let latestCaptureEvent;
+	const unsubscribeCapture = captureTabId ? await input.bridge.subscribe(hostIdentity, (event) => {
+		if ((event.type === "snapshot.ready" || event.type === "screenshot.ready") && event.sessionId === input.hostSessionId && event.payload.tabId === captureTabId) latestCaptureEvent = event;
+	}) : void 0;
+	let result;
+	try {
+		result = await dispatchHostCommand({
+			...input,
+			hostIdentity,
+			preCommandSnapshot
+		});
+	} finally {
+		unsubscribeCapture?.();
+	}
+	if (input.commandInput.command.type === "closeTab") {
+		await runPromise(input.options?.displayPeers?.closeForSession({
+			sessionId: input.hostSessionId,
+			tabId: input.commandInput.command.tabId
+		}) ?? void_$1);
+		input.state.clearConnectedDisplay({
+			sessionId: input.hostSessionId,
+			tabId: input.commandInput.command.tabId
+		});
+	}
+	const display = input.state.displayForSnapshot(result.snapshot);
+	const controlState = input.state.controlStateFor(input.hostSessionId);
+	controlState.lastAppliedControlSequence = input.controlSequence;
+	return toCommandResult({
+		result,
+		command: input.commandInput,
+		display,
+		controlState,
+		acknowledgedControlSequence: input.controlSequence,
+		latestCapture: latestCaptureEvent ? toCommandLatestCapture({
+			event: latestCaptureEvent,
+			command: input.commandInput,
+			browserId: BrowserId.make(result.snapshot.browserId),
+			display,
+			controlState
+		}) : void 0
+	});
+}
+async function executeOrderedHostCommand(input) {
+	const hostSessionId = sessionIdForThread(input.commandInput.threadId);
+	return input.state.runSerializedCommand(hostSessionId, async () => {
+		const controlDecision = resolveBrowserControlDecision(input.state.controlStateFor(hostSessionId), input.commandInput);
+		if (controlDecision.type === "reject") throw new BrowserError({ detail: browserControlRejectionDetail(controlDecision) });
+		if (controlDecision.type === "duplicate") return duplicateControlResult({
+			...input,
+			hostSessionId,
+			acknowledgedControlSequence: controlDecision.acknowledgedControlSequence
+		});
+		return executeHostCommand({
+			...input,
+			hostSessionId,
+			controlSequence: controlDecision.controlSequence
+		});
+	});
+}
+//#endregion
+//#region src/browser/AgentBrowserHostBridgeManagerState.ts
+function resolveDisplay(snapshot, options) {
+	if (typeof options?.display === "function") return options.display(snapshot);
+	return options?.display ?? DEFAULT_AGENT_BROWSER_DISPLAY;
+}
+function subscriptionMatchesEvent(subscription, event) {
+	if (subscription.input.threadId && subscription.input.threadId !== event.threadId) return false;
+	if (subscription.input.browserId && subscription.input.browserId !== event.browserId) return false;
+	if (subscription.input.environmentId && subscription.input.environmentId !== event.environmentId) return false;
+	if (subscription.input.userId && subscription.input.userId !== event.userId) return false;
+	return true;
+}
+function createAgentBrowserHostBridgeState(options) {
+	const localSubscriptions = /* @__PURE__ */ new Set();
+	const connectedDisplays = /* @__PURE__ */ new Map();
+	const controlStates = /* @__PURE__ */ new Map();
+	const commandQueues = /* @__PURE__ */ new Map();
+	const controlStateFor = (sessionId) => {
+		const existing = controlStates.get(sessionId);
+		if (existing) return existing;
+		const created = {
+			sessionEpoch: crypto.randomUUID(),
+			lastAppliedControlSequence: 0
+		};
+		controlStates.set(sessionId, created);
+		return created;
+	};
+	const runSerializedCommand = async (sessionId, task) => {
+		const previous = commandQueues.get(sessionId) ?? Promise.resolve();
+		let releaseCurrent;
+		const current = new Promise((resolve) => {
+			releaseCurrent = resolve;
+		});
+		const queued = previous.catch(() => void 0).then(() => current);
+		commandQueues.set(sessionId, queued);
+		await previous.catch(() => void 0);
+		try {
+			return await task();
+		} finally {
+			releaseCurrent();
+			if (commandQueues.get(sessionId) === queued) commandQueues.delete(sessionId);
+		}
+	};
+	const clearConnectedDisplay = (input) => {
+		const active = connectedDisplays.get(input.sessionId);
+		if (!active) return;
+		if (input.tabId === void 0 || active.tabId === input.tabId) connectedDisplays.delete(input.sessionId);
+	};
+	const displayForSnapshot = (snapshot) => {
+		const fallback = resolveDisplay(snapshot, options);
+		const active = connectedDisplays.get(snapshot.sessionId);
+		if (!active) return fallback;
+		if (!snapshot.tabs.some((tab) => tab.id === active.tabId)) {
+			connectedDisplays.delete(snapshot.sessionId);
+			return fallback;
+		}
+		if (snapshot.activeTabId !== active.tabId) return fallback;
+		const { reason: _reason, detail: _detail, ...fallbackWithoutDegradedReason } = fallback;
+		return {
+			...fallbackWithoutDegradedReason,
+			...active.display,
+			reconnect: active.display.reconnect ?? fallback.reconnect
+		};
+	};
+	const publishLocalEvent = (event) => {
+		for (const subscription of localSubscriptions) {
+			if (!subscriptionMatchesEvent(subscription, event)) continue;
+			runPromise(subscription.listener(event)).catch((error) => {
+				console.warn("[browser] Failed to publish local browser event", { error });
+			});
+		}
+	};
+	const publishWebRtcIceCandidate = (event) => {
+		publishLocalEvent({
+			eventId: EventId.make(crypto.randomUUID()),
+			browserId: event.input.browserId ?? browserIdFrom(event.input),
+			threadId: event.input.threadId,
+			environmentId: event.input.environmentId ?? DEFAULT_BROWSER_ENVIRONMENT_ID,
+			userId: event.input.userId ?? "local-user",
+			agentId: null,
+			createdAt: nowIso$2(),
+			type: "display.iceCandidate",
+			payload: {
+				sessionId: event.input.sessionId,
+				tabId: event.input.tabId,
+				clientId: event.input.clientId,
+				candidate: event.candidate
+			}
+		});
+	};
+	return {
+		localSubscriptions,
+		connectedDisplays,
+		controlStates,
+		controlStateFor,
+		runSerializedCommand,
+		clearConnectedDisplay,
+		displayForSnapshot,
+		publishWebRtcIceCandidate
+	};
+}
+//#endregion
+//#region src/browser/AgentBrowserHostBridgeManager.ts
+function openInputForSession(input) {
+	return {
+		sessionId: input.hostSessionId,
+		...input.sessionInput.browserId ? { browserId: input.sessionInput.browserId } : {},
+		...input.initialUrl ? { initialUrl: input.initialUrl } : {},
+		...input.sessionInput.name ? { name: input.sessionInput.name } : {},
+		...input.sessionInput.visibility ? { visibility: input.sessionInput.visibility } : {},
+		...input.sessionInput.viewport ? { viewport: input.sessionInput.viewport } : {}
+	};
+}
+function forgetHostSession(input) {
+	input.state.clearConnectedDisplay({ sessionId: input.hostSessionId });
+	input.state.controlStates.delete(input.hostSessionId);
+	input.options?.forgetRuntimeSession?.({ sessionId: input.hostSessionId });
+}
+async function quarantineTimedOutOpenSession(input) {
+	console.warn("[browser] Agent Browser openSession timed out; quarantining session", {
+		sessionId: input.hostSessionId,
+		...input.sessionInput.browserId ? { browserId: input.sessionInput.browserId } : {}
+	});
+	await withAgentBrowserBridgeTimeout("Agent Browser openSession quarantine close", input.bridge.closeSession({
+		sessionId: input.hostSessionId,
+		...input.sessionInput.browserId ? { browserId: input.sessionInput.browserId } : {}
+	}), agentBrowserCloseTimeoutMs()).catch(() => void 0);
+	forgetHostSession(input);
+	throw new Error(`${input.error instanceof Error ? input.error.message : String(input.error)} The pending browser session was quarantined and closed.`, { cause: input.error });
+}
+async function openHostBridgeSession(input) {
+	const hostSessionId = sessionIdForThread(input.sessionInput.threadId);
+	const initialUrl = input.sessionInput.initialUrl ? normalizeUserVisibleBrowserUrl(input.sessionInput.initialUrl) : void 0;
+	input.options?.prepareRuntimeSession?.({
+		sessionId: hostSessionId,
+		initialUrl: initialUrl ?? "about:blank"
+	});
+	try {
+		const snapshot = await withAgentBrowserBridgeTimeout("Agent Browser openSession", openAgentBrowserSessionReady(input.bridge, openInputForSession({
+			sessionInput: input.sessionInput,
+			hostSessionId,
+			initialUrl
+		})), agentBrowserOpenTimeoutMs());
+		return toForgeSession({
+			snapshot,
+			threadId: input.sessionInput.threadId,
+			environmentId: input.sessionInput.environmentId,
+			userId: input.sessionInput.userId,
+			agentId: input.sessionInput.agentId,
+			ownerRole: input.sessionInput.ownerRole,
+			display: input.state.displayForSnapshot(snapshot),
+			controlState: input.state.controlStateFor(snapshot.sessionId)
+		});
+	} catch (error) {
+		if (!isAgentBrowserBridgeTimeoutError(error)) {
+			input.options?.forgetRuntimeSession?.({ sessionId: hostSessionId });
+			throw error;
+		}
+		return quarantineTimedOutOpenSession({
+			...input,
+			error,
+			hostSessionId
+		});
+	}
+}
+async function verifyTimedOutClose(input) {
+	const remaining = await withAgentBrowserBridgeTimeout("Agent Browser closeSession verification", input.bridge.getSession(input.hostIdentity), 2e3).catch(() => void 0);
+	console.warn(remaining === null ? "[browser] Agent Browser closeSession timed out after session removal" : "[browser] Agent Browser closeSession timed out; forgetting session", {
+		sessionId: input.hostIdentity.sessionId,
+		...input.sessionInput.browserId ? { browserId: input.sessionInput.browserId } : {}
+	});
+}
+async function closeHostBridgeSession(input) {
+	const hostSessionId = sessionIdForThread(input.sessionInput.threadId);
+	await runPromise(input.options?.displayPeers?.closeForSession({ sessionId: hostSessionId }) ?? void_$1);
+	const hostIdentity = {
+		sessionId: hostSessionId,
+		...input.sessionInput.browserId ? { browserId: input.sessionInput.browserId } : {}
+	};
+	try {
+		await withAgentBrowserBridgeTimeout("Agent Browser closeSession", input.bridge.closeSession(hostIdentity), agentBrowserCloseTimeoutMs());
+	} catch (error) {
+		if (!isAgentBrowserBridgeTimeoutError(error)) throw error;
+		await verifyTimedOutClose({
+			...input,
+			hostIdentity
+		});
+	}
+	forgetHostSession({
+		...input,
+		hostSessionId
+	});
+}
+function createAgentBrowserHostBridgeManager(bridge, options) {
+	const state = createAgentBrowserHostBridgeState(options);
+	return {
+		openSession: (input) => tryPromise({
+			try: () => openHostBridgeSession({
+				bridge,
+				options,
+				state,
+				sessionInput: input
+			}),
+			catch: (error) => toBrowserError(error, "Failed to open Agent Browser session.")
+		}),
+		closeSession: (input) => tryPromise({
+			try: () => closeHostBridgeSession({
+				bridge,
+				options,
+				state,
+				sessionInput: input
+			}),
+			catch: (error) => toBrowserError(error, "Failed to close Agent Browser session.")
+		}),
+		clearBrowsingData: () => succeed({
+			closedSessionCount: 0,
+			deletedSessionCount: 0,
+			deletedCaptureCount: 0
+		}),
+		getSession: (input) => tryPromise({
+			try: async () => {
+				const snapshot = await withAgentBrowserBridgeTimeout("Agent Browser getSession", bridge.getSession({
+					sessionId: sessionIdForThread(input.threadId),
+					...input.browserId ? { browserId: input.browserId } : {}
+				}), agentBrowserFastTimeoutMs());
+				return snapshot ? toForgeSession({
+					snapshot,
+					threadId: input.threadId,
+					environmentId: input.environmentId,
+					userId: input.userId,
+					display: state.displayForSnapshot(snapshot),
+					controlState: state.controlStateFor(snapshot.sessionId)
+				}) : null;
+			},
+			catch: (error) => toBrowserError(error, "Failed to read Agent Browser session.")
+		}),
+		listSessions: (input) => tryPromise({
+			try: async () => {
+				return (await withAgentBrowserBridgeTimeout("Agent Browser listSessions", bridge.listSessions(input.browserId ? { browserId: input.browserId } : void 0), agentBrowserFastTimeoutMs())).map((snapshot) => toForgeSession({
+					snapshot,
+					threadId: input.threadId ?? ThreadId.make(snapshot.sessionId),
+					environmentId: input.environmentId,
+					userId: input.userId,
+					display: state.displayForSnapshot(snapshot),
+					controlState: state.controlStateFor(snapshot.sessionId)
+				}));
+			},
+			catch: (error) => toBrowserError(error, "Failed to list Agent Browser sessions.")
+		}),
+		command: (input) => tryPromise({
+			try: () => executeOrderedHostCommand({
+				bridge,
+				options,
+				state,
+				commandInput: input
+			}),
+			catch: (error) => toBrowserError(error, "Failed to run Agent Browser command.")
+		}),
+		attachDisplay: (input) => {
+			const displayPeers = options?.displayPeers;
+			if (!displayPeers) return fail(remoteWebRtcUnavailableError(input));
+			return tryPromise({
+				try: async () => {
+					const iceServers = await resolveDisplayIceServers(options);
+					if (options?.requiresWebRtcRelay === true && !hasTurnRelay(iceServers)) throw remoteWebRtcRelayRequiredError(input);
+					const result = await runPromise(displayPeers.attach(input, {
+						display: {
+							transport: "remote-webrtc",
+							status: "connecting",
+							...input.viewport ? { viewport: input.viewport } : {},
+							devicePixelRatio: 1,
+							...iceServers.length > 0 ? { iceServers } : {},
+							reconnect: {
+								status: "ready",
+								attempt: 0
+							}
+						},
+						onIceCandidate: state.publishWebRtcIceCandidate
+					}));
+					state.connectedDisplays.set(input.sessionId, {
+						tabId: input.tabId,
+						display: result.display
+					});
+					return result;
+				},
+				catch: (error) => {
+					if (isBrowserError(error)) return error;
+					return toBrowserError(error, "Failed to attach WebRTC browser display.");
+				}
+			});
+		},
+		addDisplayIceCandidate: (input) => {
+			const displayPeers = options?.displayPeers;
+			if (!displayPeers) return fail(remoteWebRtcUnavailableError(input));
+			return displayPeers.addIceCandidate(input);
+		},
+		subscribe: (input, listener) => promise(async () => {
+			const localSubscription = {
+				input,
+				listener
+			};
+			state.localSubscriptions.add(localSubscription);
+			const threadId = input.threadId ?? ThreadId.make("unknown-thread");
+			const browserId = browserIdFrom(input);
+			const environmentId = input.environmentId ?? DEFAULT_BROWSER_ENVIRONMENT_ID;
+			const userId = input.userId ?? "local-user";
+			const subscribeInput = {
+				...input.threadId ? { sessionId: sessionIdForThread(input.threadId) } : {},
+				...input.browserId ? { browserId: input.browserId } : {}
+			};
+			const unsubscribeBridge = await bridge.subscribe(subscribeInput, (event) => {
+				if (event.type === "session.closed") state.clearConnectedDisplay({ sessionId: event.payload.sessionId });
+				if (event.type === "tab.closed") state.clearConnectedDisplay({
+					sessionId: event.sessionId,
+					tabId: event.payload.tabId
+				});
+				const mapped = toStreamEvent({
+					event,
+					threadId,
+					browserId,
+					environmentId,
+					userId,
+					agentId: null,
+					ownerRole: "lead",
+					display: event.type === "session.started" || event.type === "session.updated" ? state.displayForSnapshot(event.payload.snapshot) : DEFAULT_AGENT_BROWSER_DISPLAY,
+					controlState: state.controlStateFor(event.type === "session.closed" ? event.payload.sessionId : event.sessionId)
+				});
+				if (mapped) runPromise(listener(mapped));
+				if (event.type === "session.closed") state.controlStates.delete(event.payload.sessionId);
+			});
+			return () => {
+				state.localSubscriptions.delete(localSubscription);
+				unsubscribeBridge();
+			};
+		})
+	};
+}
+//#endregion
 //#region ../../node_modules/.bun/debug@4.4.0+2b91fc17bf64bdfd/node_modules/debug/src/common.js
 var require_common$2 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	/**
@@ -282784,234 +284032,317 @@ async function createBrowserWebRtcDisplayCaptureRuntime(options = {}) {
 	}
 }
 //#endregion
-//#region src/sprite/spriteTaskHold.ts
+//#region src/browser/browserProfilePaths.ts
 /**
-* Keeps a Fly.io Sprite awake for the duration of an agent turn.
-*
-* ── why this exists ─────────────────────────────────────────────────────────
-* A sprite's container cgroup is frozen within ~1 second of the last inbound
-* request. Processes are paused mid-instruction, not killed, and resume when
-* traffic returns. Measured on a throwaway sprite with a 1 Hz ticker
-* (`pocs/sprite-lifecycle-spike/`):
-*
-*   detached, nothing connected      2 ticks / 121 s  =   1.7%
-*   with a task hold               90 ticks /  90 s  = 100%
-*
-* So an agent turn that nobody is watching effectively stops. fly.io names our
-* previous approach — relying on a running process after disconnection — as an
-* anti-pattern, and points at the Tasks API instead. See
-* https://docs.sprites.dev/keeping-sprites-running/ and
-* `docs/specs/2026-07-30-sprites-platform-ground-truth.md` §1.
-*
-* Note that Services (the platform supervisor) do NOT solve this: "a Sprite with
-* ten services defined still pauses when it goes idle." Supervision and
-* wakefulness are separate primitives, and this module is only the second one.
-*
-* ── why it lives in the guest ───────────────────────────────────────────────
-* The Tasks API is guest-only. `GET https://api.sprites.dev/v1/sprites/{n}/tasks`
-* answers 404; the socket at /.sprite/api.sock is the only surface. CMMD cannot
-* take this hold on our behalf, which is why the env vars below are exported by
-* CMMD's provider and consumed here.
-*
-* ── the ordering rules ──────────────────────────────────────────────────────
-* 1. The refresher MUST be stopped before the DELETE is issued. A refresher that
-*    outlives the delete re-acquires the hold on its next tick; that was
-*    previously measured leaking 37 renewals over 18 minutes, pinning a sprite
-*    running — and billing — 33 minutes after its work had ended.
-* 2. Stopping the interval only cancels FUTURE ticks. A PUT already on the wire
-*    must be JOINED before the DELETE, or it lands afterwards and recreates the
-*    hold for another full expiry window. fly.io's reference worker cancels and
-*    awaits its heartbeat for the same reason.
-* 3. `release` can arrive while `acquire` is still awaiting its own PUT —
-*    `releaseAll` runs from runtime drain and the shutdown finalizer,
-*    concurrently with the provider event stream. The hold is registered before
-*    that await (so a duplicate turn.started cannot double-acquire), so release
-*    can remove the map entry first; `acquire` must then NOT install a
-*    refresher. One attached to an unmapped hold is unreachable by release,
-*    releaseThread and releaseAll alike, and re-PUTs every 60 s for the life of
-*    the process — an unbounded pin.
-*
-* All three are pinned by tests.
+* Canonical Agent Browser Chromium profile paths.
 *
-* Pure and dependency-free on purpose, for the same reason as
-* `provider/claudeCredentialContainment.ts`: this rule is cost-critical and must
-* stay directly unit-testable without booting the Effect runtime.
-*/
-/** Set by CMMD's Sprites provider on every project sprite. Absent elsewhere. */
-const SPRITE_TASK_HOLD_SOCKET_ENV = "FORGE_CMMD_SPRITE_TASK_HOLD_SOCKET";
-const SPRITE_TASK_HOLD_REFRESH_MS = 6e4;
-/**
-* Per-request deadline for the guest-socket calls. Must stay strictly under
-* SPRITE_TASK_HOLD_REFRESH_MS: the manager serializes refreshes, so a PUT that
-* never settles turns every later tick into a no-op and the hold expires
-* mid-turn. Bounding the call means a hung socket settles as a rejection, the
-* next 60 s tick retries, and release is not wedged joining it. From the last
-* good refresh there are still four attempts (+60/+120/+180/+240 s) before the
-* 300 s expiry. 10 s matches the `-m 10` cap CMMD already puts on every curl in
-* its own hold preamble; the guest-side manager was the one path left unbounded.
+* Both the host bridge adapter (which launches Chromium with a per-session
+* `userDataDir`) and the orphan reaper (which reconciles live Chromium
+* processes against registered sessions) must agree byte-for-byte on this
+* mapping — the reaper matches processes to sessions by profile directory
+* basename.
 */
-const SPRITE_TASK_HOLD_REQUEST_TIMEOUT_MS = 1e4;
+const AGENT_BROWSER_PROFILE_ROOT = "/tmp/forge-agent-browser-profiles";
+/** Sanitized directory basename for a session id. Lossy — never invert it. */
+function browserProfileSessionKey(sessionId) {
+	return sessionId.replace(/[^a-zA-Z0-9_.-]/g, "_").slice(0, 160) || "default";
+}
+function browserProfileDirForSession(sessionId, root = AGENT_BROWSER_PROFILE_ROOT) {
+	return `${root}/${browserProfileSessionKey(sessionId)}`;
+}
+//#endregion
+//#region src/browser/Layers/BrowserOrphanReaper.ts
 /**
-* Resolve the hold configuration from the process environment.
+* E7 production orphan reaper (spec:
+* docs/specs/2026-06-10-windows-free-dev-and-browser-lifecycle-hardening-plan.md).
 *
-* Returns null on every runtime that is not a project sprite — desktop-local and
-* browser runtimes have no `/.sprite/api.sock`, so the whole feature no-ops
-* there rather than erroring.
+* Periodically reconciles live Chromium browser-main processes (distinct
+* `--user-data-dir` under the Agent Browser profile root) against the set of
+* sessions the host bridge knows about, kills orphans, enforces a max-session
+* TTL through graceful closes, and removes stale profile directories.
+*
+* Guard-rails:
+* - never kills a registered live session;
+* - the first sweep *attempt* after boot is observe-only (cold-start grace)
+*   -- this is consumed unconditionally by that one attempt, so a transient
+*   read failure on it can never grant a second free pass (which would
+*   otherwise let a restart-orphaned Chromium outlive two sweep intervals
+*   instead of one);
+* - unregistered Chromium younger than `minOrphanAgeMs` is spared so
+*   in-flight opens are never raced;
+* - if the session registry cannot be read, the sweep kills nothing --
+*   distinct from a registry that reads back empty (e.g. a freshly booted
+*   server with zero sessions), which is healthy and reapable;
+* - `protectedSessionKeys` (the shared "default" backend profile) are never
+*   touched.
 */
-function resolveSpriteTaskHoldConfig(env = process.env) {
-	const socketPath = env[SPRITE_TASK_HOLD_SOCKET_ENV]?.trim();
-	if (socketPath === void 0 || socketPath.length === 0) return null;
+const execFileAsync$2 = promisify$1(execFile);
+var BrowserReaperStepError = class extends TaggedError("BrowserReaperStepError") {};
+const DEFAULT_REAPER_INTERVAL_MS = 6e4;
+const DEFAULT_MAX_SESSION_TTL_MS = 14400 * 1e3;
+const DEFAULT_MIN_ORPHAN_AGE_MS = 120 * 1e3;
+const KILL_ESCALATION_TIMEOUT_MS = 5e3;
+const KILL_POLL_INTERVAL_MS = 100;
+function positiveIntFromEnv(value) {
+	if (!value) return;
+	const parsed = Number.parseInt(value, 10);
+	return Number.isFinite(parsed) && parsed >= 0 ? parsed : void 0;
+}
+function browserOrphanReaperConfigFromEnv(env, profileRoot = "/tmp/forge-agent-browser-profiles") {
+	const enabledRaw = env.FORGE_BROWSER_REAPER_ENABLED?.trim().toLowerCase();
 	return {
-		socketPath,
-		namePrefix: env["FORGE_CMMD_SPRITE_TASK_HOLD_PREFIX"]?.trim() ?? ""
+		profileRoot,
+		intervalMs: positiveIntFromEnv(env.FORGE_BROWSER_REAPER_INTERVAL_MS) || DEFAULT_REAPER_INTERVAL_MS,
+		maxSessionTtlMs: positiveIntFromEnv(env.FORGE_BROWSER_SESSION_MAX_TTL_MS) ?? DEFAULT_MAX_SESSION_TTL_MS,
+		minOrphanAgeMs: positiveIntFromEnv(env.FORGE_BROWSER_REAPER_MIN_ORPHAN_AGE_MS) ?? DEFAULT_MIN_ORPHAN_AGE_MS,
+		enabled: enabledRaw !== "0" && enabledRaw !== "false",
+		protectedSessionKeys: new Set(["default"])
 	};
 }
+/** [[dd-]hh:]mm:ss as printed by `ps -o etime=`. Returns null on malformed input. */
+function parseEtimeToMs(etime) {
+	const match = /^(?:(\d+)-)?(?:(\d+):)?(\d+):(\d+)$/.exec(etime.trim());
+	if (!match) return null;
+	const [, days, hours, minutes, seconds] = match;
+	return (Number(days ?? 0) * 24 * 60 * 60 + Number(hours ?? 0) * 60 * 60 + Number(minutes) * 60 + Number(seconds)) * 1e3;
+}
 /**
-* Hold names must be unique per turn: several git worktrees inside one sprite
-* can run turns concurrently, and each has to be released independently.
+* A Chromium browser-main owns a profile under our root and has no `--type=`
+* flag (renderer/gpu/utility children all carry one). Killing the main tears
+* down the whole Chromium process tree.
 */
-function spriteTaskHoldName(namePrefix, turnId) {
-	return `${namePrefix}${turnId}`;
+function isChromiumMainCommand(command, profileRoot) {
+	return command.includes(`--user-data-dir=${profileRoot}/`) && !/\s--type=/.test(` ${command}`);
 }
-const DEFAULT_TIMER = {
-	setInterval: (handler, ms) => setInterval(handler, ms),
-	clearInterval: (handle) => {
-		clearInterval(handle);
+function extractUserDataDir(command) {
+	const match = /--user-data-dir=(\S+)/.exec(command);
+	return match ? match[1] ?? null : null;
+}
+function profileKeyForDir(userDataDir, profileRoot) {
+	const resolved = path.resolve(userDataDir);
+	const resolvedRoot = path.resolve(profileRoot);
+	if (resolved === resolvedRoot || !resolved.startsWith(resolvedRoot + path.sep)) return null;
+	const relative = resolved.slice(resolvedRoot.length + 1);
+	return relative.includes(path.sep) ? null : relative;
+}
+function makeSweepState(deps, config, observeOnly) {
+	return {
+		deps,
+		config,
+		observeOnly,
+		errors: [],
+		wouldReapOrphans: [],
+		wouldCloseTtlSessions: [],
+		wouldRemoveStaleProfiles: [],
+		killedOrphans: [],
+		closedTtlSessions: [],
+		removedStaleProfiles: []
+	};
+}
+function sweepReport(state, registryUnavailable) {
+	return {
+		observeOnly: state.observeOnly,
+		registryUnavailable,
+		wouldReapOrphans: state.wouldReapOrphans,
+		wouldCloseTtlSessions: state.wouldCloseTtlSessions,
+		wouldRemoveStaleProfiles: state.wouldRemoveStaleProfiles,
+		killedOrphans: state.killedOrphans,
+		closedTtlSessions: state.closedTtlSessions,
+		removedStaleProfiles: state.removedStaleProfiles,
+		errors: state.errors
+	};
+}
+/** Run a dep call; on failure record the error into the state and yield null. */
+function attemptOrNull(state, label, run) {
+	return tryPromise({
+		try: run,
+		catch: (error) => new BrowserReaperStepError({
+			message: `${label}: ${error instanceof Error ? error.message : String(error)}`,
+			cause: error
+		})
+	}).pipe(map$3((value) => value), catch_((error) => sync$1(() => (state.errors.push(error.message), null))));
+}
+/** Like attemptOrNull, but collapse the outcome to a success flag. */
+function attemptFlag(state, label, run) {
+	return attemptOrNull(state, label, async () => {
+		await run();
+		return true;
+	}).pipe(map$3((value) => value === true));
+}
+function mapRegisteredByKey(registered) {
+	const registeredByKey = /* @__PURE__ */ new Map();
+	for (const sessionId of registered) registeredByKey.set(browserProfileSessionKey(sessionId), sessionId);
+	return registeredByKey;
+}
+const enforceSessionTtl = (state, sessionId, main) => gen(function* () {
+	if (state.config.maxSessionTtlMs <= 0 || main.ageMs <= state.config.maxSessionTtlMs) return;
+	if (state.observeOnly) {
+		state.wouldCloseTtlSessions.push(sessionId);
+		return;
 	}
-};
-/**
-* Tracks one hold per active turn.
-*
-* Every method is failure-tolerant by design. Acquiring a hold is an
-* optimisation, not a precondition: if it fails the turn still runs, just at the
-* degraded speed it has today. Failing the turn instead would convert a billing
-* inefficiency into an outage.
-*/
-var SpriteTaskHoldManager = class {
-	#config;
-	#transport;
-	#timer;
-	#onError;
-	#holds = /* @__PURE__ */ new Map();
-	constructor(options) {
-		this.#config = options.config;
-		this.#transport = options.transport;
-		this.#timer = options.timer ?? DEFAULT_TIMER;
-		this.#onError = options.onError ?? (() => {});
+	if (yield* attemptFlag(state, `closeSession(${sessionId})`, () => state.deps.closeSession(sessionId))) {
+		state.closedTtlSessions.push(sessionId);
+		yield* increment(browserSessionsReapedTotal, { reason: "ttl" });
 	}
-	/** Turn ids that currently hold the sprite awake. Test/diagnostic surface. */
-	activeTurnIds() {
-		return [...this.#holds.keys()];
+});
+const reapOrphanMain = (state, key, main) => gen(function* () {
+	if (main.ageMs < state.config.minOrphanAgeMs) return;
+	if (state.observeOnly) {
+		state.wouldReapOrphans.push(key);
+		return;
 	}
-	async acquire(turnId, threadId = null) {
-		if (this.#holds.has(turnId)) return;
-		const name = spriteTaskHoldName(this.#config.namePrefix, turnId);
-		const hold = {
-			name,
-			threadId,
-			refresher: null,
-			inFlight: /* @__PURE__ */ new Set(),
-			released: false
-		};
-		this.#holds.set(turnId, hold);
-		const put = this.#transport.put(name, 300);
-		const tracked = put.then(() => {}, () => {});
-		hold.inFlight.add(tracked);
-		try {
-			await put;
-		} catch (cause) {
-			hold.inFlight.delete(tracked);
-			this.#onError(`failed to acquire sprite task hold for turn ${turnId}`, cause);
-			if (hold.released || this.#holds.get(turnId) !== hold) return;
+	if (!(yield* attemptFlag(state, `killProcess(${main.pid})`, () => state.deps.killProcess(main.pid)))) return;
+	state.killedOrphans.push(key);
+	yield* increment(browserSessionsReapedTotal, { reason: "orphan" });
+	yield* attemptFlag(state, `removeProfileDir(${main.userDataDir})`, () => state.deps.removeProfileDir(main.userDataDir));
+});
+const sweepChromiumMains = (state, registeredByKey, mains) => gen(function* () {
+	const liveKeys = /* @__PURE__ */ new Set();
+	for (const main of mains) {
+		const key = profileKeyForDir(main.userDataDir, state.config.profileRoot);
+		if (key === null) continue;
+		liveKeys.add(key);
+		if (state.config.protectedSessionKeys.has(key)) continue;
+		const registeredSessionId = registeredByKey.get(key);
+		if (registeredSessionId !== void 0) yield* enforceSessionTtl(state, registeredSessionId, main);
+		else yield* reapOrphanMain(state, key, main);
+	}
+	return liveKeys;
+});
+function isRetainedProfileDir(state, registeredByKey, liveKeys, entry) {
+	const key = profileKeyForDir(entry.path, state.config.profileRoot);
+	return key === null || state.config.protectedSessionKeys.has(key) || registeredByKey.has(key) || liveKeys.has(key) || entry.ageMs < state.config.minOrphanAgeMs;
+}
+const sweepStaleProfileDirs = (state, registeredByKey, liveKeys) => gen(function* () {
+	const profileDirs = yield* attemptOrNull(state, "listProfileDirs", state.deps.listProfileDirs);
+	if (profileDirs === null) return;
+	for (const entry of profileDirs) {
+		if (isRetainedProfileDir(state, registeredByKey, liveKeys, entry)) continue;
+		if (state.observeOnly) {
+			state.wouldRemoveStaleProfiles.push(entry.path);
+			continue;
+		}
+		if (yield* attemptFlag(state, `removeProfileDir(${entry.path})`, () => state.deps.removeProfileDir(entry.path))) {
+			state.removedStaleProfiles.push(entry.path);
+			yield* increment(browserSessionsReapedTotal, { reason: "stale_profile" });
 		}
-		hold.inFlight.delete(tracked);
-		if (hold.released || this.#holds.get(turnId) !== hold) return;
-		hold.refresher = this.#timer.setInterval(() => {
-			if (hold.inFlight.size > 0) return;
-			const refresh = this.#transport.put(name, 300).catch((cause) => this.#onError(`failed to refresh sprite task hold for turn ${turnId}`, cause));
-			hold.inFlight.add(refresh);
-			refresh.finally(() => hold.inFlight.delete(refresh));
-		}, SPRITE_TASK_HOLD_REFRESH_MS);
 	}
-	async release(turnId) {
-		const hold = this.#holds.get(turnId);
-		if (!hold) return;
-		hold.released = true;
-		if (hold.refresher !== null) {
-			this.#timer.clearInterval(hold.refresher);
-			hold.refresher = null;
+});
+function sweepHasActivity(report) {
+	return report.killedOrphans.length > 0 || report.closedTtlSessions.length > 0 || report.removedStaleProfiles.length > 0 || report.wouldReapOrphans.length > 0 || report.wouldCloseTtlSessions.length > 0 || report.wouldRemoveStaleProfiles.length > 0 || report.errors.length > 0;
+}
+const logSweepReportIfActive = (report) => sweepHasActivity(report) ? logInfo("browser orphan reaper sweep", {
+	observeOnly: report.observeOnly,
+	killedOrphans: report.killedOrphans,
+	closedTtlSessions: report.closedTtlSessions,
+	removedStaleProfiles: report.removedStaleProfiles,
+	wouldReapOrphans: report.wouldReapOrphans,
+	wouldCloseTtlSessions: report.wouldCloseTtlSessions,
+	wouldRemoveStaleProfiles: report.wouldRemoveStaleProfiles,
+	errors: report.errors
+}) : void_$1;
+function createBrowserOrphanReaper(deps, config) {
+	let coldStartGraceConsumed = false;
+	return { sweep: gen(function* () {
+		const observeOnly = !coldStartGraceConsumed;
+		coldStartGraceConsumed = true;
+		const state = makeSweepState(deps, config, observeOnly);
+		const registered = yield* attemptOrNull(state, "listRegisteredSessionIds", deps.listRegisteredSessionIds);
+		if (registered === null) {
+			yield* logWarning$1("browser orphan reaper: session registry unavailable; skipping", { errors: state.errors });
+			return sweepReport(state, true);
 		}
-		this.#holds.delete(turnId);
-		if (hold.inFlight.size > 0) await Promise.all(hold.inFlight);
+		const mains = yield* attemptOrNull(state, "listChromiumMains", deps.listChromiumMains);
+		if (mains === null) return sweepReport(state, false);
+		const registeredByKey = mapRegisteredByKey(registered);
+		yield* sweepStaleProfileDirs(state, registeredByKey, yield* sweepChromiumMains(state, registeredByKey, mains));
+		const report = sweepReport(state, false);
+		yield* logSweepReportIfActive(report);
+		return report;
+	}) };
+}
+function sleep(ms) {
+	return new Promise((resolve) => {
+		setTimeout(resolve, ms).unref?.();
+	});
+}
+function isEsrch(error) {
+	return typeof error === "object" && error !== null && "code" in error && error.code === "ESRCH";
+}
+/** SIGTERM, poll for exit, escalate to SIGKILL. Chromium tears down its own children. */
+async function killProcessWithEscalation(pid) {
+	try {
+		process.kill(pid, "SIGTERM");
+	} catch (error) {
+		if (isEsrch(error)) return;
+		throw error;
+	}
+	const deadline = Date.now() + KILL_ESCALATION_TIMEOUT_MS;
+	while (Date.now() < deadline) {
+		await sleep(KILL_POLL_INTERVAL_MS);
 		try {
-			await this.#transport.delete(hold.name);
-		} catch (cause) {
-			this.#onError(`failed to release sprite task hold for turn ${turnId}`, cause);
+			process.kill(pid, 0);
+		} catch {
+			return;
 		}
 	}
-	/**
-	* Release every hold belonging to one thread.
-	*
-	* `session.exited` names only the thread whose provider process died, and a
-	* dead session's turn will never emit `turn.completed`. Releasing by thread —
-	* rather than releasing everything — is what keeps a crash in one worktree
-	* from silently dropping the holds of the other turns running beside it.
-	*/
-	async releaseThread(threadId) {
-		const turnIds = [...this.#holds.entries()].filter(([, hold]) => hold.threadId === threadId).map(([turnId]) => turnId);
-		await Promise.all(turnIds.map((turnId) => this.release(turnId)));
-	}
-	/**
-	* Release everything. Runtime drain and server shutdown must call this, or a
-	* drained sprite keeps billing until each hold expires.
-	*/
-	async releaseAll() {
-		await Promise.all([...this.#holds.keys()].map((turnId) => this.release(turnId)));
+	try {
+		process.kill(pid, "SIGKILL");
+	} catch (error) {
+		if (!isEsrch(error)) throw error;
 	}
-};
-/**
-* HTTP-over-unix-socket transport for the guest API.
-*
-* Bun's fetch takes a `unix` option; the URL host is ignored by the socket but
-* still has to parse, which is why it is the literal `http://sprite` the
-* platform docs use.
-*/
-function makeSpriteTaskHoldTransport(config, fetchImpl = fetch) {
-	const call = async (path, init) => {
-		const controller = new AbortController();
-		const deadline = setTimeout(() => controller.abort(), SPRITE_TASK_HOLD_REQUEST_TIMEOUT_MS);
-		try {
-			const response = await fetchImpl(`http://sprite/v1/tasks${path}`, {
-				...init,
-				signal: controller.signal,
-				unix: config.socketPath
+}
+function createSystemBrowserOrphanReaperDeps(input) {
+	const { profileRoot } = input;
+	return {
+		listChromiumMains: async () => {
+			const { stdout } = await execFileAsync$2("ps", ["-axo", "pid=,etime=,args="], { maxBuffer: 16 * 1024 * 1024 });
+			const mains = [];
+			for (const line of stdout.split("\n")) {
+				const match = /^\s*(\d+)\s+(\S+)\s+(.+)$/.exec(line);
+				if (!match) continue;
+				const [, pidRaw, etime, command] = match;
+				if (!isChromiumMainCommand(command, profileRoot)) continue;
+				const userDataDir = extractUserDataDir(command);
+				const ageMs = parseEtimeToMs(etime);
+				if (userDataDir === null || ageMs === null) continue;
+				mains.push({
+					pid: Number(pidRaw),
+					userDataDir,
+					ageMs
+				});
+			}
+			return mains;
+		},
+		listRegisteredSessionIds: async () => (await input.listSessions()).map((session) => session.sessionId),
+		closeSession: input.closeSession,
+		killProcess: killProcessWithEscalation,
+		listProfileDirs: async () => {
+			const entries = await fs$1.readdir(profileRoot, { withFileTypes: true }).catch(() => []);
+			const now = Date.now();
+			const dirs = [];
+			for (const entry of entries) {
+				if (!entry.isDirectory()) continue;
+				const dirPath = path.join(profileRoot, entry.name);
+				const stat = await fs$1.stat(dirPath).catch(() => null);
+				if (stat === null) continue;
+				dirs.push({
+					path: dirPath,
+					ageMs: Math.max(0, now - stat.mtimeMs)
+				});
+			}
+			return dirs;
+		},
+		removeProfileDir: async (dir) => {
+			const resolved = path.resolve(dir);
+			const resolvedRoot = path.resolve(profileRoot);
+			if (resolved === resolvedRoot || !resolved.startsWith(resolvedRoot + path.sep)) throw new Error(`refusing to remove path outside the profile root: ${dir}`);
+			await fs$1.rm(resolved, {
+				recursive: true,
+				force: true
 			});
-			if (!response.ok) throw new Error(`sprite task API responded ${response.status}`);
-		} finally {
-			clearTimeout(deadline);
 		}
 	};
-	return {
-		put: (name, expireSeconds) => call(`/${encodeURIComponent(name)}`, {
-			method: "PUT",
-			headers: { "content-type": "application/json" },
-			body: JSON.stringify({ expire: `${expireSeconds}s` })
-		}),
-		delete: (name) => call(`/${encodeURIComponent(name)}`, { method: "DELETE" })
-	};
-}
-/**
-* Build a manager for this process, or null when the runtime is not a sprite.
-* Callers treat null as "this feature does not apply here".
-*/
-function makeSpriteTaskHoldManager(env = process.env, onError) {
-	const config = resolveSpriteTaskHoldConfig(env);
-	if (config === null) return null;
-	return new SpriteTaskHoldManager({
-		config,
-		transport: makeSpriteTaskHoldTransport(config),
-		...onError ? { onError } : {}
-	});
 }
 //#endregion
 //#region src/browser/Layers/displaySessionTaskHold.ts
@@ -283443,364 +284774,6 @@ function createWebRtcDisplaySessionManager(input = {}) {
 		})
 	};
 }
-//#endregion
-//#region src/browser/browserProfilePaths.ts
-/**
-* Canonical Agent Browser Chromium profile paths.
-*
-* Both the host bridge adapter (which launches Chromium with a per-session
-* `userDataDir`) and the orphan reaper (which reconciles live Chromium
-* processes against registered sessions) must agree byte-for-byte on this
-* mapping — the reaper matches processes to sessions by profile directory
-* basename.
-*/
-const AGENT_BROWSER_PROFILE_ROOT = "/tmp/forge-agent-browser-profiles";
-/** Sanitized directory basename for a session id. Lossy — never invert it. */
-function browserProfileSessionKey(sessionId) {
-	return sessionId.replace(/[^a-zA-Z0-9_.-]/g, "_").slice(0, 160) || "default";
-}
-function browserProfileDirForSession(sessionId, root = AGENT_BROWSER_PROFILE_ROOT) {
-	return `${root}/${browserProfileSessionKey(sessionId)}`;
-}
-//#endregion
-//#region src/browser/Layers/BrowserOrphanReaper.ts
-/**
-* E7 production orphan reaper (spec:
-* docs/specs/2026-06-10-windows-free-dev-and-browser-lifecycle-hardening-plan.md).
-*
-* Periodically reconciles live Chromium browser-main processes (distinct
-* `--user-data-dir` under the Agent Browser profile root) against the set of
-* sessions the host bridge knows about, kills orphans, enforces a max-session
-* TTL through graceful closes, and removes stale profile directories.
-*
-* Guard-rails:
-* - never kills a registered live session;
-* - the first sweep *attempt* after boot is observe-only (cold-start grace)
-*   -- this is consumed unconditionally by that one attempt, so a transient
-*   read failure on it can never grant a second free pass (which would
-*   otherwise let a restart-orphaned Chromium outlive two sweep intervals
-*   instead of one);
-* - unregistered Chromium younger than `minOrphanAgeMs` is spared so
-*   in-flight opens are never raced;
-* - if the session registry cannot be read, the sweep kills nothing --
-*   distinct from a registry that reads back empty (e.g. a freshly booted
-*   server with zero sessions), which is healthy and reapable;
-* - `protectedSessionKeys` (the shared "default" backend profile) are never
-*   touched.
-*/
-const execFileAsync$2 = promisify$1(execFile);
-var BrowserReaperStepError = class extends TaggedError("BrowserReaperStepError") {};
-const DEFAULT_REAPER_INTERVAL_MS = 6e4;
-const DEFAULT_MAX_SESSION_TTL_MS = 14400 * 1e3;
-const DEFAULT_MIN_ORPHAN_AGE_MS = 120 * 1e3;
-const KILL_ESCALATION_TIMEOUT_MS = 5e3;
-const KILL_POLL_INTERVAL_MS = 100;
-function positiveIntFromEnv(value) {
-	if (!value) return;
-	const parsed = Number.parseInt(value, 10);
-	return Number.isFinite(parsed) && parsed >= 0 ? parsed : void 0;
-}
-function browserOrphanReaperConfigFromEnv(env, profileRoot = "/tmp/forge-agent-browser-profiles") {
-	const enabledRaw = env.FORGE_BROWSER_REAPER_ENABLED?.trim().toLowerCase();
-	return {
-		profileRoot,
-		intervalMs: positiveIntFromEnv(env.FORGE_BROWSER_REAPER_INTERVAL_MS) || DEFAULT_REAPER_INTERVAL_MS,
-		maxSessionTtlMs: positiveIntFromEnv(env.FORGE_BROWSER_SESSION_MAX_TTL_MS) ?? DEFAULT_MAX_SESSION_TTL_MS,
-		minOrphanAgeMs: positiveIntFromEnv(env.FORGE_BROWSER_REAPER_MIN_ORPHAN_AGE_MS) ?? DEFAULT_MIN_ORPHAN_AGE_MS,
-		enabled: enabledRaw !== "0" && enabledRaw !== "false",
-		protectedSessionKeys: new Set(["default"])
-	};
-}
-/** [[dd-]hh:]mm:ss as printed by `ps -o etime=`. Returns null on malformed input. */
-function parseEtimeToMs(etime) {
-	const match = /^(?:(\d+)-)?(?:(\d+):)?(\d+):(\d+)$/.exec(etime.trim());
-	if (!match) return null;
-	const [, days, hours, minutes, seconds] = match;
-	return (Number(days ?? 0) * 24 * 60 * 60 + Number(hours ?? 0) * 60 * 60 + Number(minutes) * 60 + Number(seconds)) * 1e3;
-}
-/**
-* A Chromium browser-main owns a profile under our root and has no `--type=`
-* flag (renderer/gpu/utility children all carry one). Killing the main tears
-* down the whole Chromium process tree.
-*/
-function isChromiumMainCommand(command, profileRoot) {
-	return command.includes(`--user-data-dir=${profileRoot}/`) && !/\s--type=/.test(` ${command}`);
-}
-function extractUserDataDir(command) {
-	const match = /--user-data-dir=(\S+)/.exec(command);
-	return match ? match[1] ?? null : null;
-}
-function profileKeyForDir(userDataDir, profileRoot) {
-	const resolved = path.resolve(userDataDir);
-	const resolvedRoot = path.resolve(profileRoot);
-	if (resolved === resolvedRoot || !resolved.startsWith(resolvedRoot + path.sep)) return null;
-	const relative = resolved.slice(resolvedRoot.length + 1);
-	return relative.includes(path.sep) ? null : relative;
-}
-function makeSweepState(deps, config, observeOnly) {
-	return {
-		deps,
-		config,
-		observeOnly,
-		errors: [],
-		wouldReapOrphans: [],
-		wouldCloseTtlSessions: [],
-		wouldRemoveStaleProfiles: [],
-		killedOrphans: [],
-		closedTtlSessions: [],
-		removedStaleProfiles: []
-	};
-}
-function sweepReport(state, registryUnavailable) {
-	return {
-		observeOnly: state.observeOnly,
-		registryUnavailable,
-		wouldReapOrphans: state.wouldReapOrphans,
-		wouldCloseTtlSessions: state.wouldCloseTtlSessions,
-		wouldRemoveStaleProfiles: state.wouldRemoveStaleProfiles,
-		killedOrphans: state.killedOrphans,
-		closedTtlSessions: state.closedTtlSessions,
-		removedStaleProfiles: state.removedStaleProfiles,
-		errors: state.errors
-	};
-}
-/** Run a dep call; on failure record the error into the state and yield null. */
-function attemptOrNull(state, label, run) {
-	return tryPromise({
-		try: run,
-		catch: (error) => new BrowserReaperStepError({
-			message: `${label}: ${error instanceof Error ? error.message : String(error)}`,
-			cause: error
-		})
-	}).pipe(map$3((value) => value), catch_((error) => sync$1(() => (state.errors.push(error.message), null))));
-}
-/** Like attemptOrNull, but collapse the outcome to a success flag. */
-function attemptFlag(state, label, run) {
-	return attemptOrNull(state, label, async () => {
-		await run();
-		return true;
-	}).pipe(map$3((value) => value === true));
-}
-function mapRegisteredByKey(registered) {
-	const registeredByKey = /* @__PURE__ */ new Map();
-	for (const sessionId of registered) registeredByKey.set(browserProfileSessionKey(sessionId), sessionId);
-	return registeredByKey;
-}
-const enforceSessionTtl = (state, sessionId, main) => gen(function* () {
-	if (state.config.maxSessionTtlMs <= 0 || main.ageMs <= state.config.maxSessionTtlMs) return;
-	if (state.observeOnly) {
-		state.wouldCloseTtlSessions.push(sessionId);
-		return;
-	}
-	if (yield* attemptFlag(state, `closeSession(${sessionId})`, () => state.deps.closeSession(sessionId))) {
-		state.closedTtlSessions.push(sessionId);
-		yield* increment(browserSessionsReapedTotal, { reason: "ttl" });
-	}
-});
-const reapOrphanMain = (state, key, main) => gen(function* () {
-	if (main.ageMs < state.config.minOrphanAgeMs) return;
-	if (state.observeOnly) {
-		state.wouldReapOrphans.push(key);
-		return;
-	}
-	if (!(yield* attemptFlag(state, `killProcess(${main.pid})`, () => state.deps.killProcess(main.pid)))) return;
-	state.killedOrphans.push(key);
-	yield* increment(browserSessionsReapedTotal, { reason: "orphan" });
-	yield* attemptFlag(state, `removeProfileDir(${main.userDataDir})`, () => state.deps.removeProfileDir(main.userDataDir));
-});
-const sweepChromiumMains = (state, registeredByKey, mains) => gen(function* () {
-	const liveKeys = /* @__PURE__ */ new Set();
-	for (const main of mains) {
-		const key = profileKeyForDir(main.userDataDir, state.config.profileRoot);
-		if (key === null) continue;
-		liveKeys.add(key);
-		if (state.config.protectedSessionKeys.has(key)) continue;
-		const registeredSessionId = registeredByKey.get(key);
-		if (registeredSessionId !== void 0) yield* enforceSessionTtl(state, registeredSessionId, main);
-		else yield* reapOrphanMain(state, key, main);
-	}
-	return liveKeys;
-});
-function isRetainedProfileDir(state, registeredByKey, liveKeys, entry) {
-	const key = profileKeyForDir(entry.path, state.config.profileRoot);
-	return key === null || state.config.protectedSessionKeys.has(key) || registeredByKey.has(key) || liveKeys.has(key) || entry.ageMs < state.config.minOrphanAgeMs;
-}
-const sweepStaleProfileDirs = (state, registeredByKey, liveKeys) => gen(function* () {
-	const profileDirs = yield* attemptOrNull(state, "listProfileDirs", state.deps.listProfileDirs);
-	if (profileDirs === null) return;
-	for (const entry of profileDirs) {
-		if (isRetainedProfileDir(state, registeredByKey, liveKeys, entry)) continue;
-		if (state.observeOnly) {
-			state.wouldRemoveStaleProfiles.push(entry.path);
-			continue;
-		}
-		if (yield* attemptFlag(state, `removeProfileDir(${entry.path})`, () => state.deps.removeProfileDir(entry.path))) {
-			state.removedStaleProfiles.push(entry.path);
-			yield* increment(browserSessionsReapedTotal, { reason: "stale_profile" });
-		}
-	}
-});
-function sweepHasActivity(report) {
-	return report.killedOrphans.length > 0 || report.closedTtlSessions.length > 0 || report.removedStaleProfiles.length > 0 || report.wouldReapOrphans.length > 0 || report.wouldCloseTtlSessions.length > 0 || report.wouldRemoveStaleProfiles.length > 0 || report.errors.length > 0;
-}
-const logSweepReportIfActive = (report) => sweepHasActivity(report) ? logInfo("browser orphan reaper sweep", {
-	observeOnly: report.observeOnly,
-	killedOrphans: report.killedOrphans,
-	closedTtlSessions: report.closedTtlSessions,
-	removedStaleProfiles: report.removedStaleProfiles,
-	wouldReapOrphans: report.wouldReapOrphans,
-	wouldCloseTtlSessions: report.wouldCloseTtlSessions,
-	wouldRemoveStaleProfiles: report.wouldRemoveStaleProfiles,
-	errors: report.errors
-}) : void_$1;
-function createBrowserOrphanReaper(deps, config) {
-	let coldStartGraceConsumed = false;
-	return { sweep: gen(function* () {
-		const observeOnly = !coldStartGraceConsumed;
-		coldStartGraceConsumed = true;
-		const state = makeSweepState(deps, config, observeOnly);
-		const registered = yield* attemptOrNull(state, "listRegisteredSessionIds", deps.listRegisteredSessionIds);
-		if (registered === null) {
-			yield* logWarning$1("browser orphan reaper: session registry unavailable; skipping", { errors: state.errors });
-			return sweepReport(state, true);
-		}
-		const mains = yield* attemptOrNull(state, "listChromiumMains", deps.listChromiumMains);
-		if (mains === null) return sweepReport(state, false);
-		const registeredByKey = mapRegisteredByKey(registered);
-		yield* sweepStaleProfileDirs(state, registeredByKey, yield* sweepChromiumMains(state, registeredByKey, mains));
-		const report = sweepReport(state, false);
-		yield* logSweepReportIfActive(report);
-		return report;
-	}) };
-}
-function sleep(ms) {
-	return new Promise((resolve) => {
-		setTimeout(resolve, ms).unref?.();
-	});
-}
-function isEsrch(error) {
-	return typeof error === "object" && error !== null && "code" in error && error.code === "ESRCH";
-}
-/** SIGTERM, poll for exit, escalate to SIGKILL. Chromium tears down its own children. */
-async function killProcessWithEscalation(pid) {
-	try {
-		process.kill(pid, "SIGTERM");
-	} catch (error) {
-		if (isEsrch(error)) return;
-		throw error;
-	}
-	const deadline = Date.now() + KILL_ESCALATION_TIMEOUT_MS;
-	while (Date.now() < deadline) {
-		await sleep(KILL_POLL_INTERVAL_MS);
-		try {
-			process.kill(pid, 0);
-		} catch {
-			return;
-		}
-	}
-	try {
-		process.kill(pid, "SIGKILL");
-	} catch (error) {
-		if (!isEsrch(error)) throw error;
-	}
-}
-function createSystemBrowserOrphanReaperDeps(input) {
-	const { profileRoot } = input;
-	return {
-		listChromiumMains: async () => {
-			const { stdout } = await execFileAsync$2("ps", ["-axo", "pid=,etime=,args="], { maxBuffer: 16 * 1024 * 1024 });
-			const mains = [];
-			for (const line of stdout.split("\n")) {
-				const match = /^\s*(\d+)\s+(\S+)\s+(.+)$/.exec(line);
-				if (!match) continue;
-				const [, pidRaw, etime, command] = match;
-				if (!isChromiumMainCommand(command, profileRoot)) continue;
-				const userDataDir = extractUserDataDir(command);
-				const ageMs = parseEtimeToMs(etime);
-				if (userDataDir === null || ageMs === null) continue;
-				mains.push({
-					pid: Number(pidRaw),
-					userDataDir,
-					ageMs
-				});
-			}
-			return mains;
-		},
-		listRegisteredSessionIds: async () => (await input.listSessions()).map((session) => session.sessionId),
-		closeSession: input.closeSession,
-		killProcess: killProcessWithEscalation,
-		listProfileDirs: async () => {
-			const entries = await fs$1.readdir(profileRoot, { withFileTypes: true }).catch(() => []);
-			const now = Date.now();
-			const dirs = [];
-			for (const entry of entries) {
-				if (!entry.isDirectory()) continue;
-				const dirPath = path.join(profileRoot, entry.name);
-				const stat = await fs$1.stat(dirPath).catch(() => null);
-				if (stat === null) continue;
-				dirs.push({
-					path: dirPath,
-					ageMs: Math.max(0, now - stat.mtimeMs)
-				});
-			}
-			return dirs;
-		},
-		removeProfileDir: async (dir) => {
-			const resolved = path.resolve(dir);
-			const resolvedRoot = path.resolve(profileRoot);
-			if (resolved === resolvedRoot || !resolved.startsWith(resolvedRoot + path.sep)) throw new Error(`refusing to remove path outside the profile root: ${dir}`);
-			await fs$1.rm(resolved, {
-				recursive: true,
-				force: true
-			});
-		}
-	};
-}
-//#endregion
-//#region src/browser/browserControlProtocol.ts
-function resolveBrowserControlDecision(state, metadata) {
-	const hasSessionEpoch = metadata.sessionEpoch !== void 0;
-	const hasControlSequence = metadata.controlSequence !== void 0;
-	const expectedControlSequence = state.lastAppliedControlSequence + 1;
-	if (!hasSessionEpoch && !hasControlSequence) return {
-		type: "apply",
-		controlSequence: expectedControlSequence
-	};
-	if (!hasSessionEpoch || !hasControlSequence) return {
-		type: "reject",
-		reason: "incomplete_metadata",
-		expectedSessionEpoch: state.sessionEpoch,
-		expectedControlSequence,
-		acknowledgedControlSequence: state.lastAppliedControlSequence
-	};
-	if (metadata.sessionEpoch !== state.sessionEpoch) return {
-		type: "reject",
-		reason: "stale_epoch",
-		expectedSessionEpoch: state.sessionEpoch,
-		acknowledgedControlSequence: state.lastAppliedControlSequence
-	};
-	if (metadata.controlSequence <= state.lastAppliedControlSequence) return {
-		type: "duplicate",
-		acknowledgedControlSequence: state.lastAppliedControlSequence
-	};
-	if (metadata.controlSequence !== expectedControlSequence) return {
-		type: "reject",
-		reason: "sequence_gap",
-		expectedControlSequence,
-		acknowledgedControlSequence: state.lastAppliedControlSequence
-	};
-	return {
-		type: "apply",
-		controlSequence: metadata.controlSequence
-	};
-}
-function browserControlRejectionDetail(decision) {
-	switch (decision.reason) {
-		case "stale_epoch": return `Browser session is stale. Expected epoch ${decision.expectedSessionEpoch}.`;
-		case "sequence_gap": return `Browser control sequence is out of order. Expected ${decision.expectedControlSequence}.`;
-		case "incomplete_metadata": return "Browser control ordering requires both sessionEpoch and controlSequence.";
-	}
-}
 const HOST_BRIDGE_RECONNECT_MAX_MS = 1e3;
 /**
 * Exponential backoff, capped.
@@ -284098,162 +285071,21 @@ function createNativeHostBrowserBridgeClientImplementation(options, deps) {
 }
 //#endregion
 //#region src/browser/AgentBrowserHostBridgeAdapter.ts
-const DEFAULT_URL = "about:blank";
-const DEFAULT_RENDER_MODE = "interactive";
-const DEFAULT_AGENT_BROWSER_ID = "embedded";
-const DEFAULT_AGENT_BROWSER_VIEWPORT = {
-	width: 1280,
-	height: 720
-};
-const ABSOLUTE_WEB_URL_PATTERN = /^[a-z][a-z\d+\-.]*:\/\//i;
-const SPECIAL_URL_PATTERN = /^(about|blob|chrome|data|devtools|file):/i;
-const LOCAL_URL_LIKE_PATTERN = /^(localhost|127\.0\.0\.1|\[::1\]|::1|[a-z0-9.-]+\.localhost)(?::\d+)?(?:[/?#].*)?$/i;
-const DEFAULT_AGENT_BROWSER_DISPLAY = {
-	transport: "remote-webrtc",
-	status: "connected",
-	reconnect: {
-		status: "ready",
-		attempt: 0
-	}
-};
-const DEFAULT_AGENT_BROWSER_CONTROL_COMMAND_TIMEOUT_MS = 1500;
-const DEFAULT_AGENT_BROWSER_FAST_COMMAND_TIMEOUT_MS = 1e4;
-const DEFAULT_AGENT_BROWSER_NAVIGATION_COMMAND_TIMEOUT_MS = 9e4;
-const DEFAULT_AGENT_BROWSER_CAPTURE_COMMAND_TIMEOUT_MS = 9e4;
-const DEFAULT_AGENT_BROWSER_BRIDGE_OPEN_TIMEOUT_MS = 9e4;
-const DEFAULT_AGENT_BROWSER_BRIDGE_CLOSE_TIMEOUT_MS = 3e4;
-const DEFAULT_AGENT_BROWSER_PLAYWRIGHT_BACKEND_CLOSE_TIMEOUT_MS = 1e4;
-const REMOTE_WEBRTC_UNAVAILABLE_DETAIL = "Remote WebRTC browser display is not available: the current Agent Browser runtime exposes tab control but does not provide a media transport.";
-const REMOTE_WEBRTC_RELAY_REQUIRED_DETAIL = "Remote WebRTC browser display requires a TURN relay in cloud mode. Configure FORGE_BROWSER_WEBRTC_ICE_SERVERS with authenticated turn: or turns: URLs.";
-function nowIso$2() {
-	return (/* @__PURE__ */ new Date()).toISOString();
-}
-function positiveTimeoutMs(value) {
-	if (!value) return;
-	const parsed = Number.parseInt(value, 10);
-	return Number.isFinite(parsed) && parsed > 0 ? parsed : void 0;
-}
-function agentBrowserCommandTimeoutMs(command, env = process.env) {
-	const explicitCommandTimeout = positiveTimeoutMs(env.FORGE_AGENT_BROWSER_BRIDGE_COMMAND_TIMEOUT_MS);
-	if (explicitCommandTimeout !== void 0) return explicitCommandTimeout;
-	if (isAgentBrowserBoundedControlCommand(command)) return positiveTimeoutMs(env.FORGE_AGENT_BROWSER_BRIDGE_CONTROL_TIMEOUT_MS) ?? DEFAULT_AGENT_BROWSER_CONTROL_COMMAND_TIMEOUT_MS;
-	switch (command.type) {
-		case "screenshot":
-		case "snapshot": return positiveTimeoutMs(env.FORGE_AGENT_BROWSER_BRIDGE_CAPTURE_TIMEOUT_MS) ?? DEFAULT_AGENT_BROWSER_CAPTURE_COMMAND_TIMEOUT_MS;
-		case "newTab":
-		case "navigate":
-		case "goBack":
-		case "goForward":
-		case "reload": return DEFAULT_AGENT_BROWSER_NAVIGATION_COMMAND_TIMEOUT_MS;
-		default: return DEFAULT_AGENT_BROWSER_FAST_COMMAND_TIMEOUT_MS;
-	}
-}
-function agentBrowserCloseTimeoutMs(env = process.env) {
-	return positiveTimeoutMs(env.FORGE_AGENT_BROWSER_BRIDGE_CLOSE_TIMEOUT_MS) ?? DEFAULT_AGENT_BROWSER_BRIDGE_CLOSE_TIMEOUT_MS;
-}
-function agentBrowserOpenTimeoutMs(env = process.env) {
-	return positiveTimeoutMs(env.FORGE_AGENT_BROWSER_BRIDGE_OPEN_TIMEOUT_MS) ?? DEFAULT_AGENT_BROWSER_BRIDGE_OPEN_TIMEOUT_MS;
-}
-function agentBrowserFastTimeoutMs(env = process.env) {
-	return positiveTimeoutMs(env.FORGE_AGENT_BROWSER_BRIDGE_COMMAND_TIMEOUT_MS) ?? DEFAULT_AGENT_BROWSER_FAST_COMMAND_TIMEOUT_MS;
-}
-function agentBrowserPlaywrightBackendCloseTimeoutMs(env = process.env) {
-	return positiveTimeoutMs(env.FORGE_AGENT_BROWSER_PLAYWRIGHT_BACKEND_CLOSE_TIMEOUT_MS) ?? DEFAULT_AGENT_BROWSER_PLAYWRIGHT_BACKEND_CLOSE_TIMEOUT_MS;
-}
-async function withAgentBrowserBridgeTimeout(label, promise, timeoutMs) {
-	let timeout;
-	try {
-		return await Promise.race([promise, new Promise((_, reject) => {
-			timeout = setTimeout(() => {
-				reject(/* @__PURE__ */ new Error(`${label} timed out after ${Math.ceil(timeoutMs / 1e3)}s.`));
-			}, timeoutMs);
-		})]);
-	} finally {
-		if (timeout !== void 0) clearTimeout(timeout);
-	}
-}
-async function openAgentBrowserSessionReady(bridge, input) {
-	let resolveStarted;
-	const started = new Promise((resolve) => {
-		resolveStarted = resolve;
-	});
-	const unsubscribe = await bridge.subscribe({
-		sessionId: input.sessionId,
-		...input.browserId ? { browserId: input.browserId } : {}
-	}, (event) => {
-		if (event.type === "session.started" && event.sessionId === input.sessionId) resolveStarted(event.payload.snapshot);
-	});
-	try {
-		return await Promise.race([bridge.openSession(input), started]);
-	} finally {
-		unsubscribe();
-	}
-}
-function isAgentBrowserBridgeTimeoutError(error) {
-	const message = [
-		is$1(BrowserError)(error) ? error.detail : void 0,
-		error instanceof Error ? error.message : void 0,
-		error instanceof Error ? error.stack : void 0,
-		typeof error === "string" ? error : void 0,
-		(() => {
-			try {
-				return JSON.stringify(error);
-			} catch {
-				return;
-			}
-		})(),
-		String(error)
-	].filter((part) => typeof part === "string" && part.length > 0).join("\n");
-	return /timed out after \d+s\./.test(message);
-}
-function isAgentBrowserBoundedControlCommand(command) {
-	switch (command.type) {
-		case "click":
-		case "clickPoint":
-		case "pressKey":
-		case "resetViewport":
-		case "scroll":
-		case "setViewport":
-		case "type":
-		case "typeText":
-		case "wheel": return true;
-		default: return false;
-	}
-}
-function snapshotAfterTimedOutControl(snapshot, command) {
-	switch (command.type) {
-		case "setViewport": return {
-			...snapshot,
-			viewport: command.viewport,
-			updatedAt: nowIso$2()
-		};
-		case "resetViewport": return {
-			...snapshot,
-			viewport: DEFAULT_AGENT_BROWSER_VIEWPORT,
-			updatedAt: nowIso$2()
-		};
-		default: return snapshot;
-	}
-}
-async function closeAgentBrowserBackendWithTimeout(closeBackend, env = process.env) {
-	try {
-		await withAgentBrowserBridgeTimeout("Agent Browser Playwright backend close", closeBackend(), agentBrowserPlaywrightBackendCloseTimeoutMs(env));
-	} catch (error) {
-		if (!isAgentBrowserBridgeTimeoutError(error)) throw error;
-		console.warn("[browser] Agent Browser Playwright backend close timed out; continuing", { timeoutMs: agentBrowserPlaywrightBackendCloseTimeoutMs(env) });
-	}
-}
 function createNativeHostBrowserBridgeClient(options) {
 	return createNativeHostBrowserBridgeClientImplementation(options, { closeSessionTimeoutMs: agentBrowserCloseTimeoutMs });
 }
+function browserBackendOptionsForSession(input) {
+	return {
+		...input.baseOptions,
+		userDataDir: browserProfileDirForSession(input.sessionId)
+	};
+}
 /**
 * Builds the Playwright-backed backend from the lazily loaded module. The
-* `playwright` package (and everything that statically imports it) must stay
-* out of the standalone bundle's eager import graph: the bundle keeps
-* `playwright` external, so a static import would hoist it to the top of
-* `dist/bin.mjs` and the server would fail to boot on any machine that has
-* not provisioned playwright yet. Deferring the import to backend construction
-* keeps boot playwright-free and lets a later provision satisfy first use.
+* `playwright` package and everything that statically imports it must stay out
+* of the standalone bundle's eager import graph. Deferring the import to
+* backend construction keeps boot playwright-free and lets a later provision
+* satisfy first use.
 */
 function createForgeAgentBrowserPlaywrightBackend(PlaywrightBackend, options) {
 	class ForgeAgentBrowserPlaywrightBackend extends PlaywrightBackend {
@@ -284263,757 +285095,6 @@ function createForgeAgentBrowserPlaywrightBackend(PlaywrightBackend, options) {
 	}
 	return new ForgeAgentBrowserPlaywrightBackend(options);
 }
-function toBrowserError(error, fallback) {
-	console.warn("[browser] Agent Browser host bridge operation failed", {
-		operation: fallback,
-		error
-	});
-	if (is$1(BrowserError)(error)) return error;
-	if (error instanceof Error && error.message.trim().length > 0) return new BrowserError({ detail: error.message.trim() });
-	return new BrowserError({ detail: fallback });
-}
-function remoteWebRtcUnavailableError(_input) {
-	return new BrowserError({ detail: REMOTE_WEBRTC_UNAVAILABLE_DETAIL });
-}
-function remoteWebRtcRelayRequiredError(_input) {
-	return new BrowserError({ detail: REMOTE_WEBRTC_RELAY_REQUIRED_DETAIL });
-}
-function subscriptionMatchesEvent(subscription, event) {
-	if (subscription.input.threadId && subscription.input.threadId !== event.threadId) return false;
-	if (subscription.input.browserId && subscription.input.browserId !== event.browserId) return false;
-	if (subscription.input.environmentId && subscription.input.environmentId !== event.environmentId) return false;
-	if (subscription.input.userId && subscription.input.userId !== event.userId) return false;
-	return true;
-}
-function sessionIdForThread(threadId) {
-	return BrowserSessionId.make(threadId);
-}
-function browserBackendOptionsForSession(input) {
-	return {
-		...input.baseOptions,
-		userDataDir: browserProfileDirForSession(input.sessionId)
-	};
-}
-function browserIdFrom(input) {
-	return BrowserId.make(input.browserId ?? DEFAULT_AGENT_BROWSER_ID);
-}
-function normalizeUserVisibleBrowserUrl(url) {
-	const trimmed = url.trim();
-	if (trimmed.length === 0) return trimmed;
-	if (ABSOLUTE_WEB_URL_PATTERN.test(trimmed) || SPECIAL_URL_PATTERN.test(trimmed) || trimmed.startsWith("//")) return trimmed;
-	if (LOCAL_URL_LIKE_PATTERN.test(trimmed)) return `http://${trimmed}`;
-	return `https://${trimmed}`;
-}
-function agentBrowserDisplayForRuntimeMode(input) {
-	if (input.mode !== "desktop") {
-		const hasRelay = hasTurnRelay(input.iceServers ?? []);
-		return {
-			transport: "remote-webrtc",
-			status: "degraded",
-			reason: input.requiresRelay === true && !hasRelay ? "network_unreachable" : "transport_unavailable",
-			detail: input.requiresRelay === true && !hasRelay ? REMOTE_WEBRTC_RELAY_REQUIRED_DETAIL : "Remote WebRTC browser display is not attached yet.",
-			...input.viewport ? { viewport: input.viewport } : {},
-			...input.iceServers && input.iceServers.length > 0 ? { iceServers: input.iceServers } : {},
-			reconnect: {
-				status: "ready",
-				attempt: 0
-			}
-		};
-	}
-	return {
-		transport: "native-embedded",
-		status: "connected",
-		...input.viewport ? { viewport: input.viewport } : {},
-		reconnect: {
-			status: "ready",
-			attempt: 0
-		}
-	};
-}
-function hasTurnRelay(iceServers) {
-	return browserWebRtcIceServersIncludeRelay(iceServers);
-}
-async function resolveDisplayIceServers(options) {
-	return options?.resolveDisplayIceServers ? await options.resolveDisplayIceServers() : options?.displayIceServers ?? [];
-}
-function webRtcDisplayRequiresRelay(serverConfig) {
-	return serverConfig.mode === "web" && serverConfig.devUrl === void 0;
-}
-function toForgeTab(input) {
-	return {
-		tabId: BrowserTabId.make(input.tab.id),
-		restoreKey: input.tab.id,
-		...input.tab.title ? { title: input.tab.title } : {},
-		url: input.tab.url ?? DEFAULT_URL,
-		isActive: input.tab.isActive,
-		canGoBack: input.tab.canGoBack ?? false,
-		canGoForward: input.tab.canGoForward ?? false,
-		renderMode: DEFAULT_RENDER_MODE,
-		status: "live",
-		...input.tab.navigationStatus !== void 0 ? { navigationStatus: input.tab.navigationStatus } : {},
-		...input.tab.requestedUrl !== void 0 ? { requestedUrl: input.tab.requestedUrl } : {},
-		...input.tab.navigationError !== void 0 ? { navigationError: input.tab.navigationError } : {},
-		updatedAt: input.updatedAt
-	};
-}
-function toForgeSession(input) {
-	return {
-		browserId: BrowserId.make(input.snapshot.browserId),
-		threadId: input.threadId,
-		environmentId: EnvironmentId.make(input.environmentId ?? DEFAULT_BROWSER_ENVIRONMENT_ID),
-		userId: BrowserUserId.make(input.userId ?? "local-user"),
-		agentId: input.agentId ?? null,
-		ownerRole: input.ownerRole ?? "lead",
-		name: input.snapshot.name,
-		visibility: input.snapshot.visibility,
-		viewport: input.snapshot.viewport,
-		display: input.display ?? DEFAULT_AGENT_BROWSER_DISPLAY,
-		sessionId: BrowserSessionId.make(input.snapshot.sessionId),
-		...input.controlState ? {
-			sessionEpoch: input.controlState.sessionEpoch,
-			lastAppliedControlSequence: input.controlState.lastAppliedControlSequence
-		} : {},
-		activeTabId: input.snapshot.activeTabId ? BrowserTabId.make(input.snapshot.activeTabId) : null,
-		tabs: input.snapshot.tabs.map((tab) => toForgeTab({
-			tab,
-			updatedAt: input.snapshot.updatedAt
-		})),
-		updatedAt: input.snapshot.updatedAt
-	};
-}
-function resolveDisplay(snapshot, options) {
-	if (typeof options?.display === "function") return options.display(snapshot);
-	return options?.display ?? DEFAULT_AGENT_BROWSER_DISPLAY;
-}
-function toHostCommand(command) {
-	switch (command.type) {
-		case "activateTab": return {
-			type: "activateTab",
-			tabId: command.tabId
-		};
-		case "click": return {
-			type: "click",
-			tabId: command.tabId,
-			selector: command.selector
-		};
-		case "clickPoint": return {
-			type: "clickPoint",
-			tabId: command.tabId,
-			x: command.x,
-			y: command.y,
-			...command.button !== void 0 ? { button: command.button } : {},
-			...command.clickCount !== void 0 ? { clickCount: command.clickCount } : {}
-		};
-		case "closeTab": return {
-			type: "closeTab",
-			tabId: command.tabId
-		};
-		case "consoleLogs": return {
-			type: "consoleLogs",
-			...command.tabId !== void 0 ? { tabId: command.tabId } : {},
-			...command.limit !== void 0 ? { limit: command.limit } : {},
-			...command.levels !== void 0 ? { levels: command.levels } : {}
-		};
-		case "goBack": return {
-			type: "goBack",
-			tabId: command.tabId
-		};
-		case "goForward": return {
-			type: "goForward",
-			tabId: command.tabId
-		};
-		case "nameSession": return {
-			type: "nameSession",
-			name: command.name
-		};
-		case "navigate": return {
-			type: "navigate",
-			url: normalizeUserVisibleBrowserUrl(command.url),
-			...command.tabId !== void 0 ? { tabId: command.tabId } : {}
-		};
-		case "newTab": return {
-			type: "newTab",
-			...command.url !== void 0 ? { url: normalizeUserVisibleBrowserUrl(command.url) } : {},
-			...command.makeActive !== void 0 ? { makeActive: command.makeActive } : {}
-		};
-		case "pressKey": return {
-			type: "pressKey",
-			tabId: command.tabId,
-			key: command.key
-		};
-		case "reload": return {
-			type: "reload",
-			tabId: command.tabId
-		};
-		case "resetViewport": return { type: "resetViewport" };
-		case "screenshot": return {
-			type: "screenshot",
-			tabId: command.tabId,
-			...command.fullPage !== void 0 ? { fullPage: command.fullPage } : {}
-		};
-		case "scroll": return {
-			type: "scroll",
-			tabId: command.tabId,
-			scrollX: 0,
-			scrollY: command.toTop === true ? -900 : 900,
-			...command.x !== void 0 ? { x: command.x } : {},
-			...command.y !== void 0 ? { y: command.y } : {}
-		};
-		case "setViewport": return {
-			type: "setViewport",
-			viewport: command.viewport
-		};
-		case "setVisibility": return {
-			type: "setVisibility",
-			visibility: command.visibility
-		};
-		case "snapshot": return {
-			type: "snapshot",
-			tabId: command.tabId
-		};
-		case "type": return {
-			type: "type",
-			tabId: command.tabId,
-			selector: command.selector,
-			text: command.text,
-			...command.append !== void 0 ? { append: command.append } : {}
-		};
-		case "typeText": return {
-			type: "typeText",
-			tabId: command.tabId,
-			text: command.text,
-			...command.pressEnter !== void 0 ? { pressEnter: command.pressEnter } : {}
-		};
-		case "wheel": return {
-			type: "wheel",
-			tabId: command.tabId,
-			deltaX: command.deltaX,
-			deltaY: command.deltaY,
-			...command.x !== void 0 ? { x: command.x } : {},
-			...command.y !== void 0 ? { y: command.y } : {}
-		};
-		default: throw new Error(`Unsupported browser command: ${command.type}`);
-	}
-}
-function toStreamEvent(input) {
-	const base = {
-		eventId: EventId.make(crypto.randomUUID()),
-		browserId: input.browserId,
-		threadId: input.threadId,
-		environmentId: EnvironmentId.make(input.environmentId),
-		userId: BrowserUserId.make(input.userId),
-		agentId: input.agentId,
-		...input.controlState ? { sessionEpoch: input.controlState.sessionEpoch } : {},
-		createdAt: nowIso$2()
-	};
-	switch (input.event.type) {
-		case "session.started": return {
-			...base,
-			type: "session.started",
-			payload: { snapshot: toForgeSession({
-				snapshot: input.event.payload.snapshot,
-				threadId: input.threadId,
-				environmentId: input.environmentId,
-				userId: input.userId,
-				agentId: input.agentId,
-				ownerRole: input.ownerRole,
-				display: input.display,
-				controlState: input.controlState
-			}) }
-		};
-		case "session.updated": return {
-			...base,
-			type: input.event.type,
-			payload: { snapshot: toForgeSession({
-				snapshot: input.event.payload.snapshot,
-				threadId: input.threadId,
-				environmentId: input.environmentId,
-				userId: input.userId,
-				agentId: input.agentId,
-				ownerRole: input.ownerRole,
-				display: input.display,
-				controlState: input.controlState
-			}) }
-		};
-		case "session.closed": return {
-			...base,
-			type: "session.closed",
-			payload: { sessionId: BrowserSessionId.make(input.event.payload.sessionId) }
-		};
-		case "tab.closed": return {
-			...base,
-			type: "tab.closed",
-			payload: {
-				sessionId: BrowserSessionId.make(input.event.sessionId),
-				tabId: BrowserTabId.make(input.event.payload.tabId)
-			}
-		};
-		case "snapshot.ready": return {
-			...base,
-			type: "snapshot.ready",
-			payload: {
-				sessionId: BrowserSessionId.make(input.event.sessionId),
-				tabId: BrowserTabId.make(input.event.payload.tabId),
-				captureId: BrowserCaptureId.make(input.event.payload.captureId ?? crypto.randomUUID()),
-				capturedAt: input.event.payload.capturedAt,
-				url: input.event.payload.url ?? DEFAULT_URL,
-				viewport: input.event.payload.viewport,
-				content: input.event.payload.content
-			}
-		};
-		case "screenshot.ready": return {
-			...base,
-			type: "screenshot.ready",
-			payload: {
-				sessionId: BrowserSessionId.make(input.event.sessionId),
-				tabId: BrowserTabId.make(input.event.payload.tabId),
-				captureId: BrowserCaptureId.make(input.event.payload.captureId ?? crypto.randomUUID()),
-				capturedAt: input.event.payload.capturedAt,
-				url: input.event.payload.url ?? DEFAULT_URL,
-				viewport: input.event.payload.viewport,
-				imageDataUrl: input.event.payload.imageDataUrl
-			}
-		};
-		case "console.logs.ready": return {
-			...base,
-			type: "console.logs.ready",
-			payload: {
-				sessionId: BrowserSessionId.make(input.event.sessionId),
-				tabId: BrowserTabId.make(input.event.payload.tabId),
-				logs: input.event.payload.logs.map((log) => ({
-					level: log.level === "warn" ? "warning" : log.level === "log" ? "info" : log.level,
-					message: log.message,
-					createdAt: log.timestamp
-				}))
-			}
-		};
-		case "action.failed": return {
-			...base,
-			type: "action.failed",
-			payload: {
-				commandType: input.event.payload.commandType,
-				message: input.event.payload.message,
-				...input.event.payload.tabId ? { tabId: BrowserTabId.make(input.event.payload.tabId) } : {}
-			}
-		};
-		case "dom.visible.ready":
-		case "element.info.ready":
-		case "element.screenshot.ready":
-		case "clipboard.text.ready": return null;
-	}
-}
-function toCommandResult(input) {
-	return {
-		ok: input.result.ok,
-		snapshot: toForgeSession({
-			snapshot: input.result.snapshot,
-			threadId: input.command.threadId,
-			environmentId: input.command.environmentId,
-			userId: input.command.userId,
-			display: input.display,
-			controlState: input.controlState
-		}),
-		sessionEpoch: input.controlState.sessionEpoch,
-		acknowledgedControlSequence: input.acknowledgedControlSequence,
-		...input.result.detail ? { detail: input.result.detail } : {},
-		...input.latestCapture ? { latestCapture: input.latestCapture } : {}
-	};
-}
-function commandCaptureTabId(command) {
-	switch (command.type) {
-		case "snapshot":
-		case "screenshot": return command.tabId;
-		default: return;
-	}
-}
-function toCommandLatestCapture(input) {
-	const tabId = commandCaptureTabId(input.command.command);
-	if (tabId === void 0 || input.event.type !== "snapshot.ready" && input.event.type !== "screenshot.ready" || input.event.sessionId !== sessionIdForThread(input.command.threadId) || input.event.payload.tabId !== tabId) return;
-	const mapped = toStreamEvent({
-		event: input.event,
-		threadId: input.command.threadId,
-		browserId: input.browserId,
-		environmentId: input.command.environmentId ?? DEFAULT_BROWSER_ENVIRONMENT_ID,
-		userId: input.command.userId ?? "local-user",
-		agentId: null,
-		ownerRole: "lead",
-		display: input.display,
-		controlState: input.controlState
-	});
-	return mapped?.type === "snapshot.ready" || mapped?.type === "screenshot.ready" ? mapped : void 0;
-}
-function createAgentBrowserHostBridgeManager(bridge, options) {
-	const localSubscriptions = /* @__PURE__ */ new Set();
-	const connectedDisplays = /* @__PURE__ */ new Map();
-	const controlStates = /* @__PURE__ */ new Map();
-	const commandQueues = /* @__PURE__ */ new Map();
-	const controlStateFor = (sessionId) => {
-		const existing = controlStates.get(sessionId);
-		if (existing) return existing;
-		const created = {
-			sessionEpoch: crypto.randomUUID(),
-			lastAppliedControlSequence: 0
-		};
-		controlStates.set(sessionId, created);
-		return created;
-	};
-	const runSerializedCommand = async (sessionId, task) => {
-		const previous = commandQueues.get(sessionId) ?? Promise.resolve();
-		let releaseCurrent;
-		const current = new Promise((resolve) => {
-			releaseCurrent = resolve;
-		});
-		const queued = previous.catch(() => void 0).then(() => current);
-		commandQueues.set(sessionId, queued);
-		await previous.catch(() => void 0);
-		try {
-			return await task();
-		} finally {
-			releaseCurrent();
-			if (commandQueues.get(sessionId) === queued) commandQueues.delete(sessionId);
-		}
-	};
-	const clearConnectedDisplay = (input) => {
-		const active = connectedDisplays.get(input.sessionId);
-		if (!active) return;
-		if (input.tabId === void 0 || active.tabId === input.tabId) connectedDisplays.delete(input.sessionId);
-	};
-	const displayForSnapshot = (snapshot) => {
-		const fallback = resolveDisplay(snapshot, options);
-		const active = connectedDisplays.get(snapshot.sessionId);
-		if (!active) return fallback;
-		if (!snapshot.tabs.some((tab) => tab.id === active.tabId)) {
-			connectedDisplays.delete(snapshot.sessionId);
-			return fallback;
-		}
-		if (snapshot.activeTabId !== active.tabId) return fallback;
-		const { reason: _reason, detail: _detail, ...fallbackWithoutDegradedReason } = fallback;
-		return {
-			...fallbackWithoutDegradedReason,
-			...active.display,
-			reconnect: active.display.reconnect ?? fallback.reconnect
-		};
-	};
-	const duplicateControlResult = async (input, hostSessionId, controlState, acknowledgedControlSequence) => {
-		const snapshot = await withAgentBrowserBridgeTimeout("Agent Browser duplicate command session read", bridge.getSession({
-			sessionId: hostSessionId,
-			...input.browserId ? { browserId: input.browserId } : {}
-		}), agentBrowserFastTimeoutMs());
-		if (!snapshot) throw new BrowserError({ detail: "Browser session not found." });
-		return {
-			ok: true,
-			snapshot: toForgeSession({
-				snapshot,
-				threadId: input.threadId,
-				environmentId: input.environmentId,
-				userId: input.userId,
-				display: displayForSnapshot(snapshot),
-				controlState
-			}),
-			sessionEpoch: controlState.sessionEpoch,
-			acknowledgedControlSequence,
-			detail: "Browser control was already applied"
-		};
-	};
-	const dispatchHostCommand = async (input, hostIdentity, preCommandSnapshot) => {
-		try {
-			return await withAgentBrowserBridgeTimeout(`Agent Browser command ${input.command.type}`, bridge.command({
-				...hostIdentity,
-				command: toHostCommand(input.command)
-			}), agentBrowserCommandTimeoutMs(input.command));
-		} catch (error) {
-			if (!(isAgentBrowserBridgeTimeoutError(error) && isAgentBrowserBoundedControlCommand(input.command) && preCommandSnapshot !== null)) throw error;
-			console.warn("[browser] Agent Browser control command timed out after dispatch", {
-				commandType: input.command.type,
-				sessionId: hostIdentity.sessionId,
-				...input.browserId ? { browserId: input.browserId } : {}
-			});
-			return {
-				ok: true,
-				snapshot: snapshotAfterTimedOutControl(preCommandSnapshot, input.command),
-				detail: "Agent Browser control command dispatch timed out before post-action observation completed."
-			};
-		}
-	};
-	const executeHostCommand = async (input, hostSessionId, controlState, controlSequence) => {
-		const captureTabId = commandCaptureTabId(input.command);
-		const hostIdentity = {
-			sessionId: hostSessionId,
-			...input.browserId ? { browserId: input.browserId } : {}
-		};
-		const preCommandSnapshot = isAgentBrowserBoundedControlCommand(input.command) ? await withAgentBrowserBridgeTimeout(`Agent Browser command ${input.command.type} preflight session read`, bridge.getSession(hostIdentity), agentBrowserCommandTimeoutMs(input.command)).catch(() => null) : null;
-		let latestCaptureEvent;
-		const unsubscribeCapture = captureTabId ? await bridge.subscribe(hostIdentity, (event) => {
-			if ((event.type === "snapshot.ready" || event.type === "screenshot.ready") && event.sessionId === hostSessionId && event.payload.tabId === captureTabId) latestCaptureEvent = event;
-		}) : void 0;
-		let result;
-		try {
-			result = await dispatchHostCommand(input, hostIdentity, preCommandSnapshot);
-		} finally {
-			unsubscribeCapture?.();
-		}
-		if (input.command.type === "closeTab") {
-			await runPromise(options?.displayPeers?.closeForSession({
-				sessionId: hostSessionId,
-				tabId: input.command.tabId
-			}) ?? void_$1);
-			clearConnectedDisplay({
-				sessionId: hostSessionId,
-				tabId: input.command.tabId
-			});
-		}
-		const display = displayForSnapshot(result.snapshot);
-		controlState.lastAppliedControlSequence = controlSequence;
-		return toCommandResult({
-			result,
-			command: input,
-			display,
-			controlState,
-			acknowledgedControlSequence: controlSequence,
-			latestCapture: latestCaptureEvent ? toCommandLatestCapture({
-				event: latestCaptureEvent,
-				command: input,
-				browserId: BrowserId.make(result.snapshot.browserId),
-				display,
-				controlState
-			}) : void 0
-		});
-	};
-	const executeOrderedHostCommand = async (input) => {
-		const hostSessionId = sessionIdForThread(input.threadId);
-		return runSerializedCommand(hostSessionId, async () => {
-			const controlState = controlStateFor(hostSessionId);
-			const controlDecision = resolveBrowserControlDecision(controlState, input);
-			if (controlDecision.type === "reject") throw new BrowserError({ detail: browserControlRejectionDetail(controlDecision) });
-			if (controlDecision.type === "duplicate") return duplicateControlResult(input, hostSessionId, controlState, controlDecision.acknowledgedControlSequence);
-			return executeHostCommand(input, hostSessionId, controlState, controlDecision.controlSequence);
-		});
-	};
-	const publishLocalEvent = (event) => {
-		for (const subscription of localSubscriptions) {
-			if (!subscriptionMatchesEvent(subscription, event)) continue;
-			runPromise(subscription.listener(event)).catch((error) => {
-				console.warn("[browser] Failed to publish local browser event", { error });
-			});
-		}
-	};
-	const publishWebRtcIceCandidate = (event) => {
-		publishLocalEvent({
-			eventId: EventId.make(crypto.randomUUID()),
-			browserId: event.input.browserId ?? browserIdFrom(event.input),
-			threadId: event.input.threadId,
-			environmentId: event.input.environmentId ?? DEFAULT_BROWSER_ENVIRONMENT_ID,
-			userId: event.input.userId ?? "local-user",
-			agentId: null,
-			createdAt: nowIso$2(),
-			type: "display.iceCandidate",
-			payload: {
-				sessionId: event.input.sessionId,
-				tabId: event.input.tabId,
-				clientId: event.input.clientId,
-				candidate: event.candidate
-			}
-		});
-	};
-	return {
-		openSession: (input) => tryPromise({
-			try: async () => {
-				const hostSessionId = sessionIdForThread(input.threadId);
-				const initialUrl = input.initialUrl ? normalizeUserVisibleBrowserUrl(input.initialUrl) : void 0;
-				options?.prepareRuntimeSession?.({
-					sessionId: hostSessionId,
-					initialUrl: initialUrl ?? DEFAULT_URL
-				});
-				let snapshot;
-				try {
-					snapshot = await withAgentBrowserBridgeTimeout("Agent Browser openSession", openAgentBrowserSessionReady(bridge, {
-						sessionId: hostSessionId,
-						...input.browserId ? { browserId: input.browserId } : {},
-						...initialUrl ? { initialUrl } : {},
-						...input.name ? { name: input.name } : {},
-						...input.visibility ? { visibility: input.visibility } : {},
-						...input.viewport ? { viewport: input.viewport } : {}
-					}), agentBrowserOpenTimeoutMs());
-				} catch (error) {
-					if (!isAgentBrowserBridgeTimeoutError(error)) {
-						options?.forgetRuntimeSession?.({ sessionId: hostSessionId });
-						throw error;
-					}
-					console.warn("[browser] Agent Browser openSession timed out; quarantining session", {
-						sessionId: hostSessionId,
-						...input.browserId ? { browserId: input.browserId } : {}
-					});
-					await withAgentBrowserBridgeTimeout("Agent Browser openSession quarantine close", bridge.closeSession({
-						sessionId: hostSessionId,
-						...input.browserId ? { browserId: input.browserId } : {}
-					}), agentBrowserCloseTimeoutMs()).catch(() => void 0);
-					clearConnectedDisplay({ sessionId: hostSessionId });
-					controlStates.delete(hostSessionId);
-					options?.forgetRuntimeSession?.({ sessionId: hostSessionId });
-					throw new Error(`${error instanceof Error ? error.message : String(error)} The pending browser session was quarantined and closed.`, { cause: error });
-				}
-				return toForgeSession({
-					snapshot,
-					threadId: input.threadId,
-					environmentId: input.environmentId,
-					userId: input.userId,
-					agentId: input.agentId,
-					ownerRole: input.ownerRole,
-					display: displayForSnapshot(snapshot),
-					controlState: controlStateFor(snapshot.sessionId)
-				});
-			},
-			catch: (error) => toBrowserError(error, "Failed to open Agent Browser session.")
-		}),
-		closeSession: (input) => tryPromise({
-			try: async () => {
-				await runPromise(options?.displayPeers?.closeForSession({ sessionId: sessionIdForThread(input.threadId) }) ?? void_$1);
-				const hostSessionId = sessionIdForThread(input.threadId);
-				const hostIdentity = {
-					sessionId: hostSessionId,
-					...input.browserId ? { browserId: input.browserId } : {}
-				};
-				try {
-					await withAgentBrowserBridgeTimeout("Agent Browser closeSession", bridge.closeSession(hostIdentity), agentBrowserCloseTimeoutMs());
-				} catch (error) {
-					if (!isAgentBrowserBridgeTimeoutError(error)) throw error;
-					if (await withAgentBrowserBridgeTimeout("Agent Browser closeSession verification", bridge.getSession(hostIdentity), 2e3).catch(() => void 0) === null) console.warn("[browser] Agent Browser closeSession timed out after session removal", {
-						sessionId: hostSessionId,
-						...input.browserId ? { browserId: input.browserId } : {}
-					});
-					else console.warn("[browser] Agent Browser closeSession timed out; forgetting session", {
-						sessionId: hostSessionId,
-						...input.browserId ? { browserId: input.browserId } : {}
-					});
-					clearConnectedDisplay({ sessionId: hostSessionId });
-					controlStates.delete(hostSessionId);
-					options?.forgetRuntimeSession?.({ sessionId: hostSessionId });
-					return;
-				}
-				clearConnectedDisplay({ sessionId: hostSessionId });
-				controlStates.delete(hostSessionId);
-				options?.forgetRuntimeSession?.({ sessionId: hostSessionId });
-			},
-			catch: (error) => toBrowserError(error, "Failed to close Agent Browser session.")
-		}),
-		clearBrowsingData: () => succeed({
-			closedSessionCount: 0,
-			deletedSessionCount: 0,
-			deletedCaptureCount: 0
-		}),
-		getSession: (input) => tryPromise({
-			try: async () => {
-				const snapshot = await withAgentBrowserBridgeTimeout("Agent Browser getSession", bridge.getSession({
-					sessionId: sessionIdForThread(input.threadId),
-					...input.browserId ? { browserId: input.browserId } : {}
-				}), agentBrowserFastTimeoutMs());
-				return snapshot ? toForgeSession({
-					snapshot,
-					threadId: input.threadId,
-					environmentId: input.environmentId,
-					userId: input.userId,
-					display: displayForSnapshot(snapshot),
-					controlState: controlStateFor(snapshot.sessionId)
-				}) : null;
-			},
-			catch: (error) => toBrowserError(error, "Failed to read Agent Browser session.")
-		}),
-		listSessions: (input) => tryPromise({
-			try: async () => {
-				return (await withAgentBrowserBridgeTimeout("Agent Browser listSessions", bridge.listSessions(input.browserId ? { browserId: input.browserId } : void 0), agentBrowserFastTimeoutMs())).map((snapshot) => toForgeSession({
-					snapshot,
-					threadId: input.threadId ?? ThreadId.make(snapshot.sessionId),
-					environmentId: input.environmentId,
-					userId: input.userId,
-					display: displayForSnapshot(snapshot),
-					controlState: controlStateFor(snapshot.sessionId)
-				}));
-			},
-			catch: (error) => toBrowserError(error, "Failed to list Agent Browser sessions.")
-		}),
-		command: (input) => tryPromise({
-			try: () => executeOrderedHostCommand(input),
-			catch: (error) => toBrowserError(error, "Failed to run Agent Browser command.")
-		}),
-		attachDisplay: (input) => {
-			const displayPeers = options?.displayPeers;
-			if (!displayPeers) return fail(remoteWebRtcUnavailableError(input));
-			return tryPromise({
-				try: async () => {
-					const iceServers = await resolveDisplayIceServers(options);
-					if (options?.requiresWebRtcRelay === true && !hasTurnRelay(iceServers)) throw remoteWebRtcRelayRequiredError(input);
-					const result = await runPromise(displayPeers.attach(input, {
-						display: {
-							transport: "remote-webrtc",
-							status: "connecting",
-							...input.viewport ? { viewport: input.viewport } : {},
-							devicePixelRatio: 1,
-							...iceServers.length > 0 ? { iceServers } : {},
-							reconnect: {
-								status: "ready",
-								attempt: 0
-							}
-						},
-						onIceCandidate: publishWebRtcIceCandidate
-					}));
-					connectedDisplays.set(input.sessionId, {
-						tabId: input.tabId,
-						display: result.display
-					});
-					return result;
-				},
-				catch: (error) => {
-					if (is$1(BrowserError)(error)) return error;
-					return toBrowserError(error, "Failed to attach WebRTC browser display.");
-				}
-			});
-		},
-		addDisplayIceCandidate: (input) => {
-			const displayPeers = options?.displayPeers;
-			if (!displayPeers) return fail(remoteWebRtcUnavailableError(input));
-			return displayPeers.addIceCandidate(input);
-		},
-		subscribe: (input, listener) => promise(async () => {
-			const localSubscription = {
-				input,
-				listener
-			};
-			localSubscriptions.add(localSubscription);
-			const threadId = input.threadId ?? ThreadId.make("unknown-thread");
-			const browserId = browserIdFrom(input);
-			const environmentId = input.environmentId ?? DEFAULT_BROWSER_ENVIRONMENT_ID;
-			const userId = input.userId ?? "local-user";
-			const subscribeInput = {
-				...input.threadId ? { sessionId: sessionIdForThread(input.threadId) } : {},
-				...input.browserId ? { browserId: input.browserId } : {}
-			};
-			const unsubscribeBridge = await bridge.subscribe(subscribeInput, (event) => {
-				if (event.type === "session.closed") clearConnectedDisplay({ sessionId: event.payload.sessionId });
-				if (event.type === "tab.closed") clearConnectedDisplay({
-					sessionId: event.sessionId,
-					tabId: event.payload.tabId
-				});
-				const mapped = toStreamEvent({
-					event,
-					threadId,
-					browserId,
-					environmentId,
-					userId,
-					agentId: null,
-					ownerRole: "lead",
-					display: event.type === "session.started" || event.type === "session.updated" ? displayForSnapshot(event.payload.snapshot) : DEFAULT_AGENT_BROWSER_DISPLAY,
-					controlState: controlStateFor(event.type === "session.closed" ? event.payload.sessionId : event.sessionId)
-				});
-				if (mapped) runPromise(listener(mapped));
-				if (event.type === "session.closed") controlStates.delete(event.payload.sessionId);
-			});
-			return () => {
-				localSubscriptions.delete(localSubscription);
-				unsubscribeBridge();
-			};
-		})
-	};
-}
 function shouldUseNativeHostBridge(serverConfig) {
 	return serverConfig.mode === "desktop" && typeof serverConfig.nativeBrowserHostUrl === "string" && serverConfig.nativeBrowserHostUrl.trim().length > 0 && typeof serverConfig.nativeBrowserHostToken === "string" && serverConfig.nativeBrowserHostToken.trim().length > 0;
 }
@@ -285037,8 +285118,9 @@ const AgentBrowserManagerLive = effect(BrowserManager, gen(function* () {
 	const displayCaptureRuntime = yield* promise(() => createBrowserWebRtcDisplayCaptureRuntime({ chromiumExecutablePath: process.env.FORGE_PLAYWRIGHT_EXECUTABLE_PATH }));
 	yield* addFinalizer$2(() => promise(() => displayCaptureRuntime.close()).pipe(orDie));
 	if (!displayCaptureRuntime.available) yield* (!requiresWebRtcRelay && displayCaptureRuntime.unavailableDetail?.includes("root-owned /tmp/.X11-unix") === true ? logInfo : logWarning$1)("browser WebRTC display capture runtime unavailable", { detail: displayCaptureRuntime.unavailableDetail });
+	const runLayerFork = runForkWith(yield* context());
 	const displayTaskHoldManager = makeSpriteTaskHoldManager(process.env, (message, cause) => {
-		runFork(logWarning$1(message, { cause: cause instanceof Error ? cause.message : cause }));
+		runLayerFork(logWarning$1(message, { cause: cause instanceof Error ? cause.message : cause }));
 	});
 	const displayPeers = createWebRtcDisplaySessionManager({
 		mediaSourceFactory: displayCaptureRuntime.mediaSourceFactory,
@@ -285050,7 +285132,6 @@ const AgentBrowserManagerLive = effect(BrowserManager, gen(function* () {
 	yield* addFinalizer$2(() => promise(() => displayTaskHoldManager?.releaseAll() ?? Promise.resolve()));
 	const baseBackendOptions = displayCaptureRuntime.backendOptions;
 	const sessionInitialUrls = /* @__PURE__ */ new Map();
-	const reaperContext = yield* context();
 	let runtimeBuild = null;
 	const lazyDisposers = [];
 	const buildPlaywrightRuntime = async () => {
@@ -285093,13 +285174,12 @@ const AgentBrowserManagerLive = effect(BrowserManager, gen(function* () {
 					await hostBridge.closeSession({ sessionId: BrowserSessionId.make(sessionId) });
 				}
 			}), reaperConfig);
-			const runReaperFork = runForkWith(reaperContext);
 			const reaperInterval = setInterval(() => {
-				runReaperFork(reaper.sweep);
+				runLayerFork(reaper.sweep);
 			}, reaperConfig.intervalMs);
 			reaperInterval.unref?.();
 			lazyDisposers.push(() => clearInterval(reaperInterval));
-			runReaperFork(reaper.sweep);
+			runLayerFork(reaper.sweep);
 		}
 		return createAgentBrowserHostBridgeManager(hostBridge, {
 			display: (snapshot) => agentBrowserDisplayForRuntimeMode({
@@ -297099,7 +297179,7 @@ function resolveBuildCommitFromEnv(env) {
 * environment descriptor down instead of reporting an honest "unknown".
 */
 function readBakedBuildCommit() {
-	return "e0ef2b5174f2f50934814b1865cabaa9c7de0ce7";
+	return "c3949b7e95339eacff389726dd77379ace4989b7";
 }
 async function resolveServerBuildCommit(input) {
 	if (isFullCommitSha(input.baked)) return input.baked;