@openclaw/google-meet 2026.7.1 → 2026.7.2-beta.1

package/dist/index.js

@@ -1,11 +1,11 @@
-import { a as buildGoogleMeetCalendarDayWindow, i as resolveGoogleMeetGatewayOperationTimeoutMs, n as DEFAULT_GOOGLE_MEET_AUDIO_OUTPUT_COMMAND, o as findGoogleMeetCalendarEvent, r as resolveGoogleMeetConfig, s as listGoogleMeetCalendarEvents, t as DEFAULT_GOOGLE_MEET_AUDIO_INPUT_COMMAND } from "./config-DDYRr7-P.js";
-import { _ as fetchLatestGoogleMeetConferenceRecord, a as forceMeetEnglishUi, c as readBrowserTab, d as buildGoogleMeetPreflightReport, g as fetchGoogleMeetSpace, h as fetchGoogleMeetAttendance, i as callBrowserProxyOnNode, l as resolveChromeNode, m as fetchGoogleMeetArtifacts, n as isGoogleMeetBrowserManualActionError, o as isSameMeetUrlForReuse, p as endGoogleMeetActiveConference, r as asBrowserTabs, s as normalizeMeetUrlForReuse, t as createMeetWithBrowserProxyOnNode, u as resolveChromeNodeInfo } from "./chrome-create-BhgM0jQO.js";
+import { a as buildGoogleMeetCalendarDayWindow, c as normalizeMeetUrl, i as resolveGoogleMeetGatewayOperationTimeoutMs, n as DEFAULT_GOOGLE_MEET_AUDIO_OUTPUT_COMMAND, o as findGoogleMeetCalendarEvent, r as resolveGoogleMeetConfig, s as listGoogleMeetCalendarEvents, t as DEFAULT_GOOGLE_MEET_AUDIO_INPUT_COMMAND } from "./config-BeoHH_z5.js";
+import { _ as fetchGoogleMeetSpace, a as forceMeetEnglishUi, c as normalizeMeetUrlForReuse, d as resolveChromeNodeInfo, f as buildGoogleMeetPreflightReport, g as fetchGoogleMeetAttendance, h as fetchGoogleMeetArtifacts, i as callBrowserProxyOnNode, l as readBrowserTab, m as endGoogleMeetActiveConference, n as isGoogleMeetBrowserManualActionError, o as isEnglishMeetTab, r as asBrowserTabs, s as isSameMeetUrlForReuse, t as createMeetWithBrowserProxyOnNode, u as resolveChromeNode, v as fetchLatestGoogleMeetConferenceRecord } from "./chrome-create-DM1XJCOH.js";
 import { optionalPositiveIntegerSchema, readPositiveIntegerParam } from "openclaw/plugin-sdk/channel-actions";
 import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
 import { ErrorCodes, GatewayClient, callGatewayFromCli, errorShape, startGatewayClientWhenEventLoopReady } from "openclaw/plugin-sdk/gateway-runtime";
 import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
 import { definePluginEntry } from "openclaw/plugin-sdk/plugin-entry";
-import { normalizeAgentId } from "openclaw/plugin-sdk/routing";
+import { normalizeAgentId, parseAgentSessionKey } from "openclaw/plugin-sdk/routing";
 import { asRecord, normalizeOptionalString, uniqueStrings } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { jsonResult } from "openclaw/plugin-sdk/tool-results";
 import { Type } from "typebox";
@@ -20,6 +20,7 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { getRealtimeTranscriptionProvider, listRealtimeTranscriptionProviders } from "openclaw/plugin-sdk/realtime-transcription";
+import { truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
 //#region extensions/google-meet/src/transports/chrome-audio-device.ts
 const GOOGLE_MEET_SYSTEM_PROFILER_COMMAND = "/usr/sbin/system_profiler";
 function outputMentionsBlackHole2ch(output) {
@@ -77,23 +78,21 @@ function wake(session) {
 	for (const waiter of waiters) waiter();
 }
 function stopSession(session) {
-	const wasClosed = session.closed;
+	if (session.closed) return;
 	session.closed = true;
-	session.closedAt ??= (/* @__PURE__ */ new Date()).toISOString();
+	session.closedAt = (/* @__PURE__ */ new Date()).toISOString();
 	terminateChild(session.input);
 	terminateChild(session.output);
-	if (!wasClosed) wake(session);
+	wake(session);
 }
 function attachOutputProcessHandlers(session, outputProcess) {
-	outputProcess.on("exit", () => {
+	const stopIfCurrent = () => {
 		if (session.output === outputProcess) stopSession(session);
-	});
-	outputProcess.on("error", () => {
-		if (session.output === outputProcess) stopSession(session);
-	});
-	outputProcess.stdin?.on?.("error", () => {
-		if (session.output === outputProcess) stopSession(session);
-	});
+	};
+	outputProcess.on("exit", stopIfCurrent);
+	outputProcess.on("error", stopIfCurrent);
+	outputProcess.stdin?.on("error", stopIfCurrent);
+	outputProcess.stderr?.on("error", stopIfCurrent);
 }
 function startOutputProcess(command) {
 	return spawn(command.command, command.args, { stdio: [
@@ -134,9 +133,12 @@ function startCommandPair(params) {
 		if (session.chunks.length > 200) session.chunks.splice(0, session.chunks.length - 200);
 		wake(session);
 	});
-	inputProcess.on("exit", () => stopSession(session));
+	const stop = () => stopSession(session);
+	inputProcess.on("exit", stop);
+	inputProcess.on("error", stop);
+	inputProcess.stdout?.on("error", stop);
+	inputProcess.stderr?.on("error", stop);
 	attachOutputProcessHandlers(session, outputProcess);
-	inputProcess.on("error", () => stopSession(session));
 	sessions.set(session.id, session);
 	return session;
 }
@@ -211,8 +213,7 @@ function clearAudio(params) {
 	};
 }
 function startChrome(params) {
-	const url = readString$2(params.url);
-	if (!url) throw new Error("url required");
+	const url = normalizeMeetUrl(params.url);
 	const timeoutMs = readNumber(params.joinTimeoutMs, 3e4);
 	const mode = readString$2(params.mode);
 	let bridgeId;
@@ -399,6 +400,179 @@ async function handleGoogleMeetNodeHostCommand(paramsJSON) {
 	return JSON.stringify(result);
 }
 //#endregion
+//#region extensions/google-meet/src/node-invoke-policy.ts
+const GOOGLE_MEET_CHROME_NODE_COMMAND = "googlemeet.chrome";
+const START_MODES = /* @__PURE__ */ new Set([
+	"agent",
+	"bidi",
+	"realtime",
+	"transcribe"
+]);
+function asRecord$2(value) {
+	return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function readString$1(value) {
+	return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function readPositiveNumber(value) {
+	return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : void 0;
+}
+function copyCommand(command) {
+	return command && command.length > 0 ? [...command] : void 0;
+}
+function denied(message, code = "GOOGLE_MEET_NODE_POLICY_DENIED") {
+	return {
+		ok: false,
+		code,
+		message
+	};
+}
+function approved(params) {
+	return {
+		approved: true,
+		params
+	};
+}
+function buildStartParams(params, config) {
+	let url;
+	try {
+		url = normalizeMeetUrl(params.url);
+	} catch (error) {
+		return {
+			approved: false,
+			result: denied(error instanceof Error ? error.message : "googlemeet.chrome start requires url")
+		};
+	}
+	const mode = readString$1(params.mode);
+	if (mode && !START_MODES.has(mode)) return {
+		approved: false,
+		result: denied(`googlemeet.chrome start mode is unsupported: ${mode}`)
+	};
+	const startParams = {
+		action: "start",
+		url,
+		launch: params.launch === false ? false : config.chrome.launch,
+		browserProfile: config.chrome.browserProfile,
+		joinTimeoutMs: config.chrome.joinTimeoutMs
+	};
+	if (mode) startParams.mode = mode;
+	const audioInputCommand = copyCommand(config.chrome.audioInputCommand);
+	if (audioInputCommand) startParams.audioInputCommand = audioInputCommand;
+	const audioOutputCommand = copyCommand(config.chrome.audioOutputCommand);
+	if (audioOutputCommand) startParams.audioOutputCommand = audioOutputCommand;
+	const audioBridgeCommand = copyCommand(config.chrome.audioBridgeCommand);
+	if (audioBridgeCommand) startParams.audioBridgeCommand = audioBridgeCommand;
+	const audioBridgeHealthCommand = copyCommand(config.chrome.audioBridgeHealthCommand);
+	if (audioBridgeHealthCommand) startParams.audioBridgeHealthCommand = audioBridgeHealthCommand;
+	return approved(startParams);
+}
+function denyMissing(action, field) {
+	return {
+		approved: false,
+		result: denied(`googlemeet.chrome ${action} requires ${field}`)
+	};
+}
+function buildForwardParams(params) {
+	const action = readString$1(params.action);
+	switch (action) {
+		case "setup": return approved({ action });
+		case "status": {
+			const bridgeId = readString$1(params.bridgeId);
+			return approved(bridgeId ? {
+				action,
+				bridgeId
+			} : { action });
+		}
+		case "list": {
+			const forwarded = { action };
+			const url = readString$1(params.url);
+			const mode = readString$1(params.mode);
+			if (url) try {
+				forwarded.url = normalizeMeetUrl(url);
+			} catch (error) {
+				return {
+					approved: false,
+					result: denied(error instanceof Error ? error.message : "googlemeet.chrome list url")
+				};
+			}
+			if (mode) forwarded.mode = mode;
+			return approved(forwarded);
+		}
+		case "stopByUrl": {
+			const forwarded = { action };
+			const url = readString$1(params.url);
+			const mode = readString$1(params.mode);
+			const exceptBridgeId = readString$1(params.exceptBridgeId);
+			if (!url) return denyMissing(action, "url");
+			try {
+				forwarded.url = normalizeMeetUrl(url);
+			} catch (error) {
+				return {
+					approved: false,
+					result: denied(error instanceof Error ? error.message : "googlemeet.chrome stopByUrl url")
+				};
+			}
+			if (mode) forwarded.mode = mode;
+			if (exceptBridgeId) forwarded.exceptBridgeId = exceptBridgeId;
+			return approved(forwarded);
+		}
+		case "pullAudio": {
+			const forwarded = { action };
+			const bridgeId = readString$1(params.bridgeId);
+			const timeoutMs = readPositiveNumber(params.timeoutMs);
+			if (!bridgeId) return denyMissing(action, "bridgeId");
+			forwarded.bridgeId = bridgeId;
+			if (timeoutMs) forwarded.timeoutMs = timeoutMs;
+			return approved(forwarded);
+		}
+		case "pushAudio": {
+			const forwarded = { action };
+			const bridgeId = readString$1(params.bridgeId);
+			const base64 = readString$1(params.base64);
+			if (!bridgeId) return denyMissing(action, "bridgeId");
+			if (!base64) return denyMissing(action, "base64");
+			forwarded.bridgeId = bridgeId;
+			forwarded.base64 = base64;
+			return approved(forwarded);
+		}
+		case "clearAudio": {
+			const bridgeId = readString$1(params.bridgeId);
+			if (!bridgeId) return denyMissing(action, "bridgeId");
+			return approved({
+				action,
+				bridgeId
+			});
+		}
+		case "stop": {
+			const bridgeId = readString$1(params.bridgeId);
+			return approved(bridgeId ? {
+				action,
+				bridgeId
+			} : { action });
+		}
+		default: return null;
+	}
+}
+function createGoogleMeetChromeNodeInvokePolicy(config) {
+	return {
+		commands: [GOOGLE_MEET_CHROME_NODE_COMMAND],
+		dangerous: true,
+		async handle(ctx) {
+			if (ctx.command !== "googlemeet.chrome") return denied(`unsupported Google Meet node command: ${ctx.command}`);
+			const params = asRecord$2(ctx.params);
+			const action = readString$1(params.action);
+			let decision;
+			if (action === "start") decision = buildStartParams(params, config);
+			else decision = buildForwardParams(params) ?? {
+				approved: false,
+				result: denied("unsupported googlemeet.chrome action")
+			};
+			if (!decision.approved) return decision.result;
+			return await ctx.invokeNode({ params: decision.params });
+		}
+	};
+}
+//#endregion
 //#region extensions/google-meet/src/setup.ts
 function resolveUserPath(input) {
 	if (input === "~") return os.homedir();
@@ -555,9 +729,9 @@ const GOOGLE_MEET_CONSULT_SYSTEM_PROMPT = [
 function resolveGoogleMeetRealtimeTools(policy) {
 	return resolveRealtimeVoiceAgentConsultTools(policy);
 }
-function submitGoogleMeetConsultWorkingResponse(session, callId) {
+async function submitGoogleMeetConsultWorkingResponse(session, callId) {
 	if (!session.bridge.supportsToolResultContinuation) return;
-	session.submitToolResult(callId, buildRealtimeVoiceAgentConsultWorkingResponse("participant"), { willContinue: true });
+	await session.submitToolResult(callId, buildRealtimeVoiceAgentConsultWorkingResponse("participant"), { willContinue: true });
 }
 async function consultOpenClawAgentForGoogleMeet(params) {
 	const agentId = normalizeAgentId(params.config.realtime.agentId);
@@ -584,34 +758,37 @@ async function consultOpenClawAgentForGoogleMeet(params) {
 		extraSystemPrompt: GOOGLE_MEET_CONSULT_SYSTEM_PROMPT
 	});
 }
-function handleGoogleMeetRealtimeConsultToolCall(params) {
+async function handleGoogleMeetRealtimeConsultToolCall(params) {
 	const callId = params.event.callId || params.event.itemId;
 	if (params.strategy !== "bidi") {
+		const error = `Tool "${params.event.name}" is only available in bidi realtime strategy`;
+		await params.session.submitToolResult(callId, { error });
 		params.onTalkEvent?.({
 			type: "tool.error",
 			callId,
 			payload: {
 				name: params.event.name,
-				error: `Tool "${params.event.name}" is only available in bidi realtime strategy`
+				error
 			},
 			final: true
 		});
-		params.session.submitToolResult(callId, { error: `Tool "${params.event.name}" is only available in bidi realtime strategy` });
 		return;
 	}
 	if (params.event.name !== REALTIME_VOICE_AGENT_CONSULT_TOOL_NAME) {
+		const error = `Tool "${params.event.name}" not available`;
+		await params.session.submitToolResult(callId, { error });
 		params.onTalkEvent?.({
 			type: "tool.error",
 			callId,
 			payload: {
 				name: params.event.name,
-				error: `Tool "${params.event.name}" not available`
+				error
 			},
 			final: true
 		});
-		params.session.submitToolResult(callId, { error: `Tool "${params.event.name}" not available` });
 		return;
 	}
+	await submitGoogleMeetConsultWorkingResponse(params.session, callId);
 	params.onTalkEvent?.({
 		type: "tool.progress",
 		callId,
@@ -620,38 +797,41 @@ function handleGoogleMeetRealtimeConsultToolCall(params) {
 			status: "working"
 		}
 	});
-	submitGoogleMeetConsultWorkingResponse(params.session, callId);
-	consultOpenClawAgentForGoogleMeet({
-		config: params.config,
-		fullConfig: params.fullConfig,
-		runtime: params.runtime,
-		logger: params.logger,
-		meetingSessionId: params.meetingSessionId,
-		requesterSessionKey: params.requesterSessionKey,
-		args: params.event.args,
-		transcript: params.transcript
-	}).then((result) => {
-		params.onTalkEvent?.({
-			type: "tool.result",
-			callId,
-			payload: {
-				name: params.event.name,
-				result
-			},
-			final: true
+	let result;
+	try {
+		result = await consultOpenClawAgentForGoogleMeet({
+			config: params.config,
+			fullConfig: params.fullConfig,
+			runtime: params.runtime,
+			logger: params.logger,
+			meetingSessionId: params.meetingSessionId,
+			requesterSessionKey: params.requesterSessionKey,
+			args: params.event.args,
+			transcript: params.transcript
 		});
-		params.session.submitToolResult(callId, result);
-	}).catch((error) => {
+	} catch (error) {
+		const message = formatErrorMessage(error);
+		await params.session.submitToolResult(callId, { error: message });
 		params.onTalkEvent?.({
 			type: "tool.error",
 			callId,
 			payload: {
 				name: params.event.name,
-				error: formatErrorMessage(error)
+				error: message
 			},
 			final: true
 		});
-		params.session.submitToolResult(callId, { error: formatErrorMessage(error) });
+		return;
+	}
+	await params.session.submitToolResult(callId, result);
+	params.onTalkEvent?.({
+		type: "tool.result",
+		callId,
+		payload: {
+			name: params.event.name,
+			result
+		},
+		final: true
 	});
 }
 //#endregion
@@ -814,7 +994,7 @@ function readLogString(value) {
 	return typeof value === "string" && value.trim() ? value.trim() : void 0;
 }
 function formatLogValue(value) {
-	return value?.replace(/\s+/g, "_").slice(0, 180) || "unknown";
+	return (value ? truncateUtf16Safe(value.replace(/\s+/g, "_"), 180) : void 0) || "unknown";
 }
 function resolveProviderModelForLog(params) {
 	return readLogString(params.providerConfig.model) ?? readLogString(params.providerConfig.modelId) ?? readLogString(params.fallbackModel) ?? readLogString(params.provider.defaultModel) ?? "provider-default";
@@ -1499,7 +1679,7 @@ async function startCommandRealtimeAudioBridge(params) {
 				}
 			});
 			const turnId = ensureTalkTurn();
-			handleGoogleMeetRealtimeConsultToolCall({
+			return handleGoogleMeetRealtimeConsultToolCall({
 				strategy,
 				session,
 				event,
@@ -1592,10 +1772,10 @@ async function startCommandRealtimeAudioBridge(params) {
 }
 //#endregion
 //#region extensions/google-meet/src/realtime-node.ts
-function asRecord$2(value) {
+function asRecord$1(value) {
 	return value && typeof value === "object" && !Array.isArray(value) ? value : {};
 }
-function readString$1(value) {
+function readString(value) {
 	return typeof value === "string" && value.trim() ? value : void 0;
 }
 function normalizeGoogleMeetTtsPromptText(text) {
@@ -1626,10 +1806,10 @@ function startGoogleMeetNodeAudioInputLoop(params) {
 					},
 					timeoutMs: 2e3
 				});
-				const result = asRecord$2(asRecord$2(raw).payload ?? raw);
+				const result = asRecord$1(asRecord$1(raw).payload ?? raw);
 				consecutiveInputErrors = 0;
 				lastInputError = void 0;
-				const base64 = readString$1(result.base64);
+				const base64 = readString(result.base64);
 				if (base64) {
 					const audio = Buffer.from(base64, "base64");
 					if (params.isInputSuppressed()) {
@@ -2084,7 +2264,7 @@ async function startNodeRealtimeAudioBridge(params) {
 				}
 			});
 			const turnId = ensureTalkTurn();
-			handleGoogleMeetRealtimeConsultToolCall({
+			return handleGoogleMeetRealtimeConsultToolCall({
 				strategy,
 				session,
 				event,
@@ -2173,11 +2353,23 @@ async function startNodeRealtimeAudioBridge(params) {
 	};
 }
 //#endregion
+//#region extensions/google-meet/src/transports/types.ts
+const GOOGLE_MEET_TRANSCRIPT_MAX_LINES = 2e3;
+//#endregion
 //#region extensions/google-meet/src/transports/chrome.ts
 const chromeTransportDeps = { callGatewayFromCli };
+const GOOGLE_MEET_CAPTION_SETTLE_MS = 1e3;
 function isGoogleMeetTalkBackMode$2(mode) {
 	return mode === "agent" || mode === "bidi";
 }
+function readMeetAuthUser(url) {
+	if (!url) return;
+	try {
+		return new URL(url).searchParams.get("authuser") ?? void 0;
+	} catch {
+		return;
+	}
+}
 async function assertBlackHole2chAvailable(params) {
 	if (process.platform !== "darwin") throw new Error("Chrome Meet transport with blackhole-2ch audio is currently macOS-only");
 	const result = await params.runtime.system.runCommandWithTimeout([GOOGLE_MEET_SYSTEM_PROFILER_COMMAND, "SPAudioDataType"], { timeoutMs: params.timeoutMs });
@@ -2250,9 +2442,10 @@ async function launchChromeMeet(params) {
 		audioBridge: await startRealtimeAudioBridge()
 	};
 	const result = await openMeetWithBrowserRequest({
-		callBrowser: callLocalBrowserRequest,
+		callBrowser: await resolveLocalBrowserRequest(params.runtime),
 		config: params.config,
 		mode: params.mode,
+		meetingSessionId: params.meetingSessionId,
 		url: params.url
 	});
 	const audioBridge = isGoogleMeetTalkBackMode$2(params.mode) && result.browser?.inCall === true && result.browser.micMuted !== true && result.browser.manualActionRequired !== true ? await startRealtimeAudioBridge() : void 0;
@@ -2310,6 +2503,18 @@ async function callLocalBrowserRequest(params) {
 		timeoutMs: params.timeoutMs
 	}, { progress: false });
 }
+async function resolveLocalBrowserRequest(runtime) {
+	if (!await runtime.gateway.isAvailable()) return callLocalBrowserRequest;
+	return async (params) => await runtime.gateway.request("browser.request", {
+		method: params.method,
+		path: params.path,
+		body: params.body,
+		timeoutMs: params.timeoutMs
+	}, {
+		timeoutMs: resolveBrowserGatewayTimeoutMs(params.timeoutMs),
+		scopes: ["operator.admin"]
+	});
+}
 function resolveBrowserGatewayTimeoutMs(timeoutMs) {
 	return addTimerTimeoutGraceMs(timeoutMs) ?? 1;
 }
@@ -2350,6 +2555,7 @@ function meetStatusScript(params) {
 	return `async () => {
   const text = (node) => (node?.innerText || node?.textContent || "").trim();
   const allowMicrophone = ${JSON.stringify(params.allowMicrophone)};
+  const captionSessionId = ${JSON.stringify(params.captionSessionId)};
   const captureCaptions = ${JSON.stringify(params.captureCaptions)};
   const readOnly = ${JSON.stringify(Boolean(params.readOnly))};
   const buttons = [...document.querySelectorAll('button')];
@@ -2405,8 +2611,9 @@ function meetStatusScript(params) {
     mic.click();
     notes.push("Muted Meet microphone for observe-only mode.");
   }
+  const joinElsewhere = findButton(/join here too/i);
   const join = !readOnly && ${JSON.stringify(params.autoJoin)}
-    ? findButton(/join now|ask to join|join here too/i)
+    ? findButton(/join now|ask to join/i)
     : null;
   if (join) join.click();
   const microphoneChoice = findButton(/\\buse microphone\\b/i);
@@ -2480,42 +2687,127 @@ function meetStatusScript(params) {
     if (!captureCaptions) return undefined;
     const w = window;
     if (!inCall && !w.__openclawMeetCaptions) return undefined;
-    if (!w.__openclawMeetCaptions) {
+    // A reused tab starts a fresh logical transcript for each OpenClaw session.
+    // Status refreshes omit the id, so they preserve the active page-owned buffer.
+    if (!w.__openclawMeetCaptions || (captionSessionId && w.__openclawMeetCaptions.sessionId !== captionSessionId)) {
+      if (w.__openclawMeetCaptions?.settleTimer !== undefined) {
+        clearTimeout(w.__openclawMeetCaptions.settleTimer);
+      }
+      w.__openclawMeetCaptions?.observer?.disconnect?.();
       w.__openclawMeetCaptions = {
+        sessionId: captionSessionId,
+        // Epochs cross document lifetimes in the runtime transcript cursor.
+        // Strong UUIDs keep a reloaded page distinct from its prior buffer.
+        epoch: crypto.randomUUID(),
         enabledAttempted: false,
         observerInstalled: false,
+        observer: undefined,
+        droppedLines: 0,
         lines: [],
-        seen: {}
+        settleTimer: undefined,
+        visible: []
       };
     }
     return w.__openclawMeetCaptions;
   })();
-  const recordCaption = (speaker, captionText) => {
+  const normalizeCaption = (speaker, captionText) => {
     if (!captionState) return;
     const clean = String(captionText || "").replace(/\\s+/g, " ").trim();
     const cleanSpeaker = String(speaker || "").replace(/\\s+/g, " ").trim();
-    if (!clean || clean.length < 2) return;
-    if (/^(turn on captions|turn off captions|captions)$/i.test(clean)) return;
-    const key = (cleanSpeaker + "\\n" + clean).toLowerCase();
-    if (captionState.seen[key]) return;
-    captionState.seen[key] = true;
-    const entry = { at: new Date().toISOString(), speaker: cleanSpeaker || undefined, text: clean };
-    captionState.lines.push(entry);
-    if (captionState.lines.length > 50) captionState.lines.splice(0, captionState.lines.length - 50);
+    if (!clean || clean.length < 2) return undefined;
+    if (/^(turn on captions|turn off captions|captions)$/i.test(clean)) return undefined;
+    return { speaker: cleanSpeaker || undefined, text: clean };
+  };
+  const commitLines = (state, entries) => {
+    state.lines.push(...entries.map((entry) => ({
+      at: entry.at,
+      speaker: entry.speaker,
+      text: entry.text
+    })));
+    const excess = state.lines.length - ${GOOGLE_MEET_TRANSCRIPT_MAX_LINES};
+    if (excess > 0) {
+      state.lines.splice(0, excess);
+      state.droppedLines = (state.droppedLines || 0) + excess;
+    }
   };
   const scrapeCaptions = () => {
     if (!captionState) return;
     const regions = [...document.querySelectorAll(captionSelector)];
+    const rows = [];
     for (const region of regions) {
       const raw = text(region);
       if (!raw) continue;
       const pieces = raw.split(/\\n+/).map((part) => part.trim()).filter(Boolean);
-      if (pieces.length >= 2) {
-        recordCaption(pieces[0], pieces.slice(1).join(" "));
-      } else {
-        recordCaption("", pieces[0] || raw);
+      const row = pieces.length >= 2
+        ? normalizeCaption(pieces[0], pieces.slice(1).join(" "))
+        : normalizeCaption("", pieces[0] || raw);
+      if (row) rows.push({ ...row, node: region });
+    }
+    if (rows.length === 0) {
+      // Meet briefly removes caption rows while rerendering. Keep them mutable
+      // for one settle window so a DOM gap cannot fabricate a repeated line.
+      if (captionState.visible.length > 0 && captionState.settleTimer === undefined) {
+        const pendingState = captionState;
+        pendingState.settleTimer = setTimeout(() => {
+          if (window.__openclawMeetCaptions !== pendingState) return;
+          commitLines(pendingState, pendingState.visible);
+          pendingState.visible = [];
+          pendingState.settleTimer = undefined;
+        }, ${GOOGLE_MEET_CAPTION_SETTLE_MS});
       }
+      return;
     }
+    if (captionState.settleTimer !== undefined) {
+      clearTimeout(captionState.settleTimer);
+      captionState.settleTimer = undefined;
+    }
+    const previous = Array.isArray(captionState.visible) ? captionState.visible : [];
+    const unmatchedPrevious = [...previous];
+    const nextVisible = [];
+    const now = Date.now();
+    for (let index = 0; index < rows.length; index += 1) {
+      const row = rows[index];
+      const priorIndex = unmatchedPrevious.findIndex((candidate) => {
+        const sameTextLifecycle =
+          candidate.text === row.text ||
+          row.text.startsWith(candidate.text) ||
+          candidate.text.startsWith(row.text);
+        const sameDomLifecycle =
+          candidate.node === row.node || now - candidate.seenAt <= ${GOOGLE_MEET_CAPTION_SETTLE_MS};
+        return candidate.speaker === row.speaker && sameTextLifecycle && sameDomLifecycle;
+      });
+      const prior = priorIndex >= 0 ? unmatchedPrevious.splice(priorIndex, 1)[0] : undefined;
+      const sameSpeaker = Boolean(prior) && prior.speaker === row.speaker;
+      if (sameSpeaker && prior.text === row.text) {
+        prior.node = row.node;
+        prior.seenAt = now;
+        nextVisible.push(prior);
+        continue;
+      }
+      if (sameSpeaker && row.text.startsWith(prior.text)) {
+        prior.text = row.text;
+        prior.node = row.node;
+        prior.seenAt = now;
+        nextVisible.push(prior);
+        continue;
+      }
+      if (sameSpeaker && prior.text.startsWith(row.text)) {
+        prior.node = row.node;
+        prior.seenAt = now;
+        nextVisible.push(prior);
+        continue;
+      }
+      const entry = {
+        at: new Date().toISOString(),
+        node: row.node,
+        seenAt: now,
+        speaker: row.speaker,
+        text: row.text
+      };
+      nextVisible.push(entry);
+    }
+    commitLines(captionState, unmatchedPrevious);
+    captionState.visible = nextVisible;
   };
   if (captionState) {
     if (!readOnly && inCall && !captionState.enabledAttempted) {
@@ -2534,7 +2826,8 @@ function meetStatusScript(params) {
     }
     if (inCall && !captionState.observerInstalled) {
       captionState.observerInstalled = true;
-      new MutationObserver(scrapeCaptions).observe(document.body, {
+      captionState.observer = new MutationObserver(scrapeCaptions);
+      captionState.observer.observe(document.body, {
         childList: true,
         subtree: true,
         characterData: true
@@ -2544,17 +2837,19 @@ function meetStatusScript(params) {
     if (inCall) {
       scrapeCaptions();
     }
-    const lines = Array.isArray(captionState.lines) ? captionState.lines : [];
+    const committedLines = Array.isArray(captionState.lines) ? captionState.lines : [];
+    const visibleLines = Array.isArray(captionState.visible) ? captionState.visible : [];
+    const lines = [...committedLines, ...visibleLines];
     const last = lines[lines.length - 1];
     captioning = document.querySelector(captionSelector) !== null || lines.length > 0;
-    transcriptLines = lines.length;
+    transcriptLines = (captionState.droppedLines || 0) + lines.length;
     lastCaptionAt = last?.at;
     lastCaptionSpeaker = last?.speaker;
     lastCaptionText = last?.text;
     recentTranscript = lines.slice(-5);
   }
   const lobbyWaiting = !inCall && /asking to be let in|you.?ll join when someone lets you in|waiting to be let in|ask to join/i.test(pageText);
-  const leaveReason = /you left the meeting|you.?ve left the meeting|removed from the meeting|you were removed|call ended|meeting ended/i.test(pageText)
+  const leaveReason = !inCall && /you left the meeting|you.?ve left the meeting|removed from the meeting|you were removed|call ended|meeting ended/i.test(pageText)
     ? pageText.match(/you left the meeting|you.?ve left the meeting|removed from the meeting|you were removed|call ended|meeting ended/i)?.[0]
     : undefined;
   let manualActionReason;
@@ -2562,6 +2857,9 @@ function meetStatusScript(params) {
   if (!inCall && (host === "accounts.google.com" || /use your google account|to continue to google meet|choose an account|sign in to (join|continue)/i.test(pageText))) {
     manualActionReason = "google-login-required";
     manualActionMessage = "Sign in to Google in the OpenClaw browser profile, then retry the Meet join.";
+  } else if (!inCall && joinElsewhere) {
+    manualActionReason = "meet-session-conflict";
+    manualActionMessage = "Meet is already active in another tab or device. Leave that session or reuse an English-pinned tab before retrying.";
   } else if (!inCall && /asking to be let in|you.?ll join when someone lets you in|waiting to be let in|ask to join/i.test(pageText)) {
     manualActionReason = "meet-admission-required";
     manualActionMessage = "Admit the OpenClaw browser participant in Google Meet, then retry speech.";
@@ -2602,63 +2900,404 @@ function meetStatusScript(params) {
   });
 }`;
 }
-async function openMeetWithBrowserProxy(params) {
-	return await openMeetWithBrowserRequest({
-		callBrowser: async (request) => await callBrowserProxyOnNode({
-			runtime: params.runtime,
-			nodeId: params.nodeId,
-			method: request.method,
-			path: request.path,
-			body: request.body,
-			timeoutMs: request.timeoutMs
-		}),
-		config: params.config,
-		mode: params.mode,
-		url: params.url
-	});
+function meetTranscriptScript(meetingUrl, meetingSessionId, finalize) {
+	const expectedMeetingUrl = normalizeMeetUrlForReuse(meetingUrl);
+	return `() => {
+  const expectedMeetingUrl = ${JSON.stringify(expectedMeetingUrl)};
+  const expectedSessionId = ${JSON.stringify(meetingSessionId)};
+  let currentMeetingUrl;
+  try {
+    const currentUrl = new URL(location.href);
+    currentMeetingUrl = currentUrl.origin + currentUrl.pathname.toLowerCase().replace(/\\/$/, "");
+  } catch {
+    return JSON.stringify({ urlMatched: false });
+  }
+  if (!expectedMeetingUrl || currentMeetingUrl !== expectedMeetingUrl) {
+    return JSON.stringify({ urlMatched: false });
+  }
+  const state = window.__openclawMeetCaptions;
+  if (state?.sessionId && state.sessionId !== expectedSessionId) {
+    return JSON.stringify({ urlMatched: true, sessionMatched: false });
+  }
+  if (${JSON.stringify(finalize)} && Array.isArray(state?.visible) && state.visible.length > 0) {
+    if (state.settleTimer !== undefined) clearTimeout(state.settleTimer);
+    state.settleTimer = undefined;
+    state.lines = Array.isArray(state.lines) ? state.lines : [];
+    state.lines.push(...state.visible.map((entry) => ({
+      at: entry.at,
+      speaker: entry.speaker,
+      text: entry.text
+    })));
+    state.visible = [];
+    const excess = state.lines.length - ${GOOGLE_MEET_TRANSCRIPT_MAX_LINES};
+    if (excess > 0) {
+      state.lines.splice(0, excess);
+      state.droppedLines = (state.droppedLines || 0) + excess;
+    }
+  }
+  const lines = Array.isArray(state?.lines) ? state.lines : [];
+  return JSON.stringify({
+    urlMatched: true,
+    sessionMatched: true,
+    epoch: typeof state?.epoch === "string" ? state.epoch : undefined,
+    droppedLines: Number.isFinite(state?.droppedLines) ? Math.max(0, Math.trunc(state.droppedLines)) : 0,
+    lines: lines.map((line) => ({
+      at: typeof line?.at === "string" ? line.at : undefined,
+      speaker: typeof line?.speaker === "string" ? line.speaker : undefined,
+      text: typeof line?.text === "string" ? line.text : ""
+    })).filter((line) => line.text)
+  });
+}`;
 }
-async function openMeetWithBrowserRequest(params) {
-	if (!params.config.chrome.launch) return { launched: false };
-	const timeoutMs = Math.max(1e3, params.config.chrome.joinTimeoutMs);
-	let targetId;
-	let tab;
-	if (params.config.chrome.reuseExistingTab) {
-		tab = asBrowserTabs(await params.callBrowser({
-			method: "GET",
-			path: "/tabs",
-			timeoutMs: Math.min(timeoutMs, 5e3)
-		})).find((entry) => isSameMeetUrlForReuse(entry.url, params.url));
-		targetId = tab?.targetId;
-		if (targetId) await params.callBrowser({
-			method: "POST",
-			path: "/tabs/focus",
-			body: { targetId },
-			timeoutMs: Math.min(timeoutMs, 5e3)
-		});
-	}
-	if (!targetId) {
-		tab = readBrowserTab(await params.callBrowser({
-			method: "POST",
-			path: "/tabs/open",
-			body: { url: forceMeetEnglishUi(params.url) },
-			timeoutMs
-		}));
-		targetId = tab?.targetId;
+function parseMeetTranscriptSnapshot(result) {
+	const raw = (result && typeof result === "object" ? result : {}).result;
+	if (typeof raw !== "string" || !raw.trim()) return {
+		droppedLines: 0,
+		lines: []
+	};
+	let parsed;
+	try {
+		parsed = JSON.parse(raw);
+	} catch {
+		throw new Error("Google Meet transcript JSON is malformed.");
 	}
-	if (!targetId) return {
-		launched: true,
-		browser: {
-			status: "browser-control",
-			notes: ["Browser proxy opened Meet but did not return a targetId."],
-			browserUrl: tab?.url,
-			browserTitle: tab?.title
-		}
+	if (!parsed || typeof parsed !== "object") throw new Error("Google Meet transcript payload is invalid.");
+	const payload = parsed;
+	const droppedLines = typeof payload.droppedLines === "number" && Number.isSafeInteger(payload.droppedLines) ? Math.max(0, payload.droppedLines) : 0;
+	const lines = Array.isArray(payload.lines) ? payload.lines.flatMap((value) => {
+		if (!value || typeof value !== "object") return [];
+		const line = value;
+		if (typeof line.text !== "string" || !line.text.trim()) return [];
+		return [{
+			...typeof line.at === "string" ? { at: line.at } : {},
+			...typeof line.speaker === "string" ? { speaker: line.speaker } : {},
+			text: line.text
+		}];
+	}) : [];
+	return {
+		droppedLines,
+		...typeof payload.epoch === "string" ? { epoch: payload.epoch } : {},
+		lines,
+		...typeof payload.urlMatched === "boolean" ? { urlMatched: payload.urlMatched } : {},
+		...typeof payload.sessionMatched === "boolean" ? { sessionMatched: payload.sessionMatched } : {}
 	};
-	const permissionNotes = await grantMeetMediaPermissions({
-		allowMicrophone: isGoogleMeetTalkBackMode$2(params.mode),
-		callBrowser: params.callBrowser,
-		targetId,
-		timeoutMs
+}
+async function readMeetTranscriptWithBrowserRequest(params) {
+	const snapshot = parseMeetTranscriptSnapshot(await params.callBrowser({
+		method: "POST",
+		path: "/act",
+		body: {
+			kind: "evaluate",
+			targetId: params.tab.targetId,
+			fn: meetTranscriptScript(params.meetingUrl, params.meetingSessionId, params.finalize)
+		},
+		timeoutMs: params.timeoutMs
+	}));
+	if (snapshot.urlMatched === false) throw new Error("The tracked Meet tab no longer shows this session's meeting URL.");
+	if (snapshot.sessionMatched === false) throw new Error("The tracked Meet tab now belongs to another OpenClaw meeting session.");
+	return {
+		droppedLines: snapshot.droppedLines,
+		...snapshot.epoch ? { epoch: snapshot.epoch } : {},
+		lines: snapshot.lines
+	};
+}
+function meetLeaveScript(meetingUrl) {
+	const expectedMeetingUrl = normalizeMeetUrlForReuse(meetingUrl);
+	return `() => {
+  const expectedMeetingUrl = ${JSON.stringify(expectedMeetingUrl)};
+  let currentMeetingUrl;
+  try {
+    const currentUrl = new URL(location.href);
+    currentMeetingUrl = currentUrl.origin + currentUrl.pathname.toLowerCase().replace(/\\/$/, "");
+  } catch {
+    return JSON.stringify({ departed: false });
+  }
+  if (!expectedMeetingUrl || currentMeetingUrl !== expectedMeetingUrl) {
+    return JSON.stringify({ departed: true, urlMatched: false });
+  }
+  const text = (node) => (node?.innerText || node?.textContent || "").trim();
+  // Locale-independent fallback: Meet renders the leave control as a Material
+  // Symbols icon whose ligature text is "call_end" in every UI language, so a
+  // localized aria-label (e.g. "Anruf verlassen") still resolves to the button.
+  const hasLeaveIcon = (button) => {
+    const icon = button.querySelector ? button.querySelector("i") : null;
+    return icon ? (icon.textContent || "").trim() === "call_end" : false;
+  };
+  const buttons = [...document.querySelectorAll('button')];
+  const label = (button) => [
+    button.getAttribute("aria-label"),
+    button.getAttribute("data-tooltip"),
+    text(button),
+  ]
+    .filter(Boolean)
+    .join(" ");
+  const postCall = buttons.some((button) => /\\b(rejoin|return to home screen)\\b/i.test(label(button)));
+  if (postCall) {
+    return JSON.stringify({ departed: true, urlMatched: true });
+  }
+  // Managed join tabs are reused only after the English-tab gate or opened
+  // through the English-UI helper, so follow-up labels are pinned to English.
+  const confirmation = buttons.find((button) => {
+    return !button.disabled && /\\bleave meeting\\b/i.test(label(button));
+  });
+  if (confirmation) {
+    confirmation.click();
+    return JSON.stringify({ departed: false, leaveAction: "confirm", urlMatched: true });
+  }
+  const leave = buttons.find((button) => {
+    if (button.disabled) return false;
+    return /leave call/i.test(label(button)) || hasLeaveIcon(button);
+  });
+  if (leave) {
+    leave.click();
+    return JSON.stringify({ departed: false, leaveAction: "leave", urlMatched: true });
+  }
+  return JSON.stringify({ departed: false, urlMatched: true });
+}`;
+}
+function parseMeetLeaveResult(result) {
+	const raw = (result && typeof result === "object" ? result : {}).result;
+	if (typeof raw !== "string" || !raw.trim()) return { departed: false };
+	try {
+		const parsed = JSON.parse(raw);
+		const leaveAction = parsed.leaveAction === "leave" || parsed.leaveAction === "confirm" ? parsed.leaveAction : void 0;
+		return {
+			departed: parsed.departed === true,
+			...leaveAction ? { leaveAction } : {},
+			...typeof parsed.urlMatched === "boolean" ? { urlMatched: parsed.urlMatched } : {}
+		};
+	} catch {
+		return { departed: false };
+	}
+}
+async function leaveMeetInPage(params) {
+	const deadline = Date.now() + params.timeoutMs;
+	let clickedLeave = false;
+	let clickedConfirmation = false;
+	do {
+		const step = parseMeetLeaveResult(await params.callBrowser({
+			method: "POST",
+			path: "/act",
+			body: {
+				kind: "evaluate",
+				targetId: params.targetId,
+				fn: meetLeaveScript(params.meetingUrl)
+			},
+			timeoutMs: params.timeoutMs
+		}));
+		clickedLeave ||= step.leaveAction === "leave";
+		clickedConfirmation ||= step.leaveAction === "confirm";
+		if (step.departed || step.urlMatched !== true) return {
+			departed: step.departed,
+			clickedLeave,
+			clickedConfirmation,
+			urlMatched: step.urlMatched
+		};
+		if (!step.leaveAction && !clickedLeave) return {
+			departed: false,
+			clickedLeave,
+			clickedConfirmation,
+			urlMatched: true
+		};
+		if (!step.leaveAction) await new Promise((resolve) => {
+			setTimeout(resolve, 100);
+		});
+	} while (Date.now() < deadline);
+	return {
+		departed: false,
+		clickedLeave,
+		clickedConfirmation,
+		urlMatched: true
+	};
+}
+async function leaveMeetWithBrowserRequest(params) {
+	if (!params.config.chrome.launch) return {
+		left: false,
+		note: "Browser leave skipped because chrome.launch is disabled."
+	};
+	const timeoutMs = Math.min(Math.max(1e3, params.config.chrome.joinTimeoutMs), 5e3);
+	const { targetId, openedByPlugin } = params.tab;
+	try {
+		if (!asBrowserTabs(await params.callBrowser({
+			method: "GET",
+			path: "/tabs",
+			timeoutMs
+		})).find((entry) => entry.targetId === targetId)) return {
+			left: true,
+			note: "Meet tab is already closed."
+		};
+		let leaveResult;
+		try {
+			leaveResult = await leaveMeetInPage({
+				callBrowser: params.callBrowser,
+				meetingUrl: params.meetingUrl,
+				targetId,
+				timeoutMs
+			});
+		} catch (error) {
+			return {
+				left: false,
+				note: `Browser control could not verify the Meet tab before leaving: ${error instanceof Error ? error.message : String(error)}`
+			};
+		}
+		if (leaveResult.urlMatched === false) return {
+			left: true,
+			note: "Meet tab moved away from this session; left its current page untouched."
+		};
+		if (leaveResult.urlMatched !== true) return {
+			left: false,
+			note: "Browser control could not verify that the tracked tab still showed this meeting."
+		};
+		const { clickedLeave, departed } = leaveResult;
+		if (!openedByPlugin) return {
+			left: departed,
+			note: departed ? "Clicked Meet's Leave call button; kept the reused browser tab open." : clickedLeave ? "Clicked Meet's Leave call button, but could not verify departure; leave it manually." : "Could not find Meet's Leave call button in the reused browser tab; leave it manually."
+		};
+		await params.callBrowser({
+			method: "DELETE",
+			path: `/tabs/${targetId}`,
+			timeoutMs
+		});
+		return {
+			left: true,
+			note: clickedLeave ? "Clicked Meet's Leave call button and closed the Meet tab." : "Closed the Meet tab to leave the meeting (Leave call button was not found)."
+		};
+	} catch (error) {
+		return {
+			left: false,
+			note: `Browser control could not leave the Meet tab: ${error instanceof Error ? error.message : String(error)}`
+		};
+	}
+}
+async function leaveChromeMeet(params) {
+	return await leaveMeetWithBrowserRequest({
+		callBrowser: await resolveLocalBrowserRequest(params.runtime),
+		config: params.config,
+		meetingUrl: params.meetingUrl,
+		tab: params.tab
+	});
+}
+async function readChromeMeetTranscript(params) {
+	return await readMeetTranscriptWithBrowserRequest({
+		callBrowser: await resolveLocalBrowserRequest(params.runtime),
+		finalize: params.finalize === true,
+		meetingUrl: params.meetingUrl,
+		meetingSessionId: params.meetingSessionId,
+		tab: params.tab,
+		timeoutMs: Math.min(Math.max(1e3, params.config.chrome.joinTimeoutMs), 1e4)
+	});
+}
+async function readChromeMeetTranscriptOnNode(params) {
+	const nodeId = params.nodeId ?? await resolveChromeNode({
+		runtime: params.runtime,
+		requestedNode: params.config.chromeNode.node
+	});
+	const timeoutMs = Math.min(Math.max(1e3, params.config.chrome.joinTimeoutMs), 1e4);
+	return await readMeetTranscriptWithBrowserRequest({
+		callBrowser: async (request) => await callBrowserProxyOnNode({
+			runtime: params.runtime,
+			nodeId,
+			method: request.method,
+			path: request.path,
+			body: request.body,
+			timeoutMs: request.timeoutMs
+		}),
+		finalize: params.finalize === true,
+		meetingUrl: params.meetingUrl,
+		meetingSessionId: params.meetingSessionId,
+		tab: params.tab,
+		timeoutMs
+	});
+}
+async function leaveChromeMeetOnNode(params) {
+	const nodeId = params.nodeId ?? await resolveChromeNode({
+		runtime: params.runtime,
+		requestedNode: params.config.chromeNode.node
+	});
+	return await leaveMeetWithBrowserRequest({
+		callBrowser: async (request) => await callBrowserProxyOnNode({
+			runtime: params.runtime,
+			nodeId,
+			method: request.method,
+			path: request.path,
+			body: request.body,
+			timeoutMs: request.timeoutMs
+		}),
+		config: params.config,
+		meetingUrl: params.meetingUrl,
+		tab: params.tab
+	});
+}
+async function openMeetWithBrowserProxy(params) {
+	return await openMeetWithBrowserRequest({
+		callBrowser: async (request) => await callBrowserProxyOnNode({
+			runtime: params.runtime,
+			nodeId: params.nodeId,
+			method: request.method,
+			path: request.path,
+			body: request.body,
+			timeoutMs: request.timeoutMs
+		}),
+		config: params.config,
+		mode: params.mode,
+		meetingSessionId: params.meetingSessionId,
+		url: params.url
+	});
+}
+async function openMeetWithBrowserRequest(params) {
+	if (!params.config.chrome.launch) return { launched: false };
+	const timeoutMs = Math.max(1e3, params.config.chrome.joinTimeoutMs);
+	let targetId;
+	let tab;
+	let openUrl = params.url;
+	let openedByPlugin = false;
+	if (params.config.chrome.reuseExistingTab) {
+		const matchingTabs = asBrowserTabs(await params.callBrowser({
+			method: "GET",
+			path: "/tabs",
+			timeoutMs: Math.min(timeoutMs, 5e3)
+		})).filter((entry) => isSameMeetUrlForReuse(entry.url, params.url));
+		const requestedAuthUser = readMeetAuthUser(params.url);
+		tab = matchingTabs.find((entry) => isEnglishMeetTab(entry.url) && (!requestedAuthUser || readMeetAuthUser(entry.url) === requestedAuthUser));
+		if (!tab) {
+			if (!new URL(params.url).searchParams.has("authuser")) openUrl = matchingTabs.find((entry) => entry.url)?.url ?? params.url;
+		}
+		targetId = tab?.targetId;
+		if (tab && targetId) await params.callBrowser({
+			method: "POST",
+			path: "/tabs/focus",
+			body: { targetId },
+			timeoutMs: Math.min(timeoutMs, 5e3)
+		});
+	}
+	if (!targetId) {
+		tab = readBrowserTab(await params.callBrowser({
+			method: "POST",
+			path: "/tabs/open",
+			body: { url: forceMeetEnglishUi(openUrl) },
+			timeoutMs
+		}));
+		targetId = tab?.targetId;
+		openedByPlugin = Boolean(targetId);
+	}
+	if (!targetId) return {
+		launched: true,
+		browser: {
+			status: "browser-control",
+			notes: ["Browser proxy opened Meet but did not return a targetId."],
+			browserUrl: tab?.url,
+			browserTitle: tab?.title
+		}
+	};
+	const tabIdentity = {
+		targetId,
+		openedByPlugin
+	};
+	const permissionNotes = await grantMeetMediaPermissions({
+		allowMicrophone: isGoogleMeetTalkBackMode$2(params.mode),
+		callBrowser: params.callBrowser,
+		targetId,
+		timeoutMs
 	});
 	const deadline = Date.now() + Math.max(0, params.config.chrome.waitForInCallMs);
 	let browser = {
@@ -2677,6 +3316,7 @@ async function openMeetWithBrowserRequest(params) {
 					targetId,
 					fn: meetStatusScript({
 						allowMicrophone: isGoogleMeetTalkBackMode$2(params.mode),
+						captionSessionId: params.meetingSessionId,
 						captureCaptions: params.mode === "transcribe",
 						guestName: params.config.chrome.guestName,
 						autoJoin: params.config.chrome.autoJoin
@@ -2686,11 +3326,13 @@ async function openMeetWithBrowserRequest(params) {
 			})) ?? browser, permissionNotes);
 			if (browser?.inCall === true && (!isGoogleMeetTalkBackMode$2(params.mode) || browser.micMuted !== true)) return {
 				launched: true,
-				browser
+				browser,
+				tab: tabIdentity
 			};
 			if (browser?.manualActionRequired === true) return {
 				launched: true,
-				browser
+				browser,
+				tab: tabIdentity
 			};
 		} catch (error) {
 			browser = {
@@ -2710,7 +3352,8 @@ async function openMeetWithBrowserRequest(params) {
 	} while (Date.now() < deadline);
 	return {
 		launched: true,
-		browser
+		browser,
+		tab: tabIdentity
 	};
 }
 function isRecoverableMeetTab(tab, url) {
@@ -2718,6 +3361,13 @@ function isRecoverableMeetTab(tab, url) {
 	if (normalizeMeetUrlForReuse(tab.url)) return true;
 	return (tab.url ?? "").startsWith("https://accounts.google.com/") && /sign in|google accounts|meet/i.test(tab.title ?? "");
 }
+function findRecoverableMeetTab(tabs, url) {
+	const candidates = tabs.filter((tab) => isRecoverableMeetTab(tab, url));
+	if (!url) return candidates[0];
+	const requestedAuthUser = readMeetAuthUser(url);
+	const accountCandidates = requestedAuthUser ? candidates.filter((tab) => readMeetAuthUser(tab.url) === requestedAuthUser) : candidates;
+	return accountCandidates.find((tab) => isEnglishMeetTab(tab.url)) ?? accountCandidates[0];
+}
 async function inspectRecoverableMeetTab(params) {
 	const allowMicrophone = params.mode !== "transcribe";
 	await params.callBrowser({
@@ -2726,6 +3376,23 @@ async function inspectRecoverableMeetTab(params) {
 		body: { targetId: params.targetId },
 		timeoutMs: Math.min(params.timeoutMs, 5e3)
 	});
+	if (normalizeMeetUrlForReuse(params.tab.url) && !isEnglishMeetTab(params.tab.url)) {
+		const manualActionMessage = "The existing Meet tab is not pinned to English. Open the meeting with ?hl=en, then retry recovery.";
+		return {
+			found: true,
+			targetId: params.targetId,
+			tab: params.tab,
+			browser: {
+				status: "browser-control",
+				browserUrl: params.tab.url,
+				browserTitle: params.tab.title,
+				manualActionRequired: true,
+				manualActionReason: "meet-locale-required",
+				manualActionMessage
+			},
+			message: manualActionMessage
+		};
+	}
 	const permissionNotes = params.readOnly ? [] : await grantMeetMediaPermissions({
 		allowMicrophone,
 		callBrowser: params.callBrowser,
@@ -2763,11 +3430,12 @@ async function inspectRecoverableMeetTab(params) {
 }
 async function recoverCurrentMeetTab(params) {
 	const timeoutMs = Math.max(1e3, params.config.chrome.joinTimeoutMs);
-	const tab = asBrowserTabs(await callLocalBrowserRequest({
+	const callBrowser = await resolveLocalBrowserRequest(params.runtime);
+	const tab = findRecoverableMeetTab(asBrowserTabs(await callBrowser({
 		method: "GET",
 		path: "/tabs",
 		timeoutMs: Math.min(timeoutMs, 5e3)
-	})).find((entry) => isRecoverableMeetTab(entry, params.url));
+	})), params.url);
 	const targetId = tab?.targetId;
 	if (!tab || !targetId) return {
 		transport: "chrome",
@@ -2778,7 +3446,7 @@ async function recoverCurrentMeetTab(params) {
 	return {
 		transport: "chrome",
 		...await inspectRecoverableMeetTab({
-			callBrowser: callLocalBrowserRequest,
+			callBrowser,
 			config: params.config,
 			mode: params.mode,
 			readOnly: params.readOnly,
@@ -2794,13 +3462,13 @@ async function recoverCurrentMeetTabOnNode(params) {
 		requestedNode: params.config.chromeNode.node
 	});
 	const timeoutMs = Math.max(1e3, params.config.chrome.joinTimeoutMs);
-	const tab = asBrowserTabs(await callBrowserProxyOnNode({
+	const tab = findRecoverableMeetTab(asBrowserTabs(await callBrowserProxyOnNode({
 		runtime: params.runtime,
 		nodeId,
 		method: "GET",
 		path: "/tabs",
 		timeoutMs: Math.min(timeoutMs, 5e3)
-	})).find((entry) => isRecoverableMeetTab(entry, params.url));
+	})), params.url);
 	const targetId = tab?.targetId;
 	if (!tab || !targetId) return {
 		transport: "chrome-node",
@@ -2854,6 +3522,7 @@ async function launchChromeMeetOnNode(params) {
 		nodeId,
 		config: params.config,
 		mode: params.mode,
+		meetingSessionId: params.meetingSessionId,
 		url: params.url
 	});
 	const result = parseNodeStartResult(await params.runtime.nodes.invoke({
@@ -2895,19 +3564,22 @@ async function launchChromeMeetOnNode(params) {
 			nodeId,
 			launched: browserControl.launched || result.launched === true,
 			audioBridge: bridge,
-			browser: browserControl.browser ?? result.browser
+			browser: browserControl.browser ?? result.browser,
+			tab: browserControl.tab
 		};
 	}
 	if (result.audioBridge?.type === "external-command") return {
 		nodeId,
 		launched: browserControl.launched || result.launched === true,
 		audioBridge: { type: "external-command" },
-		browser: browserControl.browser ?? result.browser
+		browser: browserControl.browser ?? result.browser,
+		tab: browserControl.tab
 	};
 	return {
 		nodeId,
 		launched: browserControl.launched || result.launched === true,
-		browser: browserControl.browser ?? result.browser
+		browser: browserControl.browser ?? result.browser,
+		tab: browserControl.tab
 	};
 }
 //#endregion
@@ -3075,28 +3747,33 @@ function nowIso() {
 function buildTwilioVoiceCallSessionKey(meetingSessionId) {
 	return `voice:google-meet:${meetingSessionId}`;
 }
-function normalizeMeetUrl(input) {
-	const raw = normalizeOptionalString(input);
-	if (!raw) throw new Error("url required");
-	let url;
-	try {
-		url = new URL(raw);
-	} catch {
-		throw new Error("url must be a valid Google Meet URL");
-	}
-	if (url.protocol !== "https:" || url.hostname.toLowerCase() !== "meet.google.com") throw new Error("url must be an explicit https://meet.google.com/... URL");
-	if (!/^\/[a-z]{3}-[a-z]{4}-[a-z]{3}(?:$|[/?#])/i.test(url.pathname)) throw new Error("url must include a Google Meet meeting code");
-	return url.toString();
-}
 function resolveTransport(input, config) {
 	return input ?? config.defaultTransport;
 }
 function resolveMode(input, config) {
 	return input === "realtime" ? "agent" : input ?? config.defaultMode;
 }
+function resolveSessionAgentId(request, config) {
+	return normalizeAgentId(request.agentId ?? config.realtime.agentId);
+}
+function withSessionAgentConfig(config, agentId) {
+	return config.realtime.agentId === agentId ? config : {
+		...config,
+		realtime: {
+			...config.realtime,
+			agentId
+		}
+	};
+}
 function isGoogleMeetTalkBackMode$1(mode) {
 	return mode === "agent" || mode === "bidi";
 }
+function isBrowserTransport(transport) {
+	return transport === "chrome" || transport === "chrome-node";
+}
+function isReusableMeetSession(session, params) {
+	return session.state === "active" && isSameMeetUrlForReuse(session.url, params.url) && session.transport === params.transport && session.mode === params.mode && session.agentId === params.agentId;
+}
 function hasRealtimeAudioOutputAdvanced(health, startOutputBytes) {
 	return (health?.lastOutputBytes ?? 0) > startOutputBytes;
 }
@@ -3181,9 +3858,16 @@ async function commandExists(runtime, command) {
 }
 var GoogleMeetRuntime = class {
 	#sessions = /* @__PURE__ */ new Map();
+	#sessionLeaves = /* @__PURE__ */ new Map();
+	#browserMeetingLocks = /* @__PURE__ */ new Map();
+	#createdBrowserTabs = /* @__PURE__ */ new Map();
 	#sessionStops = /* @__PURE__ */ new Map();
 	#sessionSpeakers = /* @__PURE__ */ new Map();
 	#sessionHealth = /* @__PURE__ */ new Map();
+	#transcripts = /* @__PURE__ */ new Map();
+	#transcriptCaptures = /* @__PURE__ */ new Map();
+	#transcriptFinalizing = /* @__PURE__ */ new Set();
+	#retiredTranscripts = /* @__PURE__ */ new Set();
 	#voiceCallGateway;
 	constructor(params) {
 		this.params = params;
@@ -3210,6 +3894,28 @@ var GoogleMeetRuntime = class {
 			session
 		} : { found: false };
 	}
+	async transcript(sessionId, options = {}) {
+		const session = this.#sessions.get(sessionId);
+		if (!session) return { found: false };
+		if (session.mode !== "transcribe") throw new Error("transcript is only available for transcribe-mode sessions");
+		const sinceIndex = options.sinceIndex ?? 0;
+		if (!Number.isSafeInteger(sinceIndex) || sinceIndex < 0) throw new Error("sinceIndex must be a non-negative safe integer");
+		if (session.state === "active" && !this.#transcriptFinalizing.has(session.id)) await this.#captureTranscriptSnapshot(session);
+		const snapshot = this.#transcripts.get(sessionId) ?? {
+			droppedLines: 0,
+			lines: []
+		};
+		const startIndex = Math.max(sinceIndex, snapshot.droppedLines);
+		return {
+			found: true,
+			sessionId,
+			startIndex,
+			nextIndex: snapshot.droppedLines + snapshot.lines.length,
+			droppedLines: snapshot.droppedLines,
+			...session.transcriptEvicted ? { evicted: true } : {},
+			lines: snapshot.lines.slice(startIndex - snapshot.droppedLines)
+		};
+	}
 	async setupStatus(options = {}) {
 		const transport = resolveTransport(options.transport, this.params.config);
 		const mode = resolveMode(options.mode, this.params.config);
@@ -3273,10 +3979,12 @@ var GoogleMeetRuntime = class {
 		return status;
 	}
 	async createViaBrowser() {
-		return createMeetWithBrowserProxyOnNode({
+		const result = await createMeetWithBrowserProxyOnNode({
 			runtime: this.params.runtime,
 			config: this.params.config
 		});
+		if (result.openedByPlugin && result.targetId) this.#createdBrowserTabs.set(`${result.nodeId}:${result.targetId}`, result.meetingUri);
+		return result;
 	}
 	async recoverCurrentTab(request = {}) {
 		const transport = resolveTransport(request.transport, this.params.config);
@@ -3288,6 +3996,7 @@ var GoogleMeetRuntime = class {
 			url
 		});
 		return recoverCurrentMeetTab({
+			runtime: this.params.runtime,
 			config: this.params.config,
 			url
 		});
@@ -3296,7 +4005,51 @@ var GoogleMeetRuntime = class {
 		const url = normalizeMeetUrl(request.url);
 		const transport = resolveTransport(request.transport, this.params.config);
 		const mode = resolveMode(request.mode, this.params.config);
-		let reusable = this.list().find((session) => session.state === "active" && isSameMeetUrlForReuse(session.url, url) && session.transport === transport && session.mode === mode);
+		const agentId = resolveSessionAgentId(request, this.params.config);
+		if (!isBrowserTransport(transport)) return await this.#joinUnlocked(request, {
+			url,
+			transport,
+			mode,
+			agentId
+		});
+		return await this.#withBrowserMeetingLock(transport, url, async () => await this.#joinUnlocked(request, {
+			url,
+			transport,
+			mode,
+			agentId
+		}));
+	}
+	async #joinUnlocked(request, resolved) {
+		const { url, transport, mode, agentId } = resolved;
+		const activeSessions = this.list().filter((session) => session.state === "active" && isSameMeetUrlForReuse(session.url, url) && session.transport === transport);
+		const retainedBrowserTabs = [];
+		if (isBrowserTransport(transport) && isGoogleMeetTalkBackMode$1(mode)) for (const session of activeSessions) {
+			if (!isGoogleMeetTalkBackMode$1(session.mode) || isReusableMeetSession(session, {
+				url,
+				transport,
+				mode,
+				agentId
+			})) continue;
+			const tab = this.params.config.chrome.reuseExistingTab ? session.chrome?.browserTab : void 0;
+			const keepBrowserParticipant = Boolean(tab) || session.chrome?.launched === false;
+			if (tab) retainedBrowserTabs.push({
+				session,
+				tab
+			});
+			try {
+				if ((await this.#leaveUnlocked(session.id, keepBrowserParticipant ? { keepBrowserTab: true } : void 0)).browserLeft === false) throw new Error("Could not leave the previous Meet browser tab before reassignment.");
+			} catch (error) {
+				await this.#settleRetainedBrowserTabs(retainedBrowserTabs);
+				throw error;
+			}
+			noteSession(session, "Ended before the same Meet tab was reassigned to another agent.");
+		}
+		let reusable = activeSessions.find((session) => isReusableMeetSession(session, {
+			url,
+			transport,
+			mode,
+			agentId
+		}));
 		if (reusable?.transport === "twilio") {
 			await this.#refreshTwilioVoiceCallStatus(reusable);
 			if (reusable.state !== "active") reusable = void 0;
@@ -3319,6 +4072,7 @@ var GoogleMeetRuntime = class {
 			url,
 			transport,
 			mode,
+			agentId,
 			state: "active",
 			createdAt,
 			updatedAt: createdAt,
@@ -3335,40 +4089,60 @@ var GoogleMeetRuntime = class {
 		};
 		try {
 			if (transport === "chrome" || transport === "chrome-node") {
-				const chromeConfig = request.agentId ? {
-					...this.params.config,
-					realtime: {
-						...this.params.config.realtime,
-						agentId: request.agentId
-					}
-				} : this.params.config;
-				const result = transport === "chrome-node" ? await launchChromeMeetOnNode({
-					runtime: this.params.runtime,
-					config: chromeConfig,
-					fullConfig: this.params.fullConfig,
-					meetingSessionId: session.id,
-					requesterSessionKey: request.requesterSessionKey,
-					mode,
-					url,
-					logger: this.params.logger
-				}) : await launchChromeMeet({
-					runtime: this.params.runtime,
-					config: chromeConfig,
-					fullConfig: this.params.fullConfig,
-					meetingSessionId: session.id,
-					requesterSessionKey: request.requesterSessionKey,
-					mode,
-					url,
-					logger: this.params.logger
+				const chromeConfig = withSessionAgentConfig(this.params.config, agentId);
+				let result;
+				try {
+					result = transport === "chrome-node" ? await launchChromeMeetOnNode({
+						runtime: this.params.runtime,
+						config: chromeConfig,
+						fullConfig: this.params.fullConfig,
+						meetingSessionId: session.id,
+						requesterSessionKey: request.requesterSessionKey,
+						mode,
+						url,
+						logger: this.params.logger
+					}) : await launchChromeMeet({
+						runtime: this.params.runtime,
+						config: chromeConfig,
+						fullConfig: this.params.fullConfig,
+						meetingSessionId: session.id,
+						requesterSessionKey: request.requesterSessionKey,
+						mode,
+						url,
+						logger: this.params.logger
+					});
+				} catch (error) {
+					await this.#settleRetainedBrowserTabs(retainedBrowserTabs);
+					throw error;
+				}
+				const resultNodeId = "nodeId" in result ? result.nodeId : void 0;
+				const browserTab = this.#inheritBrowserTabOwnership({
+					transport,
+					nodeId: resultNodeId,
+					meetingUrl: url,
+					tab: result.tab
 				});
 				session.chrome = {
 					audioBackend: this.params.config.chrome.audioBackend,
 					launched: result.launched,
-					nodeId: "nodeId" in result ? result.nodeId : void 0,
+					nodeId: resultNodeId,
 					browserProfile: this.params.config.chrome.browserProfile,
+					browserTab,
 					health: "browser" in result ? result.browser : void 0
 				};
 				this.#attachChromeAudioBridge(session, result.audioBridge);
+				if (!await this.#settleRetainedBrowserTabs(retainedBrowserTabs, browserTab ? {
+					transport,
+					nodeId: resultNodeId,
+					tab: browserTab
+				} : void 0)) {
+					try {
+						await this.#leaveSession(session);
+					} catch (error) {
+						this.params.logger.warn(`[google-meet] replacement cleanup failed: ${formatErrorMessage(error)}`);
+					}
+					throw new Error("Could not leave the previous Meet browser tab before reassignment.");
+				}
 				session.notes.push(result.audioBridge ? transport === "chrome-node" ? "Chrome node transport joins as the signed-in Google profile on the selected node and routes realtime audio through the node bridge." : "Chrome transport joins as the signed-in Google profile and routes realtime audio through the configured bridge." : isGoogleMeetTalkBackMode$1(mode) ? "Chrome transport joins as the signed-in Google profile and expects BlackHole 2ch audio routing." : "Chrome transport joins as the signed-in Google profile without starting the realtime audio bridge.");
 				this.#refreshSpeechReadiness(session);
 			} else {
@@ -3379,6 +4153,7 @@ var GoogleMeetRuntime = class {
 					dtmfSequence: request.dtmfSequence ?? this.params.config.twilio.defaultDtmfSequence
 				});
 				const dtmfSequence = request.dtmfSequence || this.params.config.twilio.defaultDtmfSequence ? rawDtmfSequence : prefixDtmfWait(rawDtmfSequence, this.params.config.voiceCall.dtmfDelayMs);
+				const delegatedAgentId = Boolean(normalizeOptionalString(request.agentId) || normalizeOptionalString(this.params.config.realtime.agentId)) ? agentId : void 0;
 				const voiceCallResult = this.params.config.voiceCall.enabled ? await joinMeetViaVoiceCallGateway({
 					config: this.params.config,
 					gateway: this.#voiceCallGateway,
@@ -3386,8 +4161,8 @@ var GoogleMeetRuntime = class {
 					dtmfSequence,
 					logger: this.params.logger,
 					...request.requesterSessionKey ? { requesterSessionKey: request.requesterSessionKey } : {},
-					agentId: request.agentId,
-					sessionKey: request.agentId ? `agent:${request.agentId}:google-meet:${session.id}` : buildTwilioVoiceCallSessionKey(session.id),
+					agentId: delegatedAgentId,
+					sessionKey: delegatedAgentId ? `agent:${delegatedAgentId}:google-meet:${session.id}` : buildTwilioVoiceCallSessionKey(session.id),
 					message: isGoogleMeetTalkBackMode$1(mode) ? request.message ?? this.params.config.voiceCall.introMessage ?? this.params.config.realtime.introMessage : void 0
 				}) : void 0;
 				delegatedTwilioSpoken = Boolean(voiceCallResult?.introSent);
@@ -3417,28 +4192,218 @@ var GoogleMeetRuntime = class {
 			spoken: transport === "twilio" ? delegatedTwilioSpoken : isGoogleMeetTalkBackMode$1(mode) && speechInstructions ? await this.#speakWhenReady(session, speechInstructions) : false
 		};
 	}
-	async leave(sessionId) {
+	async leave(sessionId, opts) {
+		const session = this.#sessions.get(sessionId);
+		if (!session) return { found: false };
+		if (!isBrowserTransport(session.transport)) return await this.#leaveUnlocked(sessionId, opts);
+		return await this.#withBrowserMeetingLock(session.transport, session.url, async () => await this.#leaveUnlocked(sessionId, opts));
+	}
+	async #leaveUnlocked(sessionId, opts) {
+		const inFlight = this.#sessionLeaves.get(sessionId);
+		if (inFlight) return await inFlight;
 		const session = this.#sessions.get(sessionId);
 		if (!session) return { found: false };
-		const stop = this.#sessionStops.get(sessionId);
-		if (stop) {
-			this.#sessionStops.delete(sessionId);
-			this.#sessionSpeakers.delete(sessionId);
-			this.#sessionHealth.delete(sessionId);
+		if (session.state === "ended") return {
+			found: true,
+			session,
+			...session.browserLeft === void 0 ? {} : { browserLeft: session.browserLeft }
+		};
+		const leave = this.#leaveSession(session, opts);
+		this.#sessionLeaves.set(sessionId, leave);
+		try {
+			return await leave;
+		} finally {
+			if (this.#sessionLeaves.get(sessionId) === leave) this.#sessionLeaves.delete(sessionId);
+		}
+	}
+	async #withBrowserMeetingLock(transport, url, operation) {
+		const key = `${transport}:${normalizeMeetUrlForReuse(url) ?? url}`;
+		const previous = this.#browserMeetingLocks.get(key) ?? Promise.resolve();
+		let release;
+		const gate = new Promise((resolve) => {
+			release = resolve;
+		});
+		const tail = previous.then(() => gate);
+		this.#browserMeetingLocks.set(key, tail);
+		await previous;
+		try {
+			return await operation();
+		} finally {
+			release?.();
+			if (this.#browserMeetingLocks.get(key) === tail) this.#browserMeetingLocks.delete(key);
+		}
+	}
+	async #leaveSession(session, opts) {
+		if (session.mode === "transcribe") {
+			this.#transcriptFinalizing.add(session.id);
+			await this.#captureTranscriptSnapshot(session, { finalize: true }).catch((error) => {
+				this.params.logger.debug?.(`[google-meet] final transcript snapshot ignored: ${formatErrorMessage(error)}`);
+			});
+		}
+		session.state = "ended";
+		session.updatedAt = nowIso();
+		const stop = this.#sessionStops.get(session.id);
+		this.#sessionStops.delete(session.id);
+		this.#sessionSpeakers.delete(session.id);
+		this.#sessionHealth.delete(session.id);
+		let browserLeft;
+		try {
+			await stop?.();
+		} finally {
 			try {
-				await stop();
+				if (!opts?.keepBrowserTab) browserLeft = await this.#releaseBrowserTab(session);
 			} finally {
-				session.state = "ended";
-				session.updatedAt = nowIso();
+				this.#retireTranscript(session.id);
+				this.#transcriptFinalizing.delete(session.id);
 			}
 		}
-		session.state = "ended";
-		session.updatedAt = nowIso();
 		return {
 			found: true,
-			session
+			session,
+			...browserLeft === void 0 ? {} : { browserLeft }
 		};
 	}
+	async #captureTranscriptSnapshot(session, options = {}) {
+		const capture = (this.#transcriptCaptures.get(session.id) ?? Promise.resolve()).catch(() => {}).then(async () => {
+			if (!isBrowserTransport(session.transport) || session.mode !== "transcribe") return;
+			const tab = session.chrome?.browserTab;
+			if (!tab) return;
+			const snapshot = session.transport === "chrome-node" ? await readChromeMeetTranscriptOnNode({
+				runtime: this.params.runtime,
+				nodeId: session.chrome?.nodeId,
+				config: this.params.config,
+				...options.finalize === void 0 ? {} : { finalize: options.finalize },
+				meetingUrl: session.url,
+				meetingSessionId: session.id,
+				tab
+			}) : await readChromeMeetTranscript({
+				runtime: this.params.runtime,
+				config: this.params.config,
+				...options.finalize === void 0 ? {} : { finalize: options.finalize },
+				meetingUrl: session.url,
+				meetingSessionId: session.id,
+				tab
+			});
+			this.#mergeTranscriptSnapshot(session.id, snapshot);
+		});
+		this.#transcriptCaptures.set(session.id, capture);
+		try {
+			await capture;
+		} finally {
+			if (this.#transcriptCaptures.get(session.id) === capture) this.#transcriptCaptures.delete(session.id);
+		}
+	}
+	#mergeTranscriptSnapshot(sessionId, snapshot) {
+		const pageNextIndex = snapshot.droppedLines + snapshot.lines.length;
+		const retained = this.#transcripts.get(sessionId);
+		if (!retained) {
+			this.#transcripts.set(sessionId, {
+				droppedLines: snapshot.droppedLines,
+				lines: snapshot.lines,
+				pageEpoch: snapshot.epoch,
+				pageNextIndex
+			});
+			return;
+		}
+		if (retained.pageEpoch !== snapshot.epoch) {
+			retained.droppedLines += snapshot.droppedLines;
+			retained.lines.push(...snapshot.lines);
+			retained.pageEpoch = snapshot.epoch;
+			retained.pageNextIndex = pageNextIndex;
+		} else if (pageNextIndex > retained.pageNextIndex) {
+			const appendFrom = Math.max(retained.pageNextIndex, snapshot.droppedLines);
+			retained.droppedLines += Math.max(0, snapshot.droppedLines - retained.pageNextIndex);
+			retained.lines.push(...snapshot.lines.slice(appendFrom - snapshot.droppedLines));
+			retained.pageNextIndex = pageNextIndex;
+		}
+		const excess = retained.lines.length - GOOGLE_MEET_TRANSCRIPT_MAX_LINES;
+		if (excess > 0) {
+			retained.lines.splice(0, excess);
+			retained.droppedLines += excess;
+		}
+	}
+	#retireTranscript(sessionId) {
+		const snapshot = this.#transcripts.get(sessionId);
+		if (snapshot) {
+			this.#transcripts.delete(sessionId);
+			this.#transcripts.set(sessionId, snapshot);
+			this.#retiredTranscripts.delete(sessionId);
+			this.#retiredTranscripts.add(sessionId);
+		}
+		const retainedIds = [...this.#retiredTranscripts].filter((id) => this.#transcripts.has(id)).toSorted((a, b) => (this.#sessions.get(a)?.updatedAt ?? "").localeCompare(this.#sessions.get(b)?.updatedAt ?? ""));
+		for (const id of retainedIds.slice(0, -4)) {
+			this.#transcripts.delete(id);
+			this.#retiredTranscripts.delete(id);
+			const session = this.#sessions.get(id);
+			if (session) session.transcriptEvicted = true;
+		}
+	}
+	#inheritBrowserTabOwnership(params) {
+		if (!params.tab) return;
+		const tab = params.tab;
+		const createdTabKey = params.transport === "chrome-node" && params.nodeId ? `${params.nodeId}:${tab.targetId}` : void 0;
+		const createdMeetingUrl = createdTabKey ? this.#createdBrowserTabs.get(createdTabKey) : void 0;
+		const inheritedFromCreate = isSameMeetUrlForReuse(createdMeetingUrl, params.meetingUrl);
+		if (createdMeetingUrl && createdTabKey) this.#createdBrowserTabs.delete(createdTabKey);
+		const inheritedFromSession = [...this.#sessions.values()].some((session) => {
+			const trackedTab = session.chrome?.browserTab;
+			if (!trackedTab) return false;
+			return session.transport === params.transport && isSameMeetUrlForReuse(session.url, params.meetingUrl) && session.chrome?.nodeId === params.nodeId && trackedTab.targetId === tab.targetId && trackedTab.openedByPlugin;
+		});
+		return inheritedFromCreate || inheritedFromSession ? {
+			...tab,
+			openedByPlugin: true
+		} : tab;
+	}
+	async #settleRetainedBrowserTabs(retained, adopted) {
+		let settled = true;
+		for (const { session, tab } of retained.splice(0)) {
+			if (adopted?.transport === session.transport && adopted.nodeId === session.chrome?.nodeId && adopted.tab.targetId === tab.targetId) {
+				if (session.chrome) session.chrome.browserTab = void 0;
+				continue;
+			}
+			if (await this.#releaseBrowserTab(session) === false) settled = false;
+		}
+		return settled;
+	}
+	async #releaseBrowserTab(session) {
+		let browserLeft;
+		try {
+			browserLeft = await this.#leaveBrowserMeetTab(session);
+		} catch (error) {
+			noteSession(session, `Browser control could not leave the Meet tab: ${formatErrorMessage(error)}`);
+			browserLeft = false;
+		}
+		session.browserLeft = browserLeft;
+		if (session.chrome && browserLeft !== false) session.chrome.browserTab = void 0;
+		return browserLeft;
+	}
+	async #leaveBrowserMeetTab(session) {
+		if (!isBrowserTransport(session.transport)) return;
+		const tab = session.chrome?.browserTab;
+		if (!tab) {
+			noteSession(session, "No tracked Meet browser tab for this session; close the Meet tab manually if it is still in the call.");
+			return false;
+		}
+		if (this.list().some((other) => other.id !== session.id && other.state === "active" && isBrowserTransport(other.transport) && other.chrome?.browserTab?.targetId === tab.targetId && other.chrome?.nodeId === session.chrome?.nodeId)) {
+			noteSession(session, "Kept the shared Meet tab open because another active session uses it.");
+			return;
+		}
+		const result = session.transport === "chrome-node" ? await leaveChromeMeetOnNode({
+			runtime: this.params.runtime,
+			nodeId: session.chrome?.nodeId,
+			config: this.params.config,
+			meetingUrl: session.url,
+			tab
+		}) : await leaveChromeMeet({
+			runtime: this.params.runtime,
+			config: this.params.config,
+			meetingUrl: session.url,
+			tab
+		});
+		noteSession(session, result.note);
+		return result.left;
+	}
 	async speak(sessionId, instructions) {
 		const session = this.#sessions.get(sessionId);
 		if (!session) return {
@@ -3519,9 +4484,16 @@ var GoogleMeetRuntime = class {
 		const mode = requestedMode && isGoogleMeetTalkBackMode$1(requestedMode) ? requestedMode : isGoogleMeetTalkBackMode$1(this.params.config.defaultMode) ? this.params.config.defaultMode : "agent";
 		const url = normalizeMeetUrl(request.url);
 		const transport = resolveTransport(request.transport, this.params.config);
+		const agentId = resolveSessionAgentId(request, this.params.config);
 		const beforeSessions = this.list();
 		const before = new Set(beforeSessions.map((session) => session.id));
-		const startOutputBytes = beforeSessions.find((session) => session.state === "active" && isSameMeetUrlForReuse(session.url, url) && session.transport === transport && isGoogleMeetTalkBackMode$1(session.mode))?.chrome?.health?.lastOutputBytes ?? 0;
+		const existingSession = beforeSessions.find((session) => isReusableMeetSession(session, {
+			url,
+			transport,
+			mode,
+			agentId
+		}));
+		const existingOutputBytes = existingSession?.chrome?.health?.lastOutputBytes ?? 0;
 		const result = await this.join({
 			...request,
 			transport,
@@ -3529,6 +4501,7 @@ var GoogleMeetRuntime = class {
 			mode,
 			message: request.message ?? "Say exactly: Google Meet speech test complete."
 		});
+		const startOutputBytes = existingSession?.id === result.session.id ? existingOutputBytes : 0;
 		let health = result.session.chrome?.health;
 		const shouldWaitForOutput = result.spoken === true && health?.manualActionRequired !== true && this.#sessionHealth.has(result.session.id);
 		if (shouldWaitForOutput && !hasRealtimeAudioOutputAdvanced(health, startOutputBytes)) {
@@ -3564,9 +4537,16 @@ var GoogleMeetRuntime = class {
 		const url = normalizeMeetUrl(request.url);
 		const transport = resolveTransport(request.transport, this.params.config);
 		if (transport === "twilio") throw new Error("test_listen supports chrome or chrome-node transports");
+		const agentId = resolveSessionAgentId(request, this.params.config);
 		const beforeSessions = this.list();
 		const before = new Set(beforeSessions.map((session) => session.id));
-		const start = transcriptCheckpoint(beforeSessions.find((session) => session.state === "active" && isSameMeetUrlForReuse(session.url, url) && session.transport === transport && session.mode === "transcribe")?.chrome?.health);
+		const existingSession = beforeSessions.find((session) => isReusableMeetSession(session, {
+			url,
+			transport,
+			mode: "transcribe",
+			agentId
+		}));
+		const existingStart = transcriptCheckpoint(existingSession?.chrome?.health);
 		const result = await this.join({
 			...request,
 			transport,
@@ -3574,6 +4554,7 @@ var GoogleMeetRuntime = class {
 			mode: "transcribe",
 			message: void 0
 		});
+		const start = existingSession?.id === result.session.id ? existingStart : transcriptCheckpoint(void 0);
 		let health = result.session.chrome?.health;
 		const timeoutMs = resolveProbeTimeoutMs(request.timeoutMs, this.params.config.chrome.joinTimeoutMs);
 		const shouldWait = health?.manualActionRequired !== true && isManagedChromeBrowserSession(result.session);
@@ -3667,6 +4648,7 @@ var GoogleMeetRuntime = class {
 				readOnly: options.readOnly,
 				url: session.url
 			}) : await recoverCurrentMeetTab({
+				runtime: this.params.runtime,
 				config: this.params.config,
 				mode: session.mode,
 				readOnly: options.readOnly,
@@ -3700,12 +4682,13 @@ var GoogleMeetRuntime = class {
 		if (!isGoogleMeetTalkBackMode$1(session.mode) || session.transport !== "chrome" || session.state !== "active" || !session.chrome || session.chrome.audioBridge) return;
 		const health = session.chrome.health;
 		if (health?.inCall !== true || health.micMuted === true || health.manualActionRequired === true) return;
+		const sessionConfig = withSessionAgentConfig(this.params.config, session.agentId);
 		const result = await launchChromeMeet({
 			runtime: this.params.runtime,
 			config: {
-				...this.params.config,
+				...sessionConfig,
 				chrome: {
-					...this.params.config.chrome,
+					...sessionConfig.chrome,
 					launch: false
 				}
 			},
@@ -3744,154 +4727,9 @@ var GoogleMeetRuntime = class {
 	}
 };
 //#endregion
-//#region extensions/google-meet/src/node-invoke-policy.ts
-const GOOGLE_MEET_CHROME_NODE_COMMAND = "googlemeet.chrome";
-const START_MODES = /* @__PURE__ */ new Set([
-	"agent",
-	"bidi",
-	"realtime",
-	"transcribe"
-]);
-function asRecord$1(value) {
-	return value && typeof value === "object" && !Array.isArray(value) ? value : {};
-}
-function readString(value) {
-	return typeof value === "string" && value.length > 0 ? value : void 0;
-}
-function readPositiveNumber(value) {
-	return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : void 0;
-}
-function copyCommand(command) {
-	return command && command.length > 0 ? [...command] : void 0;
-}
-function denied(message, code = "GOOGLE_MEET_NODE_POLICY_DENIED") {
-	return {
-		ok: false,
-		code,
-		message
-	};
-}
-function approved(params) {
-	return {
-		approved: true,
-		params
-	};
-}
-function buildStartParams(params, config) {
-	let url;
-	try {
-		url = normalizeMeetUrl(params.url);
-	} catch (error) {
-		return {
-			approved: false,
-			result: denied(error instanceof Error ? error.message : "googlemeet.chrome start requires url")
-		};
-	}
-	const mode = readString(params.mode);
-	if (mode && !START_MODES.has(mode)) return {
-		approved: false,
-		result: denied(`googlemeet.chrome start mode is unsupported: ${mode}`)
-	};
-	const startParams = {
-		action: "start",
-		url,
-		launch: params.launch === false ? false : config.chrome.launch,
-		browserProfile: config.chrome.browserProfile,
-		joinTimeoutMs: config.chrome.joinTimeoutMs
-	};
-	if (mode) startParams.mode = mode;
-	const audioInputCommand = copyCommand(config.chrome.audioInputCommand);
-	if (audioInputCommand) startParams.audioInputCommand = audioInputCommand;
-	const audioOutputCommand = copyCommand(config.chrome.audioOutputCommand);
-	if (audioOutputCommand) startParams.audioOutputCommand = audioOutputCommand;
-	const audioBridgeCommand = copyCommand(config.chrome.audioBridgeCommand);
-	if (audioBridgeCommand) startParams.audioBridgeCommand = audioBridgeCommand;
-	const audioBridgeHealthCommand = copyCommand(config.chrome.audioBridgeHealthCommand);
-	if (audioBridgeHealthCommand) startParams.audioBridgeHealthCommand = audioBridgeHealthCommand;
-	return approved(startParams);
-}
-function buildForwardParams(params) {
-	const action = readString(params.action);
-	switch (action) {
-		case "setup": return { action };
-		case "status": {
-			const bridgeId = readString(params.bridgeId);
-			return bridgeId ? {
-				action,
-				bridgeId
-			} : { action };
-		}
-		case "list": {
-			const forwarded = { action };
-			const url = readString(params.url);
-			const mode = readString(params.mode);
-			if (url) forwarded.url = url;
-			if (mode) forwarded.mode = mode;
-			return forwarded;
-		}
-		case "stopByUrl": {
-			const forwarded = { action };
-			const url = readString(params.url);
-			const mode = readString(params.mode);
-			const exceptBridgeId = readString(params.exceptBridgeId);
-			if (url) forwarded.url = url;
-			if (mode) forwarded.mode = mode;
-			if (exceptBridgeId) forwarded.exceptBridgeId = exceptBridgeId;
-			return forwarded;
-		}
-		case "pullAudio": {
-			const forwarded = { action };
-			const bridgeId = readString(params.bridgeId);
-			const timeoutMs = readPositiveNumber(params.timeoutMs);
-			if (bridgeId) forwarded.bridgeId = bridgeId;
-			if (timeoutMs) forwarded.timeoutMs = timeoutMs;
-			return forwarded;
-		}
-		case "pushAudio": {
-			const forwarded = { action };
-			const bridgeId = readString(params.bridgeId);
-			const base64 = readString(params.base64);
-			if (bridgeId) forwarded.bridgeId = bridgeId;
-			if (base64) forwarded.base64 = base64;
-			return forwarded;
-		}
-		case "clearAudio":
-		case "stop": {
-			const bridgeId = readString(params.bridgeId);
-			return bridgeId ? {
-				action,
-				bridgeId
-			} : { action };
-		}
-		default: return null;
-	}
-}
-function createGoogleMeetChromeNodeInvokePolicy(config) {
-	return {
-		commands: [GOOGLE_MEET_CHROME_NODE_COMMAND],
-		dangerous: true,
-		async handle(ctx) {
-			if (ctx.command !== "googlemeet.chrome") return denied(`unsupported Google Meet node command: ${ctx.command}`);
-			const params = asRecord$1(ctx.params);
-			const action = readString(params.action);
-			let decision;
-			if (action === "start") decision = buildStartParams(params, config);
-			else {
-				const forwardParams = buildForwardParams(params);
-				decision = forwardParams ? approved(forwardParams) : {
-					approved: false,
-					result: denied("unsupported googlemeet.chrome action")
-				};
-			}
-			if (!decision.approved) return decision.result;
-			return await ctx.invokeNode({ params: decision.params });
-		}
-	};
-}
-//#endregion
 //#region extensions/google-meet/index.ts
-const loadGoogleMeetCreateModule = createLazyRuntimeModule(() => import("./create-CkkaRlbI.js"));
-const loadGoogleMeetCliModule = createLazyRuntimeModule(() => import("./cli-D364Yrym.js"));
+const loadGoogleMeetCreateModule = createLazyRuntimeModule(() => import("./create-CWcFI0ub.js"));
+const loadGoogleMeetCliModule = createLazyRuntimeModule(() => import("./cli-SodPSOFX.js"));
 const googleMeetConfigSchema = {
 	parse(value) {
 		return resolveGoogleMeetConfig(value);
@@ -4099,6 +4937,7 @@ const GoogleMeetToolSchema = Type.Object({
 			"join",
 			"create",
 			"status",
+			"transcript",
 			"setup_status",
 			"resolve_space",
 			"preflight",
@@ -4150,6 +4989,10 @@ const GoogleMeetToolSchema = Type.Object({
 	pin: Type.Optional(Type.String({ description: "Meet phone PIN for Twilio; # is appended if omitted" })),
 	dtmfSequence: Type.Optional(Type.String({ description: "Explicit DTMF sequence for Twilio" })),
 	sessionId: Type.Optional(Type.String({ description: "Meet session ID" })),
+	sinceIndex: Type.Optional(Type.Integer({
+		description: "For transcript, resume from the previous response's nextIndex.",
+		minimum: 0
+	})),
 	message: Type.Optional(Type.String({ description: "Realtime instructions to speak now" })),
 	timeoutMs: optionalPositiveIntegerSchema({ description: "Probe timeout in milliseconds" }),
 	meeting: Type.Optional(Type.String({ description: "Meet URL, meeting code, or spaces/{id}" })),
@@ -4236,11 +5079,17 @@ function readGatewayErrorDetails(err) {
 }
 async function callGoogleMeetGatewayFromTool(params) {
 	try {
-		if (params.runtime) return await params.runtime.gateway.request(googleMeetGatewayMethodForToolAction(params.action), params.raw, { timeoutMs: resolveGoogleMeetGatewayOperationTimeoutMs(params.config) });
+		if (params.runtime) return await params.runtime.gateway.request(googleMeetGatewayMethodForToolAction(params.action), params.raw, {
+			timeoutMs: resolveGoogleMeetGatewayOperationTimeoutMs(params.config),
+			scopes: ["operator.admin"]
+		});
 		return await googleMeetToolDeps.callGatewayFromCli(googleMeetGatewayMethodForToolAction(params.action), {
 			json: true,
 			timeout: String(resolveGoogleMeetGatewayOperationTimeoutMs(params.config))
-		}, params.raw, { progress: false });
+		}, params.raw, {
+			progress: false,
+			scopes: ["operator.admin"]
+		});
 	} catch (err) {
 		const details = readGatewayErrorDetails(err);
 		if (details && typeof details === "object") return details;
@@ -4263,7 +5112,7 @@ async function createAndJoinMeetFromParams(params) {
 	return (await loadGoogleMeetCreateModule()).createAndJoinMeetFromParams(params);
 }
 async function resolveGoogleMeetTokenFromParams(config, raw) {
-	const { resolveGoogleMeetAccessToken } = await import("./oauth-75iPDzIn.js");
+	const { resolveGoogleMeetAccessToken } = await import("./oauth-DOfMKlGp.js");
 	return resolveGoogleMeetAccessToken({
 		clientId: normalizeOptionalString(raw.clientId) ?? config.oauth.clientId,
 		clientSecret: normalizeOptionalString(raw.clientSecret) ?? config.oauth.clientSecret,
@@ -4462,6 +5311,23 @@ var google_meet_default = definePluginEntry({
 				sendError(respond, err);
 			}
 		});
+		api.registerGatewayMethod("googlemeet.transcript", async ({ params, respond }) => {
+			try {
+				const sessionId = normalizeOptionalString(params?.sessionId);
+				if (!sessionId) {
+					sendError(respond, /* @__PURE__ */ new Error("sessionId required"), ErrorCodes.INVALID_REQUEST);
+					return;
+				}
+				const sinceIndex = params?.sinceIndex;
+				if (sinceIndex !== void 0 && (typeof sinceIndex !== "number" || !Number.isSafeInteger(sinceIndex) || sinceIndex < 0)) {
+					sendError(respond, /* @__PURE__ */ new Error("sinceIndex must be a non-negative safe integer"), ErrorCodes.INVALID_REQUEST);
+					return;
+				}
+				respond(true, await (await ensureRuntime()).transcript(sessionId, sinceIndex === void 0 ? {} : { sinceIndex }));
+			} catch (err) {
+				sendError(respond, err);
+			}
+		});
 		api.registerGatewayMethod("googlemeet.recoverCurrentTab", async ({ params, respond }) => {
 			try {
 				respond(true, await (await ensureRuntime()).recoverCurrentTab({
@@ -4613,13 +5479,15 @@ var google_meet_default = definePluginEntry({
 				sendError(respond, err);
 			}
 		});
-		api.registerGatewayMethod("googlemeet.testListen", async ({ params, respond }) => {
+		api.registerGatewayMethod("googlemeet.testListen", async ({ params, client, respond }) => {
 			try {
+				const trustedParams = keepTrustedToolAgentId(asParamRecord(params), client);
 				respond(true, await (await ensureRuntime()).testListen({
-					url: resolveMeetingInput(config, params?.url),
-					transport: normalizeTransport(params?.transport),
-					mode: normalizeMode(params?.mode),
-					timeoutMs: readPositiveIntegerParam(asParamRecord(params), "timeoutMs")
+					url: resolveMeetingInput(config, trustedParams.url),
+					transport: normalizeTransport(trustedParams.transport),
+					mode: normalizeMode(trustedParams.mode),
+					agentId: normalizeOptionalString(trustedParams.agentId),
+					timeoutMs: readPositiveIntegerParam(trustedParams, "timeoutMs")
 				}));
 			} catch (err) {
 				sendError(respond, err);
@@ -4633,10 +5501,12 @@ var google_meet_default = definePluginEntry({
 			async execute(_toolCallId, params) {
 				const raw = asParamRecord(params);
 				const requesterSessionKey = normalizeOptionalString(toolContext.sessionKey);
-				const agentId = toolContext.agentId ? normalizeAgentId(toolContext.agentId) : void 0;
+				const contextAgentId = toolContext.agentId ?? parseAgentSessionKey(requesterSessionKey)?.agentId;
+				const agentId = contextAgentId ? normalizeAgentId(contextAgentId) : void 0;
 				try {
-					const useTrustedRuntime = agentId ? await api.runtime.gateway.isAvailable() : false;
-					if (agentId && agentId !== "main" && !useTrustedRuntime) throw new Error("Per-agent Google Meet routing requires a Gateway-hosted agent run.");
+					const needsTrustedAgentRouting = Boolean(agentId && agentId !== "main");
+					const useTrustedRuntime = needsTrustedAgentRouting ? await api.runtime.gateway.isAvailable() : false;
+					if (needsTrustedAgentRouting && !useTrustedRuntime) throw new Error("Per-agent Google Meet routing requires a Gateway-hosted agent run.");
 					const rawWithRequester = {
 						...raw,
 						...requesterSessionKey ? { requesterSessionKey } : {},
@@ -4668,13 +5538,19 @@ var google_meet_default = definePluginEntry({
 						case "test_listen": return jsonResult(await callGoogleMeetGatewayFromTool({
 							config,
 							action: "test_listen",
-							raw
+							raw: rawWithRequester,
+							runtime: useTrustedRuntime ? api.runtime : void 0
 						}));
 						case "status": return jsonResult(await callGoogleMeetGatewayFromTool({
 							config,
 							action: "status",
 							raw
 						}));
+						case "transcript": return jsonResult(await callGoogleMeetGatewayFromTool({
+							config,
+							action: "transcript",
+							raw
+						}));
 						case "recover_current_tab": return jsonResult(await callGoogleMeetGatewayFromTool({
 							config,
 							action: "recover_current_tab",