@pixelzx/genesis 2026.5.10-2 → 2026.5.10-3

package/dist/library-BNl9tYJG.js

@@ -1,45 +0,0 @@
-import { u as normalizeE164 } from "./utils-DaGfogP-.js";
-import { a as loadConfig } from "./io-BEkyPF5u.js";
-import { i as handlePortError, n as describePortOwner, r as ensurePortAvailable, t as PortInUseError } from "./ports-BRobddkK.js";
-import "./config-Cfk0h3C3.js";
-import { u as resolveStorePath } from "./paths-DD6L4IvS.js";
-import { t as loadSessionStore } from "./store-load-Be3alfAf.js";
-import { i as saveSessionStore } from "./store-BgVJf117.js";
-import { n as resolveSessionKey, t as deriveSessionKey } from "./session-key-C6CF_87n.js";
-import { t as applyTemplate } from "./templating-BY7aGvOx.js";
-import { t as waitForever } from "./wait-zEuSu-RK.js";
-import { t as createDefaultDeps } from "./deps-DGev-vWD.js";
-//#region src/library.ts
-let replyRuntimePromise = null;
-let promptRuntimePromise = null;
-let binariesRuntimePromise = null;
-let execRuntimePromise = null;
-let webChannelRuntimePromise = null;
-function loadReplyRuntime() {
-	replyRuntimePromise ??= import("./reply.runtime-7wnQxEUw.js");
-	return replyRuntimePromise;
-}
-function loadPromptRuntime() {
-	promptRuntimePromise ??= import("./prompt-DHgHcsYa.js");
-	return promptRuntimePromise;
-}
-function loadBinariesRuntime() {
-	binariesRuntimePromise ??= import("./binaries-gJeyo8X_.js");
-	return binariesRuntimePromise;
-}
-function loadExecRuntime() {
-	execRuntimePromise ??= import("./exec-L2AY1co6.js");
-	return execRuntimePromise;
-}
-function loadWebChannelRuntime() {
-	webChannelRuntimePromise ??= import("./runtime-web-channel-plugin-BgmdtEZ7.js");
-	return webChannelRuntimePromise;
-}
-const getReplyFromConfig = async (...args) => (await loadReplyRuntime()).getReplyFromConfig(...args);
-const promptYesNo = async (...args) => (await loadPromptRuntime()).promptYesNo(...args);
-const ensureBinary = async (...args) => (await loadBinariesRuntime()).ensureBinary(...args);
-const runExec = async (...args) => (await loadExecRuntime()).runExec(...args);
-const runCommandWithTimeout = async (...args) => (await loadExecRuntime()).runCommandWithTimeout(...args);
-const monitorWebChannel = async (...args) => (await loadWebChannelRuntime()).monitorWebChannel(...args);
-//#endregion
-export { PortInUseError, applyTemplate, createDefaultDeps, deriveSessionKey, describePortOwner, ensureBinary, ensurePortAvailable, getReplyFromConfig, handlePortError, loadConfig, loadSessionStore, monitorWebChannel, normalizeE164, promptYesNo, resolveSessionKey, resolveStorePath, runCommandWithTimeout, runExec, saveSessionStore, waitForever };

package/dist/lifecycle-8ptHb58U.js

@@ -1,571 +0,0 @@
-import { i as formatErrorMessage } from "./errors-Jbvi20TW.js";
-import { c as normalizeOptionalString } from "./string-coerce-C1IzJjqi.js";
-import { i as normalizeChannelId, t as getChannelPlugin } from "./registry-P3FIAQ37.js";
-import "./plugins-CGvdYt8g.js";
-import { o as updateSessionStore } from "./store-BgVJf117.js";
-import "./sessions-D-tQxSLz.js";
-import { r as normalizeConversationRef } from "./conversation-id-DqVCpdFE.js";
-import { r as getSessionBindingService } from "./session-binding-service-DzTd4LUl.js";
-import { h as resolveAcpSessionResolutionError, n as getAcpSessionManager } from "./manager-BQ31y7iX.js";
-import { i as resolveThreadBindingThreadName, r as resolveThreadBindingIntroText } from "./thread-bindings-messages-CWWdOYmL.js";
-import { c as resolveThreadBindingMaxAgeMsForChannel, l as resolveThreadBindingPlacementForCurrentContext, n as formatThreadBindingSpawnDisabledError, o as resolveThreadBindingIdleTimeoutMsForChannel, r as requiresNativeThreadContextForThreadHere, t as formatThreadBindingDisabledError, u as resolveThreadBindingSpawnPolicy } from "./thread-bindings-policy-BgW0fXFT.js";
-import { C as stopWithText, D as resolveAcpCommandConversationId, E as resolveAcpCommandBindingContext, O as resolveAcpCommandThreadId, S as resolveCommandRequestId, T as resolveAcpCommandAccountId, f as collectAcpErrorText, v as parseSpawnInput, w as withAcpCommandErrorBoundary, y as parseSteerInput } from "./shared-DmOIM4A2.js";
-import { a as resolveAcpDispatchPolicyError, i as resolveAcpAgentPolicyError, o as resolveAcpDispatchPolicyMessage, r as isAcpEnabledByPolicy } from "./policy-BM2-u5GN.js";
-import { a as resolveAcpThreadSessionDetailLines, n as resolveAcpSessionCwd } from "./session-identifiers-CSQWpp6N.js";
-import { c as resolveAcpSpawnRuntimePolicyError, u as cleanupFailedAcpSpawn } from "./acp-spawn-D3xu_-rE.js";
-import { t as resolveAcpTargetSessionKey } from "./targets-TpH8-6iR.js";
-import { randomUUID } from "node:crypto";
-//#region src/auto-reply/reply/commands-acp/lifecycle.ts
-function resolveAcpBindingLabelNoun(params) {
-	if (params.placement === "child") return "thread";
-	if (!params.threadId) return "conversation";
-	return params.conversationId === params.threadId ? "thread" : "conversation";
-}
-async function resolveBoundReplyPayload(params) {
-	const channelId = normalizeChannelId(params.binding.conversation.channel);
-	if (!channelId) return;
-	const buildPayload = getChannelPlugin(channelId)?.conversationBindings?.buildBoundReplyPayload;
-	if (!buildPayload) return;
-	return await buildPayload({
-		operation: "acp-spawn",
-		placement: params.placement,
-		conversation: params.binding.conversation
-	}) ?? void 0;
-}
-function buildSpawnedAcpBindingMetadata(params) {
-	return {
-		threadName: resolveThreadBindingThreadName({
-			agentId: params.agentId,
-			label: params.label
-		}),
-		agentId: params.agentId,
-		label: params.label,
-		boundBy: params.senderId || "unknown",
-		introText: resolveThreadBindingIntroText({
-			agentId: params.agentId,
-			label: params.label,
-			idleTimeoutMs: resolveThreadBindingIdleTimeoutMsForChannel({
-				cfg: params.cfg,
-				channel: params.channel,
-				accountId: params.accountId
-			}),
-			maxAgeMs: resolveThreadBindingMaxAgeMsForChannel({
-				cfg: params.cfg,
-				channel: params.channel,
-				accountId: params.accountId
-			}),
-			sessionCwd: resolveAcpSessionCwd(params.sessionMeta),
-			sessionDetails: resolveAcpThreadSessionDetailLines({
-				sessionKey: params.sessionKey,
-				meta: params.sessionMeta
-			})
-		})
-	};
-}
-async function bindSpawnedAcpSession(params) {
-	try {
-		return {
-			ok: true,
-			binding: await params.bindingService.bind({
-				targetSessionKey: params.sessionKey,
-				targetKind: "session",
-				conversation: params.conversationRef,
-				placement: params.placement,
-				metadata: buildSpawnedAcpBindingMetadata({
-					cfg: params.cfg,
-					channel: params.channel,
-					accountId: params.accountId,
-					sessionKey: params.sessionKey,
-					agentId: params.agentId,
-					label: params.label,
-					senderId: params.senderId,
-					sessionMeta: params.sessionMeta
-				})
-			})
-		};
-	} catch (error) {
-		return {
-			ok: false,
-			error: formatErrorMessage(error) || params.bindError
-		};
-	}
-}
-async function bindSpawnedAcpSessionToCurrentConversation(params) {
-	if (params.bindMode === "off") return {
-		ok: false,
-		error: "internal: conversation binding is disabled for this spawn"
-	};
-	const bindingContext = resolveAcpCommandBindingContext(params.commandParams);
-	const channel = bindingContext.channel;
-	if (!channel) return {
-		ok: false,
-		error: "ACP current-conversation binding requires a channel context."
-	};
-	const accountId = resolveAcpCommandAccountId(params.commandParams);
-	const bindingPolicy = resolveThreadBindingSpawnPolicy({
-		cfg: params.commandParams.cfg,
-		channel,
-		accountId,
-		kind: "acp"
-	});
-	if (!bindingPolicy.enabled) return {
-		ok: false,
-		error: formatThreadBindingDisabledError({
-			channel: bindingPolicy.channel,
-			accountId: bindingPolicy.accountId,
-			kind: "acp"
-		})
-	};
-	const bindingService = getSessionBindingService();
-	const capabilities = bindingService.getCapabilities({
-		channel: bindingPolicy.channel,
-		accountId: bindingPolicy.accountId
-	});
-	if (!capabilities.adapterAvailable || !capabilities.bindSupported) return {
-		ok: false,
-		error: `Conversation bindings are unavailable for ${channel}.`
-	};
-	if (!capabilities.placements.includes("current")) return {
-		ok: false,
-		error: `Conversation bindings do not support current placement for ${channel}.`
-	};
-	const currentConversationId = normalizeOptionalString(bindingContext.conversationId) ?? "";
-	if (!currentConversationId) return {
-		ok: false,
-		error: `--bind here requires running /acp spawn inside an active ${channel} conversation.`
-	};
-	const senderId = normalizeOptionalString(params.commandParams.command.senderId) ?? "";
-	const conversationRef = normalizeConversationRef({
-		channel: bindingPolicy.channel,
-		accountId: bindingPolicy.accountId,
-		conversationId: currentConversationId,
-		parentConversationId: bindingContext.parentConversationId
-	});
-	const existingBinding = bindingService.resolveByConversation(conversationRef);
-	const boundBy = normalizeOptionalString(existingBinding?.metadata?.boundBy) ?? "";
-	if (existingBinding && boundBy && boundBy !== "system" && senderId && senderId !== boundBy) return {
-		ok: false,
-		error: `Only ${boundBy} can rebind this ${resolveAcpBindingLabelNoun({
-			placement: "current",
-			threadId: bindingContext.threadId,
-			conversationId: currentConversationId
-		})}.`
-	};
-	const label = params.label || params.agentId;
-	return bindSpawnedAcpSession({
-		bindingService,
-		sessionKey: params.sessionKey,
-		conversationRef,
-		placement: "current",
-		cfg: params.commandParams.cfg,
-		channel: bindingPolicy.channel,
-		accountId: bindingPolicy.accountId,
-		agentId: params.agentId,
-		label,
-		senderId,
-		sessionMeta: params.sessionMeta,
-		bindError: `Failed to bind the current ${channel} conversation to the new ACP session.`
-	});
-}
-async function bindSpawnedAcpSessionToThread(params) {
-	const { commandParams, threadMode } = params;
-	if (threadMode === "off") return {
-		ok: false,
-		error: "internal: thread binding is disabled for this spawn"
-	};
-	const bindingContext = resolveAcpCommandBindingContext(commandParams);
-	const channel = bindingContext.channel;
-	if (!channel) return {
-		ok: false,
-		error: "ACP thread binding requires a channel context."
-	};
-	const accountId = resolveAcpCommandAccountId(commandParams);
-	const spawnPolicy = resolveThreadBindingSpawnPolicy({
-		cfg: commandParams.cfg,
-		channel,
-		accountId,
-		kind: "acp"
-	});
-	if (!spawnPolicy.enabled) return {
-		ok: false,
-		error: formatThreadBindingDisabledError({
-			channel: spawnPolicy.channel,
-			accountId: spawnPolicy.accountId,
-			kind: "acp"
-		})
-	};
-	if (!spawnPolicy.spawnEnabled) return {
-		ok: false,
-		error: formatThreadBindingSpawnDisabledError({
-			channel: spawnPolicy.channel,
-			accountId: spawnPolicy.accountId,
-			kind: "acp"
-		})
-	};
-	const bindingService = getSessionBindingService();
-	const capabilities = bindingService.getCapabilities({
-		channel: spawnPolicy.channel,
-		accountId: spawnPolicy.accountId
-	});
-	if (!capabilities.adapterAvailable) return {
-		ok: false,
-		error: `Thread bindings are unavailable for ${channel}.`
-	};
-	if (!capabilities.bindSupported) return {
-		ok: false,
-		error: `Thread bindings are unavailable for ${channel}.`
-	};
-	const currentThreadId = bindingContext.threadId ?? "";
-	const currentConversationId = normalizeOptionalString(bindingContext.conversationId) ?? "";
-	const requiresThreadIdForHere = requiresNativeThreadContextForThreadHere(channel);
-	if (threadMode === "here" && (requiresThreadIdForHere && !currentThreadId || !requiresThreadIdForHere && !currentConversationId)) return {
-		ok: false,
-		error: `--thread here requires running /acp spawn inside an active ${channel} thread/conversation.`
-	};
-	const placement = resolveThreadBindingPlacementForCurrentContext({
-		channel,
-		threadId: currentThreadId || void 0
-	});
-	if (!capabilities.placements.includes(placement)) return {
-		ok: false,
-		error: `Thread bindings do not support ${placement} placement for ${channel}.`
-	};
-	if (!currentConversationId) return {
-		ok: false,
-		error: `Could not resolve a ${channel} conversation for ACP thread spawn.`
-	};
-	const senderId = normalizeOptionalString(commandParams.command.senderId) ?? "";
-	const conversationRef = normalizeConversationRef({
-		channel: spawnPolicy.channel,
-		accountId: spawnPolicy.accountId,
-		conversationId: currentConversationId,
-		parentConversationId: bindingContext.parentConversationId
-	});
-	if (placement === "current") {
-		const existingBinding = bindingService.resolveByConversation(conversationRef);
-		const boundBy = normalizeOptionalString(existingBinding?.metadata?.boundBy) ?? "";
-		if (existingBinding && boundBy && boundBy !== "system" && senderId && senderId !== boundBy) return {
-			ok: false,
-			error: `Only ${boundBy} can rebind this ${resolveAcpBindingLabelNoun({
-				placement,
-				threadId: currentThreadId || void 0,
-				conversationId: currentConversationId
-			})}.`
-		};
-	}
-	const label = params.label || params.agentId;
-	return bindSpawnedAcpSession({
-		bindingService,
-		sessionKey: params.sessionKey,
-		conversationRef,
-		placement,
-		cfg: commandParams.cfg,
-		channel: spawnPolicy.channel,
-		accountId: spawnPolicy.accountId,
-		agentId: params.agentId,
-		label,
-		senderId,
-		sessionMeta: params.sessionMeta,
-		bindError: `Failed to bind a ${channel} thread/conversation to the new ACP session.`
-	});
-}
-async function cleanupFailedSpawn(params) {
-	await cleanupFailedAcpSpawn({
-		cfg: params.cfg,
-		sessionKey: params.sessionKey,
-		shouldDeleteSession: params.shouldDeleteSession,
-		deleteTranscript: false,
-		runtimeCloseHandle: params.initializedRuntime
-	});
-}
-async function persistSpawnedSessionLabel(params) {
-	const label = normalizeOptionalString(params.label);
-	if (!label) return;
-	const now = Date.now();
-	if (params.commandParams.sessionStore) {
-		const existing = params.commandParams.sessionStore[params.sessionKey];
-		if (existing) params.commandParams.sessionStore[params.sessionKey] = {
-			...existing,
-			label,
-			updatedAt: now
-		};
-	}
-	if (!params.commandParams.storePath) return;
-	await updateSessionStore(params.commandParams.storePath, (store) => {
-		const existing = store[params.sessionKey];
-		if (!existing) return;
-		store[params.sessionKey] = {
-			...existing,
-			label,
-			updatedAt: now
-		};
-	});
-}
-async function handleAcpSpawnAction(params, restTokens) {
-	if (!isAcpEnabledByPolicy(params.cfg)) return stopWithText("ACP is disabled by policy (`acp.enabled=false`).");
-	const parsed = parseSpawnInput(params, restTokens);
-	if (!parsed.ok) return stopWithText(`⚠️ ${parsed.error}`);
-	const spawn = parsed.value;
-	const runtimePolicyError = resolveAcpSpawnRuntimePolicyError({
-		cfg: params.cfg,
-		requesterSessionKey: params.sessionKey
-	});
-	if (runtimePolicyError) return stopWithText(`⚠️ ${runtimePolicyError}`);
-	const agentPolicyError = resolveAcpAgentPolicyError(params.cfg, spawn.agentId);
-	if (agentPolicyError) return stopWithText(collectAcpErrorText({
-		error: agentPolicyError,
-		fallbackCode: "ACP_SESSION_INIT_FAILED",
-		fallbackMessage: "ACP target agent is not allowed by policy."
-	}));
-	const acpManager = getAcpSessionManager();
-	const sessionKey = `agent:${spawn.agentId}:acp:${randomUUID()}`;
-	let initializedBackend = "";
-	let initializedMeta;
-	let initializedRuntime;
-	try {
-		const initialized = await acpManager.initializeSession({
-			cfg: params.cfg,
-			sessionKey,
-			agent: spawn.agentId,
-			mode: spawn.mode,
-			cwd: spawn.cwd
-		});
-		initializedRuntime = {
-			runtime: initialized.runtime,
-			handle: initialized.handle
-		};
-		initializedBackend = initialized.handle.backend || initialized.meta.backend;
-		initializedMeta = initialized.meta;
-	} catch (err) {
-		return stopWithText(collectAcpErrorText({
-			error: err,
-			fallbackCode: "ACP_SESSION_INIT_FAILED",
-			fallbackMessage: "Could not initialize ACP session runtime."
-		}));
-	}
-	let binding = null;
-	if (spawn.bind !== "off") {
-		const bound = await bindSpawnedAcpSessionToCurrentConversation({
-			commandParams: params,
-			sessionKey,
-			agentId: spawn.agentId,
-			label: spawn.label,
-			bindMode: spawn.bind,
-			sessionMeta: initializedMeta
-		});
-		if (!bound.ok) {
-			await cleanupFailedSpawn({
-				cfg: params.cfg,
-				sessionKey,
-				shouldDeleteSession: true,
-				initializedRuntime
-			});
-			return stopWithText(`⚠️ ${bound.error}`);
-		}
-		binding = bound.binding;
-	} else if (spawn.thread !== "off") {
-		const bound = await bindSpawnedAcpSessionToThread({
-			commandParams: params,
-			sessionKey,
-			agentId: spawn.agentId,
-			label: spawn.label,
-			threadMode: spawn.thread,
-			sessionMeta: initializedMeta
-		});
-		if (!bound.ok) {
-			await cleanupFailedSpawn({
-				cfg: params.cfg,
-				sessionKey,
-				shouldDeleteSession: true,
-				initializedRuntime
-			});
-			return stopWithText(`⚠️ ${bound.error}`);
-		}
-		binding = bound.binding;
-	}
-	try {
-		await persistSpawnedSessionLabel({
-			commandParams: params,
-			sessionKey,
-			label: spawn.label
-		});
-	} catch (err) {
-		await cleanupFailedSpawn({
-			cfg: params.cfg,
-			sessionKey,
-			shouldDeleteSession: true,
-			initializedRuntime
-		});
-		return stopWithText(`⚠️ ACP spawn failed: ${formatErrorMessage(err)}`);
-	}
-	const parts = [`✅ Spawned ACP session ${sessionKey} (${spawn.mode}, backend ${initializedBackend}).`];
-	if (binding) {
-		const currentConversationId = normalizeOptionalString(resolveAcpCommandConversationId(params)) ?? "";
-		const boundConversationId = binding.conversation.conversationId.trim();
-		const bindingPlacement = currentConversationId && boundConversationId === currentConversationId ? "current" : "child";
-		const placementLabel = resolveAcpBindingLabelNoun({
-			conversationId: currentConversationId,
-			placement: bindingPlacement,
-			threadId: resolveAcpCommandThreadId(params)
-		});
-		if (bindingPlacement === "current") parts.push(`Bound this ${placementLabel} to ${sessionKey}.`);
-		else parts.push(`Created ${placementLabel} ${boundConversationId} and bound it to ${sessionKey}.`);
-		const boundReplyPayload = await resolveBoundReplyPayload({
-			binding,
-			placement: bindingPlacement
-		});
-		if (boundReplyPayload) return {
-			shouldContinue: false,
-			reply: {
-				text: parts.join(" "),
-				...boundReplyPayload
-			}
-		};
-	} else parts.push("Session is unbound (use /acp spawn ... --bind here to bind this conversation, or /focus <session-key> where supported).");
-	const dispatchNote = resolveAcpDispatchPolicyMessage(params.cfg);
-	if (dispatchNote) parts.push(`ℹ️ ${dispatchNote}`);
-	return stopWithText(parts.join(" "));
-}
-function resolveAcpSessionForCommandOrStop(params) {
-	const error = resolveAcpSessionResolutionError(params.acpManager.resolveSession({
-		cfg: params.cfg,
-		sessionKey: params.sessionKey
-	}));
-	if (error) return stopWithText(collectAcpErrorText({
-		error,
-		fallbackCode: "ACP_SESSION_INIT_FAILED",
-		fallbackMessage: error.message
-	}));
-	return null;
-}
-async function resolveAcpTokenTargetSessionKeyOrStop(params) {
-	const token = normalizeOptionalString(params.restTokens.join(" "));
-	const target = await resolveAcpTargetSessionKey({
-		commandParams: params.commandParams,
-		token
-	});
-	if (!target.ok) return stopWithText(`⚠️ ${target.error}`);
-	return target.sessionKey;
-}
-async function withResolvedAcpSessionTarget(params) {
-	const acpManager = getAcpSessionManager();
-	const targetSessionKey = await resolveAcpTokenTargetSessionKeyOrStop({
-		commandParams: params.commandParams,
-		restTokens: params.restTokens
-	});
-	if (typeof targetSessionKey !== "string") return targetSessionKey;
-	const guardFailure = resolveAcpSessionForCommandOrStop({
-		acpManager,
-		cfg: params.commandParams.cfg,
-		sessionKey: targetSessionKey
-	});
-	if (guardFailure) return guardFailure;
-	return await params.run({
-		acpManager,
-		sessionKey: targetSessionKey
-	});
-}
-async function handleAcpCancelAction(params, restTokens) {
-	return await withResolvedAcpSessionTarget({
-		commandParams: params,
-		restTokens,
-		run: async ({ acpManager, sessionKey }) => await withAcpCommandErrorBoundary({
-			run: async () => await acpManager.cancelSession({
-				cfg: params.cfg,
-				sessionKey,
-				reason: "manual-cancel"
-			}),
-			fallbackCode: "ACP_TURN_FAILED",
-			fallbackMessage: "ACP cancel failed before completion.",
-			onSuccess: () => stopWithText(`✅ Cancel requested for ACP session ${sessionKey}.`)
-		})
-	});
-}
-async function runAcpSteer(params) {
-	const acpManager = getAcpSessionManager();
-	let output = "";
-	await acpManager.runTurn({
-		cfg: params.cfg,
-		sessionKey: params.sessionKey,
-		text: params.instruction,
-		mode: "steer",
-		requestId: params.requestId,
-		onEvent: (event) => {
-			if (event.type !== "text_delta") return;
-			if (event.stream && event.stream !== "output") return;
-			if (event.text) {
-				output += event.text;
-				if (output.length > 800) output = `${output.slice(0, 800)}…`;
-			}
-		}
-	});
-	return output.trim();
-}
-async function handleAcpSteerAction(params, restTokens) {
-	const dispatchPolicyError = resolveAcpDispatchPolicyError(params.cfg);
-	if (dispatchPolicyError) return stopWithText(collectAcpErrorText({
-		error: dispatchPolicyError,
-		fallbackCode: "ACP_DISPATCH_DISABLED",
-		fallbackMessage: dispatchPolicyError.message
-	}));
-	const parsed = parseSteerInput(restTokens);
-	if (!parsed.ok) return stopWithText(`⚠️ ${parsed.error}`);
-	const acpManager = getAcpSessionManager();
-	const target = await resolveAcpTargetSessionKey({
-		commandParams: params,
-		token: parsed.value.sessionToken
-	});
-	if (!target.ok) return stopWithText(`⚠️ ${target.error}`);
-	const guardFailure = resolveAcpSessionForCommandOrStop({
-		acpManager,
-		cfg: params.cfg,
-		sessionKey: target.sessionKey
-	});
-	if (guardFailure) return guardFailure;
-	return await withAcpCommandErrorBoundary({
-		run: async () => await runAcpSteer({
-			cfg: params.cfg,
-			sessionKey: target.sessionKey,
-			instruction: parsed.value.instruction,
-			requestId: `${resolveCommandRequestId(params)}:steer`
-		}),
-		fallbackCode: "ACP_TURN_FAILED",
-		fallbackMessage: "ACP steer failed before completion.",
-		onSuccess: (steerOutput) => {
-			if (!steerOutput) return stopWithText(`✅ ACP steer sent to ${target.sessionKey}.`);
-			return stopWithText(`✅ ACP steer sent to ${target.sessionKey}.\n${steerOutput}`);
-		}
-	});
-}
-async function handleAcpCloseAction(params, restTokens) {
-	return await withResolvedAcpSessionTarget({
-		commandParams: params,
-		restTokens,
-		run: async ({ acpManager, sessionKey }) => {
-			let runtimeNotice = "";
-			try {
-				const closed = await acpManager.closeSession({
-					cfg: params.cfg,
-					sessionKey,
-					reason: "manual-close",
-					allowBackendUnavailable: true,
-					clearMeta: true
-				});
-				runtimeNotice = closed.runtimeNotice ? ` (${closed.runtimeNotice})` : "";
-			} catch (error) {
-				return stopWithText(collectAcpErrorText({
-					error,
-					fallbackCode: "ACP_TURN_FAILED",
-					fallbackMessage: "ACP close failed before completion."
-				}));
-			}
-			const removedBindings = await getSessionBindingService().unbind({
-				targetSessionKey: sessionKey,
-				reason: "manual"
-			});
-			return stopWithText(`✅ Closed ACP session ${sessionKey}${runtimeNotice}. Removed ${removedBindings.length} binding${removedBindings.length === 1 ? "" : "s"}.`);
-		}
-	});
-}
-//#endregion
-export { handleAcpCancelAction, handleAcpCloseAction, handleAcpSpawnAction, handleAcpSteerAction };