acpx 0.10.0 → 0.11.1

package/dist/{output-Di77Yugq.js → output-BEv_BB7T.js}

@@ -1,10 +1,11 @@
-import { $ as defaultSessionEventLog, A as findGitRepositoryRoot, Bt as QueueConnectionError, C as applyConversation, Ct as formatErrorMessage, E as AcpClient, F as listSessionsForAgent, G as recordPerfDuration, H as getPerfMetricsSnapshot, I as normalizeName, J as startPerfTimer, K as resetPerfMetrics, L as pruneSessions, M as findSessionByDirectoryWalk, Mt as OUTPUT_ERROR_CODES, N as isoNow, Nt as OUTPUT_ERROR_ORIGINS, Ot as toAcpErrorPayload, P as listSessions, R as resolveSessionRecord, S as sessionOptionsFromRecord, Tt as normalizeOutputError, U as incrementPerfCounter, V as formatPerfMetric, Vt as QueueProtocolError, W as measurePerf, Z as normalizeRuntimeSessionId, _ as recordPromptSubmission, _t as withTimeout, a as applyRequestedModelIfAdvertised, at as isAcpJsonRpcMessage, b as mergeSessionOptions, c as setDesiredConfigOption, d as syncAdvertisedModelState, et as sessionBaseDir, f as applyConfigOptionsToRecord, ft as promptToDisplayText, g as recordClientOperation, gt as withInterrupt, h as createSessionConversation, ht as TimeoutError, i as connectAndLoadSession, it as extractSessionUpdateNotification, j as findSession, k as absolutePath, l as setDesiredModeId, lt as isPromptInput, m as cloneSessionConversation, mt as InterruptedError, n as runPromptTurn, nt as sessionEventLockPath, o as assertRequestedModelSupported, ot as parseJsonRpcErrorMessage, p as cloneSessionAcpxState, pt as textPrompt, q as setPerfGauge, r as withConnectedSession, rt as sessionEventSegmentPath, s as setCurrentModelId, st as parsePromptStopReason, t as LiveSessionCheckpoint, tt as sessionEventActivePath, u as setDesiredModelId, v as recordSessionUpdate, w as applyLifecycleSnapshotToRecord, wt as isRetryablePromptError, x as persistSessionOptions, y as trimConversationForRuntime, z as writeSessionRecord } from "./live-checkpoint-CuFft_Nd.js";
-import fs, { realpathSync } from "node:fs";
+import { $ as getPerfMetricsSnapshot, B as absolutePath, C as mergeSessionOptions, Ct as promptToDisplayText, D as applyLifecycleSnapshotToRecord, Dt as withInterrupt, E as applyConversation, Et as TimeoutError, F as modelStateFromConfigOptions, Ft as isRetryablePromptError, G as listSessions, H as findSession, I as splitCommandLine, It as normalizeOutputError, J as pruneSessions, K as listSessionsForAgent, N as assertRequestedModelSupported, Ot as withTimeout, Pt as formatErrorMessage, Q as formatPerfMetric, Qt as QueueProtocolError, S as advertisedModelState, T as sessionOptionsFromRecord, Tt as InterruptedError, U as findSessionByDirectoryWalk, Ut as OUTPUT_ERROR_CODES, V as findGitRepositoryRoot, W as isoNow, Wt as OUTPUT_ERROR_ORIGINS, X as writeSessionRecord, Y as resolveSessionRecord, Zt as QueueConnectionError, _ as createSessionConversation, _t as parseJsonRpcErrorMessage, a as applyRequestedModelIfAdvertised, at as startPerfTimer, b as recordSessionUpdate, bt as isPromptInput, c as setCurrentModelId, ct as normalizeRuntimeSessionId, d as setDesiredModelId, dt as sessionBaseDir, et as incrementPerfCounter, f as syncAdvertisedModelState, ft as sessionEventActivePath, g as cloneSessionConversation, gt as isAcpJsonRpcMessage, h as cloneSessionAcpxState, ht as extractSessionUpdateNotification, i as connectAndLoadSession, it as setPerfGauge, k as AcpClient, l as setDesiredConfigOption, m as applyConfigOptionsToState, mt as sessionEventSegmentPath, n as runPromptTurn, nt as recordPerfDuration, o as currentModelIdFromSetModelResponse, p as applyConfigOptionsToRecord, pt as sessionEventLockPath, q as normalizeName, r as withConnectedSession, rt as resetPerfMetrics, s as clearDesiredConfigOption, t as LiveSessionCheckpoint, tt as measurePerf, u as setDesiredModeId, ut as defaultSessionEventLog, v as recordClientOperation, vt as parsePromptStopReason, w as persistSessionOptions, wt as textPrompt, x as trimConversationForRuntime, y as recordPromptSubmission, zt as toAcpErrorPayload } from "./live-checkpoint-BWkYxMeS.js";
+import fs, { mkdtempSync, realpathSync, writeFileSync } from "node:fs";
 import path from "node:path";
 import fs$1 from "node:fs/promises";
 import os from "node:os";
 import { createHash, randomInt, randomUUID } from "node:crypto";
-import { spawn } from "node:child_process";
+import { execFile, spawn } from "node:child_process";
+import { promisify } from "node:util";
 import net from "node:net";
 //#region \0rolldown/runtime.js
 var __defProp = Object.defineProperty;
@@ -75,7 +76,9 @@ function parseQueueOwnerRecord(raw) {
 		createdAt: record.createdAt,
 		heartbeatAt: record.heartbeatAt,
 		ownerGeneration: record.ownerGeneration,
-		queueDepth: record.queueDepth
+		queueDepth: record.queueDepth,
+		...typeof record.mcpConfigPath === "string" ? { mcpConfigPath: record.mcpConfigPath } : {},
+		...typeof record.mcpConfigFingerprint === "string" ? { mcpConfigFingerprint: record.mcpConfigFingerprint } : {}
 	};
 }
 function hasValidQueueOwnerRecordFields(record) {
@@ -137,6 +140,10 @@ async function cleanupStaleQueueOwner(sessionId, owner) {
 		if (error.code !== "ENOENT") throw error;
 	});
 }
+async function retireStaleQueueOwner(sessionId, owner) {
+	if (owner && isProcessAlive(owner.pid)) await terminateProcess(owner.pid);
+	await cleanupStaleQueueOwner(sessionId, owner);
+}
 async function readQueueOwnerRecord(sessionId) {
 	const lockPath = queueLockFilePath(sessionId);
 	try {
@@ -166,8 +173,7 @@ async function ensureOwnerIsUsable(sessionId, owner) {
 	const alive = isProcessAlive(owner.pid);
 	const stale = isQueueOwnerHeartbeatStale(owner);
 	if (alive && !stale) return true;
-	if (alive) await terminateProcess(owner.pid).catch(() => {});
-	await cleanupStaleQueueOwner(sessionId, owner);
+	await retireStaleQueueOwner(sessionId, owner);
 	return false;
 }
 async function readQueueOwnerStatus(sessionId) {
@@ -185,11 +191,13 @@ async function readQueueOwnerStatus(sessionId) {
 		stale: isQueueOwnerHeartbeatStale(owner)
 	};
 }
-async function tryAcquireQueueOwnerLease(sessionId, nowIsoFactory = nowIso) {
+async function tryAcquireQueueOwnerLease(sessionId, mcpConfigOrNowIsoFactory, nowIsoFactory = nowIso) {
+	const { mcpConfigPath, clock } = resolveLeaseArguments(mcpConfigOrNowIsoFactory, nowIsoFactory);
+	const mcpConfigMetadata = createMcpConfigMetadata(mcpConfigPath, readMcpConfigFingerprint(mcpConfigOrNowIsoFactory));
 	await ensureQueueDir();
 	const lockPath = queueLockFilePath(sessionId);
 	const socketPath = queueSocketPath(sessionId);
-	const createdAt = nowIsoFactory();
+	const createdAt = clock();
 	const ownerGeneration = createOwnerGeneration();
 	const payload = JSON.stringify({
 		pid: process.pid,
@@ -198,7 +206,8 @@ async function tryAcquireQueueOwnerLease(sessionId, nowIsoFactory = nowIso) {
 		createdAt,
 		heartbeatAt: createdAt,
 		ownerGeneration,
-		queueDepth: 0
+		queueDepth: 0,
+		...mcpConfigMetadata
 	}, null, 2);
 	try {
 		await fs$1.writeFile(lockPath, `${payload}\n`, {
@@ -211,21 +220,48 @@ async function tryAcquireQueueOwnerLease(sessionId, nowIsoFactory = nowIso) {
 			lockPath,
 			socketPath,
 			createdAt,
-			ownerGeneration
+			ownerGeneration,
+			...mcpConfigMetadata
 		};
 	} catch (error) {
-		if (error.code !== "EEXIST") throw error;
-		const owner = await readQueueOwnerRecord(sessionId);
-		if (!owner) {
-			await cleanupStaleQueueOwner(sessionId, owner);
-			return;
-		}
-		if (!isProcessAlive(owner.pid) || isQueueOwnerHeartbeatStale(owner)) {
-			if (isProcessAlive(owner.pid)) await terminateProcess(owner.pid).catch(() => {});
-			await cleanupStaleQueueOwner(sessionId, owner);
-		}
+		return await handleLeaseCollision(sessionId, error);
+	}
+}
+function readMcpConfigFingerprint(mcpConfigOrNowIsoFactory) {
+	return typeof mcpConfigOrNowIsoFactory === "object" ? mcpConfigOrNowIsoFactory?.fingerprint : void 0;
+}
+function createMcpConfigMetadata(mcpConfigPath, mcpConfigFingerprint) {
+	return {
+		...mcpConfigPath ? { mcpConfigPath } : {},
+		...mcpConfigFingerprint ? { mcpConfigFingerprint } : {}
+	};
+}
+async function handleLeaseCollision(sessionId, error) {
+	if (error.code !== "EEXIST") throw error;
+	const owner = await readQueueOwnerRecord(sessionId);
+	if (!owner) {
+		await cleanupStaleQueueOwner(sessionId, owner);
 		return;
 	}
+	if (!isProcessAlive(owner.pid) || isQueueOwnerHeartbeatStale(owner)) await retireStaleQueueOwner(sessionId, owner);
+}
+function resolveLeaseArguments(mcpConfigOrNowIsoFactory, nowIsoFactory) {
+	if (typeof mcpConfigOrNowIsoFactory === "string") return {
+		mcpConfigPath: mcpConfigOrNowIsoFactory,
+		clock: nowIsoFactory
+	};
+	if (typeof mcpConfigOrNowIsoFactory === "function") return {
+		mcpConfigPath: void 0,
+		clock: mcpConfigOrNowIsoFactory
+	};
+	if (mcpConfigOrNowIsoFactory) return {
+		mcpConfigPath: mcpConfigOrNowIsoFactory.path,
+		clock: nowIsoFactory
+	};
+	return {
+		mcpConfigPath: void 0,
+		clock: nowIsoFactory
+	};
 }
 async function refreshQueueOwnerLease(lease, options, nowIsoFactory = nowIso) {
 	const payload = JSON.stringify({
@@ -235,7 +271,9 @@ async function refreshQueueOwnerLease(lease, options, nowIsoFactory = nowIso) {
 		createdAt: lease.createdAt,
 		heartbeatAt: nowIsoFactory(),
 		ownerGeneration: lease.ownerGeneration,
-		queueDepth: Math.max(0, Math.round(options.queueDepth))
+		queueDepth: Math.max(0, Math.round(options.queueDepth)),
+		...lease.mcpConfigPath ? { mcpConfigPath: lease.mcpConfigPath } : {},
+		...lease.mcpConfigFingerprint ? { mcpConfigFingerprint: lease.mcpConfigFingerprint } : {}
 	}, null, 2);
 	await fs$1.writeFile(lease.lockPath, `${payload}\n`, { encoding: "utf8" });
 }
@@ -409,6 +447,7 @@ function parseSessionOptions(value) {
 	if (!assignSessionAllowedTools(sessionOptions, record.allowedTools)) return null;
 	if (!assignSessionMaxTurns(sessionOptions, record.maxTurns)) return null;
 	if (!assignSessionSystemPrompt(sessionOptions, record.systemPrompt)) return null;
+	if (!assignSessionEnv(sessionOptions, record.env)) return null;
 	return sessionOptions;
 }
 function assignSessionModel(options, value) {
@@ -440,6 +479,15 @@ function assignSessionSystemPrompt(options, value) {
 	options.systemPrompt = { append: systemPrompt.append };
 	return true;
 }
+function assignSessionEnv(options, value) {
+	if (value == null) return true;
+	const env = asRecord$2(value);
+	if (!env) return false;
+	const entries = Object.entries(env);
+	if (entries.some(([, entryValue]) => typeof entryValue !== "string")) return false;
+	options.env = Object.fromEntries(entries);
+	return true;
+}
 function parseOwnerGeneration(value) {
 	if (value == null) return;
 	if (typeof value !== "number" || !Number.isInteger(value) || value <= 0) return null;
@@ -617,7 +665,7 @@ const QUEUE_OWNER_MESSAGE_PARSERS = {
 	cancel_result: (message, context) => parseBooleanResultOwnerMessage(message, context, "cancel_result", "cancelled"),
 	close_session_result: (message, context) => parseBooleanResultOwnerMessage(message, context, "close_session_result", "closed"),
 	set_mode_result: (message, context) => parseStringResultOwnerMessage(message, context, "set_mode_result", "modeId"),
-	set_model_result: (message, context) => parseStringResultOwnerMessage(message, context, "set_model_result", "modelId"),
+	set_model_result: parseSetModelOwnerMessage,
 	set_config_option_result: parseSetConfigOptionOwnerMessage,
 	error: parseErrorOwnerMessage
 };
@@ -665,6 +713,17 @@ function parseStringResultOwnerMessage(message, context, type, field) {
 		[field]: message[field]
 	};
 }
+function parseSetModelOwnerMessage(message, context) {
+	if (typeof message.modelId !== "string") return null;
+	const response = asRecord$2(message.response);
+	if (message.response !== void 0 && (!response || !Array.isArray(response.configOptions))) return null;
+	return {
+		type: "set_model_result",
+		...context,
+		modelId: message.modelId,
+		...response ? { response } : {}
+	};
+}
 function parseSetConfigOptionOwnerMessage(message, context) {
 	const response = asRecord$2(message.response);
 	if (!response || !Array.isArray(response.configOptions)) return null;
@@ -807,25 +866,26 @@ var SessionQueueOwner = class SessionQueueOwner {
 	}
 	enqueue(task) {
 		if (this.closed) {
-			if (task.waitForCompletion) task.send(makeQueueOwnerError(task.requestId, "Queue owner is shutting down", "QUEUE_OWNER_SHUTTING_DOWN", { retryable: true }));
+			task.send(makeQueueOwnerError(task.requestId, "Queue owner is shutting down", "QUEUE_OWNER_SHUTTING_DOWN", { retryable: true }));
 			task.close();
-			return;
+			return false;
 		}
 		const waiter = this.waiters.shift();
 		if (waiter) {
 			waiter(task);
-			return;
+			return true;
 		}
 		if (this.pending.length >= this.maxQueueDepth) {
-			if (task.waitForCompletion) task.send({
+			task.send({
 				...makeQueueOwnerError(task.requestId, `Queue owner is overloaded (${this.pending.length}/${this.maxQueueDepth} queued)`, "QUEUE_OWNER_OVERLOADED", { retryable: true }),
 				ownerGeneration: this.ownerGeneration
 			});
 			task.close();
-			return;
+			return false;
 		}
 		this.pending.push(task);
 		this.emitQueueDepth();
+		return true;
 	}
 	handleControlRequest(options) {
 		writeQueueMessage(options.socket, {
@@ -919,11 +979,12 @@ var SessionQueueOwner = class SessionQueueOwner {
 				socket,
 				requestId: request.requestId,
 				run: async () => {
-					await this.controlHandlers.setSessionModel(request.modelId, request.timeoutMs);
+					const response = await this.controlHandlers.setSessionModel(request.modelId, request.timeoutMs);
 					return {
 						type: "set_model_result",
 						requestId: request.requestId,
-						modelId: request.modelId
+						modelId: request.modelId,
+						response
 					};
 				}
 			});
@@ -968,13 +1029,13 @@ var SessionQueueOwner = class SessionQueueOwner {
 				if (!socket.destroyed) socket.end();
 			}
 		};
+		if (!this.enqueue(task)) return;
 		writeQueueMessage(socket, {
 			type: "accepted",
 			requestId: request.requestId,
 			ownerGeneration: this.ownerGeneration
 		});
 		if (!request.waitForCompletion) task.close();
-		this.enqueue(task);
 	}
 	handleConnection(socket) {
 		socket.setEncoding("utf8");
@@ -1013,7 +1074,7 @@ var SessionQueueOwner = class SessionQueueOwner {
 //#endregion
 //#region src/cli/queue/ipc.ts
 const MAX_MESSAGE_BUFFER_SIZE = 10 * 1024 * 1024;
-const STALE_OWNER_PROTOCOL_DETAIL_CODES = new Set(["QUEUE_PROTOCOL_MALFORMED_MESSAGE", "QUEUE_PROTOCOL_UNEXPECTED_RESPONSE"]);
+const STALE_OWNER_PROTOCOL_DETAIL_CODES = /* @__PURE__ */ new Set(["QUEUE_PROTOCOL_MALFORMED_MESSAGE", "QUEUE_PROTOCOL_UNEXPECTED_RESPONSE"]);
 async function maybeRecoverStaleOwnerAfterProtocolMismatch(params) {
 	if (!(params.error instanceof QueueProtocolError)) return false;
 	const detailCode = params.error.detailCode;
@@ -1344,7 +1405,7 @@ async function submitSetModelToQueueOwner(owner, modelId, timeoutMs) {
 		origin: "queue",
 		retryable: true
 	});
-	return true;
+	return response;
 }
 async function submitSetConfigOptionToQueueOwner(owner, configId, value, timeoutMs) {
 	const request = {
@@ -1380,9 +1441,22 @@ async function submitCloseSessionToQueueOwner(owner, timeoutMs) {
 	});
 	return response.closed;
 }
+function queueOwnerMcpConfigMatches(owner, options) {
+	return owner.mcpConfigPath === options.mcpConfigPath && owner.mcpConfigFingerprint === options.mcpConfigFingerprint;
+}
+function assertQueueOwnerMcpConfigMatches(owner, options) {
+	if (queueOwnerMcpConfigMatches(owner, options)) return;
+	throw new QueueConnectionError("Session queue owner uses a different MCP config; close the session before retrying", {
+		detailCode: "QUEUE_MCP_CONFIG_CONFLICT",
+		origin: "queue",
+		retryable: false
+	});
+}
 async function trySubmitToRunningOwner(options) {
 	const owner = await readQueueOwnerRecord(options.sessionId);
 	if (!owner) return;
+	if (!await ensureOwnerIsUsable(options.sessionId, owner)) return;
+	assertQueueOwnerMcpConfigMatches(owner, options);
 	let submitted;
 	try {
 		submitted = await submitToQueueOwner(owner, options);
@@ -1453,9 +1527,10 @@ async function trySetModeOnRunningOwner(sessionId, modeId, timeoutMs, verbose) {
 async function trySetModelOnRunningOwner(sessionId, modelId, timeoutMs, verbose) {
 	const owner = await readQueueOwnerRecord(sessionId);
 	if (!owner) return;
-	if (await submitSetModelToQueueOwner(owner, modelId, timeoutMs)) {
-		if (verbose) process.stderr.write(`[acpx] requested session/set_model on owner pid ${owner.pid} for session ${sessionId}\n`);
-		return true;
+	const submitted = await submitSetModelToQueueOwner(owner, modelId, timeoutMs);
+	if (submitted) {
+		if (verbose) process.stderr.write(`[acpx] requested a model config update on owner pid ${owner.pid} for session ${sessionId}\n`);
+		return submitted;
 	}
 	if (!(await probeQueueOwnerHealth(sessionId)).hasLease) return;
 	throw new QueueConnectionError("Session queue owner is running but not accepting set_model requests", {
@@ -1514,16 +1589,28 @@ async function runSessionSetModeDirect(options) {
 	})));
 }
 async function runSessionSetModelDirect(options) {
-	return toSessionMutationResult(await withConnectedSession(buildDirectConnectedSessionOptions(options, async ({ client, sessionId, record }) => {
-		await withTimeout(client.setSessionModel(sessionId, options.modelId), options.timeoutMs);
-		setDesiredModelId(record, options.modelId);
-		setCurrentModelId(record, options.modelId);
-	})));
+	const result = await withConnectedSession(buildDirectConnectedSessionOptions(options, async ({ client, sessionId, record }) => {
+		const models = advertisedModelState(record.acpx);
+		const response = await withTimeout(client.setSessionModel(sessionId, options.modelId, models), options.timeoutMs);
+		applyConfigOptionsToRecord(record, response);
+		setDesiredModelId(record, options.modelId, models?.configId);
+		setCurrentModelId(record, currentModelIdFromSetModelResponse(response, options.modelId));
+		return response;
+	}));
+	return {
+		...toSessionMutationResult(result),
+		response: result.value
+	};
 }
 async function runSessionSetConfigOptionDirect(options) {
 	const result = await withConnectedSession(buildDirectConnectedSessionOptions(options, async ({ client, sessionId, record }) => {
+		const modelConfigId = advertisedModelState(record.acpx)?.configId;
 		const response = await withTimeout(client.setSessionConfigOption(sessionId, options.configId, options.value), options.timeoutMs);
-		if (options.configId === "mode") setDesiredModeId(record, options.value);
+		applyConfigOptionsToRecord(record, response);
+		if (options.configId === modelConfigId) {
+			setDesiredModelId(record, options.value, options.configId);
+			setCurrentModelId(record, currentModelIdFromSetModelResponse(response, options.value));
+		} else if (options.configId === "mode") setDesiredModeId(record, options.value);
 		else setDesiredConfigOption(record, options.configId, options.value);
 		return response;
 	}));
@@ -1536,6 +1623,7 @@ async function runSessionSetConfigOptionDirect(options) {
 }
 //#endregion
 //#region src/cli/session/session-control.ts
+const execFileAsync = promisify(execFile);
 async function cancelSessionPrompt(options) {
 	const cancelled = await tryCancelOnRunningOwner(options);
 	return {
@@ -1566,13 +1654,16 @@ async function setSessionMode(options) {
 	});
 }
 async function setSessionModel(options) {
-	if (await trySetModelOnRunningOwner(options.sessionId, options.modelId, options.timeoutMs, options.verbose)) {
+	const submittedToOwner = await trySetModelOnRunningOwner(options.sessionId, options.modelId, options.timeoutMs, options.verbose);
+	if (submittedToOwner) {
 		const record = await resolveSessionRecord(options.sessionId);
-		setDesiredModelId(record, options.modelId);
-		setCurrentModelId(record, options.modelId);
+		applyConfigOptionsToRecord(record, submittedToOwner.response);
+		setDesiredModelId(record, options.modelId, advertisedModelState(record.acpx)?.configId);
+		setCurrentModelId(record, currentModelIdFromSetModelResponse(submittedToOwner.response, options.modelId));
 		await writeSessionRecord(record);
 		return {
 			record,
+			response: submittedToOwner.response,
 			resumed: false
 		};
 	}
@@ -1592,7 +1683,12 @@ async function setSessionConfigOption(options) {
 	const ownerResponse = await trySetConfigOptionOnRunningOwner(options.sessionId, options.configId, options.value, options.timeoutMs, options.verbose);
 	if (ownerResponse) {
 		const record = await resolveSessionRecord(options.sessionId);
-		if (options.configId === "mode") setDesiredModeId(record, options.value);
+		const modelConfigId = advertisedModelState(record.acpx)?.configId;
+		applyConfigOptionsToRecord(record, ownerResponse);
+		if (options.configId === modelConfigId) {
+			setDesiredModelId(record, options.value, options.configId);
+			setCurrentModelId(record, currentModelIdFromSetModelResponse(ownerResponse, options.value));
+		} else if (options.configId === "mode") setDesiredModeId(record, options.value);
 		else setDesiredConfigOption(record, options.configId, options.value);
 		await writeSessionRecord(record);
 		return {
@@ -1615,25 +1711,72 @@ async function setSessionConfigOption(options) {
 	});
 }
 function firstAgentCommandToken(command) {
-	const trimmed = command.trim();
-	if (!trimmed) return;
-	const token = trimmed.split(/\s+/, 1)[0];
-	return token.length > 0 ? token : void 0;
+	try {
+		return splitCommandLine(command).command || void 0;
+	} catch {
+		return;
+	}
 }
 async function isLikelyMatchingProcess(pid, agentCommand) {
 	const expectedToken = firstAgentCommandToken(agentCommand);
 	if (!expectedToken) return false;
-	const procCmdline = `/proc/${pid}/cmdline`;
+	const argv = await readProcessArgv(pid);
+	if (argv.length === 0) return false;
+	const executableBase = path.basename(argv[0]);
+	const expectedBase = path.basename(expectedToken);
+	return executableBase === expectedBase || argv.some((entry) => path.basename(entry) === expectedBase);
+}
+async function readProcessArgv(pid) {
+	const procArgv = await readProcCmdline(pid);
+	if (procArgv) return procArgv;
+	return splitCommandLineLike(process.platform === "win32" ? await readWindowsCommandLine(pid) : await readPosixCommandLine(pid));
+}
+async function readProcCmdline(pid) {
 	try {
-		const argv = (await fs$1.readFile(procCmdline, "utf8")).split("\0").map((entry) => entry.trim()).filter((entry) => entry.length > 0);
-		if (argv.length === 0) return false;
-		const executableBase = path.basename(argv[0]);
-		const expectedBase = path.basename(expectedToken);
-		return executableBase === expectedBase || argv.some((entry) => path.basename(entry) === expectedBase);
+		return (await fs$1.readFile(`/proc/${pid}/cmdline`, "utf8")).split("\0").map((entry) => entry.trim()).filter((entry) => entry.length > 0);
 	} catch {
-		return true;
+		return;
 	}
 }
+async function readPosixCommandLine(pid) {
+	try {
+		const { stdout } = await execFileAsync("ps", [
+			"-p",
+			String(pid),
+			"-o",
+			"command="
+		]);
+		return stdout.trim() || void 0;
+	} catch {
+		return;
+	}
+}
+async function readWindowsCommandLine(pid) {
+	try {
+		const { stdout } = await execFileAsync("powershell.exe", [
+			"-NoProfile",
+			"-NonInteractive",
+			"-Command",
+			`(Get-CimInstance Win32_Process -Filter "ProcessId = ${pid}").CommandLine`
+		], { windowsHide: true });
+		return stdout.trim() || void 0;
+	} catch {
+		return;
+	}
+}
+function splitCommandLineLike(commandLine) {
+	if (!commandLine) return [];
+	try {
+		const parsed = splitCommandLine(commandLine);
+		return [parsed.command, ...parsed.args];
+	} catch {
+		return commandLine.split(/\s+/u).map((entry) => entry.trim()).filter((entry) => entry.length > 0);
+	}
+}
+const sessionControlTestInternals = {
+	firstAgentCommandToken,
+	splitCommandLineLike
+};
 async function closeSession(sessionId) {
 	const record = await resolveSessionRecord(sessionId);
 	await tryCloseSessionOnRunningOwner({ sessionId: record.acpxRecordId }).catch(() => {});
@@ -1650,33 +1793,8 @@ async function closeSession(sessionId) {
 async function createSessionRecordWithClient(client, options) {
 	const cwd = absolutePath(options.cwd);
 	await withTimeout(client.start(), options.timeoutMs);
-	let sessionId;
-	let agentSessionId;
-	let sessionResult;
-	let sessionModels;
-	let requestedModelApplied = false;
-	if (options.resumeSessionId) {
-		const resumed = await resumeSessionRecordWithClient(client, options, cwd);
-		sessionId = resumed.sessionId;
-		agentSessionId = resumed.agentSessionId;
-		sessionResult = resumed.sessionResult;
-		sessionModels = resumed.sessionModels;
-		requestedModelApplied = resumed.requestedModelApplied;
-	} else {
-		const createdSession = await withTimeout(client.createSession(cwd), options.timeoutMs);
-		sessionId = createdSession.sessionId;
-		agentSessionId = normalizeRuntimeSessionId(createdSession.agentSessionId);
-		sessionResult = createdSession;
-		sessionModels = createdSession.models;
-		requestedModelApplied = await applyRequestedModelIfAdvertised({
-			client,
-			sessionId,
-			requestedModel: options.sessionOptions?.model,
-			models: sessionModels,
-			agentCommand: options.agentCommand,
-			timeoutMs: options.timeoutMs
-		});
-	}
+	const createdState = options.resumeSessionId ? await resumeSessionRecordWithClient(client, options, cwd) : await createFreshSessionState(client, options, cwd);
+	const { sessionId, agentSessionId } = createdState;
 	const lifecycle = client.getAgentLifecycleSnapshot();
 	const now = isoNow();
 	const record = {
@@ -1702,12 +1820,36 @@ async function createSessionRecordWithClient(client, options) {
 		acpx: {}
 	};
 	persistSessionOptions(record, options.sessionOptions);
-	applyConfigOptionsToRecord(record, sessionResult);
-	syncAdvertisedModelState(record, sessionModels);
-	if (requestedModelApplied) setCurrentModelId(record, options.sessionOptions?.model);
+	applyCreatedSessionModelState(record, createdState, options.sessionOptions?.model);
 	await writeSessionRecord(record);
 	return record;
 }
+function applyCreatedSessionModelState(record, state, requestedModel) {
+	applyConfigOptionsToRecord(record, state.sessionResult);
+	applyConfigOptionsToRecord(record, state.requestedModelResponse);
+	syncAdvertisedModelState(record, state.requestedModelResponse ? modelStateFromConfigOptions(state.requestedModelResponse.configOptions) : state.sessionModels);
+	if (state.requestedModelApplied) setCurrentModelId(record, currentModelIdFromSetModelResponse(state.requestedModelResponse, requestedModel));
+}
+async function createFreshSessionState(client, options, cwd) {
+	const createdSession = await withTimeout(client.createSession(cwd), options.timeoutMs);
+	const modelApplication = await applyRequestedModelIfAdvertised({
+		client,
+		sessionId: createdSession.sessionId,
+		requestedModel: options.sessionOptions?.model,
+		models: createdSession.models,
+		agentCommand: options.agentCommand,
+		timeoutMs: options.timeoutMs,
+		onWarning: options.onModelWarning
+	});
+	return {
+		sessionId: createdSession.sessionId,
+		agentSessionId: normalizeRuntimeSessionId(createdSession.agentSessionId),
+		sessionResult: createdSession,
+		sessionModels: createdSession.models,
+		requestedModelApplied: modelApplication.applied,
+		requestedModelResponse: modelApplication.response
+	};
+}
 async function resumeSessionRecordWithClient(client, options, cwd) {
 	if (!options.resumeSessionId) throw new Error("resumeSessionId is required");
 	const resumeMethod = client.supportsResumeSession() ? "session/resume" : client.supportsLoadSession() ? "session/load" : void 0;
@@ -1715,19 +1857,22 @@ async function resumeSessionRecordWithClient(client, options, cwd) {
 	try {
 		const resumedSession = await withTimeout(resumeMethod === "session/resume" ? client.resumeSession(options.resumeSessionId, cwd) : client.loadSession(options.resumeSessionId, cwd), options.timeoutMs);
 		const sessionModels = resumedSession.models;
+		const modelApplication = await applyRequestedModelIfAdvertised({
+			client,
+			sessionId: options.resumeSessionId,
+			requestedModel: options.sessionOptions?.model,
+			models: sessionModels,
+			agentCommand: options.agentCommand,
+			timeoutMs: options.timeoutMs,
+			onWarning: options.onModelWarning
+		});
 		return {
 			sessionId: options.resumeSessionId,
 			agentSessionId: normalizeRuntimeSessionId(resumedSession.agentSessionId),
 			sessionResult: resumedSession,
 			sessionModels,
-			requestedModelApplied: await applyRequestedModelIfAdvertised({
-				client,
-				sessionId: options.resumeSessionId,
-				requestedModel: options.sessionOptions?.model,
-				models: sessionModels,
-				agentCommand: options.agentCommand,
-				timeoutMs: options.timeoutMs
-			})
+			requestedModelApplied: modelApplication.applied,
+			requestedModelResponse: modelApplication.response
 		};
 	} catch (error) {
 		throw new Error(`Failed to resume ACP session ${options.resumeSessionId}: ${formatErrorMessage(error)}`, { cause: error });
@@ -2015,11 +2160,8 @@ var QueueOwnerTurnController = class {
 	async setSessionModel(modelId, timeoutMs) {
 		this.assertCanHandleControlRequest();
 		const activeController = this.activeController;
-		if (activeController) {
-			await this.options.withTimeout(async () => await activeController.setSessionModel(modelId), timeoutMs);
-			return;
-		}
-		await this.options.setSessionModelFallback(modelId, timeoutMs);
+		if (activeController) return await this.options.withTimeout(async () => await activeController.setSessionModel(modelId), timeoutMs);
+		return await this.options.setSessionModelFallback(modelId, timeoutMs);
 	}
 	async setSessionConfigOption(configId, value, timeoutMs) {
 		this.assertCanHandleControlRequest();
@@ -2030,22 +2172,24 @@ var QueueOwnerTurnController = class {
 };
 //#endregion
 //#region src/cli/session/queue-owner-process.ts
+const QUEUE_OWNER_PAYLOAD_FILE_ENV = "ACPX_QUEUE_OWNER_PAYLOAD_FILE";
+const QUEUE_OWNER_PAYLOAD_ENV = "ACPX_QUEUE_OWNER_PAYLOAD";
 function isNonEmptyStringArray(value) {
 	return Array.isArray(value) && value.length > 0 && value.every((entry) => typeof entry === "string" && entry.length > 0);
 }
-const NODE_TEST_FLAGS = new Set([
+const NODE_TEST_FLAGS = /* @__PURE__ */ new Set([
 	"--experimental-test-coverage",
 	"--test",
 	"--test-name-pattern",
 	"--test-reporter",
 	"--test-reporter-destination"
 ]);
-const NODE_TEST_FLAGS_WITH_VALUE = new Set([
+const NODE_TEST_FLAGS_WITH_VALUE = /* @__PURE__ */ new Set([
 	"--test-name-pattern",
 	"--test-reporter",
 	"--test-reporter-destination"
 ]);
-const INSPECTOR_FLAGS_WITH_VALUE = new Set([
+const INSPECTOR_FLAGS_WITH_VALUE = /* @__PURE__ */ new Set([
 	"--inspect",
 	"--inspect-brk",
 	"--inspect-port",
@@ -2105,6 +2249,8 @@ function queueOwnerRuntimeOptionsFromSend(options) {
 	return {
 		sessionId: options.sessionId,
 		mcpServers: options.mcpServers,
+		...options.mcpConfigPath ? { mcpConfigPath: options.mcpConfigPath } : {},
+		...options.mcpConfigFingerprint ? { mcpConfigFingerprint: options.mcpConfigFingerprint } : {},
 		permissionMode: options.permissionMode,
 		nonInteractivePermissions: options.nonInteractivePermissions,
 		authCredentials: options.authCredentials,
@@ -2118,20 +2264,32 @@ function queueOwnerRuntimeOptionsFromSend(options) {
 		sessionOptions: options.sessionOptions
 	};
 }
-function buildQueueOwnerSpawnOptions(payload) {
+function writeQueueOwnerPayloadFile(payload) {
+	const dir = mkdtempSync(path.join(os.tmpdir(), "acpx-queue-owner-"));
+	const payloadPath = path.join(dir, "payload.json");
+	writeFileSync(payloadPath, payload, {
+		encoding: "utf8",
+		flag: "wx",
+		mode: 384
+	});
+	return payloadPath;
+}
+function buildQueueOwnerSpawnOptions(payloadFilePath) {
+	const env = {
+		...process.env,
+		[QUEUE_OWNER_PAYLOAD_FILE_ENV]: payloadFilePath
+	};
+	delete env[QUEUE_OWNER_PAYLOAD_ENV];
 	return {
 		detached: true,
 		stdio: "ignore",
-		env: {
-			...process.env,
-			ACPX_QUEUE_OWNER_PAYLOAD: payload
-		},
+		env,
 		windowsHide: true
 	};
 }
 function spawnQueueOwnerProcess(options) {
-	const payload = JSON.stringify(options);
-	spawn(process.execPath, resolveQueueOwnerSpawnArgs(), buildQueueOwnerSpawnOptions(payload)).unref();
+	const payloadPath = writeQueueOwnerPayloadFile(JSON.stringify(options));
+	spawn(process.execPath, resolveQueueOwnerSpawnArgs(), buildQueueOwnerSpawnOptions(payloadPath)).unref();
 }
 //#endregion
 //#region src/session/events.ts
@@ -2379,35 +2537,54 @@ function toPromptResult(stopReason, sessionId, client) {
 function requestedModelId(value) {
 	return typeof value === "string" ? value.trim() : "";
 }
-function advertisedModelsForRecord(record) {
-	const availableModels = record.acpx?.available_models;
-	if (!Array.isArray(availableModels)) return;
-	return {
-		currentModelId: record.acpx?.current_model_id ?? "",
-		availableModels: availableModels.map((modelId) => ({
-			modelId,
-			name: modelId
-		}))
-	};
+function applyConfigOptionResponseToState(state, response) {
+	if (!response?.configOptions) return state;
+	return applyConfigOptionsToState(state, response.configOptions);
+}
+function mergeConnectedModelState(state, connectedState) {
+	if (!connectedState) return state;
+	const nextState = cloneSessionAcpxState(state) ?? {};
+	mergeConnectedAdvertisedModelState(nextState, connectedState);
+	mergeConnectedModelPreferences(nextState, connectedState);
+	return nextState;
+}
+function mergeConnectedAdvertisedModelState(nextState, connectedState) {
+	if (connectedState.config_options !== void 0) nextState.config_options = structuredClone(connectedState.config_options);
+	else delete nextState.config_options;
+	if (connectedState.current_model_id !== void 0) nextState.current_model_id = connectedState.current_model_id;
+	else delete nextState.current_model_id;
+	if (connectedState.available_models) nextState.available_models = [...connectedState.available_models];
+	else delete nextState.available_models;
+	if (connectedState.model_control) nextState.model_control = connectedState.model_control;
+	else delete nextState.model_control;
+}
+function mergeConnectedModelPreferences(nextState, connectedState) {
+	if (connectedState.session_options) nextState.session_options = cloneSessionAcpxState(connectedState)?.session_options;
+	if (connectedState.desired_mode_id !== void 0) nextState.desired_mode_id = connectedState.desired_mode_id;
+	if (connectedState.desired_config_options) nextState.desired_config_options = { ...connectedState.desired_config_options };
 }
 async function applyPromptModelIfAdvertised(params) {
 	const requestedModel = requestedModelId(params.requestedModel);
 	if (!requestedModel) return;
-	const models = advertisedModelsForRecord(params.record);
-	assertRequestedModelSupported({
+	const models = advertisedModelState(params.record.acpx);
+	emitModelSupportWarning(assertRequestedModelSupported({
 		requestedModel,
 		models,
 		agentCommand: params.record.agentCommand,
 		context: "apply"
-	});
+	}), params.suppressWarnings);
 	if (!models) return;
 	if (params.record.acpx?.current_model_id === requestedModel) {
-		setDesiredModelId(params.record, requestedModel);
+		setDesiredModelId(params.record, requestedModel, models.configId);
 		return;
 	}
-	await withTimeout(params.client.setSessionModel(params.sessionId, requestedModel), params.timeoutMs);
-	setDesiredModelId(params.record, requestedModel);
-	setCurrentModelId(params.record, requestedModel);
+	const response = await withTimeout(params.client.setSessionModel(params.sessionId, requestedModel, models), params.timeoutMs);
+	applyConfigOptionsToRecord(params.record, response);
+	setDesiredModelId(params.record, requestedModel, models.configId);
+	setCurrentModelId(params.record, currentModelIdFromSetModelResponse(response, requestedModel));
+}
+function emitModelSupportWarning(warning, suppressWarnings) {
+	if (warning && !suppressWarnings) process.stderr.write(`[acpx] warning: ${warning}\n`);
 }
 function jsonRpcIdKey$1(value) {
 	if (typeof value === "string") return `s:${value}`;
@@ -2428,13 +2605,14 @@ function extractJsonRpcResponseInfo(message) {
 	const idKey = jsonRpcIdKey$1(candidate.id);
 	if (!idKey) return;
 	const hasError = Object.hasOwn(candidate, "error");
-	if (!hasError && !Object.hasOwn(candidate, "result")) return;
+	const hasResult = Object.hasOwn(candidate, "result");
+	if (!hasError && !hasResult) return;
 	return {
 		idKey,
 		hasError
 	};
 }
-const SESSION_RECONNECT_METHODS = new Set(["session/load", "session/resume"]);
+const SESSION_RECONNECT_METHODS = /* @__PURE__ */ new Set(["session/load", "session/resume"]);
 function filterRecoverableLoadFallbackOutput(messages) {
 	const requestMethodById = /* @__PURE__ */ new Map();
 	const failedLoadRequestIds = /* @__PURE__ */ new Set();
@@ -2685,10 +2863,37 @@ async function runSessionPrompt(options) {
 			await client.setSessionMode(activeSessionIdForControl, modeId);
 		},
 		setSessionModel: async (modelId) => {
-			await client.setSessionModel(activeSessionIdForControl, modelId);
+			const models = advertisedModelState(acpxState);
+			const response = await client.setSessionModel(activeSessionIdForControl, modelId, models);
+			acpxState = applyConfigOptionResponseToState(acpxState, response);
+			const nextState = cloneSessionAcpxState(acpxState) ?? {};
+			nextState.session_options = {
+				...nextState.session_options,
+				model: modelId
+			};
+			nextState.current_model_id = currentModelIdFromSetModelResponse(response, modelId);
+			clearDesiredConfigOption(nextState, models?.configId);
+			acpxState = nextState;
+			return response;
 		},
 		setSessionConfigOption: async (configId, value) => {
-			return await client.setSessionConfigOption(activeSessionIdForControl, configId, value);
+			const response = await client.setSessionConfigOption(activeSessionIdForControl, configId, value);
+			acpxState = applyConfigOptionResponseToState(acpxState, response);
+			const nextState = cloneSessionAcpxState(acpxState) ?? {};
+			if (configId === modelStateFromConfigOptions(nextState.config_options)?.configId) {
+				nextState.session_options = {
+					...nextState.session_options,
+					model: value
+				};
+				nextState.current_model_id = currentModelIdFromSetModelResponse(response, value);
+				clearDesiredConfigOption(nextState, configId);
+			} else if (configId === "mode") nextState.desired_mode_id = value;
+			else nextState.desired_config_options = {
+				...nextState.desired_config_options,
+				[configId]: value
+			};
+			acpxState = nextState;
+			return response;
 		}
 	};
 	const flushConnectOutput = (loadError) => {
@@ -2707,6 +2912,7 @@ async function runSessionPrompt(options) {
 					resumePolicy: options.resumePolicy,
 					timeoutMs: options.timeoutMs,
 					verbose: options.verbose,
+					suppressWarnings: options.suppressSdkConsoleErrors,
 					activeController,
 					onClientAvailable: (controller) => {
 						options.onClientAvailable?.(controller);
@@ -2720,6 +2926,7 @@ async function runSessionPrompt(options) {
 					}
 				});
 			});
+			acpxState = mergeConnectedModelState(acpxState, record.acpx);
 			flushConnectOutput(connected.loadError);
 			emitConnectPerfMetric(connectStartedAt, options.verbose);
 			return connected;
@@ -2807,8 +3014,10 @@ async function runSessionPrompt(options) {
 				sessionId: activeSessionId,
 				requestedModel: sessionOptions?.model,
 				record,
-				timeoutMs: options.timeoutMs
+				timeoutMs: options.timeoutMs,
+				suppressWarnings: options.suppressSdkConsoleErrors
 			});
+			acpxState = cloneSessionAcpxState(record.acpx);
 			output.setContext({ sessionId: record.acpxRecordId });
 			await liveCheckpoint.checkpoint();
 			const response = await savePromptSuccess(await runPromptWithRetries(activeSessionId));
@@ -2909,7 +3118,8 @@ async function runOnce(options) {
 				requestedModel: options.sessionOptions?.model,
 				models: createdSession.models,
 				agentCommand: options.agentCommand,
-				timeoutMs: options.timeoutMs
+				timeoutMs: options.timeoutMs,
+				onWarning: options.suppressSdkConsoleErrors ? void 0 : (message) => process.stderr.write(`[acpx] warning: ${message}\n`)
 			});
 			output.setContext({ sessionId });
 			const response = await runExecPromptWithRetries(sessionId);
@@ -2956,6 +3166,8 @@ async function submitToRunningOwner(options, waitForCompletion) {
 		sessionId: options.sessionId,
 		message: promptToDisplayText(options.prompt),
 		prompt: options.prompt,
+		mcpConfigPath: options.mcpConfigPath,
+		mcpConfigFingerprint: options.mcpConfigFingerprint,
 		permissionMode: options.permissionMode,
 		nonInteractivePermissions: options.nonInteractivePermissions,
 		permissionPolicy: options.permissionPolicy,
@@ -3001,7 +3213,7 @@ function createQueueOwnerTurnController(options) {
 			});
 		},
 		setSessionModelFallback: async (modelId, timeoutMs) => {
-			await runSessionSetModelDirect({
+			return (await runSessionSetModelDirect({
 				sessionRecordId: options.sessionId,
 				modelId,
 				mcpServers: options.mcpServers,
@@ -3011,7 +3223,7 @@ function createQueueOwnerTurnController(options) {
 				terminal: options.terminal,
 				timeoutMs,
 				verbose: options.verbose
-			});
+			})).response;
 		},
 		setSessionConfigOptionFallback: async (configId, value, timeoutMs) => {
 			return (await runSessionSetConfigOptionDirect({
@@ -3054,7 +3266,10 @@ async function writeQueueOwnerLifecycleSnapshot(sessionId, sharedClient) {
 	} catch {}
 }
 async function runSessionQueueOwner(options) {
-	const lease = await tryAcquireQueueOwnerLease(options.sessionId);
+	const lease = await tryAcquireQueueOwnerLease(options.sessionId, {
+		path: options.mcpConfigPath,
+		fingerprint: options.mcpConfigFingerprint
+	});
 	if (!lease) return;
 	const sessionRecord = await resolveSessionRecord(options.sessionId);
 	let owner;
@@ -3105,9 +3320,7 @@ async function runSessionQueueOwner(options) {
 			setSessionMode: async (modeId, timeoutMs) => {
 				await turnController.setSessionMode(modeId, timeoutMs);
 			},
-			setSessionModel: async (modelId, timeoutMs) => {
-				await turnController.setSessionModel(modelId, timeoutMs);
-			},
+			setSessionModel: async (modelId, timeoutMs) => await turnController.setSessionModel(modelId, timeoutMs),
 			setSessionConfigOption: async (configId, value, timeoutMs) => {
 				return await turnController.setSessionConfigOption(configId, value, timeoutMs);
 			}
@@ -3201,6 +3414,7 @@ var session_exports = /* @__PURE__ */ __exportAll({
 	listAgentSessions: () => listAgentSessions,
 	listSessions: () => listSessions,
 	listSessionsForAgent: () => listSessionsForAgent,
+	mergeConnectedModelState: () => mergeConnectedModelState,
 	normalizeQueueOwnerTtlMs: () => normalizeQueueOwnerTtlMs,
 	pruneSessions: () => pruneSessions,
 	runOnce: () => runOnce,
@@ -3208,6 +3422,7 @@ var session_exports = /* @__PURE__ */ __exportAll({
 	runSessionQueueOwner: () => runSessionQueueOwner,
 	sendSession: () => sendSession,
 	sendSessionDirect: () => sendSessionDirect,
+	sessionControlTestInternals: () => sessionControlTestInternals,
 	setSessionConfigOption: () => setSessionConfigOption,
 	setSessionMode: () => setSessionMode,
 	setSessionModel: () => setSessionModel
@@ -3381,10 +3596,13 @@ var JsonOutputFormatter = class {
 	sanitizeReadResponse(message) {
 		const candidate = message;
 		const idKey = jsonRpcIdKey(candidate.id);
-		if (!idKey || !Object.hasOwn(candidate, "result")) return message;
+		if (!idKey) return message;
+		const hasResult = Object.hasOwn(candidate, "result");
+		const hasError = Object.hasOwn(candidate, "error");
+		if (!hasResult && !hasError) return message;
 		const method = this.requestMethodById.get(idKey);
 		this.requestMethodById.delete(idKey);
-		if (method !== "fs/read_text_file") return message;
+		if (method !== "fs/read_text_file" || !hasResult) return message;
 		const root = asRecord$1(message);
 		if (!root) return message;
 		return {
@@ -4143,4 +4361,4 @@ function createOutputFormatter(format, options = {}) {
 //#endregion
 export { runSessionQueueOwner as a, buildQueueOwnerArgOverride as c, createSessionWithClient as d, cancelSessionPrompt as f, __exportAll as g, isProcessAlive as h, session_exports as i, flushPerfMetricsCapture as l, DEFAULT_QUEUE_OWNER_TTL_MS as m, getTextErrorRemediationHints as n, runOnce as o, probeQueueOwnerHealth as p, output_exports as r, sendSessionDirect as s, createOutputFormatter as t, installPerfMetricsCapture as u };
 
-//# sourceMappingURL=output-Di77Yugq.js.map
+//# sourceMappingURL=output-BEv_BB7T.js.map