acpx 0.15.1 → 0.17.0

package/dist/cli.js

@@ -1,15 +1,18 @@
 #!/usr/bin/env node
-import { a as runSessionQueueOwner, c as buildQueueOwnerArgOverride, g as __exportAll, h as isProcessAlive, l as flushPerfMetricsCapture, n as getTextErrorRemediationHints, o as runOnce, p as probeQueueOwnerHealth, t as createOutputFormatter, u as installPerfMetricsCapture } from "./output-8-D6Gd4Z.js";
-import { $t as AgentSpawnError, At as DEFAULT_AGENT_NAME, Ct as parsePromptSource, Dt as TimeoutError, Et as InterruptedError, G as listSessions, H as findSession, It as exitCodeForOutputErrorCode, Jt as OUTPUT_FORMATS, L as getAcpxVersion, Mt as normalizeAgentName$1, P as renderArgvIdentity, Qt as AcpxOperationalError, St as mergePromptSourceWithText, Tt as textPrompt, U as findSessionByDirectoryWalk, V as findGitRepositoryRoot, Wt as EXIT_CODES, X as writeSessionRecord, _t as isAcpJsonRpcMessage, bt as PromptInputValidationError, ct as serializeSessionRecordForDisk, dt as defaultSessionEventLog, ht as sessionEventSegmentPath, jt as listBuiltInAgents, lt as normalizeRuntimeSessionId, mt as sessionEventLockPath, pt as sessionEventActivePath, q as normalizeName, st as parseSessionRecord, zt as normalizeOutputError } from "./live-checkpoint-sB7dFOYR.js";
-import { C as loadPermissionPolicySpec, S as toTimerMilliseconds, _ as resolveAgentInvocation, a as addSessionOption, b as resolvePermissionMode, c as parseDaysOlderThan, d as parseNonEmptyValue, f as parseOutputFormat$1, g as parseTtlSeconds, h as parseTimeoutSeconds, i as addSessionNameOption, l as parseHistoryLimit, m as parseSessionName, n as addGlobalFlags, p as parsePruneBeforeDate, r as addPromptInputOption, s as parseAllowedTools, t as addExecConfigOption, u as parseMaxTurns, v as resolveGlobalFlags, x as resolveSessionNameFromFlags, y as resolveOutputPolicy } from "./flags-BHcZWTov.js";
+import { n as getTextErrorRemediationHints, o as __exportAll, t as createOutputFormatter } from "./output-BPPjvJTI.js";
+import { A as listSessions, At as AgentSpawnError, C as textPrompt, D as findSession, E as findGitRepositoryRoot, I as writeSessionRecord, M as normalizeName, O as findSessionByDirectoryWalk, Ot as AcpxOperationalError, R as parseSessionRecord, V as normalizeAgentSessionId, b as mergePromptSourceWithText, bt as EXIT_CODES, ct as defaultSessionEventLog, dt as sessionEventLockPath, ht as isProcessAlive, pt as writePrivateFile, u as probeQueueOwnerHealth, ut as sessionEventActivePath, v as PromptInputValidationError, wt as OUTPUT_FORMATS, x as parsePromptSource, z as serializeSessionRecordForDisk } from "./ipc-D3akHMEq.js";
+import { X as getAcpxVersion, ct as normalizeOutputError, d as flushPerfMetricsCapture, et as listSessionEvents, f as installPerfMetricsCapture, i as runOnce, n as runSessionQueueOwner, nt as InterruptedError, rt as TimeoutError, s as DISCARD_OUTPUT_FORMATTER, st as exitCodeForOutputErrorCode, tt as isLegacyZedCodexAcpInvocation, u as buildQueueOwnerArgOverride } from "./queue-owner-runtime--IbbndGz.js";
+import { O as renderArgvIdentity, i as DEFAULT_AGENT_NAME, l as normalizeAgentName$1, s as listBuiltInAgents } from "./agent-registry-DU6mhZBL.js";
+import { C as resolvePermissionMode, S as resolveOutputPolicy, T as toTimerMilliseconds, _ as parseSessionName, a as addGlobalFlags, b as resolveAgentInvocation, c as addSessionOption, d as parseDaysOlderThan, f as parseHistoryLimit, g as parsePruneBeforeDate, h as parseOutputFormat$1, i as addExecConfigOption, m as parseNonEmptyValue, n as sessionConnectionOptions, o as addPromptInputOption, p as parseMaxTurns, r as sessionOptionsFromGlobalFlags, s as addSessionNameOption, t as resolvePermissionPolicyFromFlags, u as parseAllowedTools, v as parseTimeoutSeconds, w as resolveSessionNameFromFlags, x as resolveGlobalFlags, y as parseTtlSeconds } from "./invocation-options-DbCcOAzM.js";
 import { realpathSync } from "node:fs";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import path from "node:path";
 import { Command, CommanderError, InvalidArgumentError, Option } from "commander";
 import fs$1 from "node:fs/promises";
 import os from "node:os";
-import { createHash, randomUUID } from "node:crypto";
 import { ZodError, z } from "zod";
+import { createHash, randomUUID } from "node:crypto";
+import { text } from "node:stream/consumers";
 import { performance } from "node:perf_hooks";
 //#region src/cli-public.ts
 function configurePublicCli(options) {
@@ -51,11 +54,6 @@ Examples:
   acpx --agent ./my-custom-server "do something"`);
 }
 //#endregion
-//#region src/acp/codex-compat.ts
-function isLegacyZedCodexAcpInvocation(agentCommand) {
-	return /@zed-industries\/codex-acp\b/u.test(agentCommand);
-}
-//#endregion
 //#region src/session/export.ts
 var SessionExportError = class extends AcpxOperationalError {
 	code;
@@ -119,25 +117,6 @@ async function isSessionActive(record) {
 	if (record.closed) return false;
 	return isProcessAlive(record.pid) || await hasLiveEventLock(record.acpxRecordId);
 }
-async function readHistoryFile(filePath) {
-	const payload = await fs$1.readFile(filePath, "utf8").catch((error) => {
-		if (error.code === "ENOENT") return "";
-		throw error;
-	});
-	const history = [];
-	for (const line of payload.split("\n").filter((entry) => entry.trim().length > 0)) try {
-		const parsed = JSON.parse(line);
-		if (isAcpJsonRpcMessage(parsed)) history.push(parsed);
-	} catch {}
-	return history;
-}
-async function readSessionHistory(record) {
-	const history = [];
-	const maxSegments = Number.isInteger(record.eventLog.max_segments) ? record.eventLog.max_segments : 0;
-	for (let segment = maxSegments; segment >= 1; segment -= 1) history.push(...await readHistoryFile(sessionEventSegmentPath(record.acpxRecordId, segment)));
-	history.push(...await readHistoryFile(sessionEventActivePath(record.acpxRecordId)));
-	return history;
-}
 function cwdRelativeToHome(cwd, home) {
 	const relative = path.relative(home, cwd);
 	if (relative.length === 0) return ".";
@@ -174,10 +153,23 @@ async function exportSession(sessionLookup, outputPath) {
 			updated_at: record.lastUsedAt,
 			state: serializeSessionRecordForArchive(record, cwdRelative)
 		},
-		history: await readSessionHistory(record)
+		history: await listSessionEvents(record.acpxRecordId, record.eventLog.max_segments)
 	};
-	await fs$1.mkdir(path.dirname(path.resolve(outputPath)), { recursive: true });
-	await fs$1.writeFile(outputPath, `${JSON.stringify(exported, null, 2)}\n`, "utf8");
+	const target = await resolveExportTarget(outputPath);
+	await writePrivateFile(target, `${JSON.stringify(exported, null, 2)}\n`, { privateDirectory: false });
+}
+async function resolveExportTarget(filePath) {
+	for (let hops = 0; hops < 40; hops += 1) {
+		const stat = await fs$1.lstat(filePath).catch((error) => {
+			if (error.code === "ENOENT") return;
+			throw error;
+		});
+		if (!stat || stat.isFile()) return filePath;
+		if (!stat.isSymbolicLink()) throw new Error("Session export output must be a regular file");
+		const target = await fs$1.readlink(filePath);
+		filePath = path.isAbsolute(target) ? target : `${path.dirname(filePath)}${path.sep}${target}`;
+	}
+	throw new Error("Too many symbolic links in session export output");
 }
 function normalizeAgentName(agentName) {
 	const normalized = agentName?.trim().toLowerCase();
@@ -362,7 +354,7 @@ async function importSession(archivePath, options = {}) {
 	await writeSessionRecord(newRecord);
 	if (parsed.history.length > 0) {
 		const history = parsed.history;
-		await fs$1.writeFile(sessionEventActivePath(newRecordId), `${history.map((entry) => JSON.stringify(entry)).join("\n")}\n`, "utf8");
+		await writePrivateFile(sessionEventActivePath(newRecordId), `${history.map((entry) => JSON.stringify(entry)).join("\n")}\n`);
 	}
 	return {
 		record_id: newRecordId,
@@ -377,6 +369,28 @@ function emitJsonResult(format, payload) {
 	return true;
 }
 //#endregion
+//#region src/cli/prompt-input.ts
+async function readPromptInput(filePath, promptText, cwd, positionalLabel = "argument") {
+	try {
+		if (filePath) return await readPromptFile(filePath, promptText, cwd);
+		const joined = promptText.trim();
+		if (joined.length > 0) return textPrompt(joined);
+		if (process.stdin.isTTY) throw new InvalidArgumentError(`Prompt is required (pass as ${positionalLabel}, --file, or pipe via stdin)`);
+		const prompt = parsePromptSource(await text(process.stdin));
+		if (prompt.length === 0) throw new InvalidArgumentError("Prompt from stdin is empty");
+		return prompt;
+	} catch (error) {
+		if (error instanceof PromptInputValidationError) throw new InvalidArgumentError(error.message);
+		throw error;
+	}
+}
+async function readPromptFile(filePath, promptText, cwd) {
+	const source = filePath === "-" ? await text(process.stdin) : await fs$1.readFile(path.resolve(cwd, filePath), "utf8");
+	const prompt = mergePromptSourceWithText(source, promptText);
+	if (prompt.length === 0) throw new InvalidArgumentError("Prompt from --file is empty");
+	return prompt;
+}
+//#endregion
 //#region src/cli/command-handlers.ts
 var NoSessionError = class extends Error {
 	constructor(message) {
@@ -388,42 +402,17 @@ let sessionModulePromise;
 let outputModulePromise;
 let outputRenderModulePromise;
 function loadSessionModule() {
-	sessionModulePromise ??= import("./output-8-D6Gd4Z.js").then((n) => n.i);
+	sessionModulePromise ??= import("./output-BPPjvJTI.js").then((n) => n.a);
 	return sessionModulePromise;
 }
 function loadOutputModule() {
-	outputModulePromise ??= import("./output-8-D6Gd4Z.js").then((n) => n.r);
+	outputModulePromise ??= import("./output-BPPjvJTI.js").then((n) => n.r);
 	return outputModulePromise;
 }
 function loadOutputRenderModule() {
 	outputRenderModulePromise ??= Promise.resolve().then(() => render_exports);
 	return outputRenderModulePromise;
 }
-async function readPromptInputFromStdin() {
-	let data = "";
-	for await (const chunk of process.stdin) data += String(chunk);
-	return data;
-}
-async function readPrompt(promptParts, filePath, cwd) {
-	try {
-		if (filePath) return await readPromptFromFile(filePath, cwd, promptParts);
-		const joined = promptParts.join(" ").trim();
-		if (joined.length > 0) return textPrompt(joined);
-		if (process.stdin.isTTY) throw new InvalidArgumentError("Prompt is required (pass as argument, --file, or pipe via stdin)");
-		const prompt = parsePromptSource(await readPromptInputFromStdin());
-		if (prompt.length === 0) throw new InvalidArgumentError("Prompt from stdin is empty");
-		return prompt;
-	} catch (error) {
-		if (error instanceof PromptInputValidationError) throw new InvalidArgumentError(error.message);
-		throw error;
-	}
-}
-async function readPromptFromFile(filePath, cwd, promptParts) {
-	const source = filePath === "-" ? await readPromptInputFromStdin() : await fs$1.readFile(path.resolve(cwd, filePath), "utf8");
-	const prompt = mergePromptSourceWithText(source, promptParts.join(" "));
-	if (prompt.length === 0) throw new InvalidArgumentError("Prompt from --file is empty");
-	return prompt;
-}
 function applyPermissionExitCode(result, quietOutput) {
 	const stats = result.permissionStats;
 	const deniedOrCancelled = stats.denied + stats.cancelled;
@@ -447,40 +436,17 @@ function resolveRequestedOutputPolicy(globalFlags) {
 		suppressReads: globalFlags.suppressReads === true
 	};
 }
-function sessionOptionsFromGlobalFlags$1(globalFlags) {
-	return {
-		model: globalFlags.model,
-		allowedTools: globalFlags.allowedTools,
-		maxTurns: globalFlags.maxTurns,
-		systemPrompt: globalFlags.systemPrompt
-	};
-}
-async function resolvePermissionPolicyFromFlags$1(globalFlags) {
-	try {
-		return await loadPermissionPolicySpec(globalFlags.permissionPolicy, globalFlags.cwd);
-	} catch (error) {
-		const message = error instanceof Error ? error.message : String(error);
-		throw new InvalidArgumentError(`Invalid permission policy: ${message}`);
-	}
-}
 function buildSessionStartOptions(params) {
 	return {
+		...sessionConnectionOptions(params.globalFlags, params.config),
 		agentCommand: params.agent.agentCommand,
 		agentArgv: params.agent.agentArgv,
 		cwd: params.agent.cwd,
 		name: params.flags.name,
 		resumeSessionId: params.flags.resumeSession,
-		mcpServers: params.config.mcpServers,
 		permissionMode: params.permissionMode,
-		nonInteractivePermissions: params.globalFlags.nonInteractivePermissions,
 		permissionPolicy: params.permissionPolicy,
-		authCredentials: params.config.auth,
-		authPolicy: params.globalFlags.authPolicy,
-		fs: params.globalFlags.fs,
-		terminal: params.globalFlags.terminal,
-		timeoutMs: params.globalFlags.timeout,
-		verbose: params.globalFlags.verbose,
-		sessionOptions: sessionOptionsFromGlobalFlags$1(params.globalFlags),
+		sessionOptions: sessionOptionsFromGlobalFlags(params.globalFlags),
 		onModelWarning: params.globalFlags.jsonStrict ? void 0 : (message) => process.stderr.write(`[acpx] warning: ${message}\n`)
 	};
 }
@@ -520,8 +486,8 @@ async function handlePrompt(explicitAgentName, promptParts, flags, command, conf
 	const globalFlags = resolveGlobalFlags(command, config);
 	const outputPolicy = resolveRequestedOutputPolicy(globalFlags);
 	const permissionMode = resolvePermissionMode(globalFlags, config.defaultPermissions);
-	const permissionPolicy = await resolvePermissionPolicyFromFlags$1(globalFlags);
-	const prompt = await readPrompt(promptParts, flags.file, globalFlags.cwd);
+	const permissionPolicy = await resolvePermissionPolicyFromFlags(globalFlags);
+	const prompt = await readPromptInput(flags.file, promptParts.join(" "), globalFlags.cwd);
 	const agent = resolveAgentInvocation(explicitAgentName, globalFlags, config);
 	const [{ createOutputFormatter }, { printPromptSessionBanner, printQueuedPromptByFormat }, { sendSession }] = await Promise.all([
 		loadOutputModule(),
@@ -535,33 +501,21 @@ async function handlePrompt(explicitAgentName, promptParts, flags, command, conf
 	});
 	await printPromptSessionBanner(record, agent.cwd, outputPolicy.format, outputPolicy.jsonStrict);
 	const result = await sendSession({
+		...sessionConnectionOptions(globalFlags, config),
 		sessionId: record.acpxRecordId,
 		prompt,
-		mcpServers: config.mcpServers,
 		mcpConfigPath: config.mcpConfigPath,
 		mcpConfigFingerprint: config.mcpConfigFingerprint,
 		permissionMode,
-		nonInteractivePermissions: globalFlags.nonInteractivePermissions,
 		permissionPolicy,
-		authCredentials: config.auth,
-		authPolicy: globalFlags.authPolicy,
-		fs: globalFlags.fs,
-		terminal: globalFlags.terminal,
 		outputFormatter,
 		errorEmissionPolicy: { queueErrorAlreadyEmitted: outputPolicy.queueErrorAlreadyEmitted },
 		suppressSdkConsoleErrors: outputPolicy.suppressSdkConsoleErrors,
-		timeoutMs: globalFlags.timeout,
 		ttlMs: globalFlags.ttl,
 		maxQueueDepth: config.queueMaxDepth,
 		promptRetries: globalFlags.promptRetries,
-		verbose: globalFlags.verbose,
 		waitForCompletion: flags.wait !== false,
-		sessionOptions: {
-			model: globalFlags.model,
-			allowedTools: globalFlags.allowedTools,
-			maxTurns: globalFlags.maxTurns,
-			systemPrompt: globalFlags.systemPrompt
-		}
+		sessionOptions: sessionOptionsFromGlobalFlags(globalFlags)
 	});
 	if ("queued" in result) {
 		printQueuedPromptByFormat(result, outputPolicy.format);
@@ -587,36 +541,24 @@ async function handleExec(explicitAgentName, promptParts, flags, command, config
 	const globalFlags = resolveGlobalFlags(command, config);
 	const outputPolicy = resolveRequestedOutputPolicy(globalFlags);
 	const permissionMode = resolvePermissionMode(globalFlags, config.defaultPermissions);
-	const permissionPolicy = await resolvePermissionPolicyFromFlags$1(globalFlags);
-	const prompt = await readPrompt(promptParts, flags.file, globalFlags.cwd);
+	const permissionPolicy = await resolvePermissionPolicyFromFlags(globalFlags);
+	const prompt = await readPromptInput(flags.file, promptParts.join(" "), globalFlags.cwd);
 	const [{ createOutputFormatter }, { runOnce }] = await Promise.all([loadOutputModule(), loadSessionModule()]);
 	const outputFormatter = createOutputFormatter(outputPolicy.format, { suppressReads: outputPolicy.suppressReads });
 	const agent = resolveAgentInvocation(explicitAgentName, globalFlags, config);
 	applyPermissionExitCode(await runOnce({
+		...sessionConnectionOptions(globalFlags, config),
 		agentCommand: agent.agentCommand,
 		agentArgv: agent.agentArgv,
 		cwd: agent.cwd,
 		prompt,
-		mcpServers: config.mcpServers,
 		permissionMode,
-		nonInteractivePermissions: globalFlags.nonInteractivePermissions,
 		permissionPolicy,
-		authCredentials: config.auth,
-		authPolicy: globalFlags.authPolicy,
-		fs: globalFlags.fs,
-		terminal: globalFlags.terminal,
 		outputFormatter,
 		errorEmissionPolicy: { queueErrorAlreadyEmitted: outputPolicy.queueErrorAlreadyEmitted },
 		suppressSdkConsoleErrors: outputPolicy.suppressSdkConsoleErrors,
-		timeoutMs: globalFlags.timeout,
-		verbose: globalFlags.verbose,
 		promptRetries: globalFlags.promptRetries,
-		sessionOptions: {
-			model: globalFlags.model,
-			allowedTools: globalFlags.allowedTools,
-			maxTurns: globalFlags.maxTurns,
-			systemPrompt: globalFlags.systemPrompt
-		},
+		sessionOptions: sessionOptionsFromGlobalFlags(globalFlags),
 		configOptions: flags.configOption
 	}), outputPolicy.format === "quiet" ? outputFormatter : void 0);
 }
@@ -690,17 +632,11 @@ async function handleSetMode(explicitAgentName, modeId, flags, command, config)
 	const globalFlags = resolveGlobalFlags(command, config);
 	const agent = resolveAgentInvocation(explicitAgentName, globalFlags, config);
 	const { setSessionMode } = await loadSessionModule();
+	const record = await findRoutedSessionOrThrow(agent.agentCommand, agent.agentName, agent.cwd, resolveSessionNameFromFlags(flags, command));
 	const result = await setSessionMode({
-		sessionId: (await findRoutedSessionOrThrow(agent.agentCommand, agent.agentName, agent.cwd, resolveSessionNameFromFlags(flags, command))).acpxRecordId,
-		modeId,
-		mcpServers: config.mcpServers,
-		nonInteractivePermissions: globalFlags.nonInteractivePermissions,
-		authCredentials: config.auth,
-		authPolicy: globalFlags.authPolicy,
-		fs: globalFlags.fs,
-		terminal: globalFlags.terminal,
-		timeoutMs: globalFlags.timeout,
-		verbose: globalFlags.verbose
+		...sessionConnectionOptions(globalFlags, config),
+		sessionId: record.acpxRecordId,
+		modeId
 	});
 	if (globalFlags.verbose && result.loadError) process.stderr.write(`[acpx] session reconnect failed, started fresh session: ${result.loadError}\n`);
 	printSetModeResultByFormat(modeId, result, globalFlags.format);
@@ -709,17 +645,11 @@ async function handleSetModel(explicitAgentName, modelId, flags, command, config
 	const globalFlags = resolveGlobalFlags(command, config);
 	const agent = resolveAgentInvocation(explicitAgentName, globalFlags, config);
 	const { setSessionModel } = await loadSessionModule();
+	const record = await findRoutedSessionOrThrow(agent.agentCommand, agent.agentName, agent.cwd, resolveSessionNameFromFlags(flags, command));
 	const result = await setSessionModel({
-		sessionId: (await findRoutedSessionOrThrow(agent.agentCommand, agent.agentName, agent.cwd, resolveSessionNameFromFlags(flags, command))).acpxRecordId,
-		modelId,
-		mcpServers: config.mcpServers,
-		nonInteractivePermissions: globalFlags.nonInteractivePermissions,
-		authCredentials: config.auth,
-		authPolicy: globalFlags.authPolicy,
-		fs: globalFlags.fs,
-		terminal: globalFlags.terminal,
-		timeoutMs: globalFlags.timeout,
-		verbose: globalFlags.verbose
+		...sessionConnectionOptions(globalFlags, config),
+		sessionId: record.acpxRecordId,
+		modelId
 	});
 	if (globalFlags.verbose && result.loadError) process.stderr.write(`[acpx] session reconnect failed, started fresh session: ${result.loadError}\n`);
 	printSetModelResultByFormat(modelId, result, globalFlags.format);
@@ -733,43 +663,30 @@ async function handleSetConfigOption(explicitAgentName, configId, value, flags,
 	}
 	const resolvedConfigId = resolveCompatibleConfigId(agent, configId);
 	const { setSessionConfigOption } = await loadSessionModule();
+	const record = await findRoutedSessionOrThrow(agent.agentCommand, agent.agentName, agent.cwd, resolveSessionNameFromFlags(flags, command));
 	const result = await setSessionConfigOption({
-		sessionId: (await findRoutedSessionOrThrow(agent.agentCommand, agent.agentName, agent.cwd, resolveSessionNameFromFlags(flags, command))).acpxRecordId,
+		...sessionConnectionOptions(globalFlags, config),
+		sessionId: record.acpxRecordId,
 		configId: resolvedConfigId,
-		value,
-		mcpServers: config.mcpServers,
-		nonInteractivePermissions: globalFlags.nonInteractivePermissions,
-		authCredentials: config.auth,
-		authPolicy: globalFlags.authPolicy,
-		fs: globalFlags.fs,
-		terminal: globalFlags.terminal,
-		timeoutMs: globalFlags.timeout,
-		verbose: globalFlags.verbose
+		value
 	});
 	if (globalFlags.verbose && result.loadError) process.stderr.write(`[acpx] session reconnect failed, started fresh session: ${result.loadError}\n`);
 	printSetConfigOptionResultByFormat(configId, value, result, globalFlags.format);
 }
 async function tryListAgentSessions(agent, flags, globalFlags, config) {
 	const permissionMode = resolvePermissionMode(globalFlags, config.defaultPermissions);
-	const permissionPolicy = await resolvePermissionPolicyFromFlags$1(globalFlags);
+	const permissionPolicy = await resolvePermissionPolicyFromFlags(globalFlags);
 	const { listAgentSessions } = await loadSessionModule();
 	try {
 		return await listAgentSessions({
+			...sessionConnectionOptions(globalFlags, config),
 			agentCommand: agent.agentCommand,
 			agentArgv: agent.agentArgv,
 			cwd: agent.cwd,
 			cursor: flags.cursor,
 			filterCwd: resolveSessionListFilterCwd(flags, agent.cwd),
-			mcpServers: config.mcpServers,
 			permissionMode,
-			nonInteractivePermissions: globalFlags.nonInteractivePermissions,
-			permissionPolicy,
-			authCredentials: config.auth,
-			authPolicy: globalFlags.authPolicy,
-			fs: globalFlags.fs,
-			terminal: globalFlags.terminal,
-			timeoutMs: globalFlags.timeout,
-			verbose: globalFlags.verbose
+			permissionPolicy
 		});
 	} catch (error) {
 		if (error instanceof AgentSpawnError) return "spawn-failed";
@@ -808,7 +725,7 @@ async function handleSessionsClose(explicitAgentName, sessionName, command, conf
 async function handleSessionsNew(explicitAgentName, flags, command, config) {
 	const globalFlags = resolveGlobalFlags(command, config);
 	const permissionMode = resolvePermissionMode(globalFlags, config.defaultPermissions);
-	const permissionPolicy = await resolvePermissionPolicyFromFlags$1(globalFlags);
+	const permissionPolicy = await resolvePermissionPolicyFromFlags(globalFlags);
 	const agent = resolveAgentInvocation(explicitAgentName, globalFlags, config);
 	const [{ createSession, closeSession }, { printCreatedSessionBanner, printNewSessionByFormat }] = await Promise.all([loadSessionModule(), loadOutputRenderModule()]);
 	const replaced = await findSession({
@@ -838,7 +755,7 @@ async function handleSessionsNew(explicitAgentName, flags, command, config) {
 async function handleSessionsEnsure(explicitAgentName, flags, command, config) {
 	const globalFlags = resolveGlobalFlags(command, config);
 	const permissionMode = resolvePermissionMode(globalFlags, config.defaultPermissions);
-	const permissionPolicy = await resolvePermissionPolicyFromFlags$1(globalFlags);
+	const permissionPolicy = await resolvePermissionPolicyFromFlags(globalFlags);
 	const agent = resolveAgentInvocation(explicitAgentName, globalFlags, config);
 	const [{ ensureSession }, { printCreatedSessionBanner, printEnsuredSessionByFormat }] = await Promise.all([loadSessionModule(), loadOutputRenderModule()]);
 	const result = await ensureSession(buildSessionStartOptions({
@@ -960,6 +877,26 @@ async function handleSessionsHistory(explicitAgentName, sessionName, flags, comm
 	const globalFlags = resolveGlobalFlags(command, config);
 	printSessionHistoryByFormat(await findScopedSessionOrThrow(resolveAgentInvocation(explicitAgentName, globalFlags, config), sessionName), flags.limit, globalFlags.format);
 }
+async function handleSessionsWatch(explicitAgentName, flags, command, config) {
+	const globalFlags = resolveGlobalFlags(command, config);
+	const agent = resolveAgentInvocation(explicitAgentName, globalFlags, config);
+	const scope = {
+		agentCommand: agent.agentCommand,
+		cwd: agent.cwd,
+		name: flags.name,
+		readOnly: true
+	};
+	const record = await findSession(scope) ?? await findSession({
+		...scope,
+		includeClosed: true
+	});
+	if (!record) throw new Error(missingScopedSessionMessage(agent, flags.name));
+	const { runSessionWatch } = await import("./session-watch--UX5dh00.js");
+	await runSessionWatch(record, {
+		cursor: flags.cursor,
+		policy: resolveRequestedOutputPolicy(globalFlags)
+	});
+}
 async function handleSessionsExport(explicitAgentName, sessionName, flags, command, config) {
 	const globalFlags = resolveGlobalFlags(command, config);
 	const agent = resolveAgentInvocation(explicitAgentName, globalFlags, config);
@@ -1017,13 +954,6 @@ async function handleSessionsPrune(explicitAgentName, flags, command, config) {
 //#region src/cli/compare-command.ts
 const DEFAULT_COMPARE_TIMEOUT_MS = 3e5;
 const FINAL_MESSAGE_PREVIEW_CHARS = 200;
-var CaptureFormatter = class {
-	setContext(_context) {}
-	onAcpMessage(_message) {}
-	onError(params) {}
-	onPermissionEscalation(_event) {}
-	flush() {}
-};
 function asRecord$2(value) {
 	return Boolean(value) && typeof value === "object" && !Array.isArray(value) ? value : void 0;
 }
@@ -1042,34 +972,6 @@ function truncate(value, maxChars) {
 	if (value.length <= maxChars) return value;
 	return `${value.slice(0, Math.max(0, maxChars - 3))}...`;
 }
-async function readStdin() {
-	let data = "";
-	for await (const chunk of process.stdin) data += String(chunk);
-	return data;
-}
-async function readPromptFile(filePath, promptText, cwd) {
-	const source = filePath === "-" ? await readStdin() : await fs$1.readFile(path.resolve(cwd, filePath), "utf8");
-	const prompt = mergePromptSourceWithText(source, promptText);
-	if (prompt.length === 0) throw new InvalidArgumentError("Prompt from --file is empty");
-	return prompt;
-}
-async function readPromptFromStdin() {
-	if (process.stdin.isTTY) throw new InvalidArgumentError("Prompt is required (pass as final argument, --file, or pipe via stdin)");
-	const prompt = parsePromptSource(await readStdin());
-	if (prompt.length === 0) throw new InvalidArgumentError("Prompt from stdin is empty");
-	return prompt;
-}
-async function readPromptInput(filePath, promptText, cwd) {
-	try {
-		if (filePath) return await readPromptFile(filePath, promptText, cwd);
-		const joined = promptText.trim();
-		if (joined.length > 0) return textPrompt(joined);
-		return await readPromptFromStdin();
-	} catch (error) {
-		if (error instanceof PromptInputValidationError) throw new InvalidArgumentError(error.message);
-		throw error;
-	}
-}
 function promptTokensAfterDoubleDash(command) {
 	const commandName = command.name();
 	const commandIndex = process.argv.findIndex((token, index) => index >= 2 && token === commandName);
@@ -1126,22 +1028,6 @@ function captureSessionUpdate(notification, capture) {
 function rowStatusFromPermissionStats(stats) {
 	return stats.denied + stats.cancelled > 0 ? "permission_denied" : "ok";
 }
-function sessionOptionsFromGlobalFlags(globalFlags) {
-	return {
-		model: globalFlags.model,
-		allowedTools: globalFlags.allowedTools,
-		maxTurns: globalFlags.maxTurns,
-		systemPrompt: globalFlags.systemPrompt
-	};
-}
-async function resolvePermissionPolicyFromFlags(globalFlags) {
-	try {
-		return await loadPermissionPolicySpec(globalFlags.permissionPolicy, globalFlags.cwd);
-	} catch (error) {
-		const message = error instanceof Error ? error.message : String(error);
-		throw new InvalidArgumentError(`Invalid permission policy: ${message}`);
-	}
-}
 function buildSuccessRow(agentName, result, capture, startedAt) {
 	const permissionStats = result.permissionStats;
 	return {
@@ -1177,30 +1063,22 @@ function buildErrorRow(agentName, caught, capture, startedAt) {
 async function runAgentForCompare(params) {
 	const capture = {
 		finalMessage: "",
-		usage: {},
-		errors: []
+		usage: {}
 	};
-	const formatter = new CaptureFormatter();
 	const t0 = performance.now();
 	try {
 		const agent = resolveAgentInvocation(params.agentName, params.globalFlags, params.config);
 		const result = await runOnce({
+			...sessionConnectionOptions(params.globalFlags, params.config),
 			agentCommand: agent.agentCommand,
 			agentArgv: agent.agentArgv,
 			cwd: agent.cwd,
 			prompt: params.prompt,
-			mcpServers: params.config.mcpServers,
 			permissionMode: resolvePermissionMode(params.globalFlags, params.config.defaultPermissions),
-			nonInteractivePermissions: params.globalFlags.nonInteractivePermissions,
 			permissionPolicy: params.permissionPolicy,
-			authCredentials: params.config.auth,
-			authPolicy: params.globalFlags.authPolicy,
-			fs: params.globalFlags.fs,
-			terminal: params.globalFlags.terminal,
-			outputFormatter: formatter,
+			outputFormatter: DISCARD_OUTPUT_FORMATTER,
 			suppressSdkConsoleErrors: true,
 			timeoutMs: params.globalFlags.timeout ?? DEFAULT_COMPARE_TIMEOUT_MS,
-			verbose: params.globalFlags.verbose,
 			promptRetries: params.globalFlags.promptRetries,
 			sessionOptions: sessionOptionsFromGlobalFlags(params.globalFlags),
 			onSessionUpdate: (notification) => captureSessionUpdate(notification, capture)
@@ -1283,7 +1161,7 @@ function registerCompareCommand(program, config) {
 		const outputPolicy = resolveOutputPolicy(flags.json === true ? "json" : globalFlags.format, globalFlags.jsonStrict === true);
 		const promptFile = resolvePromptFile(flags);
 		const { agents, promptText } = splitCompareArgs(args, promptFile, this);
-		const prompt = await readPromptInput(promptFile, promptText, globalFlags.cwd);
+		const prompt = await readPromptInput(promptFile, promptText, globalFlags.cwd, "final argument");
 		const permissionPolicy = await resolvePermissionPolicyFromFlags(globalFlags);
 		const rows = [];
 		for (const agentName of agents) rows.push(await runAgentForCompare({
@@ -1307,21 +1185,19 @@ function parseNonEmptyString(value, path) {
 	if (typeof value !== "string" || value.trim().length === 0) throw new Error(`Invalid ${path}: expected non-empty string`);
 	return value.trim();
 }
-function parseHeaders(value, path) {
+function parseNameValuePairs(value, path) {
 	if (value == null) return [];
 	if (!Array.isArray(value)) throw new Error(`Invalid ${path}: expected array`);
-	const headers = [];
-	for (const [index, rawHeader] of value.entries()) {
-		const headerRecord = asRecord$1(rawHeader);
-		if (!headerRecord) throw new Error(`Invalid ${path}[${index}]: expected object`);
-		const name = parseNonEmptyString(headerRecord.name, `${path}[${index}].name`);
-		const headerValue = parseNonEmptyString(headerRecord.value, `${path}[${index}].value`);
-		headers.push({
-			name,
-			value: headerValue
+	const entries = [];
+	for (const [index, rawEntry] of value.entries()) {
+		const entry = asRecord$1(rawEntry);
+		if (!entry) throw new Error(`Invalid ${path}[${index}]: expected object`);
+		entries.push({
+			name: parseNonEmptyString(entry.name, `${path}[${index}].name`),
+			value: parseNonEmptyString(entry.value, `${path}[${index}].value`)
 		});
 	}
-	return headers;
+	return entries;
 }
 function parseArgs(value, path) {
 	if (value == null) return [];
@@ -1333,22 +1209,6 @@ function parseArgs(value, path) {
 	}
 	return args;
 }
-function parseEnv(value, path) {
-	if (value == null) return [];
-	if (!Array.isArray(value)) throw new Error(`Invalid ${path}: expected array`);
-	const env = [];
-	for (const [index, rawEntry] of value.entries()) {
-		const entry = asRecord$1(rawEntry);
-		if (!entry) throw new Error(`Invalid ${path}[${index}]: expected object`);
-		const name = parseNonEmptyString(entry.name, `${path}[${index}].name`);
-		const envValue = parseNonEmptyString(entry.value, `${path}[${index}].value`);
-		env.push({
-			name,
-			value: envValue
-		});
-	}
-	return env;
-}
 function parseMeta(value, path) {
 	if (value === void 0) return;
 	if (value === null) return null;
@@ -1366,7 +1226,7 @@ function parseHttpServer(serverRecord, path, type, name, _meta) {
 		type,
 		name,
 		url: parseNonEmptyString(serverRecord.url, `${path}.url`),
-		headers: parseHeaders(serverRecord.headers, `${path}.headers`),
+		headers: parseNameValuePairs(serverRecord.headers, `${path}.headers`),
 		_meta
 	};
 }
@@ -1375,7 +1235,7 @@ function parseStdioServer(serverRecord, path, name, _meta) {
 		name,
 		command: parseNonEmptyString(serverRecord.command, `${path}.command`),
 		args: parseArgs(serverRecord.args, `${path}.args`),
-		env: parseEnv(serverRecord.env, `${path}.env`),
+		env: parseNameValuePairs(serverRecord.env, `${path}.env`),
 		_meta
 	};
 }
@@ -1488,7 +1348,7 @@ function parseArgvAgentEntry(raw, name, sourcePath) {
 	if (Object.prototype.hasOwnProperty.call(raw, "command") || Object.prototype.hasOwnProperty.call(raw, "args")) throw new Error(`Invalid config agents.${name} in ${sourcePath}: use argv alone, not command or args`);
 	const argv = parseAgentArgv(raw.argv, name, sourcePath);
 	return {
-		command: renderArgv(argv),
+		command: renderArgvIdentity(argv),
 		argv
 	};
 }
@@ -1524,9 +1384,6 @@ function parseAgentArgs(value, agentName, sourcePath) {
 function quoteCommandArg(value) {
 	return JSON.stringify(value);
 }
-function renderArgv(argv) {
-	return renderArgvIdentity(argv);
-}
 function parseAuth(value, sourcePath) {
 	if (value == null) return;
 	if (!isObject(value)) throw new Error(`Invalid config auth in ${sourcePath}: expected object`);
@@ -1572,18 +1429,6 @@ async function loadExplicitMcpConfig(cwd, configuredPath) {
 		config: result.config
 	};
 }
-function mergeAgents(globalAgents, projectAgents) {
-	return {
-		...globalAgents,
-		...projectAgents
-	};
-}
-function mergeAuth(globalAuth, projectAuth) {
-	return {
-		...globalAuth,
-		...projectAuth
-	};
-}
 async function loadResolvedConfig(cwd, options = {}) {
 	const globalPath = defaultGlobalConfigPath();
 	const projectPath = projectConfigPath(cwd);
@@ -1594,11 +1439,29 @@ async function loadResolvedConfig(cwd, options = {}) {
 	]);
 	const globalConfig = globalResult.config;
 	const projectConfig = projectResult.config;
-	const scalar = resolveScalarConfigValues(projectConfig, projectPath, globalConfig, globalPath);
-	const agents = mergeAgents(parseAgents(globalConfig?.agents, globalPath), parseAgents(projectConfig?.agents, projectPath));
-	const auth = mergeAuth(parseAuth(globalConfig?.auth, globalPath), parseAuth(projectConfig?.auth, projectPath));
+	function resolveScalar(key, parse, fallback) {
+		return parse(projectConfig?.[key], projectPath) ?? parse(globalConfig?.[key], globalPath) ?? fallback;
+	}
+	const scalar = {
+		defaultAgent: resolveScalar("defaultAgent", parseDefaultAgent, DEFAULT_AGENT_NAME),
+		defaultPermissions: resolveScalar("defaultPermissions", parsePermissionMode, DEFAULT_PERMISSION_MODE),
+		nonInteractivePermissions: resolveScalar("nonInteractivePermissions", parseNonInteractivePermissionPolicy, DEFAULT_NON_INTERACTIVE_PERMISSION_POLICY),
+		authPolicy: resolveScalar("authPolicy", parseAuthPolicy, DEFAULT_AUTH_POLICY),
+		ttlMs: resolveScalar("ttl", parseTtlMs, DEFAULT_TTL_MS),
+		timeoutMs: resolveTimeoutMs(projectConfig, projectPath, globalConfig, globalPath),
+		queueMaxDepth: resolveScalar("queueMaxDepth", parseQueueMaxDepth, DEFAULT_QUEUE_MAX_DEPTH),
+		format: resolveScalar("format", parseOutputFormat, DEFAULT_OUTPUT_FORMAT)
+	};
+	const agents = {
+		...parseAgents(globalConfig?.agents, globalPath),
+		...parseAgents(projectConfig?.agents, projectPath)
+	};
+	const auth = {
+		...parseAuth(globalConfig?.auth, globalPath),
+		...parseAuth(projectConfig?.auth, projectPath)
+	};
 	const mcpServers = resolveMcpServers(projectConfig, projectPath, globalConfig, globalPath, explicitMcp.config, explicitMcp.path);
-	const disableExec = resolveDisableExec(projectConfig, projectPath, globalConfig, globalPath);
+	const disableExec = resolveScalar("disableExec", parseDisableExec, DEFAULT_DISABLE_EXEC);
 	return {
 		...scalar,
 		agents,
@@ -1613,39 +1476,6 @@ async function loadResolvedConfig(cwd, options = {}) {
 		hasProjectConfig: projectResult.exists
 	};
 }
-function resolveScalarConfigValues(projectConfig, projectPath, globalConfig, globalPath) {
-	return {
-		defaultAgent: resolveDefaultAgent(projectConfig, projectPath, globalConfig, globalPath),
-		defaultPermissions: resolveDefaultPermissions(projectConfig, projectPath, globalConfig, globalPath),
-		nonInteractivePermissions: resolveNonInteractivePermissions(projectConfig, projectPath, globalConfig, globalPath),
-		authPolicy: resolveAuthPolicy(projectConfig, projectPath, globalConfig, globalPath),
-		ttlMs: resolveTtlMs(projectConfig, projectPath, globalConfig, globalPath),
-		timeoutMs: resolveTimeoutMs(projectConfig, projectPath, globalConfig, globalPath),
-		queueMaxDepth: resolveQueueMaxDepth(projectConfig, projectPath, globalConfig, globalPath),
-		format: resolveFormat(projectConfig, projectPath, globalConfig, globalPath)
-	};
-}
-function resolveDefaultAgent(projectConfig, projectPath, globalConfig, globalPath) {
-	return parseDefaultAgent(projectConfig?.defaultAgent, projectPath) ?? parseDefaultAgent(globalConfig?.defaultAgent, globalPath) ?? "codex";
-}
-function resolveDefaultPermissions(projectConfig, projectPath, globalConfig, globalPath) {
-	return parsePermissionMode(projectConfig?.defaultPermissions, projectPath) ?? parsePermissionMode(globalConfig?.defaultPermissions, globalPath) ?? DEFAULT_PERMISSION_MODE;
-}
-function resolveNonInteractivePermissions(projectConfig, projectPath, globalConfig, globalPath) {
-	return parseNonInteractivePermissionPolicy(projectConfig?.nonInteractivePermissions, projectPath) ?? parseNonInteractivePermissionPolicy(globalConfig?.nonInteractivePermissions, globalPath) ?? DEFAULT_NON_INTERACTIVE_PERMISSION_POLICY;
-}
-function resolveAuthPolicy(projectConfig, projectPath, globalConfig, globalPath) {
-	return parseAuthPolicy(projectConfig?.authPolicy, projectPath) ?? parseAuthPolicy(globalConfig?.authPolicy, globalPath) ?? DEFAULT_AUTH_POLICY;
-}
-function resolveTtlMs(projectConfig, projectPath, globalConfig, globalPath) {
-	return parseTtlMs(projectConfig?.ttl, projectPath) ?? parseTtlMs(globalConfig?.ttl, globalPath) ?? DEFAULT_TTL_MS;
-}
-function resolveQueueMaxDepth(projectConfig, projectPath, globalConfig, globalPath) {
-	return parseQueueMaxDepth(projectConfig?.queueMaxDepth, projectPath) ?? parseQueueMaxDepth(globalConfig?.queueMaxDepth, globalPath) ?? DEFAULT_QUEUE_MAX_DEPTH;
-}
-function resolveFormat(projectConfig, projectPath, globalConfig, globalPath) {
-	return parseOutputFormat(projectConfig?.format, projectPath) ?? parseOutputFormat(globalConfig?.format, globalPath) ?? DEFAULT_OUTPUT_FORMAT;
-}
 function hasConfigKey(config, key) {
 	return config != null && Object.prototype.hasOwnProperty.call(config, key);
 }
@@ -1659,9 +1489,6 @@ function resolveMcpServers(projectConfig, projectPath, globalConfig, globalPath,
 	if (hasConfigKey(globalConfig, "mcpServers")) return parseMcpServers(globalConfig?.mcpServers, globalPath);
 	return [];
 }
-function resolveDisableExec(projectConfig, projectPath, globalConfig, globalPath) {
-	return parseDisableExec(projectConfig?.disableExec, projectPath) ?? parseDisableExec(globalConfig?.disableExec, globalPath) ?? DEFAULT_DISABLE_EXEC;
-}
 function toConfigDisplay(config) {
 	const agents = {};
 	for (const [name, agent] of Object.entries(config.agents)) agents[name] = agent.argv ? { argv: [...agent.argv] } : { command: agent.command };
@@ -1681,7 +1508,10 @@ function toConfigDisplay(config) {
 }
 async function initGlobalConfigFile() {
 	const configPath = defaultGlobalConfigPath();
-	await fs$1.mkdir(path.dirname(configPath), { recursive: true });
+	await fs$1.mkdir(path.dirname(configPath), {
+		recursive: true,
+		mode: 448
+	});
 	try {
 		await fs$1.access(configPath);
 		return {
@@ -1704,7 +1534,8 @@ async function initGlobalConfigFile() {
 	try {
 		await fs$1.writeFile(configPath, `${JSON.stringify(payload, null, 2)}\n`, {
 			encoding: "utf8",
-			flag: "wx"
+			flag: "wx",
+			mode: 384
 		});
 	} catch (error) {
 		if (error.code === "EEXIST") return {
@@ -1968,7 +1799,7 @@ function formatPruneSummaryLine(result, count) {
 	return `${prefix} ${count} session${count === 1 ? "" : "s"}${bytesSuffix}`;
 }
 function agentSessionIdPayload(agentSessionId) {
-	const normalized = normalizeRuntimeSessionId(agentSessionId);
+	const normalized = normalizeAgentSessionId(agentSessionId);
 	if (!normalized) return {};
 	return { agentSessionId: normalized };
 }
@@ -2181,6 +2012,9 @@ function registerSessionsCommand(parent, explicitAgentName, config) {
 	sessionsCommand.command("read").description("Read full session history").argument("[name]", "Session name", parseSessionName).option("--tail <count>", "Show only the last N entries instead of all history", parseHistoryLimit).action(async function(name, flags) {
 		await handleSessionsHistory(explicitAgentName, name, { limit: flags.tail ?? 0 }, this, config);
 	});
+	sessionsCommand.command("watch").description("Replay and follow session events without affecting the active turn").option("-s, --name <name>", "Session name", parseSessionName).option("--cursor <cursor>", "Resume after a session watch cursor", (value) => parseNonEmptyValue("Cursor", value)).action(async function(flags) {
+		await handleSessionsWatch(explicitAgentName, flags, this, config);
+	});
 	sessionsCommand.command("export").description("Export a portable session archive").argument("[name]", "Session name", parseSessionName).requiredOption("--output <path>", "Output archive path", (value) => parseNonEmptyValue("Output path", value)).addOption(new LocalAttributeOption("--cwd <cwd>", "Session cwd to export", "sourceCwd").argParser((value) => parseNonEmptyValue("Session cwd", value))).action(async function(name, flags) {
 		await handleSessionsExport(explicitAgentName, name, flags, this, config);
 	});
@@ -2240,7 +2074,7 @@ function registerAgentCommand(program, agentName, config) {
 }
 function registerFlowCommand(program, config) {
 	program.command("flow").description("Run multi-step ACP workflows from flow files").command("run").description("Run a flow file").argument("<file>", "Flow module path").option("--input-json <json>", "Flow input as JSON").option("--input-file <path>", "Read flow input JSON from file").option("--default-agent <name>", "Default agent profile for ACP nodes without profile", (value) => parseNonEmptyValue("Default agent", value)).action(async function(file, flags) {
-		const { handleFlowRun } = await import("./cli-BHAT_D3V.js");
+		const { handleFlowRun } = await import("./cli-CiyfEC7L.js");
 		await handleFlowRun(file, flags, this, config);
 	});
 }
@@ -2259,15 +2093,19 @@ function registerDefaultCommands(program, config) {
 	registerFlowCommand(program, config);
 }
 //#endregion
-//#region src/cli/queue/owner-env.ts
-const QUEUE_OWNER_PAYLOAD_FILE_ENV = "ACPX_QUEUE_OWNER_PAYLOAD_FILE";
-const QUEUE_OWNER_PAYLOAD_ENV = "ACPX_QUEUE_OWNER_PAYLOAD";
+//#region src/session/queue/owner-input.ts
 function asRecord(value) {
 	if (!value || typeof value !== "object" || Array.isArray(value)) return;
 	return value;
 }
 function parseQueueOwnerPayload(raw) {
-	const record = asRecord(JSON.parse(raw));
+	let parsed;
+	try {
+		parsed = JSON.parse(raw);
+	} catch {
+		throw new Error("queue owner payload must be valid JSON");
+	}
+	const record = asRecord(parsed);
 	if (!record) throw new Error("queue owner payload must be an object");
 	if (typeof record.sessionId !== "string" || record.sessionId.trim().length === 0) throw new Error("queue owner payload missing sessionId");
 	if (record.permissionMode !== "approve-all" && record.permissionMode !== "approve-reads" && record.permissionMode !== "deny-all") throw new Error("queue owner payload has invalid permissionMode");
@@ -2343,30 +2181,10 @@ function assignSessionEnv(options, value) {
 	const entries = Object.entries(env).filter((entry) => typeof entry[1] === "string");
 	if (entries.length > 0) options.env = Object.fromEntries(entries);
 }
-async function runQueueOwnerFromEnv(env) {
-	const options = parseQueueOwnerPayload(await readQueueOwnerPayloadFromEnv(env));
-	await runSessionQueueOwner(options);
-}
-async function readQueueOwnerPayloadFromEnv(env) {
-	const payloadFile = env[QUEUE_OWNER_PAYLOAD_FILE_ENV];
-	if (payloadFile) {
-		const payload = await fs$1.readFile(payloadFile, "utf8");
-		await cleanupQueueOwnerPayloadFile(payloadFile).catch(() => {});
-		return payload;
-	}
-	const payload = env[QUEUE_OWNER_PAYLOAD_ENV];
-	if (!payload) throw new Error(`missing ${QUEUE_OWNER_PAYLOAD_ENV}`);
-	return payload;
-}
-async function cleanupQueueOwnerPayloadFile(payloadFile) {
-	if (!isQueueOwnerPayloadFile(payloadFile)) return;
-	await fs$1.unlink(payloadFile).catch(() => {});
-	await fs$1.rmdir(path.dirname(payloadFile)).catch(() => {});
-}
-function isQueueOwnerPayloadFile(payloadFile) {
-	const resolved = path.resolve(payloadFile);
-	const payloadDir = path.dirname(resolved);
-	return path.dirname(payloadDir) === path.resolve(os.tmpdir()) && path.basename(payloadDir).startsWith("acpx-queue-owner-") && path.basename(resolved) === "payload.json";
+async function runQueueOwnerFromStdin() {
+	const payload = await text(process.stdin);
+	if (!payload) throw new Error("queue owner startup payload is empty");
+	await runSessionQueueOwner(parseQueueOwnerPayload(payload));
 }
 //#endregion
 //#region src/cli-core.ts
@@ -2608,9 +2426,6 @@ async function emitRequestedError(error, normalized, outputPolicy) {
 		if (outputPolicy.format === "text") for (const hint of getTextErrorRemediationHints(normalized)) process.stderr.write(`${hint}\n`);
 	}
 }
-async function runWithOutputPolicy(_outputPolicy, run) {
-	return await run();
-}
 async function handleQueueOwnerCommand(argv) {
 	installPerfMetricsCapture({
 		argv: argv.slice(2),
@@ -2618,7 +2433,7 @@ async function handleQueueOwnerCommand(argv) {
 	});
 	if (argv[2] !== "__queue-owner") return false;
 	try {
-		await runQueueOwnerFromEnv(process.env);
+		await runQueueOwnerFromStdin();
 		return true;
 	} catch (error) {
 		const message = error instanceof Error ? error.message : String(error);
@@ -2700,13 +2515,9 @@ async function main(argv = process.argv) {
 		throw error;
 	});
 	try {
-		await runWithOutputPolicy(requestedOutputPolicy, async () => {
-			try {
-				await program.parseAsync(normalizedArgv);
-			} catch (error) {
-				await handleProgramParseError(error, requestedOutputPolicy);
-			}
-		});
+		await program.parseAsync(normalizedArgv);
+	} catch (error) {
+		await handleProgramParseError(error, requestedOutputPolicy);
 	} finally {
 		flushPerfMetricsCapture();
 	}