openmeld 0.3.243 → 0.3.246

package/dist/{prepare-provider-runtime-CDs1nV-P.js → prepare-provider-runtime-_XRIioDp.js}

@@ -1,24 +1,24 @@
 #!/usr/bin/env node
 
 import { F as resolveOpenMeldRootDir, P as resolveOpenMeldEnvPreset, a as accountProfileWorkspacePath, b as normalizeOpenMeldProfileId, c as deviceOpenClawProfileBootstrapPath, h as isPublishedOpenMeldHome, l as deviceOpenClawProfileDir, n as accountProfileLocalMetaPath, u as deviceOpenClawProfileWorkspaceDir } from "./paths-De9xdA2h.js";
-import { Mi as modelCatalogSchema, Rt as createAgentProfileBindingApi, en as createLocalRuntimeExpectedRoutesApi, t as OpenMeldApiClientHttpError } from "./dist-D2adiC2P.js";
-import { G as isOriginalErrorSafeForMessageDetails, J as openMeldDaemonProviderAccessEvidenceSchema, Lr as agentInteractionResolutionSchema, W as OPENMELD_ORIGINAL_ERROR_MAX_LENGTH, Wi as resolveCommandAgentWorkActivity, X as openMeldDaemonTaskResultOpenClawGatewayVisibilityStatusSchema, Y as openMeldDaemonTaskResultEnvelopeWriteSchema, gr as normalizeMessageEnvelope, pr as formatCanonicalMentionLiteral, t as CURRENT_DAEMON_EXECUTION_CONTRACT_EPOCH, tt as aiUsageObservationSchema } from "./runtime-transport-BPK70mkB.js";
-import { C as conversationExecutionStateSchema, D as normalizeOptionalWorkingDirectory, P as profileWorkspaceModeSchema, T as MAX_PROFILE_WORKING_DIRECTORY_LENGTH, o as openMeldDaemonControlPlaneRequestSchema, s as openMeldDaemonControlPlaneResponseSchema, x as providerDispatchRuntimeContextSchema } from "./control-plane-QqGL-jtT.js";
+import { G as isOriginalErrorSafeForMessageDetails, Gn as agentInteractionResolutionSchema, J as openMeldDaemonProviderAccessEvidenceSchema, W as OPENMELD_ORIGINAL_ERROR_MAX_LENGTH, X as openMeldDaemonTaskResultOpenClawGatewayVisibilityStatusSchema, Xr as resolveCommandAgentWorkActivity, Y as openMeldDaemonTaskResultEnvelopeWriteSchema, t as CURRENT_DAEMON_EXECUTION_CONTRACT_EPOCH, tt as aiUsageObservationSchema, wn as normalizeMessageEnvelope, xn as formatCanonicalMentionLiteral } from "./runtime-transport-BzCp9hM3.js";
+import { C as conversationExecutionStateSchema, D as normalizeOptionalWorkingDirectory, P as profileWorkspaceModeSchema, T as MAX_PROFILE_WORKING_DIRECTORY_LENGTH, o as openMeldDaemonControlPlaneRequestSchema, s as openMeldDaemonControlPlaneResponseSchema, x as providerDispatchRuntimeContextSchema } from "./control-plane-B93wmVS6.js";
+import { Ii as modelCatalogSchema, Rt as createAgentProfileBindingApi, en as createLocalRuntimeExpectedRoutesApi, t as OpenMeldApiClientHttpError } from "./dist-KibLweLD.js";
 import { _ as canonicalizeAgentControllerRef, b as normalizeKnownBuiltinAgentControllerId, d as resolveBuiltinAgentControllerConversationKind, f as HOSTED_CENTER_AGENT_CONTROLLER_REF, g as buildAgentControllerRoutingKey, l as buildAgentControllerConversationRef, m as HOSTED_REMOTE_AGENT_CONTROLLER_REF, p as HOSTED_CENTER_AGENT_CONTROLLER_REF_ID, s as runtimeTransportModeSchema, v as canonicalizeBuiltinAgentControllerRef, x as parseAgentControllerRef$1 } from "./controller-contract-DAOCaefz.js";
-import { J as OPENCLAW_CLI_TIMEOUT_MS$1, d as getAuthSessionState } from "./auth-session-Injt39gv.js";
+import { J as OPENCLAW_CLI_TIMEOUT_MS$1, d as getAuthSessionState } from "./auth-session-JhILeJRO.js";
 import { r as daemonServiceLaneSchema } from "./service-contract-CRyDcIIf.js";
-import { H as agentExecutionSteerRequestSchema, V as daemonRouteCatalogCacheSchema, _ as toErrorMessage$20, d as normalizeText$11, g as parseTransportMode$1, h as parseStreamingMode$1, m as parseRuntimeTransportMode, p as parseContextIdMappingSpec, s as emitRunLine, u as normalizeOptionalText$51, z as DAEMON_ROUTE_CATALOG_CACHE_SCHEMA_NAME } from "./daemon-device-id-Bo1QzbXB.js";
+import { H as agentExecutionSteerRequestSchema, V as daemonRouteCatalogCacheSchema, _ as toErrorMessage$20, d as normalizeText$11, g as parseTransportMode$1, h as parseStreamingMode$1, m as parseRuntimeTransportMode, p as parseContextIdMappingSpec, s as emitRunLine, u as normalizeOptionalText$49, z as DAEMON_ROUTE_CATALOG_CACHE_SCHEMA_NAME } from "./daemon-device-id-C3gKch4E.js";
 import { n as agentControllerPermissionModeSchema, r as agentControllerCollaborationModeSchema } from "./open-code-permission-DHFJYc_o.js";
 import { c as readWindowsProcessStartFileTime, d as resolveWindowsNativeProcessHelper, f as windowsNativeProcessRequestSchema, l as resolveWindowsPowerShellPath, o as powerShellEncodedArguments, r as isProcessIdentityAlive, t as CURRENT_PROCESS_START_IDENTITY, u as WINDOWS_NATIVE_PROCESS_REQUEST_ENV } from "./process-identity-BRbhGGTM.js";
 import { a as isOpenMeldOrphanedLockError, d as runWithHeldLock, i as isOpenMeldLockError, t as acquireLock } from "./lock-BMI00i2F.js";
 import { C as updateConfiguredDeviceRuntimeState, T as updateConfiguredSkillsConfig, a as resolveBaseUrl, d as createDefaultRuntimeAgentControllerSettings, g as getConfiguredSkillsConfig, p as getConfiguredDeviceRuntimeState, v as getRuntimeConfigReadHealth, y as resolveRuntimeSkillsCustomTargetId } from "./base-url-0AoeTi3w.js";
 import { n as normalizeCommandEnvironment } from "./process-environment-BWSFeUu6.js";
-import { F as resolveCurrentOpenMeldAccountContext, _ as touchDaemonCatalogSyncSignal, d as listOpenMeldProfiles } from "./context--QS-5kJ8.js";
+import { F as resolveCurrentOpenMeldAccountContext, _ as touchDaemonCatalogSyncSignal, d as listOpenMeldProfiles } from "./context-M7dvalCp.js";
 import { n as writeDaemonLocalStateFile, t as readDaemonLocalStateFile } from "./daemon-local-state-file-jOXuXrky.js";
 import { m as daemonRuntimeDataPath } from "./daemon-state-Dte9re5V.js";
-import { d as buildOpenMeldRequestContextFromProfile, t as createCliApiClientFoundation } from "./api-client-foundation-CytD8TbL.js";
+import { d as buildOpenMeldRequestContextFromProfile, t as createCliApiClientFoundation } from "./api-client-foundation-CYbEdm9o.js";
 import { i as readDaemonServiceContract } from "./daemon-service-contract-COPKbCy_.js";
-import { C as requestLocalSyncRouteCatalog } from "./daemon-lifecycle-journal-DFZyoyx9.js";
+import { C as requestLocalSyncRouteCatalog } from "./daemon-lifecycle-journal-CGUuJshv.js";
 import { i as resolveWindowsCommandPath, n as quoteWindowsProcessArgument, r as resolvePlatformCommand, t as execPlatformFile } from "./process-launch-B0pHlkV_.js";
 import { createRequire } from "node:module";
 import { createHash, randomUUID } from "node:crypto";
@@ -34,6 +34,7 @@ import { setTimeout as setTimeout$1 } from "node:timers/promises";
 import { connect, createServer } from "node:net";
 import { createSdkMcpServer, query, tool } from "@anthropic-ai/claude-agent-sdk";
 import { createOpencodeClient } from "@opencode-ai/sdk/v2";
+import { OpenCode } from "@opencode/client";
 //#region \0rolldown/runtime.js
 var __create = Object.create;
 var __defProp = Object.defineProperty;
@@ -3908,7 +3909,7 @@ function resolveConversationPolicyFromModelSelection(input) {
 		status: "accepted",
 		conversationPolicy: {}
 	};
-	if (parsedRef.kind === "builtin" && parsedRef.id === "codex" && normalizeOptionalText$50(input.agentControllerConversationId)) return {
+	if (parsedRef.kind === "builtin" && parsedRef.id === "codex" && normalizeOptionalText$48(input.agentControllerConversationId)) return {
 		status: "accepted",
 		conversationPolicy: {}
 	};
@@ -3920,7 +3921,7 @@ function resolveConversationPolicyFromModelSelection(input) {
 		}
 	};
 }
-function normalizeOptionalText$50(value) {
+function normalizeOptionalText$48(value) {
 	const normalized = String(value ?? "").trim();
 	return normalized.length > 0 ? normalized : null;
 }
@@ -4915,8 +4916,8 @@ const MACOS_TEMP_FOLDER_RE = /^\/var\/folders\/[^/]+\/[^/]+\/t(?:\/|$)/u;
 const WRAPPER_PATH_SEGMENT_RE = /(?:^|[-_.])(?:shim|shims|wrapper|wrappers)(?:$|[-_.])/u;
 const MAX_LAUNCH_SCRIPT_INSPECTION_BYTES = 64 * 1024;
 const DEFAULT_LOGIN_SHELL_LOOKUP_TIMEOUT_MS = 1500;
-const HOME_DIR = normalizeOptionalText$49(homedir());
-const TEMP_DIR = normalizeOptionalText$49(tmpdir());
+const HOME_DIR = normalizeOptionalText$47(homedir());
+const TEMP_DIR = normalizeOptionalText$47(tmpdir());
 const loginShellExecutablePathsCache = /* @__PURE__ */ new Map();
 function buildExecutableLaunchContract(input) {
 	return {
@@ -5123,7 +5124,7 @@ function resolveInstalledCommandPath(input) {
 	return resolveInstalledCommandPaths(input)[0] ?? null;
 }
 function resolveInstalledCommandPaths(input) {
-	const configuredCommand = normalizeOptionalText$49(input.configuredCommand);
+	const configuredCommand = normalizeOptionalText$47(input.configuredCommand);
 	if (configuredCommand) {
 		if (isAbsolute(configuredCommand)) return [configuredCommand];
 		if (configuredCommand.includes("/") || configuredCommand.includes("\\")) return [];
@@ -5132,9 +5133,9 @@ function resolveInstalledCommandPaths(input) {
 	return resolveExecutablePathsOnPath(input.commandName);
 }
 async function resolveInstalledCommandPathsForLaunch(input) {
-	const preferredCommandPath = normalizeOptionalText$49(input.preferredCommandPath);
+	const preferredCommandPath = normalizeOptionalText$47(input.preferredCommandPath);
 	const preferredCommandPaths = preferredCommandPath && isAbsolute(preferredCommandPath) ? [preferredCommandPath] : [];
-	const configuredCommand = normalizeOptionalText$49(input.configuredCommand);
+	const configuredCommand = normalizeOptionalText$47(input.configuredCommand);
 	if (configuredCommand) {
 		if (isAbsolute(configuredCommand)) return mergeUniquePaths(preferredCommandPaths, [configuredCommand]);
 		if (configuredCommand.includes("/") || configuredCommand.includes("\\")) return preferredCommandPaths;
@@ -5152,7 +5153,7 @@ function resolveExecutableOnPath(commandName) {
 	return resolveExecutablePathsOnPath(commandName)[0] ?? null;
 }
 function resolveExecutablePathsOnPath(commandName) {
-	const normalizedCommandName = normalizeOptionalText$49(commandName);
+	const normalizedCommandName = normalizeOptionalText$47(commandName);
 	if (!normalizedCommandName) return [];
 	const resolvedPaths = [];
 	for (const directory of resolvePathDirectories()) for (const candidateName of resolveCommandFileNameCandidates(normalizedCommandName)) {
@@ -5174,7 +5175,7 @@ async function resolveExecutablePathsFromSearchSurface(input) {
 }
 function resolvePathDirectories() {
 	const directories = [];
-	const pathValue = normalizeOptionalText$49(process.env.PATH);
+	const pathValue = normalizeOptionalText$47(process.env.PATH);
 	for (const pathEntry of pathValue?.split(delimiter) ?? []) addUniqueDirectory(directories, pathEntry);
 	return directories;
 }
@@ -5185,7 +5186,7 @@ function resolveExecutablePathsFromKnownInstallDirectories(commandName) {
 	});
 }
 function resolveExecutablePathsFromDirectories(input) {
-	const normalizedCommandName = normalizeOptionalText$49(input.commandName);
+	const normalizedCommandName = normalizeOptionalText$47(input.commandName);
 	if (!normalizedCommandName) return [];
 	const resolvedPaths = [];
 	for (const directory of input.directories) for (const candidateName of resolveCommandFileNameCandidates(normalizedCommandName)) {
@@ -5198,12 +5199,12 @@ function resolveKnownInstallDirectories() {
 	const directories = [];
 	if (process.platform === "win32") return directories;
 	const home = resolveHomeDirectory();
-	const nvmDir = normalizeOptionalText$49(process.env.NVM_DIR) ?? join(home, ".nvm");
-	const pnpmHome = normalizeOptionalText$49(process.env.PNPM_HOME) ?? (process.platform === "darwin" ? join(home, "Library", "pnpm") : join(home, ".local", "share", "pnpm"));
-	const bunHome = normalizeOptionalText$49(process.env.BUN_INSTALL) ?? join(home, ".bun");
-	const voltaHome = normalizeOptionalText$49(process.env.VOLTA_HOME) ?? join(home, ".volta");
-	const asdfHome = normalizeOptionalText$49(process.env.ASDF_DIR) ?? join(home, ".asdf");
-	const fnmHome = normalizeOptionalText$49(process.env.FNM_DIR) ?? join(home, ".fnm");
+	const nvmDir = normalizeOptionalText$47(process.env.NVM_DIR) ?? join(home, ".nvm");
+	const pnpmHome = normalizeOptionalText$47(process.env.PNPM_HOME) ?? (process.platform === "darwin" ? join(home, "Library", "pnpm") : join(home, ".local", "share", "pnpm"));
+	const bunHome = normalizeOptionalText$47(process.env.BUN_INSTALL) ?? join(home, ".bun");
+	const voltaHome = normalizeOptionalText$47(process.env.VOLTA_HOME) ?? join(home, ".volta");
+	const asdfHome = normalizeOptionalText$47(process.env.ASDF_DIR) ?? join(home, ".asdf");
+	const fnmHome = normalizeOptionalText$47(process.env.FNM_DIR) ?? join(home, ".fnm");
 	addUniqueDirectory(directories, join(home, ".local", "bin"));
 	addUniqueDirectory(directories, "/usr/local/bin");
 	addUniqueDirectory(directories, "/opt/homebrew/bin");
@@ -5218,18 +5219,18 @@ function resolveKnownInstallDirectories() {
 	addUniqueDirectory(directories, join(home, ".local", "share", "fnm", "aliases", "default", "bin"));
 	addUniqueDirectory(directories, join(home, ".local", "share", "fnm", "current", "bin"));
 	for (const nvmBinDir of resolveNvmDefaultBinDirectories(nvmDir)) addUniqueDirectory(directories, nvmBinDir);
-	const npmConfigPrefix = normalizeOptionalText$49(process.env.NPM_CONFIG_PREFIX);
+	const npmConfigPrefix = normalizeOptionalText$47(process.env.NPM_CONFIG_PREFIX);
 	if (npmConfigPrefix) addUniqueDirectory(directories, join(npmConfigPrefix, "bin"));
 	return directories;
 }
 function addUniqueDirectory(directories, value) {
-	const directory = normalizeOptionalText$49(value);
+	const directory = normalizeOptionalText$47(value);
 	if (directory && !directories.includes(directory)) directories.push(directory);
 }
 async function resolveExecutablePathsFromLoginShell(commandName) {
-	const normalizedCommandName = normalizeOptionalText$49(commandName);
+	const normalizedCommandName = normalizeOptionalText$47(commandName);
 	if (!(normalizedCommandName && process.platform !== "win32")) return [];
-	const shell = normalizeOptionalText$49(process.env.SHELL);
+	const shell = normalizeOptionalText$47(process.env.SHELL);
 	if (!(shell && isAbsolute(shell) && pathLooksExecutable(shell))) return [];
 	const cacheKey = [
 		shell,
@@ -5282,7 +5283,7 @@ async function runLoginShellExecutableLookup(input) {
 				finish([]);
 				return;
 			}
-			finish(stdout.split(LOGIN_SHELL_OUTPUT_LINE_SPLIT_RE).map((line) => normalizeOptionalText$49(line)).filter((line) => Boolean(line && isAbsolute(line) && pathLooksExecutable(line))));
+			finish(stdout.split(LOGIN_SHELL_OUTPUT_LINE_SPLIT_RE).map((line) => normalizeOptionalText$47(line)).filter((line) => Boolean(line && isAbsolute(line) && pathLooksExecutable(line))));
 		});
 	});
 }
@@ -5295,7 +5296,7 @@ function resolveNvmDefaultVersion(nvmDir) {
 	let value = readNvmAlias(nvmDir, "default");
 	const seenAliases = /* @__PURE__ */ new Set();
 	for (let depth = 0; depth < 4; depth += 1) {
-		const normalizedValue = normalizeOptionalText$49(value);
+		const normalizedValue = normalizeOptionalText$47(value);
 		if (!normalizedValue) return null;
 		if (isNvmVersionValue(normalizedValue)) return normalizedValue.startsWith("v") ? normalizedValue : `v${normalizedValue}`;
 		if (seenAliases.has(normalizedValue)) return null;
@@ -5306,7 +5307,7 @@ function resolveNvmDefaultVersion(nvmDir) {
 }
 function readNvmAlias(nvmDir, alias) {
 	try {
-		return normalizeOptionalText$49(readFileSync(join(nvmDir, "alias", alias), "utf8"));
+		return normalizeOptionalText$47(readFileSync(join(nvmDir, "alias", alias), "utf8"));
 	} catch {
 		return null;
 	}
@@ -5315,10 +5316,10 @@ function isNvmVersionValue(value) {
 	return NVM_VERSION_VALUE_RE.test(value);
 }
 function resolveHomeDirectory() {
-	return normalizeOptionalText$49(process.env.HOME) ?? homedir();
+	return normalizeOptionalText$47(process.env.HOME) ?? homedir();
 }
 function resolveLoginShellLookupTimeoutMs() {
-	const raw = normalizeOptionalText$49(process.env.OPENMELD_EXECUTABLE_LOGIN_SHELL_TIMEOUT_MS);
+	const raw = normalizeOptionalText$47(process.env.OPENMELD_EXECUTABLE_LOGIN_SHELL_TIMEOUT_MS);
 	if (!raw) return DEFAULT_LOGIN_SHELL_LOOKUP_TIMEOUT_MS;
 	const parsed = Number.parseInt(raw, 10);
 	return Number.isFinite(parsed) && parsed > 0 ? parsed : DEFAULT_LOGIN_SHELL_LOOKUP_TIMEOUT_MS;
@@ -5333,7 +5334,7 @@ function quotePosixShellToken$1(value) {
 	return `'${value.replaceAll("'", "'\\''")}'`;
 }
 function resolveSiblingCommandPath(input) {
-	const normalizedCommandName = normalizeOptionalText$49(input.commandName);
+	const normalizedCommandName = normalizeOptionalText$47(input.commandName);
 	if (!normalizedCommandName) return null;
 	const siblingDirectory = dirname(input.anchorPath);
 	for (const candidateName of resolveCommandFileNameCandidates(normalizedCommandName)) {
@@ -5343,7 +5344,7 @@ function resolveSiblingCommandPath(input) {
 	return null;
 }
 async function resolvePinnedNodePath(input) {
-	const firstLine = normalizeOptionalText$49(input.firstLine);
+	const firstLine = normalizeOptionalText$47(input.firstLine);
 	if (!firstLine) return null;
 	if (firstLine === ENV_NODE_SHEBANG) {
 		const nodeSiblings = [join(dirname(input.commandPath), "node"), join(dirname(input.scriptPath), "node")].filter((candidate, index, candidates) => {
@@ -5353,7 +5354,7 @@ async function resolvePinnedNodePath(input) {
 		return null;
 	}
 	if (!firstLine.startsWith("#!")) return null;
-	const interpreter = normalizeOptionalText$49(firstLine.slice(2));
+	const interpreter = normalizeOptionalText$47(firstLine.slice(2));
 	if (!(interpreter && isAbsolute(interpreter))) return null;
 	const normalizedInterpreter = interpreter.split(SHEBANG_ARGS_SPLIT_RE, 1)[0] ?? interpreter;
 	try {
@@ -5401,11 +5402,11 @@ function resolveRunnablePathAccessMode() {
 	return process.platform === "win32" ? constants.F_OK : constants.X_OK;
 }
 function resolveWindowsPathExtensions(value) {
-	const normalized = normalizeOptionalText$49(value);
+	const normalized = normalizeOptionalText$47(value);
 	if (!normalized) return [...WINDOWS_PATHEXT];
 	return normalized.split(";").map((entry) => entry.trim().toLowerCase()).filter((entry, index, values) => entry && values.indexOf(entry) === index).map((entry) => entry.startsWith(".") ? entry : `.${entry}`);
 }
-function normalizeOptionalText$49(value) {
+function normalizeOptionalText$47(value) {
 	const normalized = String(value ?? "").trim();
 	return normalized.length > 0 ? normalized : null;
 }
@@ -5499,7 +5500,7 @@ function shortenPathForDisplay(path) {
 	return `~${path.slice(HOME_DIR.length)}`;
 }
 function resolveNodeVersionFromPath(path) {
-	return normalizeOptionalText$49(path.match(NODE_VERSION_PATH_RE)?.[1]);
+	return normalizeOptionalText$47(path.match(NODE_VERSION_PATH_RE)?.[1]);
 }
 async function readLaunchScriptInspection(path) {
 	const file = await open(path, "r");
@@ -5514,7 +5515,7 @@ async function readLaunchScriptInspection(path) {
 	const firstLine = contents.split(FIRST_LINE_SPLIT_RE, 1)[0] ?? "";
 	return {
 		contents,
-		firstLine: normalizeOptionalText$49(firstLine)
+		firstLine: normalizeOptionalText$47(firstLine)
 	};
 }
 function isTransientPathWrapper(input) {
@@ -5531,7 +5532,7 @@ function hasWrapperPathSegment(path) {
 	return normalizePathForDetection(path).split("/").filter((segment) => segment.length > 0).slice(-4).some((segment) => WRAPPER_PATH_SEGMENT_RE.test(segment));
 }
 function shellScriptLooksLikeWrapper(input) {
-	const firstLine = normalizeOptionalText$49(input.firstLine)?.toLowerCase() ?? "";
+	const firstLine = normalizeOptionalText$47(input.firstLine)?.toLowerCase() ?? "";
 	if (!(firstLine.includes("bash") || firstLine.includes("/sh") || firstLine.includes("zsh"))) return false;
 	const contents = input.contents.toLowerCase();
 	return contents.includes("wrapper_shim") || contents.includes("shim_root") || contents.includes("\nexec ") && (contents.includes("wrapper") || contents.includes("shim"));
@@ -5900,7 +5901,7 @@ var AcpProcessSession = class {
 		let code = "protocol.request_failed";
 		if (error.code === -32601) code = "protocol.method_not_found";
 		else if (error.code === -32602) code = "protocol.invalid_params";
-		const message = normalizeOptionalText$48(error.message) ?? "ACP request failed";
+		const message = normalizeOptionalText$46(error.message) ?? "ACP request failed";
 		return this.#error({
 			code,
 			errorType: "adapter",
@@ -5978,7 +5979,7 @@ var AcpProcessSession = class {
 		return this.#createError(input);
 	}
 };
-function normalizeOptionalText$48(value) {
+function normalizeOptionalText$46(value) {
 	const normalized = String(value ?? "").trim();
 	return normalized.length > 0 ? normalized : null;
 }
@@ -6170,18 +6171,18 @@ function extractAcpToolActivityObservation(value) {
 	if (message?.method !== "session/update") return null;
 	const params = toRecord$15(message.params);
 	const update = toRecord$15(params?.update);
-	const updateType = normalizeOptionalText$47(update?.sessionUpdate);
+	const updateType = normalizeOptionalText$45(update?.sessionUpdate);
 	if (!(update && (updateType === "tool_call" || updateType === "tool_call_update"))) return null;
-	const toolCallId = normalizeOptionalText$47(update.toolCallId ?? update.tool_call_id);
+	const toolCallId = normalizeOptionalText$45(update.toolCallId ?? update.tool_call_id);
 	if (!toolCallId) return null;
-	const sessionId = normalizeOptionalText$47(params?.sessionId);
+	const sessionId = normalizeOptionalText$45(params?.sessionId);
 	return {
 		...Object.hasOwn(update, "rawInput") ? { providerInput: update.rawInput } : {},
-		providerKind: normalizeOptionalText$47(update.kind),
+		providerKind: normalizeOptionalText$45(update.kind),
 		...Object.hasOwn(update, "locations") ? { providerLocations: update.locations } : {},
-		providerTitle: normalizeOptionalText$47(update.title ?? update.name),
+		providerTitle: normalizeOptionalText$45(update.title ?? update.name),
 		scopedToolCallId: sessionId ? `${sessionId}\0${toolCallId}` : toolCallId,
-		status: normalizeOptionalText$47(update.status)?.toLowerCase() ?? null,
+		status: normalizeOptionalText$45(update.status)?.toLowerCase() ?? null,
 		toolCallId
 	};
 }
@@ -6224,11 +6225,11 @@ function readFilePath(value) {
 		value.filePath,
 		value.path
 	]) {
-		const path = normalizeOptionalText$47(candidate);
+		const path = normalizeOptionalText$45(candidate);
 		if (path) return path;
 	}
 	if (Array.isArray(value.changes)) for (const change of value.changes) {
-		const path = normalizeOptionalText$47(toRecord$15(change)?.path);
+		const path = normalizeOptionalText$45(toRecord$15(change)?.path);
 		if (path) return path;
 	}
 	return null;
@@ -6236,7 +6237,7 @@ function readFilePath(value) {
 function readLocationPath(value) {
 	if (!Array.isArray(value)) return null;
 	for (const location of value) {
-		const path = normalizeOptionalText$47(toRecord$15(location)?.path);
+		const path = normalizeOptionalText$45(toRecord$15(location)?.path);
 		if (path) return path;
 	}
 	return null;
@@ -6257,7 +6258,7 @@ function resolveToolActivityState$1(current, status) {
 	if (status === "completed") return "output-available";
 	return "input-available";
 }
-function normalizeOptionalText$47(value) {
+function normalizeOptionalText$45(value) {
 	const normalized = typeof value === "string" ? value.trim() : "";
 	return normalized.length > 0 ? normalized : null;
 }
@@ -6352,10 +6353,10 @@ const OPENMELD_CLI_COMMANDS = /* @__PURE__ */ new Set([
 	"openmeld-canary"
 ]);
 function resolveDispatchSpaceActionMcpServer(env) {
-	if (!normalizeOptionalText$46(env?.[SPACE_ACTION_CONTEXT_PATH_ENV])) return null;
-	const command = normalizeOptionalText$46(env?.[USER_FACING_CLI_COMMAND_ENV]);
+	if (!normalizeOptionalText$44(env?.[SPACE_ACTION_CONTEXT_PATH_ENV])) return null;
+	const command = normalizeOptionalText$44(env?.[USER_FACING_CLI_COMMAND_ENV]);
 	if (!(command && OPENMELD_CLI_COMMANDS.has(command))) throw new Error("OpenMeld cannot start the dispatch Space Action tool because the active CLI command is invalid.");
-	const commandPath = normalizeOptionalText$46(env?.[SPACE_ACTION_TOOL_COMMAND_PATH_ENV]);
+	const commandPath = normalizeOptionalText$44(env?.[SPACE_ACTION_TOOL_COMMAND_PATH_ENV]);
 	if (!(commandPath && isAbsolute(commandPath) && (basename(commandPath) === command || basename(commandPath) === `${command}.exe`))) throw new Error("OpenMeld cannot start the dispatch Space Action tool because its dispatch-owned CLI path is invalid.");
 	return {
 		args: [
@@ -6366,7 +6367,7 @@ function resolveDispatchSpaceActionMcpServer(env) {
 		command,
 		commandPath,
 		env: Object.fromEntries(FORWARDED_ENV_NAMES.flatMap((name) => {
-			const value = normalizeOptionalText$46(env?.[name]);
+			const value = normalizeOptionalText$44(env?.[name]);
 			return value ? [[name, value]] : [];
 		})),
 		id: OPENMELD_SPACE_ACTION_MCP_SERVER_ID,
@@ -6397,7 +6398,7 @@ function buildAcpDispatchSpaceActionMcpServers(env) {
 		name: config.id
 	}];
 }
-function normalizeOptionalText$46(value) {
+function normalizeOptionalText$44(value) {
 	const normalized = String(value ?? "").trim();
 	return normalized.length > 0 ? normalized : null;
 }
@@ -6446,9 +6447,9 @@ const buildProviderExitError = (input) => {
 	};
 };
 const hasVisibleText = (value) => {
-	return normalizeOptionalText$45(value) !== null;
+	return normalizeOptionalText$43(value) !== null;
 };
-const normalizeOptionalText$45 = (value) => {
+const normalizeOptionalText$43 = (value) => {
 	if (typeof value !== "string") return null;
 	const normalized = value.trim();
 	return normalized.length > 0 ? normalized : null;
@@ -6645,13 +6646,13 @@ var AdapterRepairConversationError = class extends Error {
 };
 const resolveRequiredRepairConversationId = (input) => {
 	if (input.policy !== "require_canonical" || input.request.executionMode !== "repair") return null;
-	const canonicalConversationId = normalizeOptionalText$44(input.invokeRequest.agentControllerConversationId);
+	const canonicalConversationId = normalizeOptionalText$42(input.invokeRequest.agentControllerConversationId);
 	if (!canonicalConversationId) throw new AdapterRepairConversationMissingError();
 	return canonicalConversationId;
 };
 const requireCanonicalRepairConversation = (input) => {
 	if (!input.canonicalConversationId) return input.contextDelta;
-	const observedConversationId = normalizeOptionalText$44(input.contextDelta?.agentControllerConversationId);
+	const observedConversationId = normalizeOptionalText$42(input.contextDelta?.agentControllerConversationId);
 	if (input.contextDelta?.refreshed === true || observedConversationId !== input.canonicalConversationId) throw new AdapterRepairConversationError();
 	return input.contextDelta;
 };
@@ -7041,13 +7042,13 @@ const buildDefaultInvokeRequest = (input) => {
 		agentControllerConversationId: input.request.agentControllerConversationId,
 		bridgeSpec: input.bridgeSpec,
 		agentControllerConversation: input.request.agentControllerConversation
-	}) : normalizeOptionalText$44(input.request.agentControllerConversationId);
+	}) : normalizeOptionalText$42(input.request.agentControllerConversationId);
 	return {
 		...input.request,
 		agentControllerConversationId
 	};
 };
-const normalizeOptionalText$44 = (value) => {
+const normalizeOptionalText$42 = (value) => {
 	if (typeof value !== "string") return null;
 	const normalized = value.trim();
 	return normalized.length > 0 ? normalized : null;
@@ -8303,7 +8304,7 @@ const removeConversationExecutionState = (input) => {
 	return nextState;
 };
 const seedLegacyAgentContext = (input) => {
-	const normalizedLegacyAgentControllerConversationId = normalizeOptionalText$43(input.legacyAgentControllerConversationId);
+	const normalizedLegacyAgentControllerConversationId = normalizeOptionalText$41(input.legacyAgentControllerConversationId);
 	if (!normalizedLegacyAgentControllerConversationId) return input.state;
 	if (input.state.agentContextByLookupKey[input.agentContextLookupKey]) return input.state;
 	return upsertAgentContext({
@@ -8323,7 +8324,7 @@ const seedLegacyAgentContext = (input) => {
 	});
 };
 const commitResolvedAgentContext = (input) => {
-	const normalizedAgentControllerConversationId = normalizeOptionalText$43(input.agentControllerConversationId);
+	const normalizedAgentControllerConversationId = normalizeOptionalText$41(input.agentControllerConversationId);
 	if (!normalizedAgentControllerConversationId) return input.state;
 	const existing = input.state.agentContextByLookupKey[input.agentContextLookupKey] ?? null;
 	return upsertAgentContext({
@@ -8361,7 +8362,7 @@ const appendAgentContextRotationRecord = (input) => {
 	nextState.updatedAtMs = Date.now();
 	return nextState;
 };
-function normalizeOptionalText$43(value) {
+function normalizeOptionalText$41(value) {
 	if (typeof value !== "string") return null;
 	const normalized = value.trim();
 	return normalized.length > 0 ? normalized : null;
@@ -9273,10 +9274,383 @@ function emitStructuredReconcileEvidence(eventName, payload) {
 	});
 }
 //#endregion
+//#region ../../runtime/adapters/antigravity/dist/transport/antigravity-acp-interactions.js
+const CANCELLED = { outcome: { outcome: "cancelled" } };
+async function answerAntigravityAcpInteraction(request, callback, signal) {
+	if (!(callback && request.toolCall && Array.isArray(request.options))) return CANCELLED;
+	const options = request.options;
+	if (!options.length || options.length > 20 || options.some((option) => !option.optionId || option.optionId.length > 256) || new Set(options.map((option) => option.optionId)).size !== options.length) return CANCELLED;
+	if (signal?.aborted) return CANCELLED;
+	const stopped = Promise.withResolvers();
+	const onAbort = () => stopped.resolve(void 0);
+	signal?.addEventListener("abort", onAbort, { once: true });
+	let selected;
+	try {
+		selected = await Promise.race([request.toolCall.toolCallId.startsWith("interaction_") ? answerQuestion(request, callback) : answerPermission(request, callback), stopped.promise]);
+	} finally {
+		signal?.removeEventListener("abort", onAbort);
+	}
+	return selected && options.some((option) => option.optionId === selected) ? { outcome: {
+		outcome: "selected",
+		optionId: selected
+	} } : CANCELLED;
+}
+async function answerQuestion(request, callback) {
+	const response = await callback({
+		kind: "question",
+		title: "Antigravity needs your input",
+		questions: [{
+			questionId: "choice",
+			prompt: (request.toolCall.title || "Choose an option.").slice(0, 4e3),
+			allowOther: false,
+			multiple: false,
+			options: request.options.map((option) => ({
+				optionId: option.optionId,
+				label: option.name.slice(0, 240)
+			}))
+		}]
+	});
+	if (response.kind !== "question") return;
+	const values = response.answers.find((answer) => answer.questionId === "choice")?.values;
+	return values?.length === 1 ? values[0] : void 0;
+}
+async function answerPermission(request, callback) {
+	const choices = request.options.flatMap((option) => {
+		const intent = permissionIntent(option.kind);
+		return intent ? [{
+			optionId: option.optionId,
+			intent,
+			label: intent === "allow_session" ? "Allow for this conversation" : option.name.slice(0, 240)
+		}] : [];
+	});
+	if (!choices.length) return;
+	const response = await callback({
+		kind: "permission",
+		title: "Antigravity needs permission",
+		description: [request.toolCall.title, ...request.options.flatMap(securityWarning)].filter(Boolean).join("\n").slice(0, 4e3),
+		subject: { type: permissionSubject$1(request.toolCall.kind) },
+		options: choices
+	});
+	return response.kind === "permission" && choices.some((option) => option.optionId === response.optionId) ? response.optionId : void 0;
+}
+function permissionIntent(kind) {
+	switch (kind) {
+		case "allow_once": return "allow_once";
+		case "allow_always": return "allow_session";
+		case "reject_once":
+		case "reject_always": return "deny";
+		default: return null;
+	}
+}
+function permissionSubject$1(kind) {
+	if (kind === "execute") return "command";
+	return [
+		"edit",
+		"delete",
+		"move"
+	].includes(kind ?? "") ? "file_change" : "tool";
+}
+function securityWarning(option) {
+	const warning = option._meta?.["agy.security.warning"];
+	if (!warning || typeof warning !== "object" || Array.isArray(warning)) return [];
+	const record = warning;
+	const value = record.message ?? record.title;
+	return typeof value === "string" ? [value] : [];
+}
+//#endregion
+//#region ../../runtime/adapters/antigravity/dist/transport/antigravity-acp-transport.js
+function isAntigravityAcpLaunchContract(launch) {
+	const path = launch.kind === "node_script" ? launch.scriptPath : launch.commandPath;
+	return ["agy_acp_server.par", "agy_acp_server.exe"].includes(basename(path).toLowerCase());
+}
+function acpError(input) {
+	if (input.code === "protocol.invalid" && input.message.includes("Open the following link to authenticate")) return Object.assign(/* @__PURE__ */ new Error("Sign in to Antigravity ACP, then try again."), {
+		code: "auth.required",
+		errorType: "auth"
+	});
+	return Object.assign(new Error(input.message, { cause: input.cause }), {
+		code: input.code,
+		errorType: input.errorType
+	});
+}
+function acpEnvironment(launch, env) {
+	const harness = join(dirname(launch.kind === "node_script" ? launch.scriptPath : launch.commandPath), process.platform === "win32" ? "localharness_external.exe" : "localharness_external");
+	return {
+		...env,
+		...existsSync(harness) ? { ANTIGRAVITY_HARNESS_PATH: harness } : {},
+		BROWSER: process.platform === "win32" ? "cmd /c exit 1" : "/usr/bin/false",
+		PYTHONUNBUFFERED: "1"
+	};
+}
+const initializeParams = {
+	protocolVersion: 1,
+	clientInfo: {
+		name: "openmeld",
+		version: "1"
+	},
+	clientCapabilities: {
+		fs: {
+			readTextFile: false,
+			writeTextFile: false
+		},
+		terminal: false
+	}
+};
+function readInitialize(value) {
+	const result = value;
+	if (!result || result.protocolVersion !== 1 || !result.agentCapabilities) throw acpError({
+		code: "protocol.invalid",
+		errorType: "adapter",
+		message: "Antigravity did not negotiate ACP version 1."
+	});
+	return result;
+}
+async function admissionRequest(process, method, params) {
+	const authentication = method === "authenticate";
+	const timer = setTimeout(() => process.fail(acpError({
+		code: authentication ? "auth.required" : "protocol.timeout",
+		errorType: authentication ? "auth" : "timeout",
+		message: authentication ? "Sign in to Antigravity ACP, then try again." : "Antigravity did not finish starting its ACP session."
+	})), 15e3);
+	try {
+		return await process.request(method, params);
+	} finally {
+		clearTimeout(timer);
+	}
+}
+async function probeAntigravityAcp(input) {
+	const process = new AcpProcessSession({
+		args: [],
+		cwd: input.cwd,
+		env: acpEnvironment(input.launchContract),
+		launchContract: input.launchContract,
+		createError: acpError,
+		processLabel: "Antigravity",
+		timeoutMs: input.timeoutMs ?? 15e3
+	});
+	try {
+		process.start();
+		return readInitialize(await process.request("initialize", initializeParams));
+	} finally {
+		await process.close();
+	}
+}
+async function invokeAntigravityAcpTransport(input) {
+	const { request } = input;
+	if (isDispatchSpaceActionDeliveryOnly(request.env) || request.executionMode === "repair") throw acpError({
+		code: "delivery_scope.unsupported",
+		errorType: "config",
+		message: "Antigravity ACP does not expose an exclusive reply-repair tool scope."
+	});
+	const invokedAtMs = Date.now();
+	const interactions = new AbortController();
+	let sessionId = null;
+	let turnActive = false;
+	let output = "";
+	let firstOutputAtMs = null;
+	let previewEmitted = false;
+	let callbackFailure;
+	let callbacks = Promise.resolve();
+	const tracker = createAcpToolActivityTracker();
+	const process = new AcpProcessSession({
+		args: [],
+		cwd: request.runtimeContext.providerRuntimeWorkingDirectory,
+		env: acpEnvironment(input.launchContract, request.env),
+		launchContract: input.launchContract,
+		createError: acpError,
+		processLabel: "Antigravity",
+		timeoutMs: request.timeoutMs ?? null,
+		mapJsonRpcError: (error) => {
+			const message = error.message ?? "Antigravity rejected the request.";
+			if (error.code === -32e3 || AUTH_ERROR_RE.test(message)) return acpError({
+				code: "auth.required",
+				errorType: "auth",
+				message
+			});
+			return acpError({
+				code: CONTEXT_ERROR_RE.test(message) ? "context_not_found" : "protocol.request_failed",
+				errorType: "adapter",
+				message
+			});
+		},
+		onProcessControlEvent: (event) => {
+			if (event.phase === "process_exit") interactions.abort();
+			input.onProcessControlEvent?.(event);
+		},
+		onClientRequest: async ({ method, params }) => {
+			if (method !== "session/request_permission") return { error: {
+				code: -32601,
+				message: `Unsupported ACP client method: ${method}`
+			} };
+			const permission = params;
+			if (!turnActive || permission?.sessionId !== sessionId) return { result: { outcome: { outcome: "cancelled" } } };
+			if (!request.onInteractionRequest) {
+				process.fail(acpError({
+					code: "interaction.required",
+					errorType: "adapter",
+					message: "Antigravity needs user input, but this run has no interaction channel."
+				}));
+				return { result: { outcome: { outcome: "cancelled" } } };
+			}
+			return { result: await answerAntigravityAcpInteraction(permission, request.onInteractionRequest, interactions.signal) };
+		},
+		onNotification: (notification) => {
+			if (notification.method !== "session/update") return;
+			const params = notification.params;
+			if (!turnActive || params?.sessionId !== sessionId || !params.update) return;
+			callbacks = callbacks.then(async () => {
+				const update = params.update;
+				const activity = tracker.observe(notification);
+				if (activity) await request.onRuntimeEvent?.(activity);
+				if (update.sessionUpdate === "agent_message_chunk" && update.content.type === "text") {
+					output += update.content.text;
+					firstOutputAtMs ??= Date.now();
+					if (request.streamingMode === "stream" && request.onPreview) {
+						await request.onPreview({ text: output });
+						previewEmitted = true;
+					}
+				}
+				if (update.sessionUpdate === "agent_thought_chunk" && update.content.type === "text") await request.onRuntimeEvent?.({
+					phase: "reasoning",
+					blockId: "antigravity-thought",
+					mode: "append",
+					text: update.content.text,
+					tsMs: Date.now()
+				});
+			}).catch((error) => {
+				callbackFailure = error;
+				process.fail(error);
+			});
+		}
+	});
+	try {
+		process.start();
+		sessionId = await configureSession(process, input);
+		input.registerCancel?.(() => {
+			interactions.abort();
+			process.notify("session/cancel", { sessionId });
+			return Promise.resolve();
+		});
+		turnActive = true;
+		const prompt = request.instructionPrompt ? `${request.instructionPrompt.developerInstructions}\n\n${request.instructionPrompt.userPrompt}` : request.prompt;
+		const result = await process.request("session/prompt", {
+			sessionId,
+			prompt: [{
+				type: "text",
+				text: prompt
+			}]
+		});
+		await callbacks;
+		if (callbackFailure) throw callbackFailure;
+		if (result.stopReason !== "end_turn") throw acpError({
+			code: result.stopReason === "cancelled" ? "runtime.interrupted" : "runtime.incomplete",
+			errorType: "adapter",
+			message: `Antigravity ended the turn: ${result.stopReason}`
+		});
+		if (request.streamingMode !== "stream" && request.onPreview && output) {
+			await request.onPreview({ text: output });
+			previewEmitted = true;
+		}
+		return {
+			sessionId,
+			output,
+			telemetry: process.buildTelemetry({
+				invokedAtMs,
+				firstOutputAtMs,
+				previewEmitted,
+				resumedContext: input.sessionId !== null,
+				streamingMode: request.streamingMode ?? "final"
+			})
+		};
+	} finally {
+		turnActive = false;
+		interactions.abort();
+		await process.close();
+	}
+}
+async function configureSession(process, input) {
+	const { request } = input;
+	const initialized = readInitialize(await admissionRequest(process, "initialize", initializeParams));
+	const methodId = request.env?.OPENMELD_ANTIGRAVITY_ACP_AUTH_METHOD ?? "oauth-personal";
+	if (!initialized.authMethods?.some((method) => method.id === methodId)) throw acpError({
+		code: "auth.method_unavailable",
+		errorType: "auth",
+		message: `Antigravity does not offer authentication method '${methodId}'.`
+	});
+	await admissionRequest(process, "authenticate", { methodId });
+	if (input.sessionId && !initialized.agentCapabilities?.sessionCapabilities?.resume) throw acpError({
+		code: "context.resume_unsupported",
+		errorType: "adapter",
+		message: "This Antigravity version cannot resume ACP conversations."
+	});
+	const descriptor = await admissionRequest(process, input.sessionId ? "session/resume" : "session/new", {
+		cwd: request.runtimeContext.providerRuntimeWorkingDirectory,
+		mcpServers: buildAcpDispatchSpaceActionMcpServers(request.env),
+		...input.sessionId ? { sessionId: input.sessionId } : {}
+	});
+	const sessionId = input.sessionId ?? descriptor?.sessionId;
+	if (!sessionId) throw acpError({
+		code: "protocol.invalid",
+		errorType: "adapter",
+		message: "Antigravity did not return a conversation identifier."
+	});
+	await request.onRuntimeEvent?.({
+		phase: "provider_conversation_observed",
+		agentControllerConversationId: sessionId,
+		tsMs: Date.now()
+	});
+	const mode = resolveAcpMode(request.agentControllerPermissionMode);
+	if (!descriptor.modes?.availableModes.some((value) => value.id === mode)) throw acpError({
+		code: "permission.mode_unsupported",
+		errorType: "config",
+		message: `Antigravity ACP does not offer the selected permission mode '${mode}'.`
+	});
+	await process.request("session/set_mode", {
+		sessionId,
+		modeId: mode
+	});
+	const model = request.conversationPolicy?.model;
+	if (model) {
+		const config = descriptor.configOptions?.find((option) => option.id === "model" && option.type === "select");
+		if (!(config?.type === "select" ? config.options.flatMap((option) => "value" in option ? [option] : option.options) : []).some((option) => option.value === model)) throw acpError({
+			code: "model.unavailable",
+			errorType: "config",
+			message: `Antigravity model '${model}' is not available for this account.`
+		});
+		await process.request("session/set_config_option", {
+			sessionId,
+			configId: "model",
+			value: model
+		});
+	}
+	if (request.conversationPolicy?.reasoningLevel) throw acpError({
+		code: "model.reasoning_unsupported",
+		errorType: "config",
+		message: "Antigravity ACP does not expose a reasoning-level setting."
+	});
+	return sessionId;
+}
+const AUTH_ERROR_RE = /authentication|sign.in|login/iu;
+const CONTEXT_ERROR_RE = /session.+not found|unknown session/iu;
+function resolveAcpMode(mode) {
+	switch (mode) {
+		case void 0:
+		case "antigravity:default": return "default";
+		case "antigravity:acceptEdits": return "auto_edit";
+		case "antigravity:bypassPermissions": return "yolo";
+		case "antigravity:plan": return "plan";
+		default: throw acpError({
+			code: "permission.mode_unsupported",
+			errorType: "config",
+			message: "Select an Antigravity permission mode."
+		});
+	}
+}
+//#endregion
 //#region ../../runtime/adapters/antigravity/dist/config/antigravity-runtime-config.js
 const DEFAULT_ANTIGRAVITY_COMMAND = "agy";
 async function resolveInstalledAntigravityLaunchCandidates(input) {
-	const configuredCommand = normalizeOptionalText$42(process.env.OPENMELD_DAEMON_RUNTIME_ANTIGRAVITY_BIN);
+	const configuredCommand = normalizeOptionalText$40(process.env.OPENMELD_DAEMON_RUNTIME_ANTIGRAVITY_BIN);
 	const installed = await resolveInstalledNodeScriptLaunchCandidates({
 		additionalCommandDirectories: [join(resolveHome$1(), ".local", "bin")],
 		commandName: DEFAULT_ANTIGRAVITY_COMMAND,
@@ -9284,9 +9658,16 @@ async function resolveInstalledAntigravityLaunchCandidates(input) {
 		displayName: "Antigravity CLI",
 		preferredLaunchContract: input?.preferredLaunchContract
 	});
-	if (!installed.ok) return installed;
+	const acp = await resolveInstalledNodeScriptLaunchCandidates({
+		additionalCommandDirectories: [join(resolveHome$1(), ".local", "bin")],
+		commandName: process.platform === "win32" ? "agy_acp_server.exe" : "agy_acp_server.par",
+		displayName: "Antigravity ACP",
+		preferredLaunchContract: input?.preferredLaunchContract && isAntigravityAcpLaunchContract(input.preferredLaunchContract) ? input.preferredLaunchContract : void 0
+	});
+	if (!(installed.ok || acp.ok)) return installed.reason === "not_launchable" ? installed : acp;
+	const discovered = [...installed.ok ? installed.candidates : [], ...acp.ok ? acp.candidates : []];
 	const candidates = await resolveLaunchCandidatesAfterVerification({
-		candidates: installed.candidates,
+		candidates: [...new Map(discovered.map((candidate) => [JSON.stringify(candidate.launchContract), candidate])).values()],
 		verify: async (candidate) => await verifyAntigravityLaunchContract({
 			launchContract: candidate.launchContract,
 			timeoutMs: input?.timeoutMs
@@ -9303,6 +9684,30 @@ async function resolveInstalledAntigravityLaunchCandidates(input) {
 	};
 }
 async function verifyAntigravityLaunchContract(input) {
+	if (isAntigravityAcpLaunchContract(input.launchContract)) try {
+		await probeAntigravityAcp({
+			...input,
+			cwd: input.cwd ?? process.cwd()
+		});
+		const invocation = buildCliLaunchInvocation({
+			launchContract: input.launchContract,
+			args: []
+		});
+		return {
+			ok: true,
+			launchCommand: {
+				bin: invocation.bin,
+				argsPrefix: invocation.args,
+				shell: invocation.shell
+			}
+		};
+	} catch (error) {
+		return {
+			ok: false,
+			failureKind: "incomplete_check",
+			errorMessage: error instanceof Error ? error.message : String(error)
+		};
+	}
 	return await verifyCliLaunchContract({
 		cwd: input.cwd ?? process.cwd(),
 		displayName: "Antigravity CLI",
@@ -9313,9 +9718,9 @@ async function verifyAntigravityLaunchContract(input) {
 	});
 }
 function resolveHome$1() {
-	return normalizeOptionalText$42(process.env.HOME) ?? homedir();
+	return normalizeOptionalText$40(process.env.HOME) ?? homedir();
 }
-function normalizeOptionalText$42(value) {
+function normalizeOptionalText$40(value) {
 	const normalized = String(value ?? "").trim();
 	return normalized.length > 0 ? normalized : null;
 }
@@ -9802,7 +10207,7 @@ async function invokeAntigravityCliTransport(input) {
 	}
 }
 async function invokeNativeAntigravity(input) {
-	const prompt = normalizeOptionalText$41(input.prompt);
+	const prompt = normalizeOptionalText$39(input.prompt);
 	if (!prompt) throw new AntigravityCliTransportError({
 		code: "schema.invalid",
 		errorType: "config",
@@ -9814,13 +10219,13 @@ async function invokeNativeAntigravity(input) {
 			conversationPolicy: input.conversationPolicy,
 			jsonSchema: input.jsonSchema,
 			prompt,
-			sessionId: normalizeOptionalText$41(input.sessionId)
+			sessionId: normalizeOptionalText$39(input.sessionId)
 		}), ...input.deliveryAgentName ? ["--agent", input.deliveryAgentName] : []],
 		launchContract: input.launchContract
 	});
 	const invokedAtMs = Date.now();
 	let firstOutputAtMs = null;
-	let conversationId = normalizeOptionalText$41(input.sessionId);
+	let conversationId = normalizeOptionalText$39(input.sessionId);
 	const terminal = { result: null };
 	let malformedOutput = false;
 	const providerErrorMessages = [];
@@ -9835,7 +10240,7 @@ async function invokeNativeAntigravity(input) {
 		onLifecycleEvent: input.onRuntimeEvent,
 		onProcessControlEvent: input.onProcessControlEvent,
 		onStderrLine: (lineEvent) => {
-			const message = normalizeOptionalText$41(lineEvent.line);
+			const message = normalizeOptionalText$39(lineEvent.line);
 			if (message) providerErrorMessages.push(message);
 		},
 		onStdoutLine: (lineEvent) => {
@@ -9888,8 +10293,8 @@ async function invokeNativeAntigravity(input) {
 		stderr: driverResult.stderrText,
 		telemetry
 	});
-	const output = normalizeOptionalText$41(terminalResult.response);
-	const resolvedSessionId = normalizeOptionalText$41(terminalResult.conversationId) ?? conversationId;
+	const output = normalizeOptionalText$39(terminalResult.response);
+	const resolvedSessionId = normalizeOptionalText$39(terminalResult.conversationId) ?? conversationId;
 	if (!(output && resolvedSessionId)) {
 		const permissionFailure = classifyAntigravityPermissionFailure(providerErrorMessages);
 		if (permissionFailure) throw new AntigravityCliTransportError({
@@ -9934,12 +10339,12 @@ function buildAntigravityArgs(input) {
 		"--print-timeout",
 		"0"
 	];
-	const jsonSchema = normalizeOptionalText$41(input.jsonSchema);
+	const jsonSchema = normalizeOptionalText$39(input.jsonSchema);
 	if (jsonSchema) args.push("--json-schema", jsonSchema);
 	if (input.sessionId) args.push("--conversation", input.sessionId);
-	const model = normalizeOptionalText$41(input.conversationPolicy?.model);
+	const model = normalizeOptionalText$39(input.conversationPolicy?.model);
 	if (model) args.push("--model", model);
-	const effort = normalizeOptionalText$41(input.conversationPolicy?.reasoningLevel);
+	const effort = normalizeOptionalText$39(input.conversationPolicy?.reasoningLevel);
 	if (effort) {
 		if (!ANTIGRAVITY_EFFORTS.has(effort)) throw new AntigravityCliTransportError({
 			code: "model.reasoning_level.unsupported",
@@ -10000,7 +10405,7 @@ function buildTelemetry(input) {
 	};
 }
 function classifyAntigravityFailure(input) {
-	const providerMessage = normalizeOptionalText$41(input.providerError) ?? normalizeOptionalText$41(input.stderr) ?? (input.signal ? `Antigravity CLI was interrupted by ${input.signal}.` : `Antigravity CLI exited with code ${String(input.exitCode)}.`);
+	const providerMessage = normalizeOptionalText$39(input.providerError) ?? normalizeOptionalText$39(input.stderr) ?? (input.signal ? `Antigravity CLI was interrupted by ${input.signal}.` : `Antigravity CLI exited with code ${String(input.exitCode)}.`);
 	const authFailure = AUTH_FAILURE_PATTERN.test(providerMessage);
 	const contextFailure = CONTEXT_FAILURE_PATTERN.test(providerMessage);
 	let code = "provider_exit_error";
@@ -10014,7 +10419,7 @@ function classifyAntigravityFailure(input) {
 		telemetry: input.telemetry
 	});
 }
-function normalizeOptionalText$41(value) {
+function normalizeOptionalText$39(value) {
 	const normalized = String(value ?? "").trim();
 	return normalized.length > 0 ? normalized : null;
 }
@@ -10030,7 +10435,11 @@ function createAntigravityAdapter(options = {}) {
 	const processInterruptSender = options.registerRuntimeProcess ? createProcessInterruptSender(activeTasks) : void 0;
 	const controlShell = createSharedControlShell({
 		gracefulTimeoutMs: options.gracefulTimeoutMs,
-		sendCancel: options.sendCancel,
+		sendCancel: options.sendCancel ?? (processInterruptSender ? (request) => processInterruptSender({
+			taskId: request.taskId,
+			reason: request.reason ?? "cancel",
+			mode: activeTasks.get(request.taskId)?.cancel ? "graceful" : "force"
+		}) : void 0),
 		sendInterrupt: options.sendInterrupt ?? processInterruptSender,
 		waitForMs: options.waitForMs
 	});
@@ -10073,7 +10482,7 @@ function createDefaultAntigravityInvoke(input) {
 				message: "runtime.cancelled_before_start: Antigravity dispatch was canceled before launch"
 			});
 			const result = await invokeWithSingleContextHeal({
-				contextId: normalizeOptionalText$40(request.agentControllerConversationId),
+				contextId: normalizeOptionalText$38(request.agentControllerConversationId),
 				contextLossPolicy: request.executionMode === "repair" ? "fail" : "rebuild",
 				createRebuildFailedError: (error) => new AntigravityCliTransportError({
 					code: "context.rebuild_failed",
@@ -10081,6 +10490,30 @@ function createDefaultAntigravityInvoke(input) {
 					message: `context.rebuild_failed: ${toErrorMessage$17(error)}`
 				}),
 				invokeOnce: async (sessionId) => {
+					const onProcessControlEvent = (event) => {
+						task.process = event.phase === "process_spawned" ? event : null;
+						if (event.phase === "process_spawned" && task.cancellationRequested) signalProcess(event, "SIGINT");
+						input.options.registerRuntimeProcess?.({
+							...event,
+							taskId: request.taskId
+						});
+					};
+					if (isAntigravityAcpLaunchContract(launchContract)) {
+						const transportResult = await invokeAntigravityAcpTransport({
+							request,
+							launchContract,
+							sessionId,
+							onProcessControlEvent,
+							registerCancel: (cancel) => {
+								task.cancel = cancel;
+							}
+						});
+						return {
+							contextId: transportResult.sessionId,
+							output: transportResult.output,
+							telemetry: transportResult.telemetry
+						};
+					}
 					const transportResult = await withAntigravityDispatchSpaceAction({
 						env: request.env,
 						prompt: request.prompt,
@@ -10092,14 +10525,7 @@ function createDefaultAntigravityInvoke(input) {
 							jsonSchema,
 							launchContract,
 							onPreview: request.onPreview,
-							onProcessControlEvent: (event) => {
-								task.process = event.phase === "process_spawned" ? event : null;
-								if (event.phase === "process_spawned" && task.cancellationRequested) signalProcess(event, "SIGINT");
-								input.options.registerRuntimeProcess?.({
-									...event,
-									taskId: request.taskId
-								});
-							},
+							onProcessControlEvent,
 							onRuntimeEvent: request.onRuntimeEvent,
 							prompt,
 							sessionId,
@@ -10113,7 +10539,7 @@ function createDefaultAntigravityInvoke(input) {
 						telemetry: transportResult.telemetry
 					};
 				},
-				isContextLostError: (error) => error instanceof AntigravityCliTransportError && error.code === "context_not_found"
+				isContextLostError: (error) => error instanceof Error && "code" in error && error.code === "context_not_found"
 			});
 			const agentControllerConversation = ANTIGRAVITY_CONVERSATION_BRIDGE_SPEC && result.contextId ? bridgeAgentControllerConversationRef({
 				bridgeSpec: ANTIGRAVITY_CONVERSATION_BRIDGE_SPEC,
@@ -10134,12 +10560,13 @@ function createDefaultAntigravityInvoke(input) {
 	};
 }
 async function resolveDispatchLaunchContract(input) {
-	const commandPath = normalizeOptionalText$40(input.antigravityBin);
+	const commandPath = normalizeOptionalText$38(input.antigravityBin);
 	const launchContract = input.inputLaunchContract ?? input.optionLaunchContract ?? (commandPath ? buildExecutableLaunchContract({ commandPath }) : null);
 	if (!launchContract) throw Object.assign(/* @__PURE__ */ new Error("Antigravity CLI launch contract is required for dispatch."), {
 		code: "controller.launch.needs_repair",
 		errorType: "config"
 	});
+	if (isAntigravityAcpLaunchContract(launchContract)) return launchContract;
 	const verification = await verifyAntigravityLaunchContract({ launchContract });
 	if (!verification.ok) throw Object.assign(new Error(verification.errorMessage), {
 		code: "controller.launch.needs_repair",
@@ -10152,6 +10579,7 @@ function createProcessInterruptSender(activeTasks) {
 		const task = activeTasks.get(signal.taskId);
 		if (!task) return Promise.reject(Object.assign(/* @__PURE__ */ new Error("Antigravity task is not running."), { code: "task.not_running" }));
 		task.cancellationRequested = true;
+		if (signal.mode !== "force" && task.cancel) return task.cancel();
 		if (!task.process) return Promise.resolve();
 		return signalProcess(task.process, signal.mode === "force" ? "SIGKILL" : "SIGINT") ? Promise.resolve() : Promise.reject(/* @__PURE__ */ new Error("Antigravity process signal was not sent."));
 	};
@@ -10163,7 +10591,7 @@ function signalProcess(processEvent, signal) {
 		signalTarget: processEvent.signalTarget
 	});
 }
-function normalizeOptionalText$40(value) {
+function normalizeOptionalText$38(value) {
 	const normalized = String(value ?? "").trim();
 	return normalized.length > 0 ? normalized : null;
 }
@@ -10190,7 +10618,7 @@ async function resolveInstalledClaudeCodeLaunchCandidates(input) {
 	const installedCandidates = await resolveInstalledNodeScriptLaunchCandidates({
 		additionalCommandDirectories: resolveClaudeCodeCommandDirectories(),
 		commandName: DEFAULT_CLAUDE_CODE_COMMAND,
-		configuredCommand: normalizeOptionalText$39(process.env.OPENMELD_DAEMON_RUNTIME_CLAUDE_CODE_BIN),
+		configuredCommand: normalizeOptionalText$37(process.env.OPENMELD_DAEMON_RUNTIME_CLAUDE_CODE_BIN),
 		displayName: "Claude Code",
 		preferredLaunchContract: input?.preferredLaunchContract
 	});
@@ -10222,16 +10650,16 @@ async function verifyClaudeCodeLaunchContract(input) {
 	});
 }
 function resolveClaudeCodeTimeoutMs() {
-	const raw = normalizeOptionalText$39(process.env.OPENMELD_DAEMON_RUNTIME_REQUEST_TIMEOUT_MS);
+	const raw = normalizeOptionalText$37(process.env.OPENMELD_DAEMON_RUNTIME_REQUEST_TIMEOUT_MS);
 	if (!raw) return null;
 	const parsed = Number.parseInt(raw, 10);
 	if (!Number.isFinite(parsed) || parsed <= 0) return null;
 	return parsed;
 }
 function resolveClaudeCodeCommandDirectories() {
-	return [join(normalizeOptionalText$39(process.env.HOME) ?? homedir(), ".local", "bin")];
+	return [join(normalizeOptionalText$37(process.env.HOME) ?? homedir(), ".local", "bin")];
 }
-function normalizeOptionalText$39(value) {
+function normalizeOptionalText$37(value) {
 	const normalized = String(value ?? "").trim();
 	return normalized.length > 0 ? normalized : null;
 }
@@ -10280,8 +10708,8 @@ function extractClaudeToolLifecycleObservations(message) {
 	const record = toRecord$12(message);
 	if (!record) return [];
 	if (record.type === "tool_progress") {
-		const toolCallId = normalizeOptionalText$38(record.tool_use_id);
-		const providerToolName = normalizeOptionalText$38(record.tool_name);
+		const toolCallId = normalizeOptionalText$36(record.tool_use_id);
+		const providerToolName = normalizeOptionalText$36(record.tool_name);
 		return toolCallId ? [{
 			providerToolInput: null,
 			providerToolName,
@@ -10292,11 +10720,11 @@ function extractClaudeToolLifecycleObservations(message) {
 	const content = readMessageContent(record.message);
 	if (record.type === "assistant") return content.flatMap((block) => {
 		if (block.type !== "tool_use") return [];
-		const toolCallId = normalizeOptionalText$38(block.id);
+		const toolCallId = normalizeOptionalText$36(block.id);
 		if (!toolCallId) return [];
 		return [{
 			providerToolInput: block.input,
-			providerToolName: normalizeOptionalText$38(block.name),
+			providerToolName: normalizeOptionalText$36(block.name),
 			state: "input-available",
 			toolCallId
 		}];
@@ -10304,7 +10732,7 @@ function extractClaudeToolLifecycleObservations(message) {
 	if (record.type !== "user") return [];
 	return content.flatMap((block) => {
 		if (block.type !== "tool_result") return [];
-		const toolCallId = normalizeOptionalText$38(block.tool_use_id);
+		const toolCallId = normalizeOptionalText$36(block.tool_use_id);
 		if (!toolCallId) return [];
 		return [{
 			providerToolInput: null,
@@ -10325,7 +10753,7 @@ function readMessageContent(message) {
 function toRecord$12(value) {
 	return value && typeof value === "object" && !Array.isArray(value) ? value : null;
 }
-function normalizeOptionalText$38(value) {
+function normalizeOptionalText$36(value) {
 	const normalized = typeof value === "string" ? value.trim() : "";
 	return normalized.length > 0 ? normalized : null;
 }
@@ -10820,8 +11248,8 @@ function parseClaudeOutputLine(line) {
 	}
 	const record = toObjectRecord(parsed);
 	if (!record) return null;
-	const sessionId = normalizeOptionalText$37(record.session_id);
-	const resultText = normalizeOptionalText$37(record.result);
+	const sessionId = normalizeOptionalText$35(record.session_id);
+	const resultText = normalizeOptionalText$35(record.result);
 	const isErrorResult = typeof record.is_error === "boolean" ? record.is_error : null;
 	if (record.type === "result") return {
 		errorMessage: isErrorResult ? resultText : null,
@@ -10832,7 +11260,7 @@ function parseClaudeOutputLine(line) {
 		terminal: true
 	};
 	if (record.type === "error") return {
-		errorMessage: normalizeOptionalText$37(record.message),
+		errorMessage: normalizeOptionalText$35(record.message),
 		isErrorResult: true,
 		previewDeltaText: null,
 		resultText: null,
@@ -10848,7 +11276,7 @@ function parseClaudeOutputLine(line) {
 function parseClaudeStreamEvent(record, sessionId) {
 	const event = toObjectRecord(record.event);
 	if (!event) return null;
-	const eventType = normalizeOptionalText$37(event.type);
+	const eventType = normalizeOptionalText$35(event.type);
 	if (eventType === "message_start") return {
 		errorMessage: null,
 		isErrorResult: null,
@@ -10875,7 +11303,7 @@ function toObjectRecord(value) {
 function normalizeText$9(value) {
 	return String(value ?? "").trim();
 }
-function normalizeOptionalText$37(value) {
+function normalizeOptionalText$35(value) {
 	const normalized = normalizeText$9(value);
 	return normalized.length > 0 ? normalized : null;
 }
@@ -10886,16 +11314,16 @@ function preserveOptionalText(value) {
 //#endregion
 //#region ../../runtime/adapters/claude-code/dist/transport/claude-conversation-policy.js
 function resolveClaudeConversationPolicyOptions(conversationPolicy) {
-	const model = normalizeOptionalText$36(conversationPolicy?.model);
-	const fallbackModel = normalizeOptionalText$36(conversationPolicy?.fallbackModel);
-	const reasoningLevel = normalizeOptionalText$36(conversationPolicy?.reasoningLevel);
+	const model = normalizeOptionalText$34(conversationPolicy?.model);
+	const fallbackModel = normalizeOptionalText$34(conversationPolicy?.fallbackModel);
+	const reasoningLevel = normalizeOptionalText$34(conversationPolicy?.reasoningLevel);
 	return {
 		...model ? { model } : {},
 		...fallbackModel && fallbackModel !== model ? { fallbackModel } : {},
 		...reasoningLevel ? { reasoningLevel } : {}
 	};
 }
-function normalizeOptionalText$36(value) {
+function normalizeOptionalText$34(value) {
 	const normalized = String(value ?? "").trim();
 	return normalized.length > 0 ? normalized : null;
 }
@@ -11001,7 +11429,7 @@ var ClaudeCliTransportError = class extends Error {
 	}
 };
 async function invokeClaudeCliTransport(input) {
-	const prompt = normalizeOptionalText$35(input.prompt);
+	const prompt = normalizeOptionalText$33(input.prompt);
 	if (!prompt) throw new ClaudeCliTransportError({
 		code: "schema.invalid",
 		errorType: "config",
@@ -11014,16 +11442,16 @@ async function invokeClaudeCliTransport(input) {
 			executionMode: input.executionMode,
 			env: input.env,
 			prompt,
-			sessionId: normalizeOptionalText$35(input.sessionId),
+			sessionId: normalizeOptionalText$33(input.sessionId),
 			streamingMode: input.streamingMode
 		}),
 		launchContract: input.launchContract
 	});
 	const invokedAtMs = Date.now();
-	const canonicalRepairSessionId = input.executionMode === "repair" ? normalizeOptionalText$35(input.sessionId) : null;
+	const canonicalRepairSessionId = input.executionMode === "repair" ? normalizeOptionalText$33(input.sessionId) : null;
 	let latestOutput = "";
 	let latestResultIsError = false;
-	let resolvedSessionId = normalizeOptionalText$35(input.sessionId);
+	let resolvedSessionId = normalizeOptionalText$33(input.sessionId);
 	const providerErrorMessages = [];
 	const providerOriginalErrorMessages = [];
 	let firstStdoutAtMs = null;
@@ -11043,7 +11471,7 @@ async function invokeClaudeCliTransport(input) {
 			onLifecycleEvent: input.onRuntimeEvent,
 			onProcessControlEvent: input.onProcessControlEvent,
 			onStderrLine: (event) => {
-				collectProviderErrorMessage$2(event.line, providerErrorMessages);
+				collectProviderErrorMessage$1(event.line, providerErrorMessages);
 			},
 			onStdoutLine: (event) => {
 				const nextState = handleClaudeStdoutLine({
@@ -11080,7 +11508,7 @@ async function invokeClaudeCliTransport(input) {
 			firstStdoutAtMs,
 			invokedAtMs,
 			previewEmitted: previewEmitter.emitted,
-			resumedContext: normalizeOptionalText$35(input.sessionId) !== null,
+			resumedContext: normalizeOptionalText$33(input.sessionId) !== null,
 			streamingMode: input.streamingMode ?? "final"
 		});
 		const classifiedFailure = classifyClaudeFailure({
@@ -11099,7 +11527,7 @@ async function invokeClaudeCliTransport(input) {
 			telemetry
 		});
 	}
-	const output = normalizeOptionalText$35(latestOutput);
+	const output = normalizeOptionalText$33(latestOutput);
 	if (!output) throw new ClaudeCliTransportError({
 		code: "runtime.output.empty",
 		errorType: "adapter",
@@ -11110,20 +11538,20 @@ async function invokeClaudeCliTransport(input) {
 			firstStdoutAtMs,
 			invokedAtMs,
 			previewEmitted: previewEmitter.emitted,
-			resumedContext: normalizeOptionalText$35(input.sessionId) !== null,
+			resumedContext: normalizeOptionalText$33(input.sessionId) !== null,
 			streamingMode: input.streamingMode ?? "final"
 		})
 	});
 	return {
 		output,
-		sessionId: canonicalRepairSessionId ?? normalizeOptionalText$35(resolvedSessionId),
+		sessionId: canonicalRepairSessionId ?? normalizeOptionalText$33(resolvedSessionId),
 		telemetry: buildClaudeCliTelemetry({
 			driverResult,
 			firstOutputAtMs,
 			firstStdoutAtMs,
 			invokedAtMs,
 			previewEmitted: previewEmitter.emitted,
-			resumedContext: normalizeOptionalText$35(input.sessionId) !== null,
+			resumedContext: normalizeOptionalText$33(input.sessionId) !== null,
 			streamingMode: input.streamingMode ?? "final"
 		})
 	};
@@ -11267,8 +11695,8 @@ const toClaudeCliTransportError = (error, timeoutMs) => {
 	});
 };
 const classifyClaudeFailure = (input) => {
-	const trustedProviderMessages = /* @__PURE__ */ new Set([...input.providerOriginalErrorMessages ?? [], ...extractErrorMessagesFromStdout$2(input.stdoutText)]);
-	const providerMessage = resolveProviderFailureMessage$3(input);
+	const trustedProviderMessages = /* @__PURE__ */ new Set([...input.providerOriginalErrorMessages ?? [], ...extractErrorMessagesFromStdout$1(input.stdoutText)]);
+	const providerMessage = resolveProviderFailureMessage$2(input);
 	const originalError = providerMessage && trustedProviderMessages.has(providerMessage) ? createProviderOriginalError(providerMessage) ?? void 0 : void 0;
 	if (providerMessage) {
 		const classified = classifyProviderMessageFailure(providerMessage, trustedProviderMessages.has(providerMessage));
@@ -11280,7 +11708,7 @@ const classifyClaudeFailure = (input) => {
 		message: `provider.process_terminated: claude process was terminated by ${input.exitSignal} before returning a result`,
 		originalError
 	};
-	const stderrText = normalizeOptionalText$35(input.stderrText);
+	const stderrText = normalizeOptionalText$33(input.stderrText);
 	if (stderrText) return {
 		code: "upstream_unreachable",
 		errorType: "adapter",
@@ -11343,17 +11771,17 @@ const classifyProviderMessageFailure = (providerMessage, includeOriginalError) =
 	});
 	return null;
 };
-const resolveProviderFailureMessage$3 = (input) => {
+const resolveProviderFailureMessage$2 = (input) => {
 	const candidateMessages = [
 		...input.providerErrorMessages,
-		...extractErrorMessagesFromStdout$2(input.stdoutText),
-		...normalizeOptionalText$35(input.stderrText) ? [normalizeOptionalText$35(input.stderrText)] : []
+		...extractErrorMessagesFromStdout$1(input.stdoutText),
+		...normalizeOptionalText$33(input.stderrText) ? [normalizeOptionalText$33(input.stderrText)] : []
 	].filter((value) => Boolean(value));
-	for (const candidate of candidateMessages) if (looksLikeProviderFailure$3(candidate)) return candidate;
+	for (const candidate of candidateMessages) if (looksLikeProviderFailure$2(candidate)) return candidate;
 	return candidateMessages[0] ?? null;
 };
-const extractErrorMessagesFromStdout$2 = (value) => {
-	const stdoutText = normalizeOptionalText$35(value);
+const extractErrorMessagesFromStdout$1 = (value) => {
+	const stdoutText = normalizeOptionalText$33(value);
 	if (!stdoutText) return [];
 	const messages = [];
 	const lines = stdoutText.split("\n");
@@ -11363,12 +11791,12 @@ const extractErrorMessagesFromStdout$2 = (value) => {
 	}
 	return messages;
 };
-const collectProviderErrorMessage$2 = (line, messages) => {
-	const normalizedLine = normalizeOptionalText$35(line);
+const collectProviderErrorMessage$1 = (line, messages) => {
+	const normalizedLine = normalizeOptionalText$33(line);
 	if (!normalizedLine) return;
 	messages.push(normalizedLine);
 };
-const looksLikeProviderFailure$3 = (value) => {
+const looksLikeProviderFailure$2 = (value) => {
 	const normalized = value.toLowerCase();
 	return looksLikeRuntimePermissionDenialMessage(value) || isAuthFailure$1(normalized) || isQuotaFailure$1(normalized) || isRateLimitFailure$1(normalized) || isModelConfigFailure(normalized) || isLikelyClaudeContextLostError(normalized);
 };
@@ -11414,11 +11842,137 @@ const isProviderOverloadedFailure = (value) => {
 function normalizeText$8(value) {
 	return String(value ?? "").trim();
 }
-function normalizeOptionalText$35(value) {
+function normalizeOptionalText$33(value) {
 	const normalized = normalizeText$8(value);
 	return normalized.length > 0 ? normalized : null;
 }
 //#endregion
+//#region ../../runtime/adapters/claude-code/dist/transport/claude-live-input.js
+const CLAUDE_VERSION = /^(\d+)\.(\d+)\.(\d+)/;
+function createClaudeLiveInput(taskId, prompt) {
+	const messages = [userMessage(prompt)];
+	const pending = /* @__PURE__ */ new Map();
+	const awaitingResults = /* @__PURE__ */ new Set();
+	let wake;
+	let closed = false;
+	let sessionId;
+	let supported = false;
+	let resultWhilePending = false;
+	function unconfirmed() {
+		return {
+			status: "unconfirmed",
+			taskId,
+			reasonCode: "execution_input.application_unconfirmed",
+			diagnosticCode: "claude.input_receipt_unconfirmed"
+		};
+	}
+	function close() {
+		closed = true;
+		messages.length = 0;
+		wake?.();
+		for (const receipt of pending.values()) {
+			clearTimeout(receipt.timer);
+			receipt.resolve(unconfirmed());
+		}
+		pending.clear();
+		awaitingResults.clear();
+	}
+	const steer = async (input) => {
+		if (closed || input.taskId !== taskId || !sessionId) return {
+			status: "not_applied",
+			taskId: input.taskId,
+			reasonCode: "execution_input.target_unavailable"
+		};
+		if (!supported) return {
+			status: "not_applied",
+			taskId,
+			reasonCode: "execution_input.unsupported"
+		};
+		const uuid = randomUUID();
+		return await new Promise((resolve) => {
+			const timer = setTimeout(() => {
+				pending.delete(uuid);
+				awaitingResults.delete(uuid);
+				resolve(unconfirmed());
+				if (resultWhilePending && awaitingResults.size === 0) close();
+			}, 1e4);
+			timer.unref?.();
+			pending.set(uuid, {
+				resolve,
+				timer
+			});
+			awaitingResults.add(uuid);
+			messages.push({
+				...userMessage(input.text, uuid),
+				priority: "now"
+			});
+			wake?.();
+		});
+	};
+	function observeResult(message) {
+		for (const uuid of message.user_message_uuids ?? []) awaitingResults.delete(uuid);
+		if (message.user_message_uuid) awaitingResults.delete(message.user_message_uuid);
+		if (!message.is_error && awaitingResults.size > 0) resultWhilePending = true;
+		else close();
+	}
+	return {
+		close,
+		steer,
+		async *prompt() {
+			while (!closed) {
+				const message = messages.shift();
+				if (message) yield message;
+				else {
+					await new Promise((resolve) => {
+						wake = resolve;
+					});
+					wake = void 0;
+				}
+			}
+		},
+		observe(message) {
+			if (message.type === "system" && message.subtype === "init") {
+				sessionId = message.session_id;
+				supported = supportsConsumedInputReceipt(message.claude_code_version);
+			}
+			if (message.type === "user" && "isReplay" in message && message.isReplay && message.parent_tool_use_id === null && message.session_id === sessionId) {
+				const receipt = pending.get(message.uuid);
+				if (receipt) {
+					clearTimeout(receipt.timer);
+					pending.delete(message.uuid);
+					resultWhilePending = false;
+					receipt.resolve({
+						status: "applied",
+						taskId,
+						threadId: message.session_id,
+						turnId: message.uuid
+					});
+				}
+			}
+			if (message.type === "result") observeResult(message);
+		}
+	};
+}
+function supportsConsumedInputReceipt(version) {
+	const parts = version?.match(CLAUDE_VERSION);
+	if (!parts) return false;
+	const major = Number(parts[1]);
+	const minor = Number(parts[2]);
+	const patch = Number(parts[3]);
+	return major > 2 || major === 2 && (minor > 1 || minor === 1 && patch >= 290);
+}
+function userMessage(text, uuid) {
+	return {
+		type: "user",
+		message: {
+			role: "user",
+			content: text
+		},
+		parent_tool_use_id: null,
+		...uuid ? { uuid } : {}
+	};
+}
+//#endregion
 //#region ../../runtime/adapters/claude-code/dist/transport/claude-space-action-tools.js
 function isClaudeDeliveryOnly(input) {
 	return Boolean(input.spaceActionTools?.deliveryOnly || isDispatchSpaceActionDeliveryOnly(input.env));
@@ -11664,7 +12218,7 @@ function isFailedResultMessage(resultMessage) {
 }
 function resolveCanonicalRepairSessionId(input) {
 	if (input.executionMode !== "repair") return null;
-	return normalizeOptionalText$34(input.sessionId);
+	return normalizeOptionalText$32(input.sessionId);
 }
 async function observeClaudeReasoning(message, messageId, onRuntimeEvent) {
 	if (message.type !== "stream_event") return messageId;
@@ -11680,13 +12234,13 @@ async function observeClaudeReasoning(message, messageId, onRuntimeEvent) {
 	return messageId;
 }
 async function invokeClaudeAgentSdkTransport(input) {
-	const prompt = normalizeOptionalText$34(input.prompt);
+	const prompt = normalizeOptionalText$32(input.prompt);
 	if (!prompt) throw new ClaudeAgentSdkTransportError({
 		code: "schema.invalid",
 		errorType: "config",
 		message: "schema.invalid: prompt is required"
 	});
-	const resumedContext = normalizeOptionalText$34(input.sessionId) !== null;
+	const resumedContext = normalizeOptionalText$32(input.sessionId) !== null;
 	const canonicalRepairSessionId = resolveCanonicalRepairSessionId(input);
 	const streamingMode = input.streamingMode ?? "final";
 	const resources = await createClaudeAgentSdkInvocationResources({
@@ -11708,11 +12262,12 @@ async function invokeClaudeAgentSdkTransport(input) {
 	let latestOutput = "";
 	let latestPlanDocument = "";
 	let resultMessage = null;
-	let resolvedSessionId = normalizeOptionalText$34(input.sessionId);
+	let resolvedSessionId = normalizeOptionalText$32(input.sessionId);
 	let timeoutTriggeredAtMs = null;
 	let timeoutHandle = null;
 	let queryRuntime = null;
 	let unregisterQuery;
+	let liveInput;
 	const toolActivityTracker = createClaudeAgentSdkToolActivityTracker();
 	if (input.claudeTimeoutMs !== null) timeoutHandle = setTimeout(() => {
 		timeoutTriggeredAtMs = Date.now();
@@ -11740,7 +12295,7 @@ async function invokeClaudeAgentSdkTransport(input) {
 			pathToClaudeCodeExecutable: resources.executable.pathToClaudeCodeExecutable,
 			spawnProcess: resources.executable.spawnProcess,
 			planDirectory: resources.planCapture.directory,
-			sessionId: normalizeOptionalText$34(input.sessionId),
+			sessionId: normalizeOptionalText$32(input.sessionId),
 			streamingMode: input.streamingMode
 		});
 		await applyClaudeDeliveryPermissions({
@@ -11749,11 +12304,14 @@ async function invokeClaudeAgentSdkTransport(input) {
 			options,
 			spaceActionTools: input.spaceActionTools
 		});
+		const userPrompt = [input.instructionPrompt?.userPrompt ?? prompt, ...input.spaceActionTools?.deliveryOnly ? ["Use only the supplied delivery tools. Do not repeat the user's work or change permission mode. After the final tool call, return the required small delivery report: recorded is true only after verifying a proposal_saved_locally receipt. This report is not a public reply and never authorizes publication."] : []].join("\n\n");
+		liveInput = createInvocationLiveInput(input, userPrompt, options);
 		queryRuntime = createQuery({
 			options,
-			prompt: createSinglePrompt([input.instructionPrompt?.userPrompt ?? prompt, ...input.spaceActionTools?.deliveryOnly ? ["Use only the supplied delivery tools. Do not repeat the user's work or change permission mode. After the final tool call, return the required small delivery report: recorded is true only after verifying a proposal_saved_locally receipt. This report is not a public reply and never authorizes publication."] : []].join("\n\n"))
+			prompt: liveInput?.prompt() ?? createSinglePrompt(userPrompt)
 		});
 		if (input.taskId) unregisterQuery = input.registerQuery?.({
+			liveInput,
 			permissionModeUpdatesAllowed: input.executionMode !== "repair",
 			query: queryRuntime,
 			taskId: input.taskId
@@ -11761,6 +12319,7 @@ async function invokeClaudeAgentSdkTransport(input) {
 		let reasoningMessageId = "";
 		const observeConnection = createClaudeDispatchConnectionObserver(input.spaceActionTools);
 		for await (const message of queryRuntime) {
+			liveInput?.observe(message);
 			await observeConnection(message, queryRuntime);
 			reasoningMessageId = await observeClaudeReasoning(message, reasoningMessageId, input.onRuntimeEvent);
 			await emitClaudeCodeUsageLimits({
@@ -11814,6 +12373,7 @@ async function invokeClaudeAgentSdkTransport(input) {
 	} finally {
 		if (timeoutHandle) clearTimeout(timeoutHandle);
 		unregisterQuery?.();
+		liveInput?.close();
 		queryRuntime?.close();
 		await resources.cleanup();
 	}
@@ -11890,7 +12450,7 @@ async function invokeClaudeAgentSdkTransport(input) {
 	});
 	return {
 		output,
-		sessionId: canonicalRepairSessionId ?? normalizeOptionalText$34(resolvedSessionId),
+		sessionId: canonicalRepairSessionId ?? normalizeOptionalText$32(resolvedSessionId),
 		telemetry: buildClaudeAgentSdkTelemetry({
 			aiUsage: [...aiUsage.values()],
 			firstOutputAtMs,
@@ -11904,7 +12464,7 @@ async function invokeClaudeAgentSdkTransport(input) {
 	};
 }
 async function resolveClaudeFinalOutput(input) {
-	if (!input.tools?.deliveryOnly) return normalizeOptionalText$34(input.privateOutput);
+	if (!input.tools?.deliveryOnly) return normalizeOptionalText$32(input.privateOutput);
 	return await verifyClaudeDeliveryReport(input.tools, input.result.subtype === "success" ? input.result.structured_output : void 0);
 }
 async function emitClaudeProviderConversationObservation(input) {
@@ -12093,7 +12653,7 @@ function buildClaudeAgentSdkOptions(input) {
 	};
 	Object.assign(options, buildClaudeSpaceToolOptions(input));
 	if (input.executionContext?.access === "workspace" && input.executionContext.permissionSource !== "agent_settings" && input.executionMode !== "repair" && !deliveryOnly) applyClaudeProjectToolBoundary(options, permissionMode);
-	const sessionId = normalizeOptionalText$34(input.sessionId);
+	const sessionId = normalizeOptionalText$32(input.sessionId);
 	if (sessionId) {
 		options.resume = sessionId;
 		if (input.executionMode === "repair") options.forkSession = true;
@@ -12137,7 +12697,15 @@ async function readLatestClaudePlanDocument(planDirectory) {
 	planFiles.sort((left, right) => right.mtimeMs - left.mtimeMs);
 	const latestPlanFile = planFiles[0];
 	if (!latestPlanFile) return null;
-	return normalizeOptionalText$34((await readFile(latestPlanFile.path, "utf8")).slice(0, 64e3));
+	return normalizeOptionalText$32((await readFile(latestPlanFile.path, "utf8")).slice(0, 64e3));
+}
+function createInvocationLiveInput(input, prompt, options) {
+	if (!(input.taskId && input.registerQuery) || input.executionMode === "repair" || input.spaceActionTools?.deliveryOnly) return;
+	options.extraArgs = {
+		...options.extraArgs,
+		"replay-user-messages": null
+	};
+	return createClaudeLiveInput(input.taskId, prompt);
 }
 function createDefaultClaudeAgentSdkQuery(input) {
 	return query(input);
@@ -12161,7 +12729,7 @@ function handleClaudeAgentSdkMessage(input) {
 	let observedConversationId = null;
 	let resolvedSessionId = input.resolvedSessionId;
 	let resultMessage = input.resultMessage;
-	const sessionId = normalizeOptionalText$34(input.message.session_id);
+	const sessionId = normalizeOptionalText$32(input.message.session_id);
 	if (sessionId) observedConversationId = sessionId;
 	const previewDeltaText = extractPreviewDeltaText(input.message);
 	if (previewDeltaText) {
@@ -12214,7 +12782,7 @@ function extractAssistantMessageWrittenPlan(message) {
 		if (block.type !== "tool_use" || block.name !== "Write") continue;
 		const toolInput = block.input;
 		if (!toolInput || typeof toolInput !== "object" || Array.isArray(toolInput)) continue;
-		const content = normalizeOptionalText$34(toolInput.content);
+		const content = normalizeOptionalText$32(toolInput.content);
 		if (content) writtenPlan = content.slice(0, 64e3);
 	}
 	return writtenPlan;
@@ -12256,7 +12824,7 @@ function toClaudeAgentSdkTransportError(input) {
 	const classifiedFailure = classifyClaudeFailure({
 		providerErrorMessages: input.providerErrorMessages,
 		providerOriginalErrorMessages: input.providerErrorMessages,
-		stderrText: [fallbackMessage, input.stderrText].map(normalizeOptionalText$34).filter((value) => value !== null).join("\n")
+		stderrText: [fallbackMessage, input.stderrText].map(normalizeOptionalText$32).filter((value) => value !== null).join("\n")
 	});
 	return new ClaudeAgentSdkTransportError({
 		code: classifiedFailure.code,
@@ -12293,7 +12861,7 @@ function buildPosixWrapperScript(input) {
 function shellQuote(value) {
 	return `'${value.replaceAll("'", "'\\''")}'`;
 }
-function normalizeOptionalText$34(value) {
+function normalizeOptionalText$32(value) {
 	const normalized = String(value ?? "").trim();
 	return normalized.length > 0 ? normalized : null;
 }
@@ -12521,8 +13089,9 @@ const CLAUDE_CODE_CONVERSATION_BRIDGE_SPEC = resolveBuiltinAdapterConversationBr
 const EXPECTED_FORCE_CLOSE_INTERRUPT_ERROR_RE = /query closed before response received/i;
 const createClaudeCodeAdapter = (options) => {
 	const activeAgentSdkQueries = /* @__PURE__ */ new Map();
-	const registerAgentSdkQuery = ({ permissionModeUpdatesAllowed, query, taskId }) => {
+	const registerAgentSdkQuery = ({ liveInput, permissionModeUpdatesAllowed, query, taskId }) => {
 		const activeQuery = {
+			liveInput,
 			permissionModeUpdatesAllowed,
 			query
 		};
@@ -12534,6 +13103,7 @@ const createClaudeCodeAdapter = (options) => {
 	const sendInterrupt = async (signal) => {
 		const activeQuery = activeAgentSdkQueries.get(signal.taskId);
 		if (activeQuery) {
+			activeQuery.liveInput?.close();
 			if (signal.mode === "force") {
 				Promise.resolve().then(() => activeQuery.query.interrupt()).catch((error) => {
 					if (isExpectedForceCloseInterruptError(error)) return;
@@ -12601,6 +13171,22 @@ const createClaudeCodeAdapter = (options) => {
 		cancel: controlShell.cancel,
 		dispatch,
 		interrupt: controlShell.interrupt,
+		steer: async (request) => {
+			const parsed = agentExecutionSteerRequestSchema.safeParse(request);
+			if (!parsed.success) throw new Error("execution_input.invalid");
+			const active = activeAgentSdkQueries.get(parsed.data.taskId);
+			if (!active) return {
+				status: "not_applied",
+				taskId: parsed.data.taskId,
+				reasonCode: "execution_input.target_unavailable"
+			};
+			if (!active.liveInput) return {
+				status: "not_applied",
+				taskId: parsed.data.taskId,
+				reasonCode: "execution_input.unsupported"
+			};
+			return await active.liveInput.steer(parsed.data);
+		},
 		updatePermissionMode
 	};
 };
@@ -12642,7 +13228,7 @@ const resolveDefaultClaudeCodeInvoke = (input) => {
 			...dispatchInput.onRuntimeEvent ? { onRuntimeEvent: dispatchInput.onRuntimeEvent } : {},
 			prompt: dispatchInput.prompt,
 			registerAgentSdkQuery,
-			sessionId: normalizeOptionalText$33(dispatchInput.agentControllerConversationId),
+			sessionId: normalizeOptionalText$31(dispatchInput.agentControllerConversationId),
 			...dispatchInput.onPreview ? { onPreview: dispatchInput.onPreview } : {},
 			streamingMode: dispatchInput.streamingMode,
 			taskId: dispatchInput.taskId
@@ -12663,7 +13249,7 @@ const resolveDefaultClaudeCodeInvoke = (input) => {
 	};
 };
 async function resolveClaudeDispatchLaunchContract(input) {
-	const explicitLaunchContract = input.inputLaunchContract ?? input.optionLaunchContract ?? (normalizeOptionalText$33(input.claudeBin) ? buildExecutableLaunchContract({ commandPath: normalizeOptionalText$33(input.claudeBin) }) : null);
+	const explicitLaunchContract = input.inputLaunchContract ?? input.optionLaunchContract ?? (normalizeOptionalText$31(input.claudeBin) ? buildExecutableLaunchContract({ commandPath: normalizeOptionalText$31(input.claudeBin) }) : null);
 	if (explicitLaunchContract) {
 		const verification = await verifyClaudeCodeLaunchContract({ launchContract: explicitLaunchContract });
 		if (verification.ok) return explicitLaunchContract;
@@ -12677,7 +13263,7 @@ async function resolveClaudeDispatchLaunchContract(input) {
 		errorType: "config"
 	});
 }
-const normalizeOptionalText$33 = (value) => {
+const normalizeOptionalText$31 = (value) => {
 	const normalized = String(value ?? "").trim();
 	return normalized.length > 0 ? normalized : null;
 };
@@ -12732,7 +13318,7 @@ function isCodexSubscriptionAccessFailure(value) {
 const MODEL_NOT_FOUND = /^model not found [a-z0-9_./-]+$/i;
 const CHATGPT_MODEL_NOT_SUPPORTED = /^the '[a-z0-9_./-]+' model is not supported when using codex with a chatgpt account\.?$/i;
 function classifyCodexProviderAccountFailure(input) {
-	if (normalizeOptionalText$32(input.codexErrorInfo)?.toLowerCase() === "usagelimitexceeded") return buildHardProviderFailure({
+	if (normalizeOptionalText$30(input.codexErrorInfo)?.toLowerCase() === "usagelimitexceeded") return buildHardProviderFailure({
 		code: "usage_exhausted",
 		originalError: createProviderOriginalError(input.message),
 		reasonCode: "usage_exhausted"
@@ -12781,7 +13367,7 @@ function withOriginalError(classification, message) {
 		...originalError ? { originalError } : {}
 	};
 }
-function normalizeOptionalText$32(value) {
+function normalizeOptionalText$30(value) {
 	const normalized = String(value ?? "").trim();
 	return normalized.length > 0 ? normalized : null;
 }
@@ -12813,7 +13399,7 @@ function extractCodexToolActivityEvent(value, fallbackObservedAtMs = Date.now())
 	const params = toRecord$9(record.params);
 	const item = toRecord$9(params?.item ?? record.item);
 	const itemType = normalizeCompactName(item?.type);
-	const toolCallId = normalizeOptionalText$31(item?.id);
+	const toolCallId = normalizeOptionalText$29(item?.id);
 	if (!(item && toolCallId && CODEX_TOOL_ITEM_TYPES.has(itemType))) return null;
 	const work = resolveAdapterToolWorkActivity(itemType, item);
 	return {
@@ -12857,7 +13443,7 @@ function resolveObservedAtMs(input) {
 function normalizeCompactName(value) {
 	return typeof value === "string" ? value.trim().toLowerCase() : "";
 }
-function normalizeOptionalText$31(value) {
+function normalizeOptionalText$29(value) {
 	const normalized = typeof value === "string" ? value.trim() : "";
 	return normalized.length > 0 ? normalized : null;
 }
@@ -13753,7 +14339,7 @@ async function probeCodexAppServerAccount(input) {
 }
 async function invokeCodexAppServerTransport(input) {
 	throwIfCodexDispatchCancelled(input.cancellationSignal);
-	const prompt = normalizeOptionalText$30(input.prompt);
+	const prompt = normalizeOptionalText$28(input.prompt);
 	if (!prompt) throw new CodexAppServerTransportError({
 		code: "schema.invalid",
 		errorType: "config",
@@ -13806,7 +14392,7 @@ async function invokeCodexAppServerTransport(input) {
 			threadModel: threadContext.model
 		});
 		const executionThreadId = threadContext.threadId;
-		const continuityThreadId = input.executionMode === "repair" ? normalizeOptionalText$30(input.threadId) ?? executionThreadId : executionThreadId;
+		const continuityThreadId = input.executionMode === "repair" ? normalizeOptionalText$28(input.threadId) ?? executionThreadId : executionThreadId;
 		const turnPrompt = resolveCodexTurnPrompt({
 			fallbackPrompt: prompt,
 			instructionPrompt: input.instructionPrompt,
@@ -13838,7 +14424,7 @@ async function invokeCodexAppServerTransport(input) {
 			errorType: "adapter",
 			message: interactionFailure.message
 		});
-		const output = normalizeOptionalText$30(readAgentMessageOutput(completedTurn) ?? session.readCollectedAgentMessageDeltaText());
+		const output = normalizeOptionalText$28(readAgentMessageOutput(completedTurn) ?? session.readCollectedAgentMessageDeltaText());
 		requireSuccessfulCodexTurn(completedTurn);
 		if (output) session.markAgentOutputObserved();
 		await emitPreviewIfRequested({
@@ -13851,7 +14437,7 @@ async function invokeCodexAppServerTransport(input) {
 			telemetry: session.buildTelemetry({
 				invokedAtMs,
 				previewEmitted: input.streamingMode === "stream" && input.onPreview !== void 0,
-				resumedContext: normalizeOptionalText$30(input.threadId) !== null,
+				resumedContext: normalizeOptionalText$28(input.threadId) !== null,
 				streamingMode: input.streamingMode ?? "final"
 			}),
 			threadId: continuityThreadId
@@ -14015,7 +14601,7 @@ function requireSuccessfulCodexTurn(turn) {
 	});
 }
 async function verifyCodexAppServerThread(input) {
-	const threadId = normalizeOptionalText$30(input.threadId);
+	const threadId = normalizeOptionalText$28(input.threadId);
 	if (!threadId) throw new CodexAppServerTransportError({
 		code: "schema.invalid",
 		errorType: "config",
@@ -14038,7 +14624,7 @@ async function verifyCodexAppServerThread(input) {
 	});
 }
 async function resolveCodexAppServerCompletedTurn(input) {
-	const threadId = normalizeOptionalText$30(input.threadId);
+	const threadId = normalizeOptionalText$28(input.threadId);
 	if (!threadId) throw new CodexAppServerTransportError({
 		code: "schema.invalid",
 		errorType: "config",
@@ -14070,13 +14656,13 @@ async function resolveCodexAppServerCompletedTurn(input) {
 	});
 }
 async function forkCodexAppServerThread(input) {
-	const sourceThreadId = normalizeOptionalText$30(input.sourceThreadId);
+	const sourceThreadId = normalizeOptionalText$28(input.sourceThreadId);
 	if (!sourceThreadId) throw new CodexAppServerTransportError({
 		code: "schema.invalid",
 		errorType: "config",
 		message: "schema.invalid: sourceThreadId is required"
 	});
-	const sourceCompletedTurnId = normalizeOptionalText$30(input.sourceCompletedTurnId);
+	const sourceCompletedTurnId = normalizeOptionalText$28(input.sourceCompletedTurnId);
 	const executionContextScoped = input.computerFileAccessBoundary?.executionContextAccess !== void 0;
 	if (sourceCompletedTurnId && input.forkFullHistory) throw new CodexAppServerTransportError({
 		code: "schema.invalid",
@@ -14131,7 +14717,7 @@ async function forkCodexAppServerThread(input) {
 			code: "context.fork_timeout",
 			operation: "thread/fork"
 		}));
-		const title = normalizeOptionalText$30(input.title);
+		const title = normalizeOptionalText$28(input.title);
 		if (title) try {
 			await session.requestControl("thread/name/set", {
 				name: title,
@@ -14160,7 +14746,7 @@ function scopedRuntimeWorkspaceParams(permissions, workingDirectory) {
 	return permissions.permissions ? { runtimeWorkspaceRoots: [workingDirectory] } : {};
 }
 async function resolveDispatchThreadContext(input) {
-	const existingThreadId = normalizeOptionalText$30(input.threadId);
+	const existingThreadId = normalizeOptionalText$28(input.threadId);
 	if (existingThreadId && input.executionMode === "repair" && (!input.executionContextScoped || input.session.deliveryOnly)) return await forkEphemeralCodexRepairThread({
 		conversationPolicyParams: input.conversationPolicyParams,
 		codexWorkdir: input.codexWorkdir,
@@ -14239,7 +14825,7 @@ function buildOpenMeldCodexThreadSource(instructionEpoch) {
 }
 async function resolveCodexAppServerCollaborationMode(input) {
 	if (input.collaborationMode !== "plan") return null;
-	const model = normalizeOptionalText$30(input.model);
+	const model = normalizeOptionalText$28(input.model);
 	if (!model) throw new CodexAppServerTransportError({
 		code: "protocol.invalid",
 		errorType: "adapter",
@@ -14274,12 +14860,12 @@ async function resolveCodexAppServerTurnCollaborationMode(input) {
 }
 function readCodexAppServerCollaborationModePreset(value) {
 	const preset = toRecord$7(value);
-	const mode = normalizeOptionalText$30(preset?.mode);
+	const mode = normalizeOptionalText$28(preset?.mode);
 	if (mode !== "default" && mode !== "plan") return null;
 	return {
 		mode,
-		model: normalizeOptionalText$30(preset?.model),
-		reasoningEffort: normalizeOptionalText$30(preset?.reasoning_effort)
+		model: normalizeOptionalText$28(preset?.model),
+		reasoningEffort: normalizeOptionalText$28(preset?.reasoning_effort)
 	};
 }
 function resolveCodexAppServerPermissionModeParams(value, executionMode, hasComputerFileAccessBoundary = false, hasExecutionContextBoundary = false) {
@@ -14349,9 +14935,9 @@ function resolveCodexAgentControllerPermissionMode$1(value) {
 }
 function resolveCodexAppServerConversationPolicyParams(conversationPolicy) {
 	const params = {};
-	const model = normalizeOptionalText$30(conversationPolicy?.model);
+	const model = normalizeOptionalText$28(conversationPolicy?.model);
 	if (model) params.model = model;
-	const reasoningLevel = normalizeOptionalText$30(conversationPolicy?.reasoningLevel);
+	const reasoningLevel = normalizeOptionalText$28(conversationPolicy?.reasoningLevel);
 	if (reasoningLevel) params.effort = reasoningLevel;
 	return params;
 }
@@ -14640,7 +15226,7 @@ var CodexAppServerSession = class {
 	}
 	async selectSpaceToolCarrier(input) {
 		if (!this.#spaceActionTools) return;
-		const existingThreadId = normalizeOptionalText$30(input.threadId);
+		const existingThreadId = normalizeOptionalText$28(input.threadId);
 		let nativeThread = false;
 		if (existingThreadId) {
 			nativeThread = await this.readSpaceToolCarrier({
@@ -14727,7 +15313,7 @@ var CodexAppServerSession = class {
 		return this.deliveryOnly ? { environments: [] } : {};
 	}
 	async startDispatchThread(params) {
-		const source = normalizeOptionalText$30(params.threadSource) ?? "user";
+		const source = normalizeOptionalText$28(params.threadSource) ?? "user";
 		try {
 			return await this.requestControl("thread/start", {
 				...params,
@@ -14906,7 +15492,7 @@ var CodexAppServerSession = class {
 		});
 	}
 	setNewSessionTitleInBackground(input) {
-		if (normalizeOptionalText$30(input.existingThreadId) || input.executionMode === "repair" || !input.title) return;
+		if (normalizeOptionalText$28(input.existingThreadId) || input.executionMode === "repair" || !input.title) return;
 		this.request("thread/name/set", {
 			name: input.title,
 			threadId: input.threadId
@@ -14929,7 +15515,7 @@ var CodexAppServerSession = class {
 			if (candidate.method !== "turn/completed") return false;
 			const params = toRecord$7(candidate.params);
 			const turn = toRecord$7(params?.turn);
-			return params?.threadId === input.threadId && normalizeOptionalText$30(turn?.id) === input.turnId;
+			return params?.threadId === input.threadId && normalizeOptionalText$28(turn?.id) === input.turnId;
 		})).params)?.turn);
 		if (!turn) throw new CodexAppServerTransportError({
 			code: "protocol.invalid",
@@ -15063,8 +15649,8 @@ var CodexAppServerSession = class {
 	}
 	#observeContextTelemetry(message) {
 		const params = toRecord$7(message.params);
-		if (message.method === "turn/started" && params?.threadId === this.#usageThreadId) this.#usageTurnId = normalizeOptionalText$30(toRecord$7(params.turn)?.id);
-		if (message.method === "model/rerouted" && params?.threadId === this.#usageThreadId) this.#usageModel = normalizeOptionalText$30(params.toModel);
+		if (message.method === "turn/started" && params?.threadId === this.#usageThreadId) this.#usageTurnId = normalizeOptionalText$28(toRecord$7(params.turn)?.id);
+		if (message.method === "model/rerouted" && params?.threadId === this.#usageThreadId) this.#usageModel = normalizeOptionalText$28(params.toModel);
 		if (message.method === "thread/tokenUsage/updated") {
 			const tokenUsage = readCodexTokenUsage(toRecord$7(message.params)?.tokenUsage);
 			if (tokenUsage) {
@@ -15076,11 +15662,11 @@ var CodexAppServerSession = class {
 		if ((message.method === "item/started" || message.method === "item/completed") && toRecord$7(toRecord$7(message.params)?.item)?.type === "contextCompaction") this.#contextCompactionObserved = true;
 	}
 	#observeAiUsage(params, tokenUsage) {
-		const threadId = normalizeOptionalText$30(params?.threadId);
+		const threadId = normalizeOptionalText$28(params?.threadId);
 		if (!threadId) return;
 		const previousTotal = this.#usageTotalByThread.get(threadId);
 		this.#usageTotalByThread.set(threadId, tokenUsage.total.totalTokens);
-		const turnId = normalizeOptionalText$30(params?.turnId);
+		const turnId = normalizeOptionalText$28(params?.turnId);
 		if (threadId !== this.#usageThreadId || !turnId || turnId !== this.#usageTurnId || previousTotal === tokenUsage.total.totalTokens) return;
 		const eventId = `codex:${threadId}:${turnId}:${tokenUsage.total.totalTokens}`;
 		if (this.#aiUsage.has(eventId)) return;
@@ -15170,7 +15756,7 @@ var CodexAppServerSession = class {
 	#collectAgentMessageDelta(message) {
 		if (message.method !== "item/agentMessage/delta") return;
 		const params = toRecord$7(message.params);
-		const itemId = normalizeOptionalText$30(params?.itemId);
+		const itemId = normalizeOptionalText$28(params?.itemId);
 		const delta = readAgentMessageDeltaText(params?.delta);
 		if (!(itemId && delta)) return;
 		this.markAgentOutputObserved();
@@ -15256,7 +15842,7 @@ var CodexAppServerSession = class {
 		});
 	}
 	emitProviderConversationObserved(threadId) {
-		const agentControllerConversationId = normalizeOptionalText$30(threadId);
+		const agentControllerConversationId = normalizeOptionalText$28(threadId);
 		if (!agentControllerConversationId) return;
 		this.#emitRuntimeEvent({
 			agentControllerConversationId,
@@ -15283,9 +15869,9 @@ function readThreadContextFromResponse(value) {
 	const response = toRecord$7(value);
 	return {
 		permissionResponse: value,
-		model: normalizeOptionalText$30(response?.model),
+		model: normalizeOptionalText$28(response?.model),
 		threadId: readRequiredText(response?.thread?.id, "thread response thread.id"),
-		threadSource: normalizeOptionalText$30(response?.thread?.threadSource)
+		threadSource: normalizeOptionalText$28(response?.thread?.threadSource)
 	};
 }
 function readLastCompletedTurnId(value) {
@@ -15293,8 +15879,8 @@ function readLastCompletedTurnId(value) {
 	const turns = Array.isArray(response?.thread?.turns) ? response.thread.turns : [];
 	for (let index = turns.length - 1; index >= 0; index -= 1) {
 		const turn = turns[index];
-		if (normalizeOptionalText$30(turn?.status) !== "completed") continue;
-		const turnId = normalizeOptionalText$30(turn?.id);
+		if (normalizeOptionalText$28(turn?.status) !== "completed") continue;
+		const turnId = normalizeOptionalText$28(turn?.id);
 		if (turnId) return turnId;
 	}
 	return null;
@@ -15309,14 +15895,14 @@ function readTurnStartResponse(value) {
 	return turn;
 }
 function readAgentMessageOutput(turn) {
-	const text = (Array.isArray(turn.items) ? turn.items : []).filter((item) => item.type === "agentMessage").map((item) => normalizeOptionalText$30(item.text)).filter((item) => item !== null).join("\n").trim();
+	const text = (Array.isArray(turn.items) ? turn.items : []).filter((item) => item.type === "agentMessage").map((item) => normalizeOptionalText$28(item.text)).filter((item) => item !== null).join("\n").trim();
 	return text.length > 0 ? text : null;
 }
 function readTurnFailureMessage(turn) {
-	return normalizeOptionalText$30(turn.error?.message) ?? "codex app-server turn failed";
+	return normalizeOptionalText$28(turn.error?.message) ?? "codex app-server turn failed";
 }
 function readTurnFailureCodexErrorInfo(turn) {
-	return normalizeOptionalText$30(turn.error?.codexErrorInfo);
+	return normalizeOptionalText$28(turn.error?.codexErrorInfo);
 }
 function readCodexTokenUsage(value) {
 	const usage = toRecord$7(value);
@@ -15774,7 +16360,7 @@ function convertCodexMcpElicitationValues(values, schema) {
 	return String(value);
 }
 function normalizeBoundedText$3(value, maxLength) {
-	const text = normalizeOptionalText$30(value);
+	const text = normalizeOptionalText$28(value);
 	return text ? text.slice(0, maxLength) : null;
 }
 function safeJsonStringify(value) {
@@ -15809,7 +16395,7 @@ function buildServerRequestDeclineResponse(method) {
 	}
 }
 function toJsonRpcTransportError$1(error) {
-	const message = normalizeOptionalText$30(error.message) ?? "codex app-server error";
+	const message = normalizeOptionalText$28(error.message) ?? "codex app-server error";
 	const originalError = createProviderOriginalError(message) ?? void 0;
 	if (error.code === -32601) return new CodexAppServerTransportError({
 		code: "runtime.method_unsupported",
@@ -15898,7 +16484,7 @@ function toCodexAppServerTransportError(error, timeoutMs) {
 	});
 }
 function readRequiredText(value, label) {
-	const text = normalizeOptionalText$30(value);
+	const text = normalizeOptionalText$28(value);
 	if (text) return text;
 	throw new CodexAppServerTransportError({
 		code: "protocol.invalid",
@@ -15913,7 +16499,7 @@ function toRecord$7(value) {
 function normalizeText$7(value) {
 	return String(value ?? "").trim();
 }
-function normalizeOptionalText$30(value) {
+function normalizeOptionalText$28(value) {
 	const normalized = normalizeText$7(value);
 	return normalized.length > 0 ? normalized : null;
 }
@@ -15926,7 +16512,7 @@ function isProcessGroupAbsent(processId) {
 	}
 }
 function parseCodexAppServerVersion(response) {
-	return normalizeOptionalText$30(toRecord$7(response)?.userAgent)?.match(CODEX_APP_SERVER_VERSION_PATTERN)?.[1] ?? null;
+	return normalizeOptionalText$28(toRecord$7(response)?.userAgent)?.match(CODEX_APP_SERVER_VERSION_PATTERN)?.[1] ?? null;
 }
 function resolveCodexAppServerAuthStatus(input) {
 	if (input.account) return "authenticated";
@@ -15979,7 +16565,7 @@ async function resolveInstalledCodexLaunchCandidates(input) {
 	const installedCandidates = await resolveInstalledNodeScriptLaunchCandidates({
 		additionalCommandDirectories: resolveCodexAppBundleCommandDirectories(input?.appBundleRoots),
 		commandName: DEFAULT_CODEX_COMMAND,
-		configuredCommand: normalizeOptionalText$29(process.env.OPENMELD_DAEMON_RUNTIME_CODEX_BIN),
+		configuredCommand: normalizeOptionalText$27(process.env.OPENMELD_DAEMON_RUNTIME_CODEX_BIN),
 		displayName: "Codex",
 		preferredLaunchContract: input?.preferredLaunchContract
 	});
@@ -16040,7 +16626,7 @@ async function verifyCodexCommandLaunchContract(input) {
 	});
 }
 function resolveCodexTimeoutMs() {
-	const raw = normalizeOptionalText$29(process.env.OPENMELD_DAEMON_RUNTIME_REQUEST_TIMEOUT_MS);
+	const raw = normalizeOptionalText$27(process.env.OPENMELD_DAEMON_RUNTIME_REQUEST_TIMEOUT_MS);
 	if (!raw) return null;
 	const parsed = Number.parseInt(raw, 10);
 	if (!Number.isFinite(parsed) || parsed <= 0) return null;
@@ -16050,7 +16636,7 @@ function isCodexHostApplicationCommandPath(commandPath) {
 	return resolveCodexAppLabel(commandPath) !== null;
 }
 function resolveCodexAppBundleCommandDirectories(appBundleRoots) {
-	const home = normalizeOptionalText$29(process.env.HOME) ?? homedir();
+	const home = normalizeOptionalText$27(process.env.HOME) ?? homedir();
 	return (appBundleRoots ?? ["/Applications", join(home, "Applications")]).flatMap((root) => CODEX_APP_BUNDLE_NAMES.flatMap((appBundleName) => CODEX_APP_COMMAND_LAYOUTS.map((layout) => dirname(join(root, appBundleName, "Contents", "Resources", ...layout)))));
 }
 async function inspectCodexLaunchCandidate(input) {
@@ -16111,7 +16697,7 @@ function resolveCodexControlProbeTimeoutMs(timeoutMs) {
 function toErrorMessage$14(error) {
 	return error instanceof Error ? error.message : String(error);
 }
-function normalizeOptionalText$29(value) {
+function normalizeOptionalText$27(value) {
 	const normalized = String(value ?? "").trim();
 	return normalized.length > 0 ? normalized : null;
 }
@@ -16172,9 +16758,9 @@ function extractOutputFromCodexLine(line) {
 	const item = record.item && typeof record.item === "object" && !Array.isArray(record.item) ? record.item : null;
 	const response = record.response && typeof record.response === "object" && !Array.isArray(record.response) ? record.response : null;
 	if (record.type === "item.completed" && item?.type === "agent_message") {
-		const phase = normalizeOptionalText$28(item.phase ?? record.phase);
+		const phase = normalizeOptionalText$26(item.phase ?? record.phase);
 		if (phase && phase !== "final_answer") return null;
-		const text = normalizeOptionalText$28(item.text);
+		const text = normalizeOptionalText$26(item.text);
 		return text ? {
 			previewable: false,
 			terminal: true,
@@ -16182,7 +16768,7 @@ function extractOutputFromCodexLine(line) {
 		} : null;
 	}
 	if (record.type === "response.completed") {
-		const text = normalizeOptionalText$28(response?.output_text);
+		const text = normalizeOptionalText$26(response?.output_text);
 		return text ? {
 			previewable: false,
 			terminal: true,
@@ -16212,12 +16798,12 @@ function extractThreadIdFromCodexLine(line) {
 	const record = parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
 	if (!record) return null;
 	if (record.type !== "thread.started") return null;
-	return normalizeOptionalText$28(record.thread_id);
+	return normalizeOptionalText$26(record.thread_id);
 }
 function normalizeText$6(value) {
 	return String(value ?? "").trim();
 }
-function normalizeOptionalText$28(value) {
+function normalizeOptionalText$26(value) {
 	const normalized = normalizeText$6(value);
 	return normalized.length > 0 ? normalized : null;
 }
@@ -16243,7 +16829,7 @@ async function invokeCodexCliTransport(input) {
 		errorType: "config",
 		message: "This Codex CLI path cannot restrict correction to delivery tools. No correction turn was started."
 	});
-	const prompt = normalizeOptionalText$27(input.prompt);
+	const prompt = normalizeOptionalText$25(input.prompt);
 	if (!prompt) throw new CodexCliTransportError({
 		code: "schema.invalid",
 		errorType: "config",
@@ -16336,7 +16922,7 @@ async function invokeCodexCliTransport(input) {
 			providerAccessEvidence: classifiedFailure.providerAccessEvidence
 		});
 	}
-	const output = normalizeOptionalText$27(latestOutput);
+	const output = normalizeOptionalText$25(latestOutput);
 	if (!output) {
 		if (providerErrorMessages.length > 0) {
 			const classifiedFailure = classifyCodexFailure({
@@ -16372,12 +16958,12 @@ async function invokeCodexCliTransport(input) {
 			previewEmitted: previewEmitter.emitted,
 			...driverResult.lifecycle.processId === null ? {} : { processId: driverResult.lifecycle.processId },
 			...driverResult.lifecycle.processSpawnedAtMs === null ? {} : { processSpawnedAtMs: driverResult.lifecycle.processSpawnedAtMs },
-			resumedContext: normalizeOptionalText$27(input.threadId) !== null,
+			resumedContext: normalizeOptionalText$25(input.threadId) !== null,
 			...driverResult.lifecycle.stdinClosedAtMs === null ? {} : { stdinClosedAtMs: driverResult.lifecycle.stdinClosedAtMs },
 			streamingMode: input.streamingMode ?? "final",
 			...driverResult.lifecycle.timeoutTriggeredAtMs === null ? {} : { timeoutTriggeredAtMs: driverResult.lifecycle.timeoutTriggeredAtMs }
 		},
-		threadId: normalizeOptionalText$27(resolvedThreadId)
+		threadId: normalizeOptionalText$25(resolvedThreadId)
 	};
 }
 function extractCodexToolActivityEventFromLine(line) {
@@ -16481,9 +17067,9 @@ function resolveCodexAgentControllerPermissionMode(value) {
 }
 function buildCodexConversationPolicyArgs(conversationPolicy) {
 	const args = [];
-	const model = normalizeOptionalText$27(conversationPolicy?.model);
+	const model = normalizeOptionalText$25(conversationPolicy?.model);
 	if (model) args.push("-m", model);
-	const reasoningLevel = normalizeOptionalText$27(conversationPolicy?.reasoningLevel);
+	const reasoningLevel = normalizeOptionalText$25(conversationPolicy?.reasoningLevel);
 	if (reasoningLevel) args.push("-c", `model_reasoning_effort=${reasoningLevel}`);
 	return args;
 }
@@ -16570,7 +17156,7 @@ const toCodexCliTransportError = (error, timeoutMs) => {
 	});
 };
 const collectCodexErrorMessage = (line, messages) => {
-	const normalizedLine = normalizeOptionalText$27(line);
+	const normalizedLine = normalizeOptionalText$25(line);
 	if (!normalizedLine) return;
 	const jsonMessage = readCodexJsonErrorMessage(normalizedLine);
 	if (jsonMessage) messages.push(jsonMessage);
@@ -16584,14 +17170,14 @@ const readCodexJsonErrorMessage = (line) => {
 	}
 	const record = parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
 	if (!record) return null;
-	const message = normalizeOptionalText$27(record.message);
+	const message = normalizeOptionalText$25(record.message);
 	if (record.type === "error" && message) return message;
-	const errorMessage = normalizeOptionalText$27((record.error && typeof record.error === "object" && !Array.isArray(record.error) ? record.error : null)?.message);
+	const errorMessage = normalizeOptionalText$25((record.error && typeof record.error === "object" && !Array.isArray(record.error) ? record.error : null)?.message);
 	if (record.type === "turn.failed" && errorMessage) return errorMessage;
 	return null;
 };
 const classifyCodexFailure = (input) => {
-	const providerMessage = resolveProviderFailureMessage$2(input);
+	const providerMessage = resolveProviderFailureMessage$1(input);
 	const originalError = providerMessage && input.providerErrorMessages.includes(providerMessage) ? createProviderOriginalError(providerMessage) ?? void 0 : void 0;
 	if (providerMessage) {
 		const lowered = providerMessage.toLowerCase();
@@ -16623,7 +17209,7 @@ const classifyCodexFailure = (input) => {
 			originalError
 		};
 	}
-	const stderrText = normalizeOptionalText$27(input.stderrText);
+	const stderrText = normalizeOptionalText$25(input.stderrText);
 	if (stderrText) return {
 		code: "upstream_unreachable",
 		errorType: "adapter",
@@ -16635,16 +17221,16 @@ const classifyCodexFailure = (input) => {
 		originalError
 	};
 };
-const resolveProviderFailureMessage$2 = (input) => {
+const resolveProviderFailureMessage$1 = (input) => {
 	const candidateMessages = [
 		...input.providerErrorMessages,
-		...normalizeOptionalText$27(input.stderrText) ? [normalizeOptionalText$27(input.stderrText)] : [],
-		...normalizeOptionalText$27(input.stdoutText) ? [normalizeOptionalText$27(input.stdoutText)] : []
+		...normalizeOptionalText$25(input.stderrText) ? [normalizeOptionalText$25(input.stderrText)] : [],
+		...normalizeOptionalText$25(input.stdoutText) ? [normalizeOptionalText$25(input.stdoutText)] : []
 	].filter((value) => Boolean(value));
-	for (const candidate of candidateMessages) if (looksLikeProviderFailure$2(candidate)) return candidate;
+	for (const candidate of candidateMessages) if (looksLikeProviderFailure$1(candidate)) return candidate;
 	return candidateMessages[0] ?? null;
 };
-const looksLikeProviderFailure$2 = (value) => {
+const looksLikeProviderFailure$1 = (value) => {
 	const normalized = value.toLowerCase();
 	return looksLikeRuntimePermissionDenialMessage(value) || classifyCodexProviderAccountFailure({ message: normalized }) !== null;
 };
@@ -16663,7 +17249,7 @@ const toControllerClientUpgradeRequiredMessage = (value) => {
 function normalizeText$5(value) {
 	return String(value ?? "").trim();
 }
-function normalizeOptionalText$27(value) {
+function normalizeOptionalText$25(value) {
 	const normalized = normalizeText$5(value);
 	return normalized.length > 0 ? normalized : null;
 }
@@ -17321,7 +17907,7 @@ const resolveDefaultCodexInvoke = (options) => {
 			...input.onRuntimeEvent ? { onRuntimeEvent: input.onRuntimeEvent } : {},
 			prompt: input.prompt,
 			streamingMode: input.streamingMode,
-			threadId: normalizeOptionalText$26(input.agentControllerConversationId)
+			threadId: normalizeOptionalText$24(input.agentControllerConversationId)
 		});
 		const agentControllerConversation = CODEX_CONVERSATION_BRIDGE_SPEC ? bridgeAgentControllerConversationRef({
 			bridgeSpec: CODEX_CONVERSATION_BRIDGE_SPEC,
@@ -17382,7 +17968,7 @@ const resolveDefaultCodexAppServerInvoke = (input) => {
 			prompt: dispatchInput.prompt,
 			streamingMode: dispatchInput.streamingMode,
 			taskId: dispatchInput.taskId,
-			threadId: normalizeOptionalText$26(dispatchInput.agentControllerConversationId)
+			threadId: normalizeOptionalText$24(dispatchInput.agentControllerConversationId)
 		});
 		const agentControllerConversation = CODEX_CONVERSATION_BRIDGE_SPEC ? bridgeAgentControllerConversationRef({
 			bridgeSpec: CODEX_CONVERSATION_BRIDGE_SPEC,
@@ -17443,9 +18029,9 @@ async function resolveCodexDispatchLaunchContract(input) {
 	});
 }
 function resolveConfiguredCodexLaunchContract(input) {
-	return input.inputLaunchContract ?? input.optionLaunchContract ?? (normalizeOptionalText$26(input.codexBin) ? buildExecutableLaunchContract({ commandPath: normalizeOptionalText$26(input.codexBin) }) : null);
+	return input.inputLaunchContract ?? input.optionLaunchContract ?? (normalizeOptionalText$24(input.codexBin) ? buildExecutableLaunchContract({ commandPath: normalizeOptionalText$24(input.codexBin) }) : null);
 }
-const normalizeOptionalText$26 = (value) => {
+const normalizeOptionalText$24 = (value) => {
 	const normalized = String(value ?? "").trim();
 	return normalized.length > 0 ? normalized : null;
 };
@@ -17508,7 +18094,7 @@ async function resolveInstalledCursorLaunchCandidates(input) {
 	const installedCandidates = await resolveInstalledNodeScriptLaunchCandidates({
 		additionalCommandDirectories: resolveCursorCommandDirectories(),
 		commandName: DEFAULT_CURSOR_COMMAND,
-		configuredCommand: normalizeOptionalText$25(process.env.OPENMELD_DAEMON_RUNTIME_CURSOR_BIN),
+		configuredCommand: normalizeOptionalText$23(process.env.OPENMELD_DAEMON_RUNTIME_CURSOR_BIN),
 		displayName: "Cursor CLI",
 		preferredLaunchContract: input?.preferredLaunchContract
 	});
@@ -17531,7 +18117,7 @@ async function resolveInstalledCursorLaunchCandidates(input) {
 	};
 }
 async function refreshCursorPersistedLaunchContract(input) {
-	const configuredCommand = normalizeOptionalText$25(process.env.OPENMELD_DAEMON_RUNTIME_CURSOR_BIN);
+	const configuredCommand = normalizeOptionalText$23(process.env.OPENMELD_DAEMON_RUNTIME_CURSOR_BIN);
 	if (configuredCommand) {
 		const resolution = await resolveInstalledNodeScriptLaunchContract({
 			commandName: DEFAULT_CURSOR_COMMAND,
@@ -17545,7 +18131,7 @@ async function refreshCursorPersistedLaunchContract(input) {
 	}
 	if (input.launchContract.kind !== "node_script") return input.launchContract;
 	const persistedLaunchContract = input.launchContract;
-	const home = normalizeOptionalText$25(process.env.HOME) ?? homedir();
+	const home = normalizeOptionalText$23(process.env.HOME) ?? homedir();
 	const managedVersionsRoot = join(home, ".local", "share", "cursor-agent", "versions");
 	const canonicalManagedVersionsRoot = await realpath(managedVersionsRoot).catch(() => managedVersionsRoot);
 	const canonicalPersistedScriptPath = await realpath(persistedLaunchContract.scriptPath).catch(() => persistedLaunchContract.scriptPath);
@@ -17585,7 +18171,7 @@ async function verifyCursorLaunchContract(input) {
 	});
 }
 function resolveCursorTimeoutMs() {
-	const raw = normalizeOptionalText$25(process.env.OPENMELD_DAEMON_RUNTIME_REQUEST_TIMEOUT_MS);
+	const raw = normalizeOptionalText$23(process.env.OPENMELD_DAEMON_RUNTIME_REQUEST_TIMEOUT_MS);
 	if (!raw) return null;
 	const parsed = Number.parseInt(raw, 10);
 	if (!Number.isFinite(parsed) || parsed <= 0) return null;
@@ -17598,7 +18184,7 @@ function isIncompleteLaunchContractCheck(verification) {
 	return !verification.ok && verification.failureKind === "incomplete_check";
 }
 function resolveCursorCommandDirectories() {
-	return resolveCursorCommandPaths(normalizeOptionalText$25(process.env.HOME) ?? homedir()).map(dirname);
+	return resolveCursorCommandPaths(normalizeOptionalText$23(process.env.HOME) ?? homedir()).map(dirname);
 }
 function resolveCursorCommandPaths(home) {
 	return [join(home, ".local", "bin", DEFAULT_CURSOR_COMMAND), join(home, ".cursor", "bin", DEFAULT_CURSOR_COMMAND)];
@@ -17607,7 +18193,7 @@ function isManagedCursorVersionScript(input) {
 	const segments = relative(input.managedVersionsRoot, input.scriptPath).split(PATH_SEGMENT_SPLIT_RE);
 	return segments.length === 2 && segments[0] !== ".." && segments[0] !== "." && segments[1] === DEFAULT_CURSOR_COMMAND;
 }
-function normalizeOptionalText$25(value) {
+function normalizeOptionalText$23(value) {
 	const normalized = String(value ?? "").trim();
 	return normalized.length > 0 ? normalized : null;
 }
@@ -18041,13 +18627,13 @@ var CursorAcpTransportError = class extends Error {
 	}
 };
 async function invokeCursorAcpTransport(input) {
-	const prompt = normalizeOptionalText$24(input.prompt);
+	const prompt = normalizeOptionalText$22(input.prompt);
 	if (!prompt) throw new CursorAcpTransportError({
 		code: "schema.invalid",
 		errorType: "config",
 		message: "schema.invalid: prompt is required"
 	});
-	if (normalizeOptionalText$24(input.conversationPolicy?.reasoningLevel)) throw new CursorAcpTransportError({
+	if (normalizeOptionalText$22(input.conversationPolicy?.reasoningLevel)) throw new CursorAcpTransportError({
 		code: "model.reasoning_unsupported",
 		errorType: "config",
 		message: "model.reasoning_unsupported: Cursor ACP does not expose reasoning strength as an independent session option; choose an exact Cursor ACP model variant instead"
@@ -18093,13 +18679,13 @@ async function invokeCursorAcpTransport(input) {
 }
 async function runCursorAcpTurn(input) {
 	await input.session.initialize();
-	const existingSessionId = normalizeOptionalText$24(input.input.sessionId);
+	const existingSessionId = normalizeOptionalText$22(input.input.sessionId);
 	const initialDescriptor = await input.session.openSession({ sessionId: input.deliveryScope ? null : existingSessionId });
 	const continuitySessionId = input.deliveryScope ? existingSessionId ?? initialDescriptor.sessionId : initialDescriptor.sessionId;
 	input.session.emitProviderConversationObserved(continuitySessionId);
 	const modelResolution = await resolveCursorSessionModel({
 		descriptor: initialDescriptor,
-		model: normalizeOptionalText$24(input.input.conversationPolicy?.model),
+		model: normalizeOptionalText$22(input.input.conversationPolicy?.model),
 		session: input.session
 	});
 	const { descriptor } = modelResolution;
@@ -18366,7 +18952,7 @@ var CursorAcpSession = class {
 			return readSessionDescriptor(result, input.sessionId, "load");
 		}
 		const result = await this.request("session/new", params);
-		const sessionId = normalizeOptionalText$24(toRecord$5(result)?.sessionId);
+		const sessionId = normalizeOptionalText$22(toRecord$5(result)?.sessionId);
 		if (!sessionId) throw new CursorAcpTransportError({
 			code: "protocol.invalid",
 			errorType: "adapter",
@@ -18529,8 +19115,8 @@ function readSessionDescriptor(value, sessionId, sessionOperation) {
 	const modelConfig = readConfigOption(record, "model");
 	const legacyAvailableModelIds = readLegacyAvailableModelIds(models);
 	const configAvailableModelIds = readConfigAvailableModelIds(modelConfig);
-	const legacyCurrentModelId = normalizeOptionalText$24(models?.currentModelId);
-	const configCurrentModelId = normalizeOptionalText$24(modelConfig?.currentValue);
+	const legacyCurrentModelId = normalizeOptionalText$22(models?.currentModelId);
+	const configCurrentModelId = normalizeOptionalText$22(modelConfig?.currentValue);
 	const modelInventory = resolveModelInventory({
 		configAvailableModelIds,
 		configCurrentModelId,
@@ -18542,7 +19128,7 @@ function readSessionDescriptor(value, sessionId, sessionOperation) {
 		availableModelIds: modelInventory.availableModelIds,
 		configAvailableModelIds,
 		configCurrentModelId,
-		currentModeId: normalizeOptionalText$24(modes?.currentModeId) ?? readCurrentConfigValue(record, "mode"),
+		currentModeId: normalizeOptionalText$22(modes?.currentModeId) ?? readCurrentConfigValue(record, "mode"),
 		currentModelId: modelInventory.currentModelId,
 		legacyAvailableModelIds,
 		legacyCurrentModelId,
@@ -18558,7 +19144,7 @@ function readConfigAvailableModelIds(modelConfig) {
 	return uniqueModelIds((Array.isArray(modelConfig?.options) ? modelConfig.options : []).map((option) => toRecord$5(option)?.value));
 }
 function uniqueModelIds(values) {
-	return [...new Set(values.map(normalizeOptionalText$24).filter((modelId) => modelId !== null))];
+	return [...new Set(values.map(normalizeOptionalText$22).filter((modelId) => modelId !== null))];
 }
 function resolveModelInventory(input) {
 	const currentModelId = input.configCurrentModelId ?? input.legacyCurrentModelId;
@@ -18630,10 +19216,10 @@ function sanitizeDiagnosticModelId$1(modelId) {
 	return modelId === null ? null : modelId.slice(0, MAX_MODEL_DIAGNOSTIC_ID_CHARS$1);
 }
 function readCurrentConfigValue(record, id) {
-	return normalizeOptionalText$24(readConfigOption(record, id)?.currentValue);
+	return normalizeOptionalText$22(readConfigOption(record, id)?.currentValue);
 }
 function readConfigOption(record, id) {
-	return (Array.isArray(record?.configOptions) ? record.configOptions : []).map(toRecord$5).find((option) => (normalizeOptionalText$24(option?.configId) ?? normalizeOptionalText$24(option?.id)) === id) ?? null;
+	return (Array.isArray(record?.configOptions) ? record.configOptions : []).map(toRecord$5).find((option) => (normalizeOptionalText$22(option?.configId) ?? normalizeOptionalText$22(option?.id)) === id) ?? null;
 }
 function resolveCursorAcpMode(value) {
 	switch (resolveCursorPermissionMode(value)) {
@@ -18660,7 +19246,7 @@ function buildCursorAcpArgs(permissionMode) {
 	}
 }
 function assertSuccessfulStopReason$1(value) {
-	const stopReason = normalizeOptionalText$24(toRecord$5(value)?.stopReason);
+	const stopReason = normalizeOptionalText$22(toRecord$5(value)?.stopReason);
 	if (!stopReason) throw new CursorAcpTransportError({
 		code: "protocol.invalid",
 		errorType: "adapter",
@@ -18681,7 +19267,7 @@ async function emitFinalPreviewIfRequested$1(input) {
 	await input.onPreview({ text: input.output });
 }
 function toJsonRpcTransportError(error) {
-	const message = normalizeOptionalText$24(error.message) ?? "Cursor ACP error";
+	const message = normalizeOptionalText$22(error.message) ?? "Cursor ACP error";
 	const originalError = createProviderOriginalError(message);
 	if (error.code === -32601) return new CursorAcpTransportError({
 		code: "protocol.method_not_found",
@@ -18705,7 +19291,7 @@ function toCursorAcpTransportError(error, stderr, diagnostics) {
 		message: error.message,
 		...error.originalError ? { originalError: error.originalError } : {}
 	});
-	const classified = classifyCursorFailure([toErrorMessage$11(error), normalizeOptionalText$24(stderr)].filter((value) => value !== null).join("\n"));
+	const classified = classifyCursorFailure([toErrorMessage$11(error), normalizeOptionalText$22(stderr)].filter((value) => value !== null).join("\n"));
 	return diagnostics ? new CursorAcpTransportError({
 		code: classified.code,
 		diagnostics,
@@ -18714,7 +19300,7 @@ function toCursorAcpTransportError(error, stderr, diagnostics) {
 	}) : classified;
 }
 function classifyCursorFailure(message, originalError = null) {
-	const normalized = normalizeOptionalText$24(message) ?? "Cursor ACP error";
+	const normalized = normalizeOptionalText$22(message) ?? "Cursor ACP error";
 	const lowered = normalized.toLowerCase();
 	if (isCursorPlanUpgradeRequired(normalized)) return new CursorAcpTransportError({
 		code: "cursor.plan_upgrade_required",
@@ -18750,7 +19336,7 @@ function classifyCursorFailure(message, originalError = null) {
 function normalizeOutputText$2(value) {
 	return typeof value === "string" && value.length > 0 ? value : null;
 }
-function normalizeOptionalText$24(value) {
+function normalizeOptionalText$22(value) {
 	const normalized = typeof value === "string" ? value.trim() : "";
 	return normalized.length > 0 ? normalized : null;
 }
@@ -18851,7 +19437,7 @@ function createDefaultCursorInvoke(input) {
 			});
 		} : void 0;
 		const result = await invokeWithSingleContextHeal({
-			contextId: normalizeOptionalText$23(dispatchInput.agentControllerConversationId),
+			contextId: normalizeOptionalText$21(dispatchInput.agentControllerConversationId),
 			contextLossPolicy: dispatchInput.executionMode === "repair" ? "fail" : "rebuild",
 			createRebuildFailedError: (error) => error instanceof CursorAcpTransportError && error.code === "cursor.plan_upgrade_required" ? error : new CursorAcpTransportError({
 				cause: error,
@@ -18906,7 +19492,7 @@ function createDefaultCursorInvoke(input) {
 	};
 }
 async function resolveCursorDispatchLaunchContract(input) {
-	const launchContract = input.inputLaunchContract ?? input.optionLaunchContract ?? (normalizeOptionalText$23(input.cursorBin) ? buildExecutableLaunchContract({ commandPath: normalizeOptionalText$23(input.cursorBin) }) : null);
+	const launchContract = input.inputLaunchContract ?? input.optionLaunchContract ?? (normalizeOptionalText$21(input.cursorBin) ? buildExecutableLaunchContract({ commandPath: normalizeOptionalText$21(input.cursorBin) }) : null);
 	if (!launchContract) throw Object.assign(/* @__PURE__ */ new Error("Cursor CLI launch contract is required for runtime dispatch."), {
 		code: "controller.launch.needs_repair",
 		errorType: "config"
@@ -18979,7 +19565,7 @@ async function interruptActiveCursorTurn(input) {
 		};
 	}
 }
-function normalizeOptionalText$23(value) {
+function normalizeOptionalText$21(value) {
 	const normalized = typeof value === "string" ? value.trim() : "";
 	return normalized.length > 0 ? normalized : null;
 }
@@ -19006,7 +19592,7 @@ async function resolveInstalledGrokBuildLaunchCandidates(input) {
 	const installedCandidates = await resolveInstalledNodeScriptLaunchCandidates({
 		additionalCommandDirectories: [join(resolveHome(), ".grok", "bin")],
 		commandName: DEFAULT_GROK_BUILD_COMMAND,
-		configuredCommand: normalizeOptionalText$22(process.env.OPENMELD_DAEMON_RUNTIME_GROK_BUILD_BIN),
+		configuredCommand: normalizeOptionalText$20(process.env.OPENMELD_DAEMON_RUNTIME_GROK_BUILD_BIN),
 		displayName: "Grok Build",
 		preferredLaunchContract: input?.preferredLaunchContract
 	});
@@ -19039,15 +19625,15 @@ async function verifyGrokBuildLaunchContract(input) {
 	});
 }
 function resolveGrokBuildTimeoutMs() {
-	const raw = normalizeOptionalText$22(process.env.OPENMELD_DAEMON_RUNTIME_REQUEST_TIMEOUT_MS);
+	const raw = normalizeOptionalText$20(process.env.OPENMELD_DAEMON_RUNTIME_REQUEST_TIMEOUT_MS);
 	if (!raw) return null;
 	const parsed = Number.parseInt(raw, 10);
 	return Number.isFinite(parsed) && parsed > 0 ? parsed : null;
 }
 function resolveHome() {
-	return normalizeOptionalText$22(process.env.HOME) ?? homedir();
+	return normalizeOptionalText$20(process.env.HOME) ?? homedir();
 }
-function normalizeOptionalText$22(value) {
+function normalizeOptionalText$20(value) {
 	const normalized = String(value ?? "").trim();
 	return normalized.length > 0 ? normalized : null;
 }
@@ -20423,7 +21009,7 @@ async function invokeGrokBuildAcpTransport(input) {
 		errorType: "config",
 		message: "The current Wake's delivery capability is missing. No correction turn was started."
 	});
-	const prompt = normalizeOptionalText$21(input.prompt);
+	const prompt = normalizeOptionalText$19(input.prompt);
 	if (!prompt) throw new GrokBuildAcpTransportError({
 		code: "schema.invalid",
 		errorType: "config",
@@ -20450,9 +21036,9 @@ async function invokeGrokBuildAcpTransport(input) {
 	try {
 		session.start();
 		await session.initialize({ collectUsageLimits: false });
-		const existingSessionId = normalizeOptionalText$21(input.sessionId);
+		const existingSessionId = normalizeOptionalText$19(input.sessionId);
 		const descriptor = await session.openSession({
-			requestedModelId: normalizeOptionalText$21(input.conversationPolicy?.model),
+			requestedModelId: normalizeOptionalText$19(input.conversationPolicy?.model),
 			sessionId: deliveryScope ? null : existingSessionId
 		});
 		await verifyOptionalDeliveryScope(deliveryScope, session, descriptor.sessionId);
@@ -20460,8 +21046,8 @@ async function invokeGrokBuildAcpTransport(input) {
 		session.emitProviderConversationObserved(continuitySessionId);
 		await session.applyModelSelection({
 			descriptor,
-			reasoningEffort: normalizeOptionalText$21(input.conversationPolicy?.reasoningLevel),
-			requestedModelId: normalizeOptionalText$21(input.conversationPolicy?.model)
+			reasoningEffort: normalizeOptionalText$19(input.conversationPolicy?.reasoningLevel),
+			requestedModelId: normalizeOptionalText$19(input.conversationPolicy?.model)
 		});
 		const unregisterActiveTurn = input.onActiveTurn?.({
 			cancel: () => session.cancelAndCloseSession(descriptor.sessionId),
@@ -20693,7 +21279,7 @@ var GrokBuildAcpSession = class {
 			throw error;
 		}
 		const record = toRecord$2(result);
-		const sessionId = normalizeOptionalText$21(record?.sessionId) ?? input.sessionId ?? null;
+		const sessionId = normalizeOptionalText$19(record?.sessionId) ?? input.sessionId ?? null;
 		if (!sessionId) throw new GrokBuildAcpTransportError({
 			code: "protocol.invalid",
 			errorType: "adapter",
@@ -20808,7 +21394,7 @@ var GrokBuildAcpSession = class {
 		if (toolActivity) this.#emitRuntimeEvent(toolActivity);
 	}
 	async #handleClientRequest(request) {
-		const requestSessionId = normalizeOptionalText$21(toRecord$2(request.params)?.sessionId);
+		const requestSessionId = normalizeOptionalText$19(toRecord$2(request.params)?.sessionId);
 		if (!(this.#turnActive && requestSessionId !== null && this.#sessionId !== null && requestSessionId === this.#sessionId)) {
 			this.#recordInteractionFailure("interaction.session_mismatch", "interaction.session_mismatch: Grok Build requested input for a different session");
 			return { error: {
@@ -20924,10 +21510,10 @@ function buildSessionDescriptor(input) {
 }
 function readModelState(value) {
 	const record = toRecord$2(value);
-	const currentModelId = normalizeOptionalText$21(record?.currentModelId);
+	const currentModelId = normalizeOptionalText$19(record?.currentModelId);
 	const models = (Array.isArray(record?.availableModels) ? record.availableModels : []).flatMap((candidate) => {
 		const model = toRecord$2(candidate);
-		const modelId = normalizeOptionalText$21(model?.modelId);
+		const modelId = normalizeOptionalText$19(model?.modelId);
 		if (!modelId) return [];
 		const meta = toRecord$2(model?._meta);
 		const efforts = Array.isArray(meta?.reasoningEfforts) ? uniqueStrings(meta.reasoningEfforts.map((effort) => {
@@ -20935,8 +21521,8 @@ function readModelState(value) {
 			return record?.value ?? record?.id;
 		})) : [];
 		return [{
-			currentEffort: normalizeOptionalText$21(meta?.reasoningEffort),
-			displayName: normalizeOptionalText$21(model?.name) ?? modelId,
+			currentEffort: normalizeOptionalText$19(meta?.reasoningEffort),
+			displayName: normalizeOptionalText$19(model?.name) ?? modelId,
 			efforts,
 			modelId
 		}];
@@ -20978,10 +21564,10 @@ function buildModelNegotiationDiagnostics(input) {
 }
 function resolveNonInteractiveAuthMethod(initializeResult) {
 	const authMethodIds = (Array.isArray(initializeResult.authMethods) ? initializeResult.authMethods : []).flatMap((method) => {
-		const methodId = normalizeOptionalText$21(toRecord$2(method)?.id);
+		const methodId = normalizeOptionalText$19(toRecord$2(method)?.id);
 		return methodId ? [methodId] : [];
 	});
-	const preferred = normalizeOptionalText$21(toRecord$2(initializeResult._meta)?.defaultAuthMethodId);
+	const preferred = normalizeOptionalText$19(toRecord$2(initializeResult._meta)?.defaultAuthMethodId);
 	if (preferred && (/* @__PURE__ */ new Set(["cached_token", "xai.api_key"])).has(preferred) && authMethodIds.includes(preferred)) return preferred;
 	if (authMethodIds.includes("cached_token")) return "cached_token";
 	if (authMethodIds.includes("xai.api_key")) return "xai.api_key";
@@ -21026,7 +21612,7 @@ async function resolveCanonicalDirectory(value) {
 	}
 }
 function assertSuccessfulStopReason(value) {
-	const stopReason = normalizeOptionalText$21(toRecord$2(value)?.stopReason);
+	const stopReason = normalizeOptionalText$19(toRecord$2(value)?.stopReason);
 	if (!stopReason) throw new GrokBuildAcpTransportError({
 		code: "protocol.invalid",
 		errorType: "adapter",
@@ -21044,7 +21630,7 @@ async function emitFinalPreviewIfRequested(input) {
 	await input.onPreview({ text: input.output });
 }
 function toGrokBuildTransportError(error, stderr, diagnostics) {
-	const combined = [toErrorMessage$9(error), normalizeOptionalText$21(stderr)].filter((value) => value !== null).join("\n");
+	const combined = [toErrorMessage$9(error), normalizeOptionalText$19(stderr)].filter((value) => value !== null).join("\n");
 	const providerFailure = !(error instanceof GrokBuildAcpTransportError) || error.code.startsWith("protocol.") ? classifyGrokBuildProviderFailure({
 		message: combined,
 		originalError: error instanceof GrokBuildAcpTransportError ? error.originalError : void 0
@@ -21068,7 +21654,7 @@ function toGrokBuildTransportError(error, stderr, diagnostics) {
 	const classified = new GrokBuildAcpTransportError({
 		code: "upstream_unreachable",
 		errorType: "adapter",
-		message: `upstream_unreachable: ${normalizeOptionalText$21(combined) ?? "Grok Build ACP error"}`
+		message: `upstream_unreachable: ${normalizeOptionalText$19(combined) ?? "Grok Build ACP error"}`
 	});
 	return diagnostics ? new GrokBuildAcpTransportError({
 		cause: error,
@@ -21086,7 +21672,7 @@ function toGrokBuildJsonRpcTransportError(error) {
 		code = "protocol.invalid_params";
 		errorType = "config";
 	}
-	const message = normalizeOptionalText$21(error.message) ?? "ACP request failed";
+	const message = normalizeOptionalText$19(error.message) ?? "ACP request failed";
 	const originalError = createProviderOriginalError(message);
 	return new GrokBuildAcpTransportError({
 		code,
@@ -21096,7 +21682,7 @@ function toGrokBuildJsonRpcTransportError(error) {
 	});
 }
 function classifyGrokBuildProviderFailure(input) {
-	const normalized = normalizeOptionalText$21(input.message) ?? "Grok Build ACP error";
+	const normalized = normalizeOptionalText$19(input.message) ?? "Grok Build ACP error";
 	if (AUTH_FAILURE_RE.test(normalized)) return new GrokBuildAcpTransportError({
 		code: "auth.failed",
 		errorType: "auth",
@@ -21121,12 +21707,12 @@ function haveSameStrings(left, right) {
 	return left.length === right.length && left.every((value) => right.includes(value));
 }
 function uniqueStrings(values) {
-	return [...new Set(values.map(normalizeOptionalText$21).filter((value) => value !== null))];
+	return [...new Set(values.map(normalizeOptionalText$19).filter((value) => value !== null))];
 }
 function normalizeOutputText$1(value) {
 	return typeof value === "string" && value.length > 0 ? value : null;
 }
-function normalizeOptionalText$21(value) {
+function normalizeOptionalText$19(value) {
 	const normalized = typeof value === "string" ? value.trim() : "";
 	return normalized.length > 0 ? normalized : null;
 }
@@ -21197,7 +21783,7 @@ function createDefaultGrokBuildInvoke(input) {
 			});
 		} : void 0;
 		const result = await invokeWithSingleContextHeal({
-			contextId: normalizeOptionalText$20(dispatchInput.agentControllerConversationId),
+			contextId: normalizeOptionalText$18(dispatchInput.agentControllerConversationId),
 			contextLossPolicy: dispatchInput.executionMode === "repair" ? "fail" : "rebuild",
 			createRebuildFailedError: (error) => new GrokBuildAcpTransportError({
 				cause: error,
@@ -21252,7 +21838,7 @@ function createDefaultGrokBuildInvoke(input) {
 	};
 }
 async function resolveGrokBuildDispatchLaunchContract(input) {
-	const commandPath = normalizeOptionalText$20(input.grokBuildBin);
+	const commandPath = normalizeOptionalText$18(input.grokBuildBin);
 	const launchContract = input.inputLaunchContract ?? input.optionLaunchContract ?? (commandPath ? buildExecutableLaunchContract({ commandPath }) : null);
 	if (!launchContract) throw Object.assign(/* @__PURE__ */ new Error("Grok Build launch contract is required for runtime dispatch."), {
 		code: "controller.launch.needs_repair",
@@ -21311,7 +21897,7 @@ async function interruptActiveGrokBuildTurn(input) {
 		taskId: result.taskId
 	};
 }
-function normalizeOptionalText$20(value) {
+function normalizeOptionalText$18(value) {
 	const normalized = typeof value === "string" ? value.trim() : "";
 	return normalized.length > 0 ? normalized : null;
 }
@@ -21338,7 +21924,7 @@ const DEFAULT_OPENCLAW_AGENT_ID = "main";
 async function resolveInstalledOpenClawLaunchCandidates(input) {
 	const installedCandidates = await resolveInstalledNodeScriptLaunchCandidates({
 		commandName: DEFAULT_OPENCLAW_COMMAND,
-		configuredCommand: normalizeOptionalText$19(process.env.OPENMELD_DAEMON_RUNTIME_OPENCLAW_BIN),
+		configuredCommand: normalizeOptionalText$17(process.env.OPENMELD_DAEMON_RUNTIME_OPENCLAW_BIN),
 		displayName: "OpenClaw",
 		preferredLaunchContract: input?.preferredLaunchContract
 	});
@@ -21372,9 +21958,9 @@ async function verifyOpenClawLaunchContract(input) {
 }
 function resolveOpenClawBinCandidates(explicitOpenClawBin) {
 	const candidates = [];
-	const explicitCandidate = normalizeOptionalText$19(explicitOpenClawBin);
+	const explicitCandidate = normalizeOptionalText$17(explicitOpenClawBin);
 	if (explicitCandidate) candidates.push(explicitCandidate);
-	const configuredCandidate = normalizeOptionalText$19(process.env.OPENMELD_DAEMON_RUNTIME_OPENCLAW_BIN);
+	const configuredCandidate = normalizeOptionalText$17(process.env.OPENMELD_DAEMON_RUNTIME_OPENCLAW_BIN);
 	if (configuredCandidate && !candidates.includes(configuredCandidate)) candidates.push(configuredCandidate);
 	const nodeSiblingCandidate = resolveSiblingCommandPath({
 		anchorPath: process.execPath,
@@ -21390,16 +21976,16 @@ function resolveOpenClawBinCandidates(explicitOpenClawBin) {
 	return candidates;
 }
 function resolveOpenClawTimeoutMs() {
-	const raw = normalizeOptionalText$19(process.env.OPENMELD_DAEMON_RUNTIME_REQUEST_TIMEOUT_MS);
+	const raw = normalizeOptionalText$17(process.env.OPENMELD_DAEMON_RUNTIME_REQUEST_TIMEOUT_MS);
 	if (!raw) return null;
 	const parsed = Number.parseInt(raw, 10);
 	if (!Number.isFinite(parsed) || parsed <= 0) return null;
 	return parsed;
 }
 function resolveOpenClawAgentId$1() {
-	return normalizeOptionalText$19(process.env.OPENMELD_DAEMON_RUNTIME_OPENCLAW_AGENT_ID) ?? DEFAULT_OPENCLAW_AGENT_ID;
+	return normalizeOptionalText$17(process.env.OPENMELD_DAEMON_RUNTIME_OPENCLAW_AGENT_ID) ?? DEFAULT_OPENCLAW_AGENT_ID;
 }
-function normalizeOptionalText$19(value) {
+function normalizeOptionalText$17(value) {
 	const normalized = String(value ?? "").trim();
 	return normalized.length > 0 ? normalized : null;
 }
@@ -21469,10 +22055,10 @@ function parseOpenClawOutputLine(line) {
 	}
 	const record = parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
 	if (!record) return null;
-	const isErrorResult = resolveIsErrorResult$1(record);
-	const errorMessage = resolveErrorMessage$1(record, isErrorResult);
-	const resultText = resolveResultText$1(record, isErrorResult);
-	const sessionId = resolveSessionId$1(record);
+	const isErrorResult = resolveIsErrorResult(record);
+	const errorMessage = resolveErrorMessage(record, isErrorResult);
+	const resultText = resolveResultText(record, isErrorResult);
+	const sessionId = resolveSessionId(record);
 	if (!errorMessage && resultText === null && sessionId === null) return null;
 	return {
 		errorMessage,
@@ -21493,8 +22079,8 @@ function parseOpenClawOutputDocument(text) {
 	}
 	const record = parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
 	if (!record) return null;
-	const isErrorResult = resolveIsErrorResult$1(record);
-	const errorMessage = resolveErrorMessage$1(record, isErrorResult);
+	const isErrorResult = resolveIsErrorResult(record);
+	const errorMessage = resolveErrorMessage(record, isErrorResult);
 	const outputText = resolveDocumentOutputText(record, isErrorResult);
 	const sessionId = resolveDocumentSessionId(record);
 	if (!errorMessage && outputText === null && sessionId === null) return null;
@@ -21505,11 +22091,11 @@ function parseOpenClawOutputDocument(text) {
 		sessionId
 	};
 }
-function resolveSessionId$1(record) {
-	return resolveStringByPaths$1(record, OPENCLAW_SESSION_ID_PATHS);
+function resolveSessionId(record) {
+	return resolveStringByPaths(record, OPENCLAW_SESSION_ID_PATHS);
 }
 function resolveDocumentSessionId(record) {
-	return resolveStringByPaths$1(record, [
+	return resolveStringByPaths(record, [
 		...OPENCLAW_SESSION_ID_PATHS,
 		[
 			"meta",
@@ -21519,35 +22105,35 @@ function resolveDocumentSessionId(record) {
 		["meta", "sessionId"]
 	]) ?? null;
 }
-function resolveResultText$1(record, isErrorResult) {
+function resolveResultText(record, isErrorResult) {
 	if (isErrorResult === true) return null;
-	return resolveStringByPaths$1(record, OPENCLAW_RESULT_TEXT_PATHS);
+	return resolveStringByPaths(record, OPENCLAW_RESULT_TEXT_PATHS);
 }
 function resolveDocumentOutputText(record, isErrorResult) {
 	if (isErrorResult === true) return null;
 	const payloadText = resolvePayloadsText(record.payloads);
 	if (payloadText) return payloadText;
-	return resolveResultText$1(record, isErrorResult);
+	return resolveResultText(record, isErrorResult);
 }
-function resolveErrorMessage$1(record, isErrorResult) {
+function resolveErrorMessage(record, isErrorResult) {
 	if (isErrorResult !== true) return null;
-	return resolveStringByPaths$1(record, OPENCLAW_ERROR_MESSAGE_PATHS) ?? resolveStringByPaths$1(record, OPENCLAW_RESULT_TEXT_PATHS);
+	return resolveStringByPaths(record, OPENCLAW_ERROR_MESSAGE_PATHS) ?? resolveStringByPaths(record, OPENCLAW_RESULT_TEXT_PATHS);
 }
-function resolveIsErrorResult$1(record) {
+function resolveIsErrorResult(record) {
 	if (typeof record.is_error === "boolean") return record.is_error;
 	if (typeof record.isError === "boolean") return record.isError;
 	if (typeof record.ok === "boolean") return !record.ok;
 	if (typeof record.success === "boolean") return !record.success;
-	const status = normalizeOptionalText$18(record.status)?.toLowerCase();
+	const status = normalizeOptionalText$16(record.status)?.toLowerCase();
 	if (status === "error" || status === "failed" || status === "fail") return true;
 	if (status === "ok" || status === "success" || status === "completed") return false;
-	const type = normalizeOptionalText$18(record.type)?.toLowerCase();
+	const type = normalizeOptionalText$16(record.type)?.toLowerCase();
 	if (type === "error" || type === "failure") return true;
 	if (type === "result" || type === "success") return false;
 	if (record.error !== void 0 || record.errors !== void 0) return true;
 	return null;
 }
-function resolveStringByPaths$1(record, paths) {
+function resolveStringByPaths(record, paths) {
 	for (const path of paths) {
 		const normalized = normalizeCandidateValue(getByPath(record, path));
 		if (normalized) return normalized;
@@ -21590,7 +22176,7 @@ function normalizeCandidateValue(value) {
 	}
 	return null;
 }
-function normalizeOptionalText$18(value) {
+function normalizeOptionalText$16(value) {
 	const normalized = String(value ?? "").trim();
 	return normalized.length > 0 ? normalized : null;
 }
@@ -21648,7 +22234,7 @@ function classifyOpenClawFailureMessage(input) {
 	});
 }
 function normalizeOpenClawFailureMessage(value) {
-	const normalized = normalizeOptionalText$17(value);
+	const normalized = normalizeOptionalText$15(value);
 	if (!normalized) return null;
 	return extractJsonFailureDetail(normalized) ?? normalized;
 }
@@ -21657,7 +22243,7 @@ function extractJsonFailureDetail(value) {
 		const parsed = JSON.parse(value);
 		if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return null;
 		const record = parsed;
-		return normalizeOptionalText$17(record.detail) ?? normalizeOptionalText$17(record.message) ?? (record.error && typeof record.error === "object" && !Array.isArray(record.error) ? normalizeOptionalText$17(record.error.message) : null);
+		return normalizeOptionalText$15(record.detail) ?? normalizeOptionalText$15(record.message) ?? (record.error && typeof record.error === "object" && !Array.isArray(record.error) ? normalizeOptionalText$15(record.error.message) : null);
 	} catch {
 		return null;
 	}
@@ -21677,7 +22263,7 @@ function isRateLimitFailure(value) {
 function isInputSelectorFailure(value) {
 	return value.includes("pass --to") && value.includes("--session-id") && value.includes("--agent") || value.includes("unknown agent") || value.includes("agent not found");
 }
-function normalizeOptionalText$17(value) {
+function normalizeOptionalText$15(value) {
 	const normalized = typeof value === "string" ? value.trim() : "";
 	return normalized.length > 0 ? normalized : null;
 }
@@ -21696,7 +22282,7 @@ var OpenClawCliTransportError = class extends Error {
 	}
 };
 async function invokeOpenClawCliTransport(input) {
-	const prompt = normalizeOptionalText$16(input.prompt);
+	const prompt = normalizeOptionalText$14(input.prompt);
 	if (!prompt) throw new OpenClawCliTransportError({
 		code: "schema.invalid",
 		errorType: "config",
@@ -21705,7 +22291,7 @@ async function invokeOpenClawCliTransport(input) {
 	const { args, sessionId: initialSessionId } = buildOpenClawArgs({
 		openClawAgentId: input.openClawAgentId,
 		prompt,
-		sessionId: normalizeOptionalText$16(input.sessionId)
+		sessionId: normalizeOptionalText$14(input.sessionId)
 	});
 	const invocation = buildCliLaunchInvocation({
 		args,
@@ -21731,13 +22317,13 @@ async function invokeOpenClawCliTransport(input) {
 			onProcessControlEvent: input.onProcessControlEvent,
 			onStderrLine: (event) => {
 				if (firstStderrAtMs === null) firstStderrAtMs = Date.now();
-				collectProviderErrorMessage$1(event.line, providerErrorMessages);
+				collectProviderErrorMessage(event.line, providerErrorMessages);
 			},
 			onStdoutLine: (event) => {
 				if (firstStdoutAtMs === null) firstStdoutAtMs = Date.now();
 				const parsedLine = parseOpenClawOutputLine(event.line);
 				if (!parsedLine) {
-					collectRuntimePermissionDenialMessage$1(event.line, providerErrorMessages);
+					collectRuntimePermissionDenialMessage(event.line, providerErrorMessages);
 					return;
 				}
 				if (parsedLine.resultText) latestOutput = parsedLine.resultText;
@@ -21782,7 +22368,7 @@ async function invokeOpenClawCliTransport(input) {
 			stdoutText: driverResult.stdoutText
 		}));
 	}
-	const output = normalizeOptionalText$16(latestOutput);
+	const output = normalizeOptionalText$14(latestOutput);
 	if (!output) {
 		const fallbackOutput = resolveSuccessFallbackOutput(driverResult.stdoutText);
 		if (!fallbackOutput) {
@@ -21800,25 +22386,25 @@ async function invokeOpenClawCliTransport(input) {
 		}
 		return {
 			output: fallbackOutput,
-			sessionId: normalizeOptionalText$16(resolvedSessionId),
-			telemetry: buildTransportTelemetry$1({
+			sessionId: normalizeOptionalText$14(resolvedSessionId),
+			telemetry: buildTransportTelemetry({
 				driverResult,
 				firstStderrAtMs,
 				firstStdoutAtMs,
 				invokedAtMs,
-				resumedContext: normalizeOptionalText$16(input.sessionId) !== null
+				resumedContext: normalizeOptionalText$14(input.sessionId) !== null
 			})
 		};
 	}
 	return {
 		output,
-		sessionId: normalizeOptionalText$16(resolvedSessionId),
-		telemetry: buildTransportTelemetry$1({
+		sessionId: normalizeOptionalText$14(resolvedSessionId),
+		telemetry: buildTransportTelemetry({
 			driverResult,
 			firstStderrAtMs,
 			firstStdoutAtMs,
 			invokedAtMs,
-			resumedContext: normalizeOptionalText$16(input.sessionId) !== null
+			resumedContext: normalizeOptionalText$14(input.sessionId) !== null
 		})
 	};
 }
@@ -21837,7 +22423,7 @@ const buildOpenClawArgs = (input) => {
 		sessionId
 	};
 };
-const buildTransportTelemetry$1 = (input) => ({
+const buildTransportTelemetry = (input) => ({
 	completedAtMs: Date.now(),
 	...input.driverResult.lifecycle.exitCode === null ? {} : { exitCode: input.driverResult.lifecycle.exitCode },
 	...input.driverResult.lifecycle.exitObservedAtMs === null ? {} : { exitObservedAtMs: input.driverResult.lifecycle.exitObservedAtMs },
@@ -21878,14 +22464,14 @@ const toOpenClawCliTransportError = (error, timeoutMs) => {
 	});
 };
 const classifyOpenClawFailure = (input) => {
-	const trustedProviderMessages = /* @__PURE__ */ new Set([...input.providerOriginalErrorMessages ?? [], ...extractErrorMessagesFromStdout$1(input.stdoutText)]);
-	const providerMessage = resolveProviderFailureMessage$1(input);
+	const trustedProviderMessages = /* @__PURE__ */ new Set([...input.providerOriginalErrorMessages ?? [], ...extractErrorMessagesFromStdout(input.stdoutText)]);
+	const providerMessage = resolveProviderFailureMessage(input);
 	if (providerMessage) return classifyOpenClawFailureMessage({
 		includeOriginalError: trustedProviderMessages.has(providerMessage),
 		isContextLost: isLikelyOpenClawContextLostError,
 		message: providerMessage
 	});
-	const stderrText = normalizeOptionalText$16(input.stderrText);
+	const stderrText = normalizeOptionalText$14(input.stderrText);
 	if (stderrText) return {
 		code: "upstream_unreachable",
 		errorType: "adapter",
@@ -21893,17 +22479,17 @@ const classifyOpenClawFailure = (input) => {
 	};
 	return { ...buildProviderExitError({ providerLabel: "openclaw" }) };
 };
-const resolveProviderFailureMessage$1 = (input) => {
+const resolveProviderFailureMessage = (input) => {
 	const candidateMessages = [
 		...input.providerErrorMessages,
-		...extractErrorMessagesFromStdout$1(input.stdoutText),
-		...normalizeOptionalText$16(input.stderrText) ? [normalizeOptionalText$16(input.stderrText)] : []
+		...extractErrorMessagesFromStdout(input.stdoutText),
+		...normalizeOptionalText$14(input.stderrText) ? [normalizeOptionalText$14(input.stderrText)] : []
 	].filter((value) => Boolean(value));
-	for (const candidate of candidateMessages) if (looksLikeRuntimePermissionDenialMessage(candidate) || looksLikeProviderFailure$1(candidate)) return candidate;
+	for (const candidate of candidateMessages) if (looksLikeRuntimePermissionDenialMessage(candidate) || looksLikeProviderFailure(candidate)) return candidate;
 	return candidateMessages[0] ?? null;
 };
-const extractErrorMessagesFromStdout$1 = (value) => {
-	const stdoutText = normalizeOptionalText$16(value);
+const extractErrorMessagesFromStdout = (value) => {
+	const stdoutText = normalizeOptionalText$14(value);
 	if (!stdoutText) return [];
 	const messages = [];
 	const lines = stdoutText.split("\n");
@@ -21914,7 +22500,7 @@ const extractErrorMessagesFromStdout$1 = (value) => {
 	return messages;
 };
 const resolveSuccessFallbackOutput = (value) => {
-	const stdoutText = normalizeOptionalText$16(value);
+	const stdoutText = normalizeOptionalText$14(value);
 	if (!stdoutText) return null;
 	const lines = stdoutText.split("\n").map((line) => line.trim()).filter((line) => line.length > 0);
 	if (lines.length !== 1) return null;
@@ -21923,24 +22509,24 @@ const resolveSuccessFallbackOutput = (value) => {
 	if (singleLine.startsWith("{") || singleLine.startsWith("[")) return null;
 	return singleLine;
 };
-const collectProviderErrorMessage$1 = (line, output) => {
-	const normalized = normalizeOptionalText$16(line);
+const collectProviderErrorMessage = (line, output) => {
+	const normalized = normalizeOptionalText$14(line);
 	if (!normalized) return;
 	output.push(normalized);
 };
-const collectRuntimePermissionDenialMessage$1 = (line, output) => {
-	const normalized = normalizeOptionalText$16(line);
+const collectRuntimePermissionDenialMessage = (line, output) => {
+	const normalized = normalizeOptionalText$14(line);
 	if (!(normalized && looksLikeRuntimePermissionDenialMessage(normalized))) return;
 	output.push(normalized);
 };
-const looksLikeProviderFailure$1 = (value) => {
+const looksLikeProviderFailure = (value) => {
 	const lowered = value.toLowerCase();
 	return lowered.includes("error") || lowered.includes("failed") || lowered.includes("permission") || lowered.includes("reject") || lowered.includes("denied") || lowered.includes("approval") || lowered.includes("unauthorized") || lowered.includes("not logged in") || lowered.includes("invalid") || lowered.includes("quota") || lowered.includes("rate") || lowered.includes("session") || lowered.includes("unsupported model") || lowered.includes("model is not supported");
 };
 function normalizeText$2(value) {
 	return String(value ?? "").trim();
 }
-function normalizeOptionalText$16(value) {
+function normalizeOptionalText$14(value) {
 	const normalized = normalizeText$2(value);
 	return normalized.length > 0 ? normalized : null;
 }
@@ -22072,15 +22658,15 @@ async function readSessionIndex(input) {
 	}
 }
 function resolveOpenClawStateDir(env) {
-	const configuredStateDir = normalizeOptionalText$15(env?.OPENCLAW_STATE_DIR);
+	const configuredStateDir = normalizeOptionalText$13(env?.OPENCLAW_STATE_DIR);
 	if (configuredStateDir) return configuredStateDir;
 	return join(homedir(), ".openclaw");
 }
 function resolveSessionFilePath(input) {
 	const sessionsDir = join(resolveOpenClawStateDir(input.env), "agents", input.agentId, "sessions");
-	const sessionFile = normalizeOptionalText$15(input.sessionEntry.sessionFile);
+	const sessionFile = normalizeOptionalText$13(input.sessionEntry.sessionFile);
 	if (sessionFile) return isAbsolute(sessionFile) ? sessionFile : join(sessionsDir, sessionFile);
-	const sessionId = normalizeOptionalText$15(input.sessionEntry.sessionId);
+	const sessionId = normalizeOptionalText$13(input.sessionEntry.sessionId);
 	if (!sessionId) return null;
 	return join(sessionsDir, `${sessionId}.jsonl`);
 }
@@ -22101,11 +22687,11 @@ function parseSessionErrorRecord(line) {
 		const parsed = JSON.parse(line);
 		if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return null;
 		const record = parsed;
-		if (normalizeOptionalText$15(record.type) !== "message") return null;
+		if (normalizeOptionalText$13(record.type) !== "message") return null;
 		const message = record.message && typeof record.message === "object" ? record.message : null;
 		if (!message) return null;
-		if (normalizeOptionalText$15(message.stopReason) !== "error") return null;
-		const errorMessage = normalizeOptionalText$15(message.errorMessage);
+		if (normalizeOptionalText$13(message.stopReason) !== "error") return null;
+		const errorMessage = normalizeOptionalText$13(message.errorMessage);
 		if (!errorMessage) return null;
 		const messageTimestampMs = normalizeOptionalNumber(message.timestamp) ?? normalizeIsoTimestampMs(record.timestamp);
 		if (messageTimestampMs === null) return null;
@@ -22118,7 +22704,7 @@ function parseSessionErrorRecord(line) {
 	}
 }
 function normalizeIsoTimestampMs(value) {
-	const normalized = normalizeOptionalText$15(value);
+	const normalized = normalizeOptionalText$13(value);
 	if (!normalized) return null;
 	const parsed = Date.parse(normalized);
 	return Number.isFinite(parsed) ? parsed : null;
@@ -22126,7 +22712,7 @@ function normalizeIsoTimestampMs(value) {
 function normalizeOptionalNumber(value) {
 	return typeof value === "number" && Number.isFinite(value) ? value : null;
 }
-function normalizeOptionalText$15(value) {
+function normalizeOptionalText$13(value) {
 	const normalized = typeof value === "string" ? value.trim() : "";
 	return normalized.length > 0 ? normalized : null;
 }
@@ -22147,8 +22733,8 @@ var OpenClawGatewayTransportError = class extends Error {
 	}
 };
 async function invokeOpenClawGatewayTransport(input) {
-	const prompt = normalizeOptionalText$14(input.prompt);
-	const sessionKey = normalizeOptionalText$14(input.sessionKey);
+	const prompt = normalizeOptionalText$12(input.prompt);
+	const sessionKey = normalizeOptionalText$12(input.sessionKey);
 	if (!prompt) throw new OpenClawGatewayTransportError({
 		code: "schema.invalid",
 		errorType: "config",
@@ -22261,9 +22847,9 @@ function normalizeOpenClawGatewayAgentResult(result, expectedSessionKey) {
 		message: "upstream_unreachable: openclaw gateway returned a non-object payload for agent"
 	});
 	const record = result;
-	const status = normalizeOptionalText$14(record.status);
+	const status = normalizeOptionalText$12(record.status);
 	if (!status || status === "ok") return extractSuccessfulAgentResult(record.result, expectedSessionKey);
-	throw classifyGatewayFailure(normalizeOptionalText$14(record.summary) ?? normalizeOptionalText$14(record.error) ?? `openclaw gateway agent returned status '${status}'`, true);
+	throw classifyGatewayFailure(normalizeOptionalText$12(record.summary) ?? normalizeOptionalText$12(record.error) ?? `openclaw gateway agent returned status '${status}'`, true);
 }
 function extractSuccessfulAgentResult(result, expectedSessionKey) {
 	if (!result || typeof result !== "object") throw new OpenClawGatewayTransportError({
@@ -22288,7 +22874,7 @@ function normalizeAgentMeta(meta, expectedSessionKey) {
 	const record = meta;
 	const systemPromptReport = record.systemPromptReport;
 	if (systemPromptReport && typeof systemPromptReport === "object") {
-		const actualSessionKey = normalizeOptionalText$14(systemPromptReport.sessionKey);
+		const actualSessionKey = normalizeOptionalText$12(systemPromptReport.sessionKey);
 		if (actualSessionKey && actualSessionKey !== expectedSessionKey) throw new OpenClawGatewayTransportError({
 			code: "upstream_unreachable",
 			errorType: "adapter",
@@ -22296,15 +22882,15 @@ function normalizeAgentMeta(meta, expectedSessionKey) {
 		});
 	}
 	const agentMeta = record.agentMeta;
-	const agentSessionId = agentMeta && typeof agentMeta === "object" ? normalizeOptionalText$14(agentMeta.sessionId) : null;
-	const reportSessionId = systemPromptReport && typeof systemPromptReport === "object" ? normalizeOptionalText$14(systemPromptReport.sessionId) : null;
+	const agentSessionId = agentMeta && typeof agentMeta === "object" ? normalizeOptionalText$12(agentMeta.sessionId) : null;
+	const reportSessionId = systemPromptReport && typeof systemPromptReport === "object" ? normalizeOptionalText$12(systemPromptReport.sessionId) : null;
 	return { sessionId: agentSessionId ?? reportSessionId };
 }
 function extractAgentPayloadText(payloads) {
 	if (!Array.isArray(payloads)) return null;
 	for (const payload of payloads) {
 		if (!payload || typeof payload !== "object") continue;
-		const text = normalizeOptionalText$14(payload.text);
+		const text = normalizeOptionalText$12(payload.text);
 		if (text) return text;
 	}
 	return null;
@@ -22316,8 +22902,8 @@ function toOpenClawGatewayTransportError(error) {
 		errorType: "adapter",
 		message: "upstream_unreachable: openclaw is not installed or not on PATH"
 	});
-	const stderr = normalizeOptionalText$14(error?.stderr);
-	const stdout = normalizeOptionalText$14(error?.stdout);
+	const stderr = normalizeOptionalText$12(error?.stderr);
+	const stdout = normalizeOptionalText$12(error?.stdout);
 	return classifyGatewayFailure(stderr ?? stdout ?? toErrorMessage$6(error), false);
 }
 function classifyGatewayFailure(message, includeOriginalError) {
@@ -22326,7 +22912,7 @@ function classifyGatewayFailure(message, includeOriginalError) {
 		message
 	}));
 }
-function normalizeOptionalText$14(value) {
+function normalizeOptionalText$12(value) {
 	const normalized = String(value ?? "").trim();
 	return normalized.length > 0 ? normalized : null;
 }
@@ -22699,7 +23285,7 @@ function record$2(value) {
 const OPENCLAW_CONVERSATION_BRIDGE_SPEC = resolveBuiltinAdapterConversationBridgeSpec("openclaw");
 const resolveOpenClawSessionConversation = (agentControllerConversation) => {
 	if (!agentControllerConversation) return null;
-	const agentControllerConversationId = normalizeOptionalText$13(agentControllerConversation.agentControllerConversationId);
+	const agentControllerConversationId = normalizeOptionalText$11(agentControllerConversation.agentControllerConversationId);
 	if (!agentControllerConversationId) throw new Error("conversation.bridge.agent_controller_conversation_id_missing: expected builtin:openclaw session agentControllerConversationId");
 	if (agentControllerConversation.agentControllerRef !== "builtin:openclaw" || agentControllerConversation.agentControllerConversationKind !== "session") throw new Error(`conversation.bridge.agent_controller_conversation_mismatch: expected builtin:openclaw session, received ${agentControllerConversation.agentControllerRef}/${agentControllerConversation.agentControllerConversationKind}`);
 	return buildAdapterAgentControllerConversationRef({
@@ -22712,7 +23298,7 @@ const resolveOpenClawInvokeRequest = (input) => {
 	const agentControllerConversation = resolveOpenClawSessionConversation(input.request.agentControllerConversation);
 	return {
 		...input.request,
-		agentControllerConversationId: normalizeOptionalText$13(input.request.agentControllerConversationId),
+		agentControllerConversationId: normalizeOptionalText$11(input.request.agentControllerConversationId),
 		...agentControllerConversation ? { agentControllerConversation } : {}
 	};
 };
@@ -22775,7 +23361,7 @@ const resolveDefaultOpenClawInvoke = (options) => {
 			optionAgentId: options.openClawAgentId
 		});
 		const correction = isDispatchSpaceActionDeliveryOnly(input.env);
-		const canonicalSessionId = normalizeOptionalText$13(input.agentControllerConversationId) ?? resolveOpenClawSessionKey(input);
+		const canonicalSessionId = normalizeOptionalText$11(input.agentControllerConversationId) ?? resolveOpenClawSessionKey(input);
 		const executionSessionId = correction ? randomUUID() : canonicalSessionId ?? randomUUID();
 		const result = await withOpenClawDispatchSpaceActionPlugin({
 			launchContract,
@@ -22821,7 +23407,7 @@ const resolveDefaultOpenClawInvoke = (options) => {
 	};
 };
 async function resolveOpenClawDispatchLaunchContract(input) {
-	const explicitLaunchContract = input.inputLaunchContract ?? input.optionLaunchContract ?? (normalizeOptionalText$13(input.openClawBin) ? buildExecutableLaunchContract({ commandPath: normalizeOptionalText$13(input.openClawBin) }) : null);
+	const explicitLaunchContract = input.inputLaunchContract ?? input.optionLaunchContract ?? (normalizeOptionalText$11(input.openClawBin) ? buildExecutableLaunchContract({ commandPath: normalizeOptionalText$11(input.openClawBin) }) : null);
 	if (explicitLaunchContract) {
 		const verification = isDispatchSpaceActionDeliveryOnly(input.env) ? await verifyLaunchContractFiles({ launchContract: explicitLaunchContract }) : await verifyOpenClawLaunchContract({
 			launchContract: explicitLaunchContract,
@@ -22844,8 +23430,8 @@ const resolveRuntimeProcessRegistrar$1 = (input) => input.registerRuntimeProcess
 		taskId: input.taskId
 	});
 } : void 0;
-const resolveOpenClawAgentId = (input) => normalizeOptionalText$13(input.dispatchEnvAgentId) ?? normalizeOptionalText$13(input.optionAgentId) ?? resolveOpenClawAgentId$1();
-const resolveOpenClawSessionKey = (input) => normalizeOptionalText$13(input.agentControllerConversation?.agentControllerRef === "builtin:openclaw" && input.agentControllerConversation.agentControllerConversationKind === "session" ? input.agentControllerConversation.agentControllerConversationId : null);
+const resolveOpenClawAgentId = (input) => normalizeOptionalText$11(input.dispatchEnvAgentId) ?? normalizeOptionalText$11(input.optionAgentId) ?? resolveOpenClawAgentId$1();
+const resolveOpenClawSessionKey = (input) => normalizeOptionalText$11(input.agentControllerConversation?.agentControllerRef === "builtin:openclaw" && input.agentControllerConversation.agentControllerConversationKind === "session" ? input.agentControllerConversation.agentControllerConversationId : null);
 const invokeOpenClawGatewayPath = async (input) => {
 	const gatewayResult = await invokeOpenClawGatewayTransport({
 		agentId: input.openClawAgentId,
@@ -22856,7 +23442,7 @@ const invokeOpenClawGatewayPath = async (input) => {
 		openClawTimeoutMs: input.openClawTimeoutMs,
 		openClawWorkdir: input.openClawWorkdir,
 		prompt: input.input.prompt,
-		resumedContext: normalizeOptionalText$13(input.input.agentControllerConversationId) !== null,
+		resumedContext: normalizeOptionalText$11(input.input.agentControllerConversationId) !== null,
 		sessionKey: input.sessionKey
 	});
 	return {
@@ -22883,7 +23469,7 @@ const invokeOpenClawLocalCliPath = async (input) => {
 		...input.onProcessControlEvent ? { onProcessControlEvent: input.onProcessControlEvent } : {},
 		...input.input.onRuntimeEvent ? { onRuntimeEvent: input.input.onRuntimeEvent } : {},
 		prompt: input.input.prompt,
-		sessionId: normalizeOptionalText$13(input.input.agentControllerConversationId)
+		sessionId: normalizeOptionalText$11(input.input.agentControllerConversationId)
 	});
 	const agentControllerConversation = OPENCLAW_CONVERSATION_BRIDGE_SPEC ? bridgeAgentControllerConversationRef({
 		bridgeSpec: OPENCLAW_CONVERSATION_BRIDGE_SPEC,
@@ -22902,7 +23488,7 @@ const invokeOpenClawLocalCliPath = async (input) => {
 function normalizeText$1(value) {
 	return String(value ?? "").trim();
 }
-function normalizeOptionalText$13(value) {
+function normalizeOptionalText$11(value) {
 	const normalized = normalizeText$1(value);
 	return normalized.length > 0 ? normalized : null;
 }
@@ -22929,13 +23515,19 @@ async function resolveInstalledOpenCodeLaunchCandidates(input) {
 	const installedCandidates = await resolveInstalledNodeScriptLaunchCandidates({
 		additionalCommandDirectories: resolveOpenCodeCommandDirectories(),
 		commandName: DEFAULT_OPENCODE_COMMAND,
-		configuredCommand: normalizeOptionalText$12(process.env.OPENMELD_DAEMON_RUNTIME_OPENCODE_BIN),
+		configuredCommand: normalizeOptionalText$10(process.env.OPENMELD_DAEMON_RUNTIME_OPENCODE_BIN),
 		displayName: "OpenCode",
 		preferredLaunchContract: input?.preferredLaunchContract
 	});
-	if (!installedCandidates.ok) return installedCandidates;
+	const v2 = await resolveInstalledNodeScriptLaunchCandidates({
+		additionalCommandDirectories: resolveOpenCodeCommandDirectories(),
+		commandName: "opencode2",
+		displayName: "OpenCode 2"
+	});
+	if (!(installedCandidates.ok || v2.ok)) return installedCandidates;
+	const discovered = [...installedCandidates.ok ? installedCandidates.candidates : [], ...v2.ok ? v2.candidates : []];
 	const candidates = await resolveLaunchCandidatesAfterVerification({
-		candidates: installedCandidates.candidates,
+		candidates: [...new Map(discovered.map((candidate) => [JSON.stringify(candidate.launchContract), candidate])).values()],
 		verify: async (candidate) => await verifyOpenCodeLaunchContract({
 			launchContract: candidate.launchContract,
 			timeoutMs: input?.timeoutMs
@@ -22961,16 +23553,16 @@ async function verifyOpenCodeLaunchContract(input) {
 	});
 }
 function resolveOpenCodeTimeoutMs() {
-	const raw = normalizeOptionalText$12(process.env.OPENMELD_DAEMON_RUNTIME_REQUEST_TIMEOUT_MS);
+	const raw = normalizeOptionalText$10(process.env.OPENMELD_DAEMON_RUNTIME_REQUEST_TIMEOUT_MS);
 	if (!raw) return null;
 	const parsed = Number.parseInt(raw, 10);
 	if (!Number.isFinite(parsed) || parsed <= 0) return null;
 	return parsed;
 }
 function resolveOpenCodeCommandDirectories() {
-	return [join(normalizeOptionalText$12(process.env.HOME) ?? homedir(), ".opencode", "bin")];
+	return [join(normalizeOptionalText$10(process.env.HOME) ?? homedir(), ".opencode", "bin")];
 }
-function normalizeOptionalText$12(value) {
+function normalizeOptionalText$10(value) {
 	const normalized = String(value ?? "").trim();
 	return normalized.length > 0 ? normalized : null;
 }
@@ -22981,579 +23573,6 @@ function isLikelyOpenCodeContextLostError(message) {
 	return normalized.includes("session") && (normalized.includes("not found") || normalized.includes("missing") || normalized.includes("invalid") || normalized.includes("expired") || normalized.includes("deleted"));
 }
 //#endregion
-//#region ../../runtime/adapters/opencode/dist/output/opencode-output-parser.js
-const OPENCODE_SESSION_ID_PATHS = [
-	["sessionID"],
-	["sessionId"],
-	["session_id"],
-	["session", "id"],
-	["metadata", "sessionID"],
-	["metadata", "sessionId"],
-	["metadata", "session_id"],
-	["context", "sessionID"],
-	["context", "sessionId"],
-	["context", "session_id"]
-];
-const OPENCODE_TEXT_PATHS = [
-	["part", "text"],
-	["text"],
-	["content"],
-	["message"],
-	["delta", "text"],
-	["data", "text"],
-	["data", "content"],
-	["payload", "text"],
-	["payload", "content"]
-];
-const OPENCODE_ERROR_MESSAGE_PATHS = [
-	["error", "message"],
-	["error", "text"],
-	[
-		"error",
-		"data",
-		"message"
-	],
-	[
-		"error",
-		"data",
-		"error"
-	],
-	[
-		"error",
-		"cause",
-		"message"
-	],
-	["error"],
-	[
-		"errors",
-		"0",
-		"message"
-	],
-	["message"],
-	[
-		"data",
-		"error",
-		"message"
-	],
-	[
-		"data",
-		"error",
-		"text"
-	],
-	[
-		"data",
-		"error",
-		"data",
-		"message"
-	],
-	["data", "error"],
-	["data", "message"]
-];
-function parseOpenCodeOutputLine(line) {
-	const normalizedLine = line.trim();
-	if (!normalizedLine) return null;
-	let parsed;
-	try {
-		parsed = JSON.parse(normalizedLine);
-	} catch {
-		return null;
-	}
-	const record = parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
-	if (!record) return null;
-	const isErrorResult = resolveIsErrorResult(record);
-	const errorMessage = resolveErrorMessage(record, isErrorResult);
-	const resultText = resolveResultText(record, isErrorResult);
-	const sessionId = resolveSessionId(record);
-	if (!errorMessage && resultText === null && sessionId === null && isErrorResult === null) return null;
-	return {
-		errorMessage,
-		isErrorResult,
-		resultText,
-		sessionId,
-		terminal: isErrorResult === true
-	};
-}
-function parseOpenCodeOutputDocument(text) {
-	const normalizedText = text.trim();
-	if (!normalizedText) return null;
-	const lines = normalizedText.split("\n").map((line) => line.trim()).filter((line) => line.length > 0);
-	if (lines.length === 0) return null;
-	let outputText = "";
-	let sessionId = null;
-	let errorMessage = null;
-	let isErrorResult = null;
-	let parsedAnyLine = false;
-	for (const line of lines) {
-		const parsedLine = parseOpenCodeOutputLine(line);
-		if (!parsedLine) continue;
-		parsedAnyLine = true;
-		if (parsedLine.sessionId) sessionId = parsedLine.sessionId;
-		if (parsedLine.resultText) outputText += parsedLine.resultText;
-		if (parsedLine.errorMessage) errorMessage = parsedLine.errorMessage;
-		if (parsedLine.isErrorResult !== null) isErrorResult = parsedLine.isErrorResult;
-	}
-	if (!parsedAnyLine) return null;
-	return {
-		errorMessage,
-		isErrorResult,
-		outputText: normalizeOptionalText$11(outputText),
-		sessionId
-	};
-}
-function resolveSessionId(record) {
-	return resolveStringByPaths(record, OPENCODE_SESSION_ID_PATHS);
-}
-function resolveResultText(record, isErrorResult) {
-	if (isErrorResult === true) return null;
-	if (record.type !== "text") return null;
-	return resolveTextByPaths(record, OPENCODE_TEXT_PATHS);
-}
-function resolveErrorMessage(record, isErrorResult) {
-	if (isErrorResult !== true) return null;
-	return resolveStringByPaths(record, OPENCODE_ERROR_MESSAGE_PATHS);
-}
-function resolveIsErrorResult(record) {
-	if (record.type === "error") return true;
-	if (typeof record.is_error === "boolean") return record.is_error;
-	if (typeof record.isError === "boolean") return record.isError;
-	if (typeof record.ok === "boolean") return !record.ok;
-	if (typeof record.success === "boolean") return !record.success;
-	const status = normalizeOptionalText$11(record.status)?.toLowerCase();
-	if (status === "error" || status === "failed" || status === "fail") return true;
-	if (status === "ok" || status === "success" || status === "completed") return false;
-	return null;
-}
-function resolveStringByPaths(record, paths) {
-	for (const path of paths) {
-		let current = record;
-		for (const segment of path) {
-			if (current && typeof current === "object" && !Array.isArray(current)) {
-				current = current[segment];
-				continue;
-			}
-			current = void 0;
-			break;
-		}
-		const normalized = normalizeScalarText(current);
-		if (normalized) return normalized;
-	}
-	return null;
-}
-function resolveTextByPaths(record, paths) {
-	for (const path of paths) {
-		let current = record;
-		for (const segment of path) {
-			if (current && typeof current === "object" && !Array.isArray(current)) {
-				current = current[segment];
-				continue;
-			}
-			current = void 0;
-			break;
-		}
-		if (typeof current === "string" && current.length > 0) return current;
-	}
-	return null;
-}
-function normalizeOptionalText$11(value) {
-	const normalized = String(value ?? "").trim();
-	return normalized.length > 0 ? normalized : null;
-}
-function normalizeScalarText(value) {
-	if (typeof value !== "string" && typeof value !== "number" && typeof value !== "boolean") return null;
-	return normalizeOptionalText$11(value);
-}
-//#endregion
-//#region ../../runtime/adapters/opencode/dist/transport/opencode-failure.js
-function classifyOpenCodeFailureMessage(input) {
-	const normalized = input.message.trim();
-	const lowered = normalized.toLowerCase();
-	const originalError = input.includeOriginalError ? createProviderOriginalError(normalized) : null;
-	const withOriginalError = (value) => ({
-		...value,
-		...originalError ? { originalError } : {}
-	});
-	const permissionDenial = classifyRuntimePermissionDenialMessage({
-		message: normalized,
-		source: "opencode"
-	});
-	if (permissionDenial) return withOriginalError(permissionDenial);
-	if (input.isContextLost(normalized)) return withOriginalError({
-		code: "context.lost",
-		errorType: "adapter",
-		message: `context.lost: ${normalized}`
-	});
-	if (lowered.includes("not logged in") || lowered.includes("unauthorized") || lowered.includes("authentication") || lowered.includes("credentials")) return withOriginalError({
-		code: "auth.required",
-		errorType: "auth",
-		message: `auth.required: ${normalized}`
-	});
-	if (lowered.includes("unsupported model") || lowered.includes("model is not supported") || lowered.includes("invalid model") || lowered.includes("model not found")) return withOriginalError({
-		code: "model.unsupported",
-		errorType: "config",
-		message: `model.unsupported: ${normalized}`
-	});
-	if (isInsufficientBalanceFailure(lowered)) return withOriginalError({
-		code: "provider.insufficient_balance",
-		errorType: "adapter",
-		message: `provider.insufficient_balance: ${normalized}`,
-		providerAccessEvidence: buildProviderAccessEvidence("provider_account.capacity_exhausted")
-	});
-	if (isDefinitiveHardQuotaFailure(lowered)) return withOriginalError({
-		code: "quota.exceeded",
-		errorType: "adapter",
-		message: `quota.exceeded: ${normalized}`,
-		providerAccessEvidence: buildProviderAccessEvidence("provider_account.capacity_exhausted")
-	});
-	if (isTransientRateLimitFailure(lowered)) return withOriginalError({
-		code: "provider.rate_limited",
-		errorType: "network",
-		message: `provider.rate_limited: ${normalized}`
-	});
-	if (isSubscriptionAccessFailure(lowered)) return withOriginalError({
-		code: "provider.subscription_access_unavailable",
-		errorType: "adapter",
-		message: `provider.subscription_access_unavailable: ${normalized}`,
-		providerAccessEvidence: buildProviderAccessEvidence("provider_account.subscription_access_unavailable")
-	});
-	if (isProviderUnavailableFailure(lowered)) return withOriginalError({
-		code: "provider.unavailable",
-		errorType: "network",
-		message: `provider.unavailable: ${normalized}`
-	});
-	if (isHardQuotaFailure(lowered)) return withOriginalError({
-		code: "quota.exceeded",
-		errorType: "adapter",
-		message: `quota.exceeded: ${normalized}`,
-		providerAccessEvidence: buildProviderAccessEvidence("provider_account.capacity_exhausted")
-	});
-	return withOriginalError({
-		code: "upstream_unreachable",
-		errorType: "adapter",
-		message: `upstream_unreachable: ${normalized}`
-	});
-}
-function buildProviderAccessEvidence(reasonCode) {
-	return {
-		observedAtMs: Date.now(),
-		provider: "opencode",
-		reasonCode,
-		source: "wake_failure"
-	};
-}
-function isHardQuotaFailure(value) {
-	return isDefinitiveHardQuotaFailure(value) || value.includes("usage limit") || value.includes("usage_limit");
-}
-function isDefinitiveHardQuotaFailure(value) {
-	return value.includes("insufficient quota") || value.includes("insufficient_quota") || value.includes("quota exceeded") || value.includes("exceeded your current quota");
-}
-function isSubscriptionAccessFailure(value) {
-	return value.includes("not included in your subscription") || value.includes("not available on your plan") || value.includes("subscription does not include") || value.includes("subscription access") || value.includes("upgrade your plan");
-}
-function isTransientRateLimitFailure(value) {
-	return value.includes("429") || value.includes("rate limit") || value.includes("too many requests");
-}
-function isInsufficientBalanceFailure(value) {
-	return value.includes("insufficient balance") || value.includes("insufficient_balance") || value.includes("not enough credits") || value.includes("out of credits") || value.includes("credits exhausted") || value.includes("credit balance") || value.includes("account balance") || value.includes("balance is too low") || value.includes("payment required");
-}
-function isProviderUnavailableFailure(value) {
-	return value.includes("bad gateway") || value.includes("gateway timeout") || value.includes("service unavailable") || value.includes("provider unavailable") || value.includes("socket hang up") || value.includes("econnreset") || value.includes("etimedout");
-}
-//#endregion
-//#region ../../runtime/adapters/opencode/dist/transport/opencode-cli-transport.js
-var OpenCodeCliTransportError = class extends Error {
-	code;
-	errorType;
-	originalError;
-	providerAccessEvidence;
-	constructor(input) {
-		super(input.message);
-		this.name = "OpenCodeCliTransportError";
-		this.code = input.code;
-		this.errorType = input.errorType;
-		this.originalError = input.originalError;
-		this.providerAccessEvidence = input.providerAccessEvidence;
-	}
-};
-const STREAMING_PROVIDER_FAILURE_THRESHOLD = 3;
-async function invokeOpenCodeCliTransport(input) {
-	const prompt = normalizeOptionalText$10(input.prompt);
-	if (!prompt) throw new OpenCodeCliTransportError({
-		code: "schema.invalid",
-		errorType: "config",
-		message: "schema.invalid: prompt is required"
-	});
-	if (normalizeOptionalText$10(input.sessionId)) throw new OpenCodeCliTransportError({
-		code: "context.resume_requires_server",
-		errorType: "adapter",
-		message: "An existing OpenCode conversation requires the server connection to verify its working folder."
-	});
-	const invocation = buildCliLaunchInvocation({
-		args: buildOpenCodeArgs({
-			conversationPolicy: input.conversationPolicy,
-			prompt,
-			workdir: input.openCodeWorkdir
-		}),
-		launchContract: input.launchContract
-	});
-	let latestOutput = "";
-	let latestResultIsError = false;
-	let resolvedSessionId = null;
-	const providerErrorMessages = [];
-	const invokedAtMs = Date.now();
-	let firstStdoutAtMs = null;
-	let firstStderrAtMs = null;
-	let streamingProviderFailureCount = 0;
-	let stoppedForStreamingProviderFailure = false;
-	let driverResult;
-	try {
-		driverResult = await runCliDriver({
-			allowNonZeroExit: true,
-			args: invocation.args,
-			bin: invocation.bin,
-			cwd: input.openCodeWorkdir,
-			env: input.env,
-			onLifecycleEvent: input.onRuntimeEvent,
-			onProcessControlEvent: input.onProcessControlEvent,
-			onStderrLine: (event) => {
-				if (firstStderrAtMs === null) firstStderrAtMs = Date.now();
-				const providerErrorMessage = collectProviderErrorMessage(event.line, providerErrorMessages);
-				if (!providerErrorMessage) return;
-				if (looksLikeStreamingProviderFailure(providerErrorMessage)) {
-					streamingProviderFailureCount += 1;
-					if (streamingProviderFailureCount >= STREAMING_PROVIDER_FAILURE_THRESHOLD) {
-						stoppedForStreamingProviderFailure = true;
-						return {
-							complete: true,
-							terminateProcess: true
-						};
-					}
-				}
-			},
-			onStdoutLine: (event) => {
-				if (firstStdoutAtMs === null) firstStdoutAtMs = Date.now();
-				const parsedLine = parseOpenCodeOutputLine(event.line);
-				if (!parsedLine) {
-					collectRuntimePermissionDenialMessage(event.line, providerErrorMessages);
-					return;
-				}
-				if (parsedLine.resultText) latestOutput += parsedLine.resultText;
-				if (parsedLine.errorMessage) providerErrorMessages.push(parsedLine.errorMessage);
-				if (parsedLine.isErrorResult === true) {
-					latestResultIsError = true;
-					return;
-				}
-				if (parsedLine.isErrorResult === false) latestResultIsError = false;
-				if (parsedLine.sessionId) resolvedSessionId = parsedLine.sessionId;
-				if (parsedLine.terminal) return {
-					complete: true,
-					terminateProcess: true
-				};
-			},
-			timeoutMs: input.openCodeTimeoutMs
-		});
-	} catch (error) {
-		throw toOpenCodeCliTransportError(error, input.openCodeTimeoutMs);
-	}
-	if (stoppedForStreamingProviderFailure) {
-		const classifiedFailure = classifyOpenCodeFailure({
-			providerErrorMessages,
-			stderrText: driverResult.stderrText,
-			stdoutText: driverResult.stdoutText
-		});
-		throw new OpenCodeCliTransportError({
-			code: classifiedFailure.code,
-			errorType: classifiedFailure.errorType,
-			message: classifiedFailure.message,
-			originalError: classifiedFailure.originalError,
-			providerAccessEvidence: classifiedFailure.providerAccessEvidence
-		});
-	}
-	if (driverResult.exitCode !== 0 || latestResultIsError) {
-		const classifiedFailure = classifyOpenCodeFailure({
-			providerErrorMessages,
-			stderrText: driverResult.stderrText,
-			stdoutText: driverResult.stdoutText
-		});
-		throw new OpenCodeCliTransportError({
-			code: classifiedFailure.code,
-			errorType: classifiedFailure.errorType,
-			message: classifiedFailure.message,
-			originalError: classifiedFailure.originalError,
-			providerAccessEvidence: classifiedFailure.providerAccessEvidence
-		});
-	}
-	const documentParsed = parseOpenCodeOutputDocument(driverResult.stdoutText);
-	if (documentParsed) {
-		if (documentParsed.outputText) latestOutput = documentParsed.outputText;
-		if (documentParsed.sessionId) resolvedSessionId = documentParsed.sessionId;
-		if (documentParsed.errorMessage) providerErrorMessages.push(documentParsed.errorMessage);
-		if (documentParsed.isErrorResult === true) {
-			const classifiedFailure = classifyOpenCodeFailure({
-				providerErrorMessages,
-				stderrText: driverResult.stderrText,
-				stdoutText: driverResult.stdoutText
-			});
-			throw new OpenCodeCliTransportError({
-				code: classifiedFailure.code,
-				errorType: classifiedFailure.errorType,
-				message: classifiedFailure.message,
-				originalError: classifiedFailure.originalError,
-				providerAccessEvidence: classifiedFailure.providerAccessEvidence
-			});
-		}
-	}
-	const output = normalizeOptionalText$10(latestOutput);
-	if (!output) {
-		if (providerErrorMessages.length > 0) {
-			const classifiedFailure = classifyOpenCodeFailure({
-				providerErrorMessages,
-				stderrText: driverResult.stderrText,
-				stdoutText: driverResult.stdoutText
-			});
-			throw new OpenCodeCliTransportError({
-				code: classifiedFailure.code,
-				errorType: classifiedFailure.errorType,
-				message: classifiedFailure.message,
-				originalError: classifiedFailure.originalError,
-				providerAccessEvidence: classifiedFailure.providerAccessEvidence
-			});
-		}
-		throw new OpenCodeCliTransportError({
-			code: "runtime.output.empty",
-			errorType: "adapter",
-			message: "runtime.output.empty: opencode finished without agent output"
-		});
-	}
-	return {
-		output,
-		sessionId: normalizeOptionalText$10(resolvedSessionId),
-		telemetry: buildTransportTelemetry({
-			driverResult,
-			firstStderrAtMs,
-			firstStdoutAtMs,
-			invokedAtMs,
-			resumedContext: false
-		})
-	};
-}
-const buildOpenCodeArgs = (input) => {
-	const args = [
-		"run",
-		"--format",
-		"json",
-		"--print-logs",
-		"--dir",
-		input.workdir
-	];
-	const model = normalizeOptionalText$10(input.conversationPolicy?.model);
-	if (model) args.push("--model", model);
-	const reasoningLevel = normalizeOptionalText$10(input.conversationPolicy?.reasoningLevel);
-	if (reasoningLevel) args.push("--variant", reasoningLevel);
-	args.push(input.prompt);
-	return args;
-};
-const buildTransportTelemetry = (input) => ({
-	completedAtMs: Date.now(),
-	...input.driverResult.lifecycle.exitCode === null ? {} : { exitCode: input.driverResult.lifecycle.exitCode },
-	...input.driverResult.lifecycle.exitObservedAtMs === null ? {} : { exitObservedAtMs: input.driverResult.lifecycle.exitObservedAtMs },
-	...input.driverResult.lifecycle.exitSignal === null ? {} : { exitSignal: input.driverResult.lifecycle.exitSignal },
-	...input.firstStderrAtMs === null ? {} : { firstStderrAtMs: input.firstStderrAtMs },
-	...input.firstStdoutAtMs === null ? {} : { firstStdoutAtMs: input.firstStdoutAtMs },
-	invokedAtMs: input.invokedAtMs,
-	...input.driverResult.lifecycle.processId === null ? {} : { processId: input.driverResult.lifecycle.processId },
-	...input.driverResult.lifecycle.processSpawnedAtMs === null ? {} : { processSpawnedAtMs: input.driverResult.lifecycle.processSpawnedAtMs },
-	resumedContext: input.resumedContext,
-	...input.driverResult.lifecycle.stdinClosedAtMs === null ? {} : { stdinClosedAtMs: input.driverResult.lifecycle.stdinClosedAtMs },
-	...input.driverResult.lifecycle.timeoutTriggeredAtMs === null ? {} : { timeoutTriggeredAtMs: input.driverResult.lifecycle.timeoutTriggeredAtMs }
-});
-const toOpenCodeCliTransportError = (error, timeoutMs) => {
-	if (error instanceof OpenCodeCliTransportError) return error;
-	if (error instanceof CliDriverError) {
-		if (error.code === "process.timeout") return new OpenCodeCliTransportError(classifyCliDriverTimeoutFailure({
-			error,
-			providerLabel: "opencode",
-			timeoutMs
-		}));
-		if (error.code === "process.spawn_failed") return new OpenCodeCliTransportError({
-			code: "upstream_unreachable",
-			errorType: "adapter",
-			message: `upstream_unreachable: failed to spawn opencode (${error.message})`
-		});
-		if (error.code === "process.non_zero_exit") {
-			const classifiedFailure = classifyOpenCodeFailure({
-				providerErrorMessages: [],
-				stderrText: error.stderrText,
-				stdoutText: error.stdoutText
-			});
-			return new OpenCodeCliTransportError({
-				code: classifiedFailure.code,
-				errorType: classifiedFailure.errorType,
-				message: classifiedFailure.message,
-				originalError: classifiedFailure.originalError,
-				providerAccessEvidence: classifiedFailure.providerAccessEvidence
-			});
-		}
-	}
-	return new OpenCodeCliTransportError({
-		code: "upstream_unreachable",
-		errorType: "adapter",
-		message: `upstream_unreachable: failed to execute opencode (${error instanceof Error ? error.message : String(error)})`
-	});
-};
-const classifyOpenCodeFailure = (input) => {
-	const hasProviderOwnedMessage = input.providerErrorMessages.length > 0 || extractErrorMessagesFromStdout(input.stdoutText).length > 0;
-	const providerMessage = resolveProviderFailureMessage(input);
-	if (providerMessage) return classifyOpenCodeFailureMessage({
-		includeOriginalError: hasProviderOwnedMessage,
-		isContextLost: isLikelyOpenCodeContextLostError,
-		message: providerMessage
-	});
-	return { ...buildProviderExitError({ providerLabel: "opencode" }) };
-};
-const resolveProviderFailureMessage = (input) => {
-	const candidateMessages = [
-		...input.providerErrorMessages,
-		...extractErrorMessagesFromStdout(input.stdoutText),
-		...normalizeOptionalText$10(input.stderrText) ? [normalizeOptionalText$10(input.stderrText)] : []
-	].filter((value) => Boolean(value));
-	for (const candidate of candidateMessages) if (looksLikeRuntimePermissionDenialMessage(candidate) || looksLikeProviderFailure(candidate)) return candidate;
-	return candidateMessages[0] ?? null;
-};
-const extractErrorMessagesFromStdout = (value) => {
-	const stdoutText = normalizeOptionalText$10(value);
-	if (!stdoutText) return [];
-	const messages = [];
-	const lines = stdoutText.split("\n");
-	for (const line of lines) {
-		const parsedLine = parseOpenCodeOutputLine(line);
-		if (parsedLine?.errorMessage) messages.push(parsedLine.errorMessage);
-	}
-	return messages;
-};
-const collectProviderErrorMessage = (line, output) => {
-	const normalized = normalizeOptionalText$10(line);
-	if (!normalized) return null;
-	output.push(normalized);
-	return normalized;
-};
-const collectRuntimePermissionDenialMessage = (line, output) => {
-	const normalized = normalizeOptionalText$10(line);
-	if (!(normalized && looksLikeRuntimePermissionDenialMessage(normalized))) return;
-	output.push(normalized);
-};
-const looksLikeProviderFailure = (value) => {
-	const lowered = value.toLowerCase();
-	return lowered.includes("error") || lowered.includes("failed") || lowered.includes("permission") || lowered.includes("reject") || lowered.includes("denied") || lowered.includes("unauthorized") || lowered.includes("not logged in") || lowered.includes("invalid") || lowered.includes("quota") || lowered.includes("rate") || lowered.includes("balance") || lowered.includes("credit") || lowered.includes("billing") || lowered.includes("payment required") || lowered.includes("session") || lowered.includes("unsupported model") || lowered.includes("model is not supported");
-};
-const looksLikeStreamingProviderFailure = (value) => {
-	const lowered = value.toLowerCase();
-	return lowered.includes("ai_apicallerror") || lowered.includes("bad gateway") || lowered.includes("gateway timeout") || lowered.includes("econnreset") || lowered.includes("etimedout") || lowered.includes("socket hang up");
-};
-function normalizeOptionalText$10(value) {
-	const normalized = String(value ?? "").trim();
-	return normalized.length > 0 ? normalized : null;
-}
-//#endregion
 //#region ../../runtime/adapters/opencode/dist/transport/opencode-delivery-only.js
 const SAFE_TOOL_ID = /^[A-Za-z0-9_.:-]+$/u;
 /** Narrow only the disposable correction session; never grant a final tool. */
@@ -23624,6 +23643,102 @@ function scopeError(message) {
 	});
 }
 //#endregion
+//#region ../../runtime/adapters/opencode/dist/transport/opencode-failure.js
+function classifyOpenCodeFailureMessage(input) {
+	const normalized = input.message.trim();
+	const lowered = normalized.toLowerCase();
+	const originalError = input.includeOriginalError ? createProviderOriginalError(normalized) : null;
+	const withOriginalError = (value) => ({
+		...value,
+		...originalError ? { originalError } : {}
+	});
+	const permissionDenial = classifyRuntimePermissionDenialMessage({
+		message: normalized,
+		source: "opencode"
+	});
+	if (permissionDenial) return withOriginalError(permissionDenial);
+	if (input.isContextLost(normalized)) return withOriginalError({
+		code: "context.lost",
+		errorType: "adapter",
+		message: `context.lost: ${normalized}`
+	});
+	if (lowered.includes("not logged in") || lowered.includes("unauthorized") || lowered.includes("authentication") || lowered.includes("credentials")) return withOriginalError({
+		code: "auth.required",
+		errorType: "auth",
+		message: `auth.required: ${normalized}`
+	});
+	if (lowered.includes("unsupported model") || lowered.includes("model is not supported") || lowered.includes("invalid model") || lowered.includes("model not found")) return withOriginalError({
+		code: "model.unsupported",
+		errorType: "config",
+		message: `model.unsupported: ${normalized}`
+	});
+	if (isInsufficientBalanceFailure(lowered)) return withOriginalError({
+		code: "provider.insufficient_balance",
+		errorType: "adapter",
+		message: `provider.insufficient_balance: ${normalized}`,
+		providerAccessEvidence: buildProviderAccessEvidence("provider_account.capacity_exhausted")
+	});
+	if (isDefinitiveHardQuotaFailure(lowered)) return withOriginalError({
+		code: "quota.exceeded",
+		errorType: "adapter",
+		message: `quota.exceeded: ${normalized}`,
+		providerAccessEvidence: buildProviderAccessEvidence("provider_account.capacity_exhausted")
+	});
+	if (isTransientRateLimitFailure(lowered)) return withOriginalError({
+		code: "provider.rate_limited",
+		errorType: "network",
+		message: `provider.rate_limited: ${normalized}`
+	});
+	if (isSubscriptionAccessFailure(lowered)) return withOriginalError({
+		code: "provider.subscription_access_unavailable",
+		errorType: "adapter",
+		message: `provider.subscription_access_unavailable: ${normalized}`,
+		providerAccessEvidence: buildProviderAccessEvidence("provider_account.subscription_access_unavailable")
+	});
+	if (isProviderUnavailableFailure(lowered)) return withOriginalError({
+		code: "provider.unavailable",
+		errorType: "network",
+		message: `provider.unavailable: ${normalized}`
+	});
+	if (isHardQuotaFailure(lowered)) return withOriginalError({
+		code: "quota.exceeded",
+		errorType: "adapter",
+		message: `quota.exceeded: ${normalized}`,
+		providerAccessEvidence: buildProviderAccessEvidence("provider_account.capacity_exhausted")
+	});
+	return withOriginalError({
+		code: "upstream_unreachable",
+		errorType: "adapter",
+		message: `upstream_unreachable: ${normalized}`
+	});
+}
+function buildProviderAccessEvidence(reasonCode) {
+	return {
+		observedAtMs: Date.now(),
+		provider: "opencode",
+		reasonCode,
+		source: "wake_failure"
+	};
+}
+function isHardQuotaFailure(value) {
+	return isDefinitiveHardQuotaFailure(value) || value.includes("usage limit") || value.includes("usage_limit");
+}
+function isDefinitiveHardQuotaFailure(value) {
+	return value.includes("insufficient quota") || value.includes("insufficient_quota") || value.includes("quota exceeded") || value.includes("exceeded your current quota");
+}
+function isSubscriptionAccessFailure(value) {
+	return value.includes("not included in your subscription") || value.includes("not available on your plan") || value.includes("subscription does not include") || value.includes("subscription access") || value.includes("upgrade your plan");
+}
+function isTransientRateLimitFailure(value) {
+	return value.includes("429") || value.includes("rate limit") || value.includes("too many requests");
+}
+function isInsufficientBalanceFailure(value) {
+	return value.includes("insufficient balance") || value.includes("insufficient_balance") || value.includes("not enough credits") || value.includes("out of credits") || value.includes("credits exhausted") || value.includes("credit balance") || value.includes("account balance") || value.includes("balance is too low") || value.includes("payment required");
+}
+function isProviderUnavailableFailure(value) {
+	return value.includes("bad gateway") || value.includes("gateway timeout") || value.includes("service unavailable") || value.includes("provider unavailable") || value.includes("socket hang up") || value.includes("econnreset") || value.includes("etimedout");
+}
+//#endregion
 //#region ../../runtime/adapters/opencode/dist/transport/opencode-interactions.js
 var OpenCodeInteractionHandler = class {
 	#client;
@@ -23804,8 +23919,449 @@ function normalizeBoundedText(value, maxLength) {
 	return normalized.length > 0 ? normalized.slice(0, maxLength) : null;
 }
 //#endregion
+//#region ../../runtime/adapters/opencode/dist/transport/opencode2-server.js
+function createOpenCode2Client(baseUrl, password) {
+	return OpenCode.make({
+		baseUrl,
+		headers: { Authorization: `Basic ${Buffer.from(`opencode:${password}`).toString("base64")}` }
+	});
+}
+function openCode2Error(code, message) {
+	return Object.assign(/* @__PURE__ */ new Error(`${code}: ${message}`), {
+		code,
+		errorType: "adapter"
+	});
+}
+async function readOpenCode2Inventory(input) {
+	const client = createOpenCode2Client(input.baseUrl, input.password);
+	const options = { signal: AbortSignal.timeout(input.timeoutMs) };
+	if (!(await client.server.info(options)).version.startsWith("2.")) throw openCode2Error("protocol.invalid", "OpenCode returned an unsupported API version.");
+	return (await client.model.list({ location: { directory: input.directory } }, options)).data.filter((model) => model.enabled).slice(0, 256).map((model) => ({
+		id: `${model.providerID}/${model.id}`,
+		displayName: model.name
+	}));
+}
+//#endregion
+//#region ../../runtime/adapters/opencode/dist/transport/opencode2-interactions.js
+async function answerOpenCode2Permission(client, request, onInteractionRequest, signal) {
+	const options = [
+		{
+			optionId: "once",
+			label: "Allow once",
+			intent: "allow_once"
+		},
+		...request.save?.length ? [{
+			optionId: "always",
+			label: "Always allow",
+			intent: "allow_always"
+		}] : [],
+		{
+			optionId: "reject",
+			label: "Deny",
+			intent: "deny"
+		}
+	];
+	const response = onInteractionRequest ? await requestInteraction(onInteractionRequest, {
+		kind: "permission",
+		title: "OpenCode needs permission",
+		description: (request.message || `${request.action}: ${request.resources.join(", ")}`).slice(0, 4e3),
+		subject: { type: permissionSubject(request.action) },
+		options
+	}, signal) : void 0;
+	const selected = response?.kind === "permission" && options.some((option) => option.optionId === response.optionId) ? response.optionId : "reject";
+	await client.permission.reply({
+		sessionID: request.sessionID,
+		requestID: request.id,
+		decision: selected
+	}, { signal });
+	if (!onInteractionRequest) throw openCode2Error("interaction.permission_required", "OpenCode requested permission without a user interaction channel.");
+}
+async function answerOpenCode2Form(client, form, onInteractionRequest, signal) {
+	const answer = {};
+	try {
+		if (!onInteractionRequest) throw openCode2Error("interaction.question_required", "OpenCode requested input without a user interaction channel.");
+		for (const field of form.fields) {
+			if (field.type === "external") throw openCode2Error("interaction.question_unsupported", "This OpenCode form requires an external browser action.");
+			if (field.when?.some((condition) => answer[condition.key] === condition.value !== (condition.op === "eq"))) continue;
+			if (applyHiddenField(field, answer)) continue;
+			const options = fieldOptions(field);
+			if (options.length > 20) throw openCode2Error("interaction.question_unsupported", "The OpenCode form has too many choices.");
+			if (field.key.length > 256) throw openCode2Error("interaction.question_unsupported", "The OpenCode field identifier is too long.");
+			const response = await requestInteraction(onInteractionRequest, {
+				kind: "question",
+				title: form.title.slice(0, 240),
+				questions: [{
+					questionId: field.key,
+					prompt: [field.title || field.key, field.description].filter(Boolean).join("\n").slice(0, 4e3),
+					options,
+					multiple: field.type === "multiselect",
+					allowOther: options.length === 0 || "custom" in field && field.custom === true
+				}]
+			}, signal);
+			if (response.kind !== "question") {
+				await client.session.form.cancel({
+					sessionID: form.sessionID,
+					formID: form.id
+				}, { signal });
+				return;
+			}
+			const values = response.answers.find((item) => item.questionId === field.key)?.values;
+			if (!values?.length) throw openCode2Error("interaction.response_invalid", "The form answer is missing.");
+			answer[field.key] = decodeField(field, values);
+		}
+		await client.session.form.reply({
+			sessionID: form.sessionID,
+			formID: form.id,
+			answer
+		}, { signal });
+	} catch (error) {
+		await client.session.form.cancel({
+			sessionID: form.sessionID,
+			formID: form.id
+		}, { signal }).catch(() => void 0);
+		throw error;
+	}
+}
+async function requestInteraction(callback, request, signal) {
+	signal?.throwIfAborted();
+	if (!signal) return await callback(request);
+	const stopped = Promise.withResolvers();
+	const onAbort = () => stopped.reject(signal.reason);
+	signal.addEventListener("abort", onAbort, { once: true });
+	try {
+		return await Promise.race([callback(request), stopped.promise]);
+	} finally {
+		signal.removeEventListener("abort", onAbort);
+	}
+}
+function decodeField(field, values) {
+	if (field.type !== "multiselect" && values.length !== 1) throw openCode2Error("interaction.response_invalid", "This field requires one answer.");
+	if (field.type === "boolean") {
+		if (values[0] !== "true" && values[0] !== "false") throw openCode2Error("interaction.response_invalid", "A boolean answer must be Yes or No.");
+		return values[0] === "true";
+	}
+	if (field.type === "number" || field.type === "integer") {
+		const value = Number(values[0]);
+		if (!Number.isFinite(value) || field.type === "integer" && !Number.isInteger(value) || typeof field.minimum === "number" && value < field.minimum || typeof field.maximum === "number" && value > field.maximum) throw openCode2Error("interaction.response_invalid", "The number is outside the requested range.");
+		return value;
+	}
+	const resolved = values.map((value) => {
+		const option = field.options?.find((_item, index) => String(index) === value);
+		if (option) return option.value;
+		if (field.options?.length && !field.custom) throw openCode2Error("interaction.response_invalid", "The selected choice is unavailable.");
+		return value;
+	});
+	if (field.type === "multiselect") return resolved;
+	const first = resolved[0];
+	if (first === void 0) throw openCode2Error("interaction.response_invalid", "The form answer is missing.");
+	return first;
+}
+function permissionSubject(action) {
+	if (action === "shell") return "command";
+	return action === "edit" ? "file_change" : "tool";
+}
+function applyHiddenField(field, answer) {
+	if (!field.hidden) return false;
+	if (field.default !== void 0) answer[field.key] = field.default;
+	else if (field.required) throw openCode2Error("interaction.question_unsupported", "A hidden required field has no default.");
+	return true;
+}
+function fieldOptions(field) {
+	if (field.type === "boolean") return [{
+		optionId: "true",
+		label: "Yes"
+	}, {
+		optionId: "false",
+		label: "No"
+	}];
+	if (!("options" in field)) return [];
+	return (field.options ?? []).map((option, index) => ({
+		optionId: String(index),
+		label: option.label.slice(0, 240),
+		...option.description ? { description: option.description.slice(0, 1e3) } : {}
+	}));
+}
+//#endregion
+//#region ../../runtime/adapters/opencode/dist/transport/opencode2-transport.js
+async function runOpenCode2Turn(input) {
+	const { client, signal } = input;
+	if (isDispatchSpaceActionDeliveryOnly(input.env)) throw openCode2Error("delivery_scope.unsupported", "OpenCode 2 cannot yet attest an exclusive reply-repair tool scope.");
+	const session = await prepareSession(input);
+	const eventsAbort = new AbortController();
+	const eventSignal = AbortSignal.any([signal, eventsAbort.signal]);
+	const ready = Promise.withResolvers();
+	const done = Promise.withResolvers();
+	ready.promise.catch(() => void 0);
+	done.promise.catch(() => void 0);
+	const state = {
+		sessionId: session.id,
+		sessions: /* @__PURE__ */ new Set([session.id]),
+		tools: /* @__PURE__ */ new Map(),
+		delivered: /* @__PURE__ */ new Set(),
+		assistantMessages: /* @__PURE__ */ new Set(),
+		started: false,
+		output: "",
+		previewEmitted: false
+	};
+	const events = (async () => {
+		for await (const event of client.event.subscribe({ signal: eventSignal })) {
+			if (event.type === "server.connected") {
+				ready.resolve();
+				continue;
+			}
+			if (await observeEvent(input, state, event, eventSignal)) {
+				done.resolve();
+				return;
+			}
+		}
+		throw openCode2Error("protocol.stream_closed", "OpenCode closed the event stream.");
+	})().catch((error) => {
+		ready.reject(error);
+		done.reject(error);
+	});
+	try {
+		await Promise.race([ready.promise, new Promise((_resolve, reject) => {
+			AbortSignal.timeout(5e3).addEventListener("abort", () => reject(openCode2Error("protocol.timeout", "OpenCode did not confirm its event subscription.")), { once: true });
+		})]);
+		const receipt = await client.session.prompt({
+			sessionID: session.id,
+			text: input.instructionPrompt?.userPrompt ?? input.prompt
+		}, { signal });
+		await input.onRuntimeEvent?.({
+			phase: "provider_turn_accepted",
+			agentControllerConversationId: session.id,
+			turnId: receipt.id,
+			tsMs: Date.now()
+		});
+		await done.promise;
+		if (!state.delivered.has(receipt.id)) throw openCode2Error("protocol.receipt_missing", "OpenCode ended an execution without confirming delivery of this prompt.");
+		const messages = await client.message.list({
+			sessionID: session.id,
+			type: "assistant",
+			order: "desc",
+			limit: 100
+		}, { signal });
+		const latest = messages.data.find((message) => message.type === "assistant" && state.assistantMessages.has(message.id));
+		const aiUsage = messages.data.flatMap((message) => {
+			if (message.type !== "assistant" || !state.assistantMessages.has(message.id) || !message.tokens || !message.time.completed) return [];
+			const tokens = message.tokens;
+			const inputTokens = tokens.input + tokens.cache.read + tokens.cache.write;
+			const outputTokens = tokens.output + tokens.reasoning;
+			const observation = readAdapterAiUsageObservation({
+				eventId: `opencode:${session.id}:${message.id}`,
+				provider: message.model.providerID,
+				model: message.model.id,
+				source: "opencode_message",
+				occurredAtMs: message.time.completed,
+				tokens: {
+					input: inputTokens,
+					output: outputTokens,
+					cacheRead: tokens.cache.read,
+					cacheWrite: tokens.cache.write,
+					reasoning: tokens.reasoning,
+					total: inputTokens + outputTokens
+				},
+				cost: typeof message.cost === "number" ? {
+					nanoUsd: Math.round(message.cost * 1e9),
+					kind: "provider_estimate"
+				} : null
+			});
+			return observation ? [observation] : [];
+		});
+		if (latest?.type === "assistant") state.output = latest.content.filter((part) => part.type === "text").map((part) => part.text).join("\n");
+		if (input.onPreview && input.streamingMode !== "stream" && state.output) {
+			await input.onPreview({ text: state.output });
+			state.previewEmitted = true;
+		}
+		return {
+			sessionId: session.id,
+			output: state.output,
+			previewEmitted: state.previewEmitted,
+			aiUsage
+		};
+	} finally {
+		eventsAbort.abort();
+		await events;
+	}
+}
+async function assertOpenCode2Directory(session, directory) {
+	if (await realpath(session.location.directory) !== await realpath(directory)) throw openCode2Error("context.directory_mismatch", "The OpenCode session belongs to a different working folder.");
+}
+function readOpenCode2Permissions(value) {
+	if (!value) return;
+	const raw = JSON.parse(value);
+	if (!raw || typeof raw !== "object" || Array.isArray(raw)) throw openCode2Error("permission.invalid", "OpenCode permission settings must be an object.");
+	const rules = [];
+	for (const [name, setting] of Object.entries(raw)) {
+		const action = {
+			bash: "shell",
+			task: "subagent",
+			write: "edit",
+			patch: "edit"
+		}[name] ?? name;
+		const entries = permissionEntries(setting);
+		if (!entries.length) throw openCode2Error("permission.invalid", "OpenCode permission settings are invalid.");
+		for (const [resource, effect] of entries) {
+			if (effect !== "ask" && effect !== "allow" && effect !== "deny") throw openCode2Error("permission.invalid", "OpenCode permission effects are invalid.");
+			rules.push({
+				action,
+				resource,
+				effect
+			});
+		}
+	}
+	return rules;
+}
+async function prepareSession(input) {
+	const { client, signal } = input;
+	const location = { directory: await realpath(input.directory) };
+	const spaceAction = resolveDispatchSpaceActionMcpServer(input.env);
+	if (spaceAction) {
+		await client.mcp.add({
+			location,
+			server: spaceAction.id,
+			config: {
+				type: "local",
+				command: [spaceAction.commandPath, ...spaceAction.args],
+				environment: spaceAction.env,
+				codemode: false
+			}
+		}, { signal });
+		await client.mcp.connect({
+			location,
+			server: spaceAction.id
+		}, { signal });
+		await waitForSpaceActionMcp(client, location, spaceAction.id, signal);
+		await setTimeout$1(500, void 0, { signal });
+	}
+	const modelId = input.conversationPolicy?.model;
+	const split = modelId?.indexOf("/") ?? -1;
+	if (modelId && split < 1) throw openCode2Error("model.unavailable", "OpenCode models require a provider/model identifier.");
+	const model = modelId ? {
+		providerID: modelId.slice(0, split),
+		id: modelId.slice(split + 1),
+		...input.conversationPolicy?.reasoningLevel ? { variant: input.conversationPolicy.reasoningLevel } : {}
+	} : void 0;
+	const permissions = readOpenCode2Permissions(input.env?.OPENCODE_PERMISSION);
+	let session;
+	if (input.sessionId) {
+		session = await client.session.get({ sessionID: input.sessionId }, { signal });
+		await assertOpenCode2Directory(session, location.directory);
+		if ((await client.session.active({ signal }))[session.id]) throw openCode2Error("conversation.busy", "The selected OpenCode session is already running.");
+		if (permissions) await client.session.update({
+			sessionID: session.id,
+			permissions
+		}, { signal });
+		if (model) await client.session.switchModel({
+			sessionID: session.id,
+			model
+		}, { signal });
+	} else session = await client.session.create({
+		location,
+		...model ? { model } : {},
+		...permissions ? { permissions } : {}
+	}, { signal });
+	await input.onRuntimeEvent?.({
+		phase: "provider_conversation_observed",
+		agentControllerConversationId: session.id,
+		tsMs: Date.now()
+	});
+	if (input.instructionPrompt) await client.session.instructions.entry.put({
+		sessionID: session.id,
+		key: "openmeld.dispatch",
+		value: input.instructionPrompt.developerInstructions
+	}, { signal });
+	return session;
+}
+function permissionEntries(setting) {
+	if (typeof setting === "string") return [["*", setting]];
+	return setting && typeof setting === "object" && !Array.isArray(setting) ? Object.entries(setting) : [];
+}
+async function waitForSpaceActionMcp(client, location, name, signal) {
+	const startupSignal = AbortSignal.any([signal, AbortSignal.timeout(3e4)]);
+	while (true) {
+		const status = (await client.mcp.list({ location }, { signal: startupSignal })).data.find((server) => server.name === name)?.status;
+		if (status?.status === "connected") return;
+		if (status && status.status !== "pending") throw openCode2Error("space.action.unavailable", `OpenCode could not start the Space action tools: ${JSON.stringify(status)}`);
+		await setTimeout$1(100, void 0, { signal: startupSignal });
+	}
+}
+async function observeEvent(input, state, event, signal) {
+	if (event.type === "session.created" && event.data.parentID && state.sessions.has(event.data.parentID)) state.sessions.add(event.data.sessionID);
+	if (event.type === "form.created") {
+		if (state.sessions.has(event.data.form.sessionID)) await answerOpenCode2Form(input.client, event.data.form, input.onInteractionRequest, signal);
+		return false;
+	}
+	if (!("sessionID" in event.data && state.sessions.has(event.data.sessionID))) return false;
+	if (event.type === "permission.asked") {
+		await answerOpenCode2Permission(input.client, event.data, input.onInteractionRequest, signal);
+		return false;
+	}
+	await observeTool(input, state, event);
+	if (event.data.sessionID !== state.sessionId) return false;
+	if ("assistantMessageID" in event.data && typeof event.data.assistantMessageID === "string") state.assistantMessages.add(event.data.assistantMessageID);
+	return await observeRootEvent(input, state, event);
+}
+async function observeTool(input, state, event) {
+	if (event.type === "session.tool.input.started") state.tools.set(event.data.id, event.data.name);
+	if (event.type !== "session.tool.called" && event.type !== "session.tool.success" && event.type !== "session.tool.failed") return;
+	await input.onRuntimeEvent?.({
+		phase: "tool_activity",
+		toolCallId: event.data.id,
+		toolName: resolveAdapterToolActivityName(state.tools.get(event.data.id)),
+		state: {
+			"session.tool.called": "input-available",
+			"session.tool.success": "output-available",
+			"session.tool.failed": "output-error"
+		}[event.type],
+		tsMs: Date.now()
+	});
+}
+async function observeRootEvent(input, state, event) {
+	switch (event.type) {
+		case "session.inbox.delivered":
+			state.delivered.add(event.data.inboxID);
+			break;
+		case "session.execution.started":
+			state.started = true;
+			break;
+		case "session.text.delta":
+			state.output += event.data.delta;
+			if (input.streamingMode === "stream" && input.onPreview) {
+				await input.onPreview({ text: state.output });
+				state.previewEmitted = true;
+			}
+			break;
+		case "session.reasoning.delta":
+			await input.onRuntimeEvent?.({
+				phase: "reasoning",
+				blockId: `${event.data.assistantMessageID}:${event.data.ordinal}`,
+				mode: "append",
+				text: event.data.delta,
+				tsMs: Date.now()
+			});
+			break;
+		case "session.execution.succeeded": return state.started;
+		case "session.execution.failed": {
+			if (!state.started) break;
+			const failure = classifyOpenCodeFailureMessage({
+				message: event.data.error.message,
+				isContextLost: () => false,
+				includeOriginalError: true
+			});
+			throw Object.assign(new Error(failure.message), failure);
+		}
+		case "session.execution.interrupted":
+			if (state.started) throw openCode2Error("runtime.interrupted", `OpenCode interrupted the execution: ${event.data.reason}`);
+			break;
+		default: break;
+	}
+	return false;
+}
+//#endregion
 //#region ../../runtime/adapters/opencode/dist/transport/opencode-server-transport.js
 const SERVER_HOSTNAME = "127.0.0.1";
+const OPENCODE_V1_VERSION_RE = /^v?1\./u;
 const SERVER_HEALTH_TIMEOUT_MS = 5e3;
 const SERVER_STARTUP_TIMEOUT_MS = 15e3;
 const SERVER_MAX_START_ATTEMPTS = 2;
@@ -23813,7 +24369,7 @@ const SERVER_SLOW_START_MS = 5e3;
 const SERVER_DIAGNOSTIC_CONNECT_TIMEOUT_MS = 250;
 const SERVER_PROCESS_KILL_GRACE_MS = 1e3;
 const SERVER_PROCESS_CLOSE_TIMEOUT_MS = 2e3;
-const SERVER_READY_LINE_PATTERN = /^opencode server listening on (https?:\/\/[^\s]+)$/;
+const SERVER_READY_LINE_PATTERN = /^(?:opencode )?server listening on (https?:\/\/[^\s]+)$/;
 var OpenCodeServerTransportError = class extends Error {
 	telemetry;
 	code;
@@ -23851,26 +24407,45 @@ async function invokeOpenCodeServerTransport(input) {
 	const canonicalRepairSessionId = input.executionMode === "repair" || isDispatchSpaceActionDeliveryOnly(input.env) ? normalizeOptionalText$9(input.sessionId) : null;
 	let result;
 	try {
-		const executionSessionId = canonicalRepairSessionId ? await forkOpenCodeSessionWithClient({
-			client,
-			openCodeWorkdir: input.openCodeWorkdir,
-			sourceSessionId: canonicalRepairSessionId
-		}) : normalizeOptionalText$9(input.sessionId);
-		result = await runOpenCodeServerTurn({
-			env: input.env,
-			onRuntimeEvent: input.onRuntimeEvent,
-			client,
-			conversationPolicy: input.conversationPolicy,
-			instructionPrompt: input.instructionPrompt,
-			observedSessionId: canonicalRepairSessionId,
-			onInteractionRequest: input.onInteractionRequest,
-			onPreview: input.onPreview,
-			openCodeWorkdir: input.openCodeWorkdir,
-			prompt,
-			server,
-			sessionId: executionSessionId,
-			streamingMode: input.streamingMode ?? "final"
-		});
+		if (server.apiMajor === 2) {
+			if (canonicalRepairSessionId) throw new OpenCodeServerTransportError({
+				code: "delivery_scope.unsupported",
+				errorType: "config",
+				message: "OpenCode 2 reply repair requires an attested restricted tool scope."
+			});
+			const abort = new AbortController();
+			try {
+				result = await Promise.race([runOpenCode2Turn({
+					...input,
+					client: createOpenCode2Client(serverUrl, server.apiPassword),
+					directory: input.openCodeWorkdir,
+					signal: abort.signal
+				}), server.waitForFailure()]);
+			} finally {
+				abort.abort();
+			}
+		} else {
+			const executionSessionId = canonicalRepairSessionId ? await forkOpenCodeSessionWithClient({
+				client,
+				openCodeWorkdir: input.openCodeWorkdir,
+				sourceSessionId: canonicalRepairSessionId
+			}) : normalizeOptionalText$9(input.sessionId);
+			result = await runOpenCodeServerTurn({
+				env: input.env,
+				onRuntimeEvent: input.onRuntimeEvent,
+				client,
+				conversationPolicy: input.conversationPolicy,
+				instructionPrompt: input.instructionPrompt,
+				observedSessionId: canonicalRepairSessionId,
+				onInteractionRequest: input.onInteractionRequest,
+				onPreview: input.onPreview,
+				openCodeWorkdir: input.openCodeWorkdir,
+				prompt,
+				server,
+				sessionId: executionSessionId,
+				streamingMode: input.streamingMode ?? "final"
+			});
+		}
 	} catch (error) {
 		const failure = toOpenCodeServerTransportError(error, server.readStderr());
 		failure.telemetry = server.buildTelemetry({
@@ -23891,12 +24466,15 @@ async function invokeOpenCodeServerTransport(input) {
 	return {
 		output: result.output,
 		sessionId: canonicalRepairSessionId ?? result.sessionId,
-		telemetry: server.buildTelemetry({
-			invokedAtMs,
-			previewEmitted: result.previewEmitted,
-			resumedContext: normalizeOptionalText$9(input.sessionId) !== null,
-			streamingMode: input.streamingMode ?? "final"
-		})
+		telemetry: {
+			...server.buildTelemetry({
+				invokedAtMs,
+				previewEmitted: result.previewEmitted,
+				resumedContext: normalizeOptionalText$9(input.sessionId) !== null,
+				streamingMode: input.streamingMode ?? "final"
+			}),
+			...result.aiUsage ? { aiUsage: result.aiUsage } : {}
+		}
 	};
 }
 async function forkOpenCodeServerSession(input) {
@@ -23912,6 +24490,17 @@ async function forkOpenCodeServerSession(input) {
 		deadlineMs
 	});
 	try {
+		if (server.apiMajor === 2) {
+			const client = createOpenCode2Client(serverUrl, server.apiPassword);
+			const options = { signal: AbortSignal.timeout(15e3) };
+			await assertOpenCode2Directory(await client.session.get({ sessionID: sourceSessionId }, options), input.openCodeWorkdir);
+			const fork = await client.session.fork({ sessionID: sourceSessionId }, options);
+			if (input.title) await client.session.update({
+				sessionID: fork.id,
+				title: input.title
+			}, options);
+			return { sessionId: fork.id };
+		}
 		const client = createOpencodeClient({
 			baseUrl: serverUrl,
 			directory: input.openCodeWorkdir,
@@ -23969,6 +24558,23 @@ async function forkOpenCodeSessionWithClient(input) {
 	})).sessionId;
 }
 async function startHealthyOpenCodeServer(input) {
+	const pure = isDispatchSpaceActionDeliveryOnly(input.env);
+	if (pure) {
+		const version = await runCliDriver({
+			...buildCliLaunchInvocation({
+				launchContract: input.launchContract,
+				args: ["--version"]
+			}),
+			cwd: input.openCodeWorkdir,
+			env: input.env,
+			timeoutMs: SERVER_STARTUP_TIMEOUT_MS
+		});
+		if (!OPENCODE_V1_VERSION_RE.test(version.stdoutText.trim())) throw new OpenCodeServerTransportError({
+			code: "delivery_scope.unsupported",
+			errorType: "config",
+			message: "OpenCode reply repair requires the verified OpenCode 1 pure-server contract."
+		});
+	}
 	let lastError = null;
 	const startupEvidence = [];
 	for (let attemptIndex = 0; attemptIndex < SERVER_MAX_START_ATTEMPTS; attemptIndex += 1) {
@@ -23977,6 +24583,7 @@ async function startHealthyOpenCodeServer(input) {
 		const startupTimeoutMs = Math.min(remainingTimeoutMs ?? Number.POSITIVE_INFINITY, SERVER_STARTUP_TIMEOUT_MS);
 		const attempt = await runOpenCodeServerStartAttempt({
 			...input,
+			pure,
 			openCodeTimeoutMs: remainingTimeoutMs,
 			startupTimeoutMs
 		});
@@ -24025,7 +24632,9 @@ async function runOpenCodeServerStartAttempt(input) {
 		});
 	}
 	try {
-		await assertOpenCodeServerHealthy({
+		if (server.apiMajor === 2) {
+			if (!(await createOpenCode2Client(serverUrl, server.apiPassword).server.info({ signal: AbortSignal.timeout(SERVER_HEALTH_TIMEOUT_MS) })).version.startsWith("2.")) throw new Error("OpenCode returned an unsupported server API version.");
+		} else await assertOpenCodeServerHealthy({
 			deadlineMs: input.deadlineMs,
 			directory: input.openCodeWorkdir,
 			serverUrl
@@ -24498,6 +25107,9 @@ function throwInteractionFailure(failure) {
 	});
 }
 var OpenCodeServerProcess = class {
+	apiMajor = 1;
+	apiPassword = randomUUID();
+	#pure;
 	#aiUsage = /* @__PURE__ */ new Map();
 	#env;
 	#failure = createDeferred();
@@ -24539,6 +25151,7 @@ var OpenCodeServerProcess = class {
 		timeoutTriggeredAtMs: null
 	};
 	constructor(input) {
+		this.#pure = input.pure === true;
 		this.#env = input.env;
 		this.#launchContract = input.launchContract;
 		this.#onProcessControlEvent = input.onProcessControlEvent;
@@ -24555,11 +25168,9 @@ var OpenCodeServerProcess = class {
 		const invocation = buildCliLaunchInvocation({
 			args: [
 				"serve",
-				...isDispatchSpaceActionDeliveryOnly(this.#env) ? ["--pure"] : [],
+				...this.#pure ? ["--pure"] : [],
 				`--hostname=${SERVER_HOSTNAME}`,
-				`--port=${port}`,
-				"--print-logs",
-				"--log-level=INFO"
+				`--port=${port}`
 			],
 			launchContract: this.#launchContract
 		});
@@ -24569,7 +25180,8 @@ var OpenCodeServerProcess = class {
 			cwd: this.#openCodeWorkdir,
 			env: {
 				...process.env,
-				...this.#env ?? {}
+				...this.#env ?? {},
+				OPENCODE_PASSWORD: this.apiPassword
 			},
 			shell: invocation.shell ?? false
 		});
@@ -24863,6 +25475,7 @@ var OpenCodeServerProcess = class {
 				return;
 			}
 			this.#startupResolve?.(reportedUrl);
+			this.apiMajor = line.startsWith("opencode ") ? 1 : 2;
 			this.#readyLineObserved = true;
 			this.#startupResolve = null;
 			this.#startupReject = null;
@@ -24967,6 +25580,13 @@ function unwrapSdkData(value) {
 	return record && "data" in record ? record.data : value;
 }
 function toOpenCodeServerTransportError(error, stderr) {
+	if (!(error instanceof OpenCodeServerTransportError) && error instanceof Error && "code" in error && typeof error.code === "string" && "errorType" in error && typeof error.errorType === "string") return new OpenCodeServerTransportError({
+		...error,
+		code: error.code,
+		errorType: error.errorType,
+		message: error.message,
+		originalError: createProviderOriginalError(error.message) ?? void 0
+	});
 	if (error instanceof Error && toRecord$1(error)?.code === "space.action.delivery_only_unverified") return new OpenCodeServerTransportError({
 		code: "space.action.delivery_only_unverified",
 		errorType: "config",
@@ -25070,7 +25690,7 @@ async function invokeOpenCodeWithSingleContextHeal(input) {
 }
 async function invokeOpenCodeOnce(input) {
 	try {
-		if (input.onInteractionRequest || input.sessionId) return await invokeOpenCodeServerTransport({
+		return await invokeOpenCodeServerTransport({
 			launchContract: input.launchContract,
 			openCodeTimeoutMs: input.openCodeTimeoutMs,
 			openCodeWorkdir: input.openCodeWorkdir,
@@ -25086,17 +25706,6 @@ async function invokeOpenCodeOnce(input) {
 			sessionId: input.sessionId,
 			streamingMode: input.streamingMode
 		});
-		return await invokeOpenCodeCliTransport({
-			launchContract: input.launchContract,
-			openCodeTimeoutMs: input.openCodeTimeoutMs,
-			openCodeWorkdir: input.openCodeWorkdir,
-			conversationPolicy: input.conversationPolicy,
-			env: input.env,
-			...input.onProcessControlEvent ? { onProcessControlEvent: input.onProcessControlEvent } : {},
-			...input.onRuntimeEvent ? { onRuntimeEvent: input.onRuntimeEvent } : {},
-			prompt: input.prompt,
-			sessionId: input.sessionId
-		});
 	} catch (error) {
 		if (error instanceof OpenCodeRuntimeError) throw error;
 		if (error && typeof error === "object" && "code" in error && typeof error.code === "string" && "errorType" in error && typeof error.errorType === "string" && error instanceof Error) throw new OpenCodeRuntimeError({
@@ -30534,9 +31143,9 @@ const BUILTIN_AGENT_CONTROLLER_DEFINITIONS = [
 			cancel: true,
 			interrupt: true,
 			modelSelection: true,
-			nativeEventStream: false,
+			nativeEventStream: true,
 			permissionModes: true,
-			structuredUserInput: false
+			structuredUserInput: true
 		},
 		conversationOccupancy: {
 			contractVersion: 1,
@@ -30571,7 +31180,7 @@ const BUILTIN_AGENT_CONTROLLER_DEFINITIONS = [
 			modelSelection: true,
 			nativeEventStream: true,
 			permissionModes: true,
-			structuredUserInput: false
+			structuredUserInput: true
 		},
 		conversationOccupancy: {
 			contractVersion: 1,
@@ -30612,13 +31221,13 @@ const BUILTIN_AGENT_CONTROLLER_DEFINITIONS = [
 		adapterId: "cursor",
 		agentId: "cursor",
 		capabilities: {
-			approvals: false,
+			approvals: true,
 			cancel: true,
 			interrupt: true,
 			modelSelection: true,
 			nativeEventStream: true,
 			permissionModes: true,
-			structuredUserInput: false
+			structuredUserInput: true
 		},
 		conversationOccupancy: {
 			contractVersion: 1,
@@ -30678,13 +31287,13 @@ const BUILTIN_AGENT_CONTROLLER_DEFINITIONS = [
 		adapterId: "opencode",
 		agentId: "opencode",
 		capabilities: {
-			approvals: false,
+			approvals: true,
 			cancel: false,
 			interrupt: true,
 			modelSelection: true,
-			nativeEventStream: false,
-			permissionModes: false,
-			structuredUserInput: false
+			nativeEventStream: true,
+			permissionModes: true,
+			structuredUserInput: true
 		},
 		conversationOccupancy: {
 			contractVersion: 1,
@@ -32571,9 +33180,9 @@ function createModelCatalogReadSession(input) {
 async function readModelCatalogOnce(baseUrl) {
 	try {
 		const [apiClient, baseUrlModule, clientFoundationModule] = await Promise.all([
-			import("./dist-CfvQIuzK.js"),
+			import("./dist-DMlKqjUf.js"),
 			import("./base-url-Bdjp-5vy.js"),
-			import("./api-client-foundation-DjzQysm8.js")
+			import("./api-client-foundation-B1aTRrIy.js")
 		]);
 		if (typeof apiClient.createConfigApi !== "function") throw new Error("config api client is unavailable");
 		const resolvedBaseUrl = baseUrl ?? await baseUrlModule.resolveBaseUrl();
@@ -32867,9 +33476,9 @@ function resolveBoundProfileLocalRouteCandidate(input) {
 	const agentControllerCollaborationMode = resolveNativeAgentControllerCollaborationModeForController(binding.agentControllerCollaborationMode, { agentControllerRef: agentControllerRef.ref });
 	return {
 		agentControllerRef: agentControllerRef.ref,
-		agentControllerConversationId: normalizeOptionalText$51(executionTarget.agentControllerConversationId),
+		agentControllerConversationId: normalizeOptionalText$49(executionTarget.agentControllerConversationId),
 		openMeldServiceRuntimeId: executionTarget.openMeldServiceRuntimeId.value,
-		bindingId: normalizeOptionalText$51(binding.bindingId),
+		bindingId: normalizeOptionalText$49(binding.bindingId),
 		...agentControllerCollaborationMode ? { agentControllerCollaborationMode } : {},
 		...agentControllerPermissionMode ? { agentControllerPermissionMode } : {},
 		...binding.modelSelection ? { modelSelection: binding.modelSelection } : {},
@@ -34334,7 +34943,7 @@ const DEFAULT_OPENCLAW_RUNTIME_PREPARATION_DEPS = {
 	fetchGatewayHealth: fetchOpenClawGatewayHealth
 };
 async function prepareOpenClawRuntime(input, deps = DEFAULT_OPENCLAW_RUNTIME_PREPARATION_DEPS) {
-	const profileName = normalizeOptionalText$51(input.profileName);
+	const profileName = normalizeOptionalText$49(input.profileName);
 	if (!profileName) throw new DaemonServiceRunError({
 		code: "controller.bootstrap.failed",
 		message: "controller.bootstrap.failed: OpenClaw bootstrap requires an OpenMeld profile name"
@@ -34397,12 +35006,12 @@ function buildOpenClawGatewayVisibilityFailure(error) {
 }
 function extractErrorCode(error) {
 	if (!(error && typeof error === "object" && "code" in error)) return;
-	return normalizeOptionalText$51(error.code) ?? void 0;
+	return normalizeOptionalText$49(error.code) ?? void 0;
 }
 function resolveOpenClawGatewayVisibilityDiagnostics(error) {
 	if (!(error instanceof Error)) return;
 	const diagnostics = error.diagnostics;
-	if (!diagnostics || typeof diagnostics !== "object" || !normalizeOptionalText$51(diagnostics.agentId)) return;
+	if (!diagnostics || typeof diagnostics !== "object" || !normalizeOptionalText$49(diagnostics.agentId)) return;
 	const parsedGatewayVisibility = openMeldDaemonTaskResultOpenClawGatewayVisibilityStatusSchema.safeParse(diagnostics.gatewayVisibility);
 	if (!parsedGatewayVisibility.success) return;
 	return {
@@ -34429,6 +35038,6 @@ async function prepareProviderRuntime(input, options = {}) {
 	return await preparer(input);
 }
 //#endregion
-export { canManageRegistryAgentSkillTargets as $, resolveExecutablePathsOnPath as $n, mergeOpenClawGatewayVisibility as $t, createExpectedRoutesReadSession as A, emitReconcileCompletedEvidence as An, resolveNativeAgentControllerPermissionModeForController as Ar, ensureOpenMeldManagedProfileWorkspace as At, reconcileNewRunnableBuiltinAgentsForSetup as B, resolveConversationExecutionStateByLookupKey as Bn, resolveCatalogSyncIntervalMs as Br, createMutableRouteCatalogState as Bt, createModelCatalogReadSession as C, probeCodexAppServerAccount as Cn, renderInformationProtectionPrompt as Cr, resolveLocalProjectConnectionForPath as Ct, NO_LOCAL_AGENTS_NEED_OPENMELD_SERVICE_REASON as D, probeClaudeCodeUsageLimits as Dn, resolveAgentExecutionStatus as Dr, resolveRegistryOriginLaunchCommand as Dt, resolveProfileWorkspaceRuntime as E, projectCodexUsageLimits as En, resolveAgentControllerPermissionModeForController as Er, listBuiltinAgentsRegistryEntries as Et, listAgentRegistrations as F, buildTaskResultEnvelope as Fn, MIN_HEARTBEAT_INTERVAL_MS as Fr, resolveConfiguredProfileWorkspacePathForAccount as Ft, updateAgentRegistrations as G, buildAuthenticatedControlPlaneResponse as Gn, syncRuntimeEventToInflightTaskControlRegistry as Gt, resolveAgentTargetState as H, settleInflightTask as Hn, resolveBuiltinAgentControllerBrand as Hr, summarizeSkippedDaemonProfiles as Ht, listAgentTargetStates as I, appendLedgerHistoryEntry as In, applyAcceptedLeases as Ir, setCustomProfileWorkspace as It, normalizeAgentIds as J, createUnavailableProviderUsageLimits as Jn, isDaemonReconcileInProgressError as Jt, notifyDaemonRouteCatalogChanged as K, assertLegacyAgentContextAssociation as Kn, SPACE_ACTION_CONTEXT_GUIDANCE_LINES as Kt, manageAgentRegistrationInstallation as L, commitResolvedAgentContext as Ln, applyIntervalJitterMs as Lr, setOpenMeldManagedProfileWorkspace as Lt, addAgentCustomTarget as M, DaemonServiceRunError as Mn, resolveRouteRegistrationReconcileDecision as Mr, readProfileWorkspaceConfig as Mt, createRegistrationFromCatalogTarget as N, runRuntimeTask as Nn, ADAPTIVE_HEARTBEAT_JITTER_RATIO as Nr, readProfileWorkspaceConfigForAccount as Nt, syncDeviceRuntimeStateProjection as O, resolveInstalledClaudeCodeLaunchCandidates as On, resolveAgentProfileEditCapabilities as Or, resolveRegistryRuntimeAdapterCapabilitySnapshot as Ot, listAgentCustomTargets as P, buildRuntimeWorkspaceFingerprint as Pn, MAX_HEARTBEAT_INTERVAL_MS as Pr, resolveConfiguredProfileWorkspacePath as Pt, resolveLocalRegistryAgentIdFromAgentControllerRef as Q, materializeCliLaunchCommand as Qn, createPendingAgentInteractionRegistry as Qt, readAgentRuntimeConfigHealth as R, loadLedgerState as Rn, pruneStaleLeases as Rr, validateCustomProfileWorkspacePath as Rt, syncProfileWorkspaceState as S, forkCodexAppServerThread as Sn, projectPeopleComputersToLegacyLocalRuntimes as Sr, canonicalizeLocalProjectPath as St, resolveEffectiveProfileWorkingFolderRuntime as T, verifyCodexAppServerThread as Tn, renderWorkingLanguagePrompt as Tr, withAgentActivityLocalStateLock as Tt, setAgentRegistrationEnabled as U, upsertConversationExecutionState as Un, __toESM as Ur, syncDaemonRouteCatalogState as Ut, removeAgentCustomTarget as V, seedLegacyAgentContext as Vn, compareAgentControllerRefsForDisplay as Vr, createRouteCatalogFromMutableState as Vt, updateAgentCustomTarget as W, withLedgerStateTransaction as Wn, normalizeDispatchThreadAction as Wt, sortAgentRegistrations as X, resolveDispatchSpaceActionMcpServer as Xn, buildDispatchReplyContextSummary as Xt, parseAgentEnabledOption as Y, createUnsupportedProviderUsageLimits as Yn, createSerialAgentInteractionCallback as Yt, repairBuiltinControllerInstall as Z, buildCliLaunchInvocation as Zn, normalizeDispatchPostMessageAction as Zt, loadDaemonRouteCatalog as _, probeGrokBuildAcpInterface as _n, isAgentControllerUsageRefreshUnavailable as _r, removeProjectConnection as _t, buildOpenClawSpaceSessionKey as a, resolveDispatchContinuityObservation as an, TASK_KNOWLEDGE_GUIDANCE as ar, isHomebrewCommandPath as at, resolveLocalController as b, resolveCodexTimeoutMs as bn, parseAgentControllerRef as br, setDefaultProjectConnection as bt, findOpenClawAgentById as c, resolveLatestScopedConversationExecutionState as cn, buildInformationProtectionPromptPlan as cr, ProjectBindingOperationError as ct, resolveOpenClawAuthStatus as d, createLocalAdapterEntries as dn, createAgentControllerInterfaceDisplayRows as dr, isProjectBound as dt, createLocalTaskInterruptSender as en, listAgentControllerSupervisedProcessIds as er, detectInstalledSkillsAgents as et, resolveOpenClawProviderRuntimeWorkingDirectory as f, parseOpenRouterUsageResponse as fn, createAgentExecutionStatusDisplayRows as fr, listProjectBindings as ft, writeDaemonRouteCatalogCache as g, GrokBuildAcpTransportError as gn, isAgentControllerUsageAccountUnavailable as gr, removeMissingProjectConnections as gt, readDaemonRouteCatalogCache as h, resolveInstalledOpenCodeLaunchCandidates as hn, getAgentControllerPermissionModeFieldLabel as hr, removeAgentActivityBindingsWhileDeliveryLocked as ht, listOpenClawGatewayAgents as i, resolveDispatchQueueLogMeta as in, DEFAULT_TASK_LIFECYCLE_HEARTBEAT_INTERVAL_MS as ir, isBunGlobalCommandPath as it, resolveAgentProfilePrimaryAgentControllerReport as j, emitReconcileStartedEvidence as jn, resolveSelectableCandidates as jr, normalizeCustomProfileWorkspacePath as jt, createPrimaryBindingReadSession as k, emitDriftDetectedEvidence as kn, resolveEvidenceSyncHealth as kr, resolveRegistryRuntimeAdapterContractByAgentControllerRef as kt, findOpenClawAgentsByWorkspace as l, resolveCatalogSyncSkippedProfilesLogState as ln, buildWorkingLanguagePromptPlan as lr, ProjectBindingStoreUpdateRequiredError as lt, resolveOpenClawLocalBootstrapPaths as m, forkOpenCodeServerSession as mn, getAgentControllerPermissionModeDisplayMetadata as mr, migrateProjectBindingStore as mt, fetchOpenClawGatewayHealth as n, createLocalExecutionSlots as nn, DISPATCH_SPACE_ACTION_DELIVERY_ONLY_ENV as nr, EMPTY_AGENT_CONTROLLER_INTERFACE_CAPABILITIES as nt, normalizeOpenClawSpaceIdPrefix as o, resolveCompatibleAgentContextMatch as on, areAgentControllerInterfaceAccountsSame as or, isNpmGlobalCommandPath as ot, readOpenClawLocalBootstrapState as p, parseOpenCodeGoUsageResponse as pn, createAuthorityOpenMeldServiceRuntimeId as pr, listProjectConnectionsWithStatus as pt, normalizeAgentId as q, buildAgentContextLookupKey as qn, SPACE_ACTION_TARGET_GUIDANCE_LINES as qt, listOpenClawAgents as r, createInflightTaskControlRegistry as rn, isDispatchSpaceActionDeliveryOnly as rr, resolveBuiltinAgentControllerDefinition as rt, slugifyOpenClawNamePart as s, resolveCompatibleConversationExecutionState as sn, buildAgentControllerRef as sr, isPnpmGlobalCommandPath as st, prepareProviderRuntime as t, buildLocalServiceDiagnosticsPayload as tn, createProviderOriginalError as tr, resolveSkillsAgentRegistry as tt, matchesExpectedWorkspace as u, createLocalAdapterContainer as un, compareAgentControllerVersions as ur, bindProject as ut, buildRuntimeRouteTargets as v, resolveInstalledGrokBuildLaunchCandidates as vn, isAgentExecutionReadyOrConnecting as vr, resolveProjectBindingForPath as vt, resolveCurrentEffectiveProfileWorkingFolderRuntime as w, resolveCodexAppServerCompletedTurn as wn, renderTaskKnowledgeIndex as wr, withAgentActivityDeliveryLock as wt, resolveLocalRuntimeControllerSupport as x, resolveInstalledCodexLaunchCandidates as xn, peopleComputerContainsDevice as xr, unbindProject as xt, readLocalEnabledControllers as y, projectCursorUsageLimits as yn, listAgentControllerPermissionModeOptions as yr, runIfAgentActivityBindingGenerationIsCurrent as yt, reconcileNewRunnableBuiltinAgentRegistrations as z, removeConversationExecutionState as zn, resolveAdaptiveHeartbeatIntervalMs as zr, describeProfileWorkspacePathValidationFailure as zt };
+export { canManageRegistryAgentSkillTargets as $, resolveDispatchSpaceActionMcpServer as $n, mergeOpenClawGatewayVisibility as $t, createExpectedRoutesReadSession as A, isAntigravityAcpLaunchContract as An, resolveAgentExecutionStatus as Ar, ensureOpenMeldManagedProfileWorkspace as At, reconcileNewRunnableBuiltinAgentsForSetup as B, commitResolvedAgentContext as Bn, applyIntervalJitterMs as Br, createMutableRouteCatalogState as Bt, createModelCatalogReadSession as C, forkCodexAppServerThread as Cn, parseAgentControllerRef as Cr, resolveLocalProjectConnectionForPath as Ct, NO_LOCAL_AGENTS_NEED_OPENMELD_SERVICE_REASON as D, projectCodexUsageLimits as Dn, renderTaskKnowledgeIndex as Dr, resolveRegistryOriginLaunchCommand as Dt, resolveProfileWorkspaceRuntime as E, verifyCodexAppServerThread as En, renderInformationProtectionPrompt as Er, listBuiltinAgentsRegistryEntries as Et, listAgentRegistrations as F, DaemonServiceRunError as Fn, resolveRouteRegistrationReconcileDecision as Fr, resolveConfiguredProfileWorkspacePathForAccount as Ft, updateAgentRegistrations as G, settleInflightTask as Gn, resolveBuiltinAgentControllerBrand as Gr, syncRuntimeEventToInflightTaskControlRegistry as Gt, resolveAgentTargetState as H, removeConversationExecutionState as Hn, resolveAdaptiveHeartbeatIntervalMs as Hr, summarizeSkippedDaemonProfiles as Ht, listAgentTargetStates as I, runRuntimeTask as In, ADAPTIVE_HEARTBEAT_JITTER_RATIO as Ir, setCustomProfileWorkspace as It, normalizeAgentIds as J, buildAuthenticatedControlPlaneResponse as Jn, isDaemonReconcileInProgressError as Jt, notifyDaemonRouteCatalogChanged as K, upsertConversationExecutionState as Kn, __toESM as Kr, SPACE_ACTION_CONTEXT_GUIDANCE_LINES as Kt, manageAgentRegistrationInstallation as L, buildRuntimeWorkspaceFingerprint as Ln, MAX_HEARTBEAT_INTERVAL_MS as Lr, setOpenMeldManagedProfileWorkspace as Lt, addAgentCustomTarget as M, emitDriftDetectedEvidence as Mn, resolveEvidenceSyncHealth as Mr, readProfileWorkspaceConfig as Mt, createRegistrationFromCatalogTarget as N, emitReconcileCompletedEvidence as Nn, resolveNativeAgentControllerPermissionModeForController as Nr, readProfileWorkspaceConfigForAccount as Nt, syncDeviceRuntimeStateProjection as O, probeClaudeCodeUsageLimits as On, renderWorkingLanguagePrompt as Or, resolveRegistryRuntimeAdapterCapabilitySnapshot as Ot, listAgentCustomTargets as P, emitReconcileStartedEvidence as Pn, resolveSelectableCandidates as Pr, resolveConfiguredProfileWorkspacePath as Pt, resolveLocalRegistryAgentIdFromAgentControllerRef as Q, createUnsupportedProviderUsageLimits as Qn, createPendingAgentInteractionRegistry as Qt, readAgentRuntimeConfigHealth as R, buildTaskResultEnvelope as Rn, MIN_HEARTBEAT_INTERVAL_MS as Rr, validateCustomProfileWorkspacePath as Rt, syncProfileWorkspaceState as S, resolveInstalledCodexLaunchCandidates as Sn, listAgentControllerPermissionModeOptions as Sr, canonicalizeLocalProjectPath as St, resolveEffectiveProfileWorkingFolderRuntime as T, resolveCodexAppServerCompletedTurn as Tn, projectPeopleComputersToLegacyLocalRuntimes as Tr, withAgentActivityLocalStateLock as Tt, setAgentRegistrationEnabled as U, resolveConversationExecutionStateByLookupKey as Un, resolveCatalogSyncIntervalMs as Ur, syncDaemonRouteCatalogState as Ut, removeAgentCustomTarget as V, loadLedgerState as Vn, pruneStaleLeases as Vr, createRouteCatalogFromMutableState as Vt, updateAgentCustomTarget as W, seedLegacyAgentContext as Wn, compareAgentControllerRefsForDisplay as Wr, normalizeDispatchThreadAction as Wt, sortAgentRegistrations as X, buildAgentContextLookupKey as Xn, buildDispatchReplyContextSummary as Xt, parseAgentEnabledOption as Y, assertLegacyAgentContextAssociation as Yn, createSerialAgentInteractionCallback as Yt, repairBuiltinControllerInstall as Z, createUnavailableProviderUsageLimits as Zn, normalizeDispatchPostMessageAction as Zt, loadDaemonRouteCatalog as _, GrokBuildAcpTransportError as _n, getAgentControllerPermissionModeDisplayMetadata as _r, removeProjectConnection as _t, buildOpenClawSpaceSessionKey as a, resolveDispatchContinuityObservation as an, DISPATCH_SPACE_ACTION_DELIVERY_ONLY_ENV as ar, isHomebrewCommandPath as at, resolveLocalController as b, projectCursorUsageLimits as bn, isAgentControllerUsageRefreshUnavailable as br, setDefaultProjectConnection as bt, findOpenClawAgentById as c, resolveLatestScopedConversationExecutionState as cn, TASK_KNOWLEDGE_GUIDANCE as cr, ProjectBindingOperationError as ct, resolveOpenClawAuthStatus as d, createLocalAdapterEntries as dn, buildInformationProtectionPromptPlan as dr, isProjectBound as dt, createLocalTaskInterruptSender as en, buildCliLaunchInvocation as er, detectInstalledSkillsAgents as et, resolveOpenClawProviderRuntimeWorkingDirectory as f, parseOpenRouterUsageResponse as fn, buildWorkingLanguagePromptPlan as fr, listProjectBindings as ft, writeDaemonRouteCatalogCache as g, resolveInstalledOpenCodeLaunchCandidates as gn, createAuthorityOpenMeldServiceRuntimeId as gr, removeMissingProjectConnections as gt, readDaemonRouteCatalogCache as h, readOpenCode2Inventory as hn, createAgentExecutionStatusDisplayRows as hr, removeAgentActivityBindingsWhileDeliveryLocked as ht, listOpenClawGatewayAgents as i, resolveDispatchQueueLogMeta as in, createProviderOriginalError as ir, isBunGlobalCommandPath as it, resolveAgentProfilePrimaryAgentControllerReport as j, probeAntigravityAcp as jn, resolveAgentProfileEditCapabilities as jr, normalizeCustomProfileWorkspacePath as jt, createPrimaryBindingReadSession as k, resolveInstalledClaudeCodeLaunchCandidates as kn, resolveAgentControllerPermissionModeForController as kr, resolveRegistryRuntimeAdapterContractByAgentControllerRef as kt, findOpenClawAgentsByWorkspace as l, resolveCatalogSyncSkippedProfilesLogState as ln, areAgentControllerInterfaceAccountsSame as lr, ProjectBindingStoreUpdateRequiredError as lt, resolveOpenClawLocalBootstrapPaths as m, forkOpenCodeServerSession as mn, createAgentControllerInterfaceDisplayRows as mr, migrateProjectBindingStore as mt, fetchOpenClawGatewayHealth as n, createLocalExecutionSlots as nn, resolveExecutablePathsOnPath as nr, EMPTY_AGENT_CONTROLLER_INTERFACE_CAPABILITIES as nt, normalizeOpenClawSpaceIdPrefix as o, resolveCompatibleAgentContextMatch as on, isDispatchSpaceActionDeliveryOnly as or, isNpmGlobalCommandPath as ot, readOpenClawLocalBootstrapState as p, parseOpenCodeGoUsageResponse as pn, compareAgentControllerVersions as pr, listProjectConnectionsWithStatus as pt, normalizeAgentId as q, withLedgerStateTransaction as qn, SPACE_ACTION_TARGET_GUIDANCE_LINES as qt, listOpenClawAgents as r, createInflightTaskControlRegistry as rn, listAgentControllerSupervisedProcessIds as rr, resolveBuiltinAgentControllerDefinition as rt, slugifyOpenClawNamePart as s, resolveCompatibleConversationExecutionState as sn, DEFAULT_TASK_LIFECYCLE_HEARTBEAT_INTERVAL_MS as sr, isPnpmGlobalCommandPath as st, prepareProviderRuntime as t, buildLocalServiceDiagnosticsPayload as tn, materializeCliLaunchCommand as tr, resolveSkillsAgentRegistry as tt, matchesExpectedWorkspace as u, createLocalAdapterContainer as un, buildAgentControllerRef as ur, bindProject as ut, buildRuntimeRouteTargets as v, probeGrokBuildAcpInterface as vn, getAgentControllerPermissionModeFieldLabel as vr, resolveProjectBindingForPath as vt, resolveCurrentEffectiveProfileWorkingFolderRuntime as w, probeCodexAppServerAccount as wn, peopleComputerContainsDevice as wr, withAgentActivityDeliveryLock as wt, resolveLocalRuntimeControllerSupport as x, resolveCodexTimeoutMs as xn, isAgentExecutionReadyOrConnecting as xr, unbindProject as xt, readLocalEnabledControllers as y, resolveInstalledGrokBuildLaunchCandidates as yn, isAgentControllerUsageAccountUnavailable as yr, runIfAgentActivityBindingGenerationIsCurrent as yt, reconcileNewRunnableBuiltinAgentRegistrations as z, appendLedgerHistoryEntry as zn, applyAcceptedLeases as zr, describeProfileWorkspacePathValidationFailure as zt };
 
-//# sourceMappingURL=prepare-provider-runtime-CDs1nV-P.js.map
+//# sourceMappingURL=prepare-provider-runtime-_XRIioDp.js.map