acpx 0.11.0 → 0.11.2

package/dist/{output-D_BGt1YI.js → output-Smw6kFL_.js}

@@ -1,10 +1,11 @@
-import { $ as setPerfGauge, A as assertRequestedModelSupported, At as isRetryablePromptError, B as listSessions, C as mergeSessionOptions, Ct as withTimeout, D as applyLifecycleSnapshotToRecord, E as applyConversation, F as absolutePath, G as writeSessionRecord, H as normalizeName, I as findGitRepositoryRoot, J as getPerfMetricsSnapshot, Kt as QueueConnectionError, L as findSession, Pt as toAcpErrorPayload, Q as resetPerfMetrics, R as findSessionByDirectoryWalk, Rt as OUTPUT_ERROR_CODES, S as advertisedModelState, St as withInterrupt, T as sessionOptionsFromRecord, U as pruneSessions, V as listSessionsForAgent, W as resolveSessionRecord, X as measurePerf, Y as incrementPerfCounter, Z as recordPerfDuration, _ as createSessionConversation, a as applyRequestedModelIfAdvertised, at as defaultSessionEventLog, b as recordSessionUpdate, bt as InterruptedError, c as setCurrentModelId, ct as sessionEventLockPath, d as setDesiredModelId, dt as isAcpJsonRpcMessage, et as startPerfTimer, f as syncAdvertisedModelState, ft as parseJsonRpcErrorMessage, g as cloneSessionConversation, h as cloneSessionAcpxState, ht as isPromptInput, i as connectAndLoadSession, j as modelStateFromConfigOptions, jt as normalizeOutputError, k as AcpClient, kt as formatErrorMessage, l as setDesiredConfigOption, lt as sessionEventSegmentPath, m as applyConfigOptionsToState, n as runPromptTurn, o as currentModelIdFromSetModelResponse, ot as sessionBaseDir, p as applyConfigOptionsToRecord, pt as parsePromptStopReason, q as formatPerfMetric, qt as QueueProtocolError, r as withConnectedSession, rt as normalizeRuntimeSessionId, s as clearDesiredConfigOption, st as sessionEventActivePath, t as LiveSessionCheckpoint, u as setDesiredModeId, ut as extractSessionUpdateNotification, v as recordClientOperation, vt as promptToDisplayText, w as persistSessionOptions, x as trimConversationForRuntime, xt as TimeoutError, y as recordPromptSubmission, yt as textPrompt, z as isoNow, zt as OUTPUT_ERROR_ORIGINS } from "./live-checkpoint-BZrk9Mjz.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-mdAaF3qJ.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;
@@ -818,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, {
@@ -980,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");
@@ -1025,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;
@@ -1392,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);
@@ -1561,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 {
@@ -1648,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(() => {});
@@ -2062,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",
@@ -2137,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,
@@ -2150,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
@@ -2479,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();
@@ -3039,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,
@@ -3137,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;
@@ -3290,6 +3422,7 @@ var session_exports = /* @__PURE__ */ __exportAll({
 	runSessionQueueOwner: () => runSessionQueueOwner,
 	sendSession: () => sendSession,
 	sendSessionDirect: () => sendSessionDirect,
+	sessionControlTestInternals: () => sessionControlTestInternals,
 	setSessionConfigOption: () => setSessionConfigOption,
 	setSessionMode: () => setSessionMode,
 	setSessionModel: () => setSessionModel
@@ -3463,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 {
@@ -4225,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-D_BGt1YI.js.map
+//# sourceMappingURL=output-Smw6kFL_.js.map