openmeld 0.3.259 → 0.3.262

package/dist/{prepare-provider-runtime-BYKiQArk.js → prepare-provider-runtime-B0gBhnir.js}

@@ -1,26 +1,26 @@
 #!/usr/bin/env node
 
-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-BMrQwJW4.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-C0AOV6je.js";
 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 { $E as formatCanonicalMentionLiteral, $a as daemonRouteCatalogCacheSchema, $w as openMeldDaemonControlPlaneRequestSchema, AR as normalizeOptionalWorkingDirectory, HP as agentControllerCollaborationModeSchema, KT as conversationExecutionStateSchema, LR as profileWorkspaceModeSchema, OR as MAX_PROFILE_WORKING_DIRECTORY_LENGTH, Ob as CURRENT_DAEMON_EXECUTION_CONTRACT_EPOCH, Pa as windowsNativeProcessRequestSchema, Qx as isOriginalErrorSafeForMessageDetails, RR as profileWorkspaceOriginSchema, SS as aiUsageObservationSchema, Sv as agentExecutionSteerRequestSchema, VP as agentControllerPermissionModeSchema, WT as providerDispatchRuntimeContextSchema, Za as DAEMON_ROUTE_CATALOG_CACHE_SCHEMA_NAME, Zx as OPENMELD_ORIGINAL_ERROR_MAX_LENGTH, _I as HOSTED_CENTER_AGENT_CONTROLLER_REF_ID, aD as normalizeMessageEnvelope, aS as openMeldDaemonTaskResultEnvelopeWriteSchema, bI as canonicalizeAgentControllerRef, eI as resolveCommandAgentWorkActivity, eT as openMeldDaemonControlPlaneResponseSchema, fM as daemonServiceLaneSchema, gE as resolveBuiltinAgentControllerConversationKind, gI as HOSTED_CENTER_AGENT_CONTROLLER_REF, jg as modelCatalogSchema, mE as buildAgentControllerConversationRef, mO as agentInteractionResolutionSchema, nS as openMeldDaemonProviderAccessEvidenceSchema, pI as compareAgentControllerRefsForDisplay, sS as openMeldDaemonTaskResultOpenClawGatewayVisibilityStatusSchema, uE as runtimeTransportModeSchema, vI as HOSTED_REMOTE_AGENT_CONTROLLER_REF, wI as parseAgentControllerRef$1, xI as canonicalizeBuiltinAgentControllerRef, yI as buildAgentControllerRoutingKey } from "./dist-Dx5paVZY.js";
-import { a as isOpenMeldOrphanedLockError, d as runWithHeldLock, i as isOpenMeldLockError, t as acquireLock } from "./lock-CDdQw0gQ.js";
+import { $P as agentControllerCollaborationModeSchema, $a as daemonRouteCatalogCacheSchema, AI as buildAgentControllerRoutingKey, CM as daemonServiceLaneSchema, DE as resolveBuiltinAgentControllerConversationKind, DI as HOSTED_CENTER_AGENT_CONTROLLER_REF, DS as aiUsageObservationSchema, Dv as grokBotMessageReceiptSchema, Ev as grokBotEntriesSchema, FI as parseAgentControllerRef$1, JR as profileWorkspaceModeSchema, MI as canonicalizeBuiltinAgentControllerRef, Nb as CURRENT_DAEMON_EXECUTION_CONTRACT_EPOCH, OI as HOSTED_CENTER_AGENT_CONTROLLER_REF_ID, Ov as grokBotStoredCredentialSchema, Pa as windowsNativeProcessRequestSchema, QP as agentControllerPermissionModeSchema, Sv as agentExecutionSteerRequestSchema, TE as buildAgentControllerConversationRef, TO as agentInteractionResolutionSchema, Tv as grokBotConversationIdSchema, VR as normalizeOptionalWorkingDirectory, YR as profileWorkspaceOriginSchema, YT as providerDispatchRuntimeContextSchema, Za as DAEMON_ROUTE_CATALOG_CACHE_SCHEMA_NAME, aT as openMeldDaemonControlPlaneResponseSchema, dI as resolveCommandAgentWorkActivity, fS as openMeldDaemonTaskResultOpenClawGatewayVisibilityStatusSchema, gD as normalizeMessageEnvelope, iT as openMeldDaemonControlPlaneRequestSchema, jI as canonicalizeAgentControllerRef, jg as modelCatalogSchema, kI as HOSTED_REMOTE_AGENT_CONTROLLER_REF, nS as OPENMELD_ORIGINAL_ERROR_MAX_LENGTH, rE as conversationExecutionStateSchema, rS as isOriginalErrorSafeForMessageDetails, sS as openMeldDaemonProviderAccessEvidenceSchema, uD as formatCanonicalMentionLiteral, uS as openMeldDaemonTaskResultEnvelopeWriteSchema, wI as compareAgentControllerRefsForDisplay, wv as grokBotAccountSchema, xE as runtimeTransportModeSchema, zR as MAX_PROFILE_WORKING_DIRECTORY_LENGTH } from "./dist-DRUbg0Z2.js";
+import { a as isOpenMeldOrphanedLockError, d as runWithHeldLock, i as isOpenMeldLockError, t as acquireLock } from "./lock-tTXKrDmv.js";
 import { n as normalizeCommandEnvironment } from "./process-environment-BWSFeUu6.js";
-import { c as readWindowsProcessStartFileTime, d as WINDOWS_NATIVE_PROCESS_REQUEST_ENV, f as resolveWindowsNativeProcessHelper, l as resolveWindowsPowerShellPath, o as powerShellEncodedArguments, r as isProcessIdentityAlive, t as CURRENT_PROCESS_START_IDENTITY } from "./process-identity-DtRa8niy.js";
-import { Vt as createAgentProfileBindingApi, an as createLocalRuntimeExpectedRoutesApi, t as OpenMeldApiClientHttpError } from "./dist-BJy9X73H.js";
-import { F as resolveCurrentOpenMeldAccountContext, _ as touchDaemonCatalogSyncSignal, d as listOpenMeldProfiles } from "./context-BT5P1qqr.js";
-import { Y as OPENCLAW_CLI_TIMEOUT_MS$1, d as getAuthSessionState } from "./auth-session-mNZMZihh.js";
+import { c as readWindowsProcessStartFileTime, d as WINDOWS_NATIVE_PROCESS_REQUEST_ENV, f as resolveWindowsNativeProcessHelper, l as resolveWindowsPowerShellPath, o as powerShellEncodedArguments, r as isProcessIdentityAlive, t as CURRENT_PROCESS_START_IDENTITY } from "./process-identity-BAAdyYwE.js";
+import { Vt as createAgentProfileBindingApi, an as createLocalRuntimeExpectedRoutesApi, t as OpenMeldApiClientHttpError } from "./dist-BnSaxfXN.js";
+import { F as resolveCurrentOpenMeldAccountContext, _ as touchDaemonCatalogSyncSignal, d as listOpenMeldProfiles } from "./context-nHpubzcZ.js";
+import { Y as OPENCLAW_CLI_TIMEOUT_MS$1, d as getAuthSessionState } from "./auth-session-VWQoz03f.js";
 import { n as writeDaemonLocalStateFile, t as readDaemonLocalStateFile } from "./daemon-local-state-file-jOXuXrky.js";
-import { m as daemonRuntimeDataPath } from "./daemon-state-B8L0_xPT.js";
-import { d as buildOpenMeldRequestContextFromProfile, t as createCliApiClientFoundation } from "./api-client-foundation-BDbeHD1i.js";
-import { i as readDaemonServiceContract } from "./daemon-service-contract-Dkgengx4.js";
-import { C as requestLocalSyncRouteCatalog } from "./daemon-lifecycle-journal-oMoQyKEB.js";
+import { m as daemonRuntimeDataPath } from "./daemon-state-DjfcQFlF.js";
+import { d as buildOpenMeldRequestContextFromProfile, t as createCliApiClientFoundation } from "./api-client-foundation-Dqxsa_3V.js";
+import { i as readDaemonServiceContract } from "./daemon-service-contract-Cik2oi9W.js";
+import { C as requestLocalSyncRouteCatalog } from "./daemon-lifecycle-journal-DbRJ216n.js";
 import { i as resolveWindowsCommandPath, n as quoteWindowsProcessArgument, r as resolvePlatformCommand, t as execPlatformFile } from "./process-launch-B0pHlkV_.js";
-import { _ 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 } from "./daemon-device-id-DrGRbKdb.js";
+import { _ 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 } from "./daemon-device-id-CefXWPiF.js";
 import { createRequire } from "node:module";
 import { createHash, randomBytes, randomUUID } from "node:crypto";
 import { homedir, loadavg, tmpdir } from "node:os";
 import { basename, delimiter, dirname, extname, isAbsolute, join, normalize, parse, relative, resolve, sep, win32 } from "node:path";
-import { access, chmod, copyFile, cp, mkdir, mkdtemp, open, readFile, readdir, realpath, rename, rm, stat, symlink, writeFile } from "node:fs/promises";
+import { access, chmod, copyFile, cp, lstat, mkdir, mkdtemp, open, readFile, readdir, realpath, rename, rm, stat, symlink, writeFile } from "node:fs/promises";
 import { toJSONSchema } from "zod/v4";
 import { accessSync, constants, existsSync, readFileSync, realpathSync, statSync, watch } from "node:fs";
 import { execFile, execFileSync, spawn } from "node:child_process";
@@ -1520,6 +1520,7 @@ const AGENT_CONTROLLER_USAGE_LIMIT_SUPPORT_MATRIX = {
 	codex: "native",
 	cursor: "observational",
 	"grok-build": "native",
+	"grok-bot": "unsupported",
 	opencode: "provider_scoped",
 	openclaw: "not_evaluated"
 };
@@ -3132,8 +3133,13 @@ var registry_default$1 = {
 				"adapters": [{
 					"adapterId": "grok-build",
 					"controllerRefMatcher": {
-						"kind": "contains",
-						"values": ["grok", "grok-build"]
+						"kind": "equals",
+						"values": [
+							"grok",
+							"builtin:grok",
+							"grok-build",
+							"builtin:grok-build"
+						]
 					},
 					"transportModes": ["acp"],
 					"capabilityDeclaration": {
@@ -3480,6 +3486,43 @@ var registry_default$1 = {
 				"adapters": []
 			}
 		},
+		{
+			"id": "grok-bot",
+			"displayName": "Grok Bot",
+			"category": "builtin",
+			"skillsDir": ".grok-bot/skills",
+			"globalSkillsDir": "${HOME}/.config/agent-serve",
+			"detection": {
+				"mode": "any",
+				"checks": [{
+					"kind": "commandExists",
+					"value": "bdk"
+				}]
+			},
+			"service": { "skillsInstallable": false },
+			"runtime": {
+				"supported": true,
+				"adapters": [{
+					"adapterId": "grok-bot",
+					"controllerRefMatcher": {
+						"kind": "equals",
+						"values": ["grok-bot", "builtin:grok-bot"]
+					},
+					"transportModes": ["local-cli"],
+					"capabilityDeclaration": {
+						"streamingCapability": "final_only",
+						"runtimeWorkingDirectoryMode": "provider_workspace",
+						"preparationRequirement": "none",
+						"continuationCapability": "standard",
+						"workspaceResumeBehavior": "transparent"
+					}
+				}]
+			},
+			"lifecycle": { "status": "active" },
+			"transportModes": ["local-cli"],
+			"defaultTransportMode": "local-cli",
+			"defaultStreamingMode": "final"
+		},
 		{
 			"id": "openclaw",
 			"displayName": "OpenClaw",
@@ -13082,6 +13125,48 @@ function toErrorMessage$16(error) {
 	return String(error);
 }
 //#endregion
+//#region ../../runtime/adapters/claude-code/dist/config/claude-native-update.js
+const execute = promisify(execFile);
+const VERSION = /^(\d+\.\d+\.\d+(?:-[\w.-]+)?)\s+\(Claude Code\)\s*$/u;
+async function resolveClaudeNativeUpdateCommand(contract) {
+	if (process.platform === "win32" || contract.kind !== "executable" || contract.argsPrefix?.length) return null;
+	const home = process.env.HOME?.trim() || homedir();
+	const launcher = join(home, ".local/bin/claude");
+	if (resolve(contract.commandPath) !== resolve(launcher)) return null;
+	try {
+		if (!(await lstat(launcher)).isSymbolicLink()) return null;
+		const target = await realpath(launcher);
+		const versions = await realpath(join(home, ".local/share/claude/versions"));
+		return dirname(target) === versions && (await lstat(target)).isFile() ? launcher : null;
+	} catch {
+		return null;
+	}
+}
+async function readClaudeNativeVersion(command) {
+	const version = (await execute(command, ["--version"], {
+		cwd: homedir(),
+		timeout: 1e4,
+		maxBuffer: 64 * 1024,
+		encoding: "utf8"
+	})).stdout.trim().match(VERSION)?.[1];
+	if (!version) throw new Error("Could not verify the Claude Code version.");
+	return version;
+}
+async function updateClaudeNativeInstallation(command) {
+	await new Promise((resolve, reject) => {
+		const child = spawn(command, ["update"], {
+			cwd: homedir(),
+			stdio: "ignore",
+			shell: false
+		});
+		child.once("error", reject);
+		child.once("close", (code, signal) => {
+			if (code === 0) resolve();
+			else reject(/* @__PURE__ */ new Error(`Claude Code updater exited with ${signal ?? code}.`));
+		});
+	});
+}
+//#endregion
 //#region ../../runtime/adapters/claude-code/dist/usage/claude-code-usage-probe.js
 async function probeClaudeCodeUsageLimits(input) {
 	const controller = new AbortController();
@@ -19773,6 +19858,451 @@ const installCursorAdapter = {
 	}
 };
 //#endregion
+//#region ../../runtime/adapters/grok-bot/dist/setup.js
+const NODE_VERSION = "24.14.0";
+const BDK_VERSION = "0.2.25";
+function grokBotSetupPaths(root) {
+	const directory = join(root, "connection-tools", "grok-bot");
+	const nodeDirectory = join(directory, `node-v${NODE_VERSION}-${process.platform}-${process.arch}`);
+	return {
+		directory,
+		nodeDirectory,
+		node: join(nodeDirectory, "bin", "node"),
+		npm: join(nodeDirectory, "lib", "node_modules", "npm", "bin", "npm-cli.js"),
+		script: join(directory, "bdk", "node_modules", "@cursor", "bdk", "dist", "bin", "agent-serve.js"),
+		config: join(directory, "auth"),
+		launcher: join(directory, "launcher.mjs")
+	};
+}
+function supportsGrokBotSetup() {
+	return ["darwin", "linux"].includes(process.platform) && ["arm64", "x64"].includes(process.arch);
+}
+function run(command, args, options) {
+	return new Promise((resolve, reject) => {
+		const child = spawn(command, args, {
+			cwd: options.cwd,
+			env: options.env,
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			],
+			shell: false
+		});
+		let output = "";
+		let hardKill;
+		const timer = setTimeout(() => {
+			child.kill("SIGTERM");
+			hardKill = setTimeout(() => child.kill("SIGKILL"), 5e3);
+		}, options.timeout);
+		child.stdout.on("data", (chunk) => {
+			output = (output + String(chunk)).slice(-16384);
+		});
+		child.stderr.resume();
+		child.on("error", (error) => {
+			clearTimeout(timer);
+			reject(error);
+		});
+		child.on("close", (code) => {
+			clearTimeout(timer);
+			clearTimeout(hardKill);
+			if (code === 0) resolve(output);
+			else reject(/* @__PURE__ */ new Error("The connection tool did not finish successfully. Try again or open the setup guide."));
+		});
+	});
+}
+async function readManagedGrokBotCandidate(root) {
+	const paths = grokBotSetupPaths(root);
+	try {
+		await access(paths.node);
+		await access(paths.script);
+		await access(paths.launcher);
+	} catch {
+		return null;
+	}
+	return {
+		installId: "openmeld-managed-grok-bot",
+		label: "OpenMeld connection tools",
+		detail: `BDK ${BDK_VERSION} · managed by OpenMeld`,
+		commandPath: paths.launcher,
+		launchContract: {
+			kind: "node_script",
+			nodePath: paths.node,
+			scriptPath: paths.launcher
+		}
+	};
+}
+async function installGrokBotTools(root) {
+	if (!supportsGrokBotSetup()) throw new Error("Install connection tools manually on this platform.");
+	const paths = grokBotSetupPaths(root);
+	await mkdir(paths.directory, {
+		recursive: true,
+		mode: 448
+	});
+	const archive = `node-v${NODE_VERSION}-${process.platform}-${process.arch}.tar.gz`;
+	try {
+		await access(paths.node);
+	} catch {
+		const base = `https://nodejs.org/dist/v${NODE_VERSION}/`;
+		const [checksumResponse, archiveResponse] = await Promise.all([fetch(`${base}SHASUMS256.txt`, { signal: AbortSignal.timeout(6e4) }), fetch(`${base}${archive}`, { signal: AbortSignal.timeout(18e4) })]);
+		if (!(checksumResponse.ok && archiveResponse.ok)) throw new Error("Could not download the connection runtime. Check the connection and retry.");
+		const expected = (await checksumResponse.text()).split("\n").find((line) => line.endsWith(`  ${archive}`))?.split(" ")[0];
+		const bytes = Buffer.from(await archiveResponse.arrayBuffer());
+		if (!expected || createHash("sha256").update(bytes).digest("hex") !== expected) throw new Error("Connection runtime verification failed.");
+		const temporary = join(paths.directory, "download");
+		await mkdir(temporary, {
+			recursive: true,
+			mode: 448
+		});
+		await writeFile(join(temporary, archive), bytes, { mode: 384 });
+		await run("tar", [
+			"-xzf",
+			join(temporary, archive),
+			"-C",
+			temporary
+		], {
+			cwd: temporary,
+			timeout: 6e4
+		});
+		await rename(join(temporary, archive.replace(".tar.gz", "")), paths.nodeDirectory);
+		await rm(temporary, {
+			recursive: true,
+			force: true
+		});
+	}
+	const bdk = join(paths.directory, "bdk");
+	await mkdir(bdk, {
+		recursive: true,
+		mode: 448
+	});
+	await run(paths.node, [
+		paths.npm,
+		"install",
+		"--prefix",
+		bdk,
+		"--no-audit",
+		"--no-fund",
+		"--ignore-scripts",
+		"--registry=https://registry.npmjs.org",
+		`@cursor/bdk@${BDK_VERSION}`
+	], {
+		cwd: paths.directory,
+		env: {
+			...process.env,
+			PATH: `${join(paths.nodeDirectory, "bin")}:${process.env.PATH ?? ""}`
+		},
+		timeout: 3e5
+	});
+	await run(paths.node, [paths.script, "--version"], {
+		cwd: paths.directory,
+		timeout: 15e3
+	});
+	await writeFile(paths.launcher, `import { fileURLToPath } from 'node:url';\nprocess.env.AGENT_SERVE_CONFIG_DIR = fileURLToPath(new URL('./auth', import.meta.url));\nfor (const key of ['CURSOR_API_KEY','CURSOR_API_KEY_FILE','CURSOR_SERVICE_ACCOUNT_KEY','CURSOR_API_BASE_URL','CURSOR_WEBSITE_URL']) delete process.env[key];\nawait import('./bdk/node_modules/@cursor/bdk/dist/bin/agent-serve.js');\n`, { mode: 384 });
+}
+function managedGrokBotEnvironment(root) {
+	const env = {
+		...process.env,
+		AGENT_SERVE_CONFIG_DIR: grokBotSetupPaths(root).config
+	};
+	for (const key of [
+		"CURSOR_API_KEY",
+		"CURSOR_API_KEY_FILE",
+		"CURSOR_SERVICE_ACCOUNT_KEY",
+		"CURSOR_API_BASE_URL",
+		"CURSOR_WEBSITE_URL"
+	]) delete env[key];
+	return env;
+}
+async function isManagedGrokBotSignedIn(root) {
+	const paths = grokBotSetupPaths(root);
+	try {
+		await access(join(paths.config, "credentials.json"));
+		const output = await run(paths.node, [
+			paths.script,
+			"whoami",
+			"--json"
+		], {
+			cwd: paths.directory,
+			env: managedGrokBotEnvironment(root),
+			timeout: 15e3
+		});
+		return grokBotAccountSchema.safeParse(JSON.parse(output)).success;
+	} catch {
+		return false;
+	}
+}
+async function loginManagedGrokBot(root) {
+	const paths = grokBotSetupPaths(root);
+	await mkdir(paths.config, {
+		recursive: true,
+		mode: 448
+	});
+	await run(paths.node, [
+		paths.script,
+		"login",
+		"--key-name",
+		"OpenMeld Grok Bot"
+	], {
+		cwd: paths.directory,
+		env: managedGrokBotEnvironment(root),
+		timeout: 6e5
+	});
+	if (!await isManagedGrokBotSignedIn(root)) throw new Error("Sign-in could not be verified. Sign in again.");
+}
+async function readManagedGrokBotCredential(launcher) {
+	try {
+		return grokBotStoredCredentialSchema.parse(JSON.parse(await readFile(join(dirname(launcher), "auth", "credentials.json"), "utf8"))).apiKey;
+	} catch {
+		throw new Error("Could not read the managed Grok Bot sign-in.");
+	}
+}
+//#endregion
+//#region ../../runtime/adapters/grok-bot/dist/client.js
+var GrokBotError = class extends Error {
+	errorType = "runtime";
+	code;
+	constructor(code, message) {
+		super(message);
+		this.code = code;
+		this.name = "GrokBotError";
+	}
+};
+async function readGrokBotCredential(env = process.env) {
+	const explicit = env.CURSOR_API_KEY;
+	if (explicit?.trim()) return explicit.trim();
+	if (env.CURSOR_API_KEY_FILE) return (await readFile(env.CURSOR_API_KEY_FILE, "utf8")).trim();
+	if (env.CURSOR_SERVICE_ACCOUNT_KEY?.trim()) return env.CURSOR_SERVICE_ACCOUNT_KEY.trim();
+	const config = env.AGENT_SERVE_CONFIG_DIR ?? join(env.XDG_CONFIG_HOME ?? join(homedir(), ".config"), "agent-serve");
+	try {
+		const result = grokBotStoredCredentialSchema.safeParse(JSON.parse(await readFile(join(config, "credentials.json"), "utf8")));
+		if (result.success) return result.data.apiKey;
+	} catch {}
+	throw new GrokBotError("controller.auth.unauthenticated", "Sign in with bdk login on this computer, then check the connection again.");
+}
+/** Official BDK API. Deliberately has no get-or-create-by-name operation. */
+var GrokBotClient = class {
+	apiKey;
+	fetchImpl;
+	constructor(apiKey, fetchImpl = fetch) {
+		this.apiKey = apiKey;
+		this.fetchImpl = fetchImpl;
+	}
+	async entries(sessionId, cursor) {
+		const result = grokBotEntriesSchema.safeParse(await this.request(sessionId, `/entries?afterUpdatedSeq=${encodeURIComponent(cursor)}`));
+		if (!result.success) throw new GrokBotError("grok-bot.invalid_response", "Grok Bot returned an invalid conversation response.");
+		return result.data;
+	}
+	async send(sessionId, messageId, text) {
+		const receipt = grokBotMessageReceiptSchema.safeParse(await this.request(sessionId, "/messages", {
+			messageId,
+			text
+		}));
+		if (!(receipt.success && receipt.data.messageId === messageId)) throw new GrokBotError("grok-bot.delivery_unconfirmed", "Grok Bot did not confirm this message. Do not resend it automatically.");
+	}
+	async interrupt(sessionId) {
+		await this.request(sessionId, "/interrupt", { reason: "Stopped from OpenMeld's shared conversation." });
+	}
+	async request(sessionId, suffix, body) {
+		if (!grokBotConversationIdSchema.safeParse(sessionId).success) throw new GrokBotError("grok-bot.connection_required", "Connect an existing Grok Bot conversation before sending work.");
+		let response;
+		try {
+			response = await this.fetchImpl(`https://api.cursor.com/v0/grokbot/sessions/${sessionId}${suffix}`, {
+				method: body ? "POST" : "GET",
+				headers: {
+					authorization: `Bearer ${this.apiKey}`,
+					"content-type": "application/json",
+					"x-cursor-client-type": "agent-serve"
+				},
+				...body ? { body: JSON.stringify(body) } : {},
+				redirect: "error",
+				signal: AbortSignal.timeout(3e4)
+			});
+		} catch {
+			throw new GrokBotError("grok-bot.connection_lost", "The Grok Bot connection was lost. Its work may still be running; check Grok Bot before retrying.");
+		}
+		if (!response.ok) throw new GrokBotError(response.status === 401 ? "controller.auth.unauthenticated" : "grok-bot.request_failed", `Grok Bot rejected the request (HTTP ${response.status}). Check the connection and account access.`);
+		if (suffix === "/interrupt") return null;
+		try {
+			return await response.json();
+		} catch {
+			throw new GrokBotError("grok-bot.invalid_response", "Grok Bot returned an invalid response.");
+		}
+	}
+};
+//#endregion
+//#region ../../runtime/adapters/grok-bot/dist/index.js
+async function verifyGrokBotLaunchContract(input) {
+	return await verifyCliLaunchContract({
+		...input,
+		cwd: process.cwd(),
+		displayName: "Grok Bot BDK",
+		probeArgs: ["--version"],
+		timeoutMs: input.timeoutMs ?? 8e3
+	});
+}
+async function resolveInstalledGrokBotLaunchCandidates(input) {
+	const managed = input?.managedRoot ? await readManagedGrokBotCandidate(input.managedRoot) : null;
+	const result = await resolveInstalledNodeScriptLaunchCandidates({
+		commandName: "bdk",
+		configuredCommand: process.env.OPENMELD_DAEMON_RUNTIME_GROK_BOT_BIN ?? null,
+		displayName: "Grok Bot BDK",
+		preferredLaunchContract: input?.preferredLaunchContract
+	});
+	if (!(result.ok || managed)) return result;
+	const candidates = await resolveLaunchCandidatesAfterVerification({
+		candidates: [...managed ? [managed] : [], ...result.ok ? result.candidates : []],
+		verify: (candidate) => verifyGrokBotLaunchContract({ launchContract: candidate.launchContract })
+	});
+	return candidates.length ? {
+		ok: true,
+		candidates
+	} : {
+		ok: false,
+		reason: "not_launchable",
+		errorMessage: "Install the official @cursor/bdk package and sign in with bdk login."
+	};
+}
+async function readIdleCursor(client, sessionId) {
+	let cursor = "-1";
+	while (true) {
+		const page = await client.entries(sessionId, cursor);
+		if (!page.turn.idle || page.turn.inFlight || page.turn.queued) throw new GrokBotError("grok-bot.busy", "Grok Bot is handling other work. Nothing was sent; try again when it is idle.");
+		if (!page.entries.length || cursor === page.latestUpdatedSeq) return page.latestUpdatedSeq;
+		cursor = page.latestUpdatedSeq;
+	}
+}
+async function collectReplies(client, sessionId, initialCursor, wait) {
+	let cursor = initialCursor;
+	const replies = /* @__PURE__ */ new Map();
+	let idlePolls = 0;
+	let sawBusy = false;
+	while (true) {
+		const page = await client.entries(sessionId, cursor);
+		cursor = page.latestUpdatedSeq;
+		for (const entry of page.entries) if (entry.kind === "send-message" && entry.text) replies.set(entry.seq, entry.text);
+		const busy = page.turn.inFlight || page.turn.queued > 0 || !page.turn.idle;
+		sawBusy ||= busy;
+		idlePolls = busy || page.entries.length ? 0 : idlePolls + 1;
+		if (idlePolls >= (sawBusy ? 1 : 4)) return [...replies.values()].join("\n\n");
+		await wait();
+	}
+}
+async function publishReply(request, output) {
+	if (!output.trim()) throw new GrokBotError("grok-bot.reply_missing", "Grok Bot finished without delivering a reply.");
+	if (!request.spaceActionTools) return;
+	if ((await request.spaceActionTools.call("reply", { message: output })).isError) throw new GrokBotError("grok-bot.reply_rejected", "OpenMeld could not record the Bot reply. Check the task diagnostics before retrying.");
+}
+async function readDispatchCredential(request) {
+	if (request.launchContract?.kind === "node_script" && request.launchContract.scriptPath.endsWith("/connection-tools/grok-bot/launcher.mjs")) return await readManagedGrokBotCredential(request.launchContract.scriptPath);
+	return await readGrokBotCredential({
+		...process.env,
+		...request.env
+	});
+}
+function createGrokBotAdapter(options = {}) {
+	const active = /* @__PURE__ */ new Map();
+	const conversations = /* @__PURE__ */ new Set();
+	const wait = options.wait ?? (() => new Promise((resolve) => setTimeout(resolve, 1e3)));
+	const stop = async (taskId) => {
+		const turn = active.get(taskId);
+		if (!turn) return {
+			accepted: false,
+			reasonCode: "task.not_running",
+			signalDelivery: "not_sent",
+			taskId
+		};
+		turn.stopRequested = true;
+		try {
+			if (turn.sent && turn.client) await turn.client.interrupt(turn.sessionId);
+			return {
+				accepted: true,
+				reasonCode: "accepted",
+				signalDelivery: "sent",
+				taskId,
+				localAttemptOutcome: turn.sent ? "stop_requested_after_start" : "withdrawn_before_start"
+			};
+		} catch (error) {
+			return {
+				accepted: false,
+				reasonCode: "signal.send_failed",
+				signalDelivery: "not_sent",
+				taskId,
+				reasonDetail: error instanceof Error ? error.message : "Grok Bot stop is unconfirmed."
+			};
+		}
+	};
+	const invoke = async (request) => {
+		if (request.executionMode === "repair") throw new GrokBotError("grok-bot.repair_unsupported", "Check the shared Bot conversation before sending another task. Automatic resubmission is not supported.");
+		if (request.executionContext || request.computerFileAccessBoundary) throw new GrokBotError("execution_context.controller_access_unsupported", "This Agent shares an existing provider conversation. Independent contexts and local file access are not supported.");
+		const sessionId = request.agentControllerConversationId?.trim();
+		if (!sessionId) throw new GrokBotError("grok-bot.connection_required", "Connect an existing Grok Bot conversation first. OpenMeld does not create Bots.");
+		if (conversations.has(sessionId)) throw new GrokBotError("grok-bot.busy", "This shared Bot is already working. Wait for its current work to finish.");
+		conversations.add(sessionId);
+		const turn = {
+			client: null,
+			sessionId,
+			sent: false,
+			stopRequested: false
+		};
+		active.set(request.taskId, turn);
+		try {
+			const client = options.createClient ? await options.createClient(request) : new GrokBotClient(await readDispatchCredential(request));
+			turn.client = client;
+			const cursor = await readIdleCursor(client, sessionId);
+			if (turn.stopRequested) throw new GrokBotError("runtime.turn.cancelled", "Stopped before the message was sent.");
+			const digest = createHash("sha256").update(request.dispatchId ?? request.taskId).digest("hex");
+			const messageId = `${digest.slice(0, 8)}-${digest.slice(8, 12)}-5${digest.slice(13, 16)}-a${digest.slice(17, 20)}-${digest.slice(20, 32)}`;
+			turn.sent = true;
+			await client.send(sessionId, messageId, [request.prompt, "OpenMeld shared-conversation delivery: send your public answer normally in this Bot conversation. OpenMeld collects delivered replies and submits them through its authorized reply writer. Do not run an OpenMeld CLI command or inspect local OpenMeld credentials. Your existing tools and permissions remain provider-managed."].join("\n\n"));
+			if (turn.stopRequested) await client.interrupt(sessionId);
+			const output = await collectReplies(client, sessionId, cursor, wait);
+			if (turn.stopRequested) throw new GrokBotError("runtime.turn.cancelled", "Grok Bot's shared conversation stopped.");
+			await publishReply(request, output);
+			return {
+				output,
+				contextDelta: { agentControllerConversationId: sessionId }
+			};
+		} finally {
+			active.delete(request.taskId);
+			conversations.delete(sessionId);
+		}
+	};
+	return {
+		adapterId: "grok-bot",
+		dispatch: createSharedDispatchShell({
+			adapterId: "grok-bot",
+			bridgeSpec: resolveBuiltinAdapterConversationBridgeSpec("grok-bot"),
+			resolveDefaultInvoke: () => invoke,
+			runtimeOptions: options
+		}),
+		cancel: ({ taskId }) => stop(taskId),
+		interrupt: async (input) => ({
+			...await stop(input.taskId),
+			plan: { initial: {
+				mode: input.mode ?? "graceful",
+				reason: input.reason ?? "Stop shared Bot",
+				taskId: input.taskId
+			} }
+		}),
+		verifyComputerFileAccessBoundary: async () => ({
+			supported: false,
+			reasonCode: "computer.file_access.controller_unsupported"
+		})
+	};
+}
+//#endregion
+//#region ../../runtime/local-service/src/adapters/installers/install-grok-bot.ts
+const installGrokBotAdapter = {
+	adapterId: "grok-bot",
+	install() {
+		return {
+			adapter: createGrokBotAdapter(),
+			adapterId: "grok-bot",
+			transportModes: ["local-cli"]
+		};
+	}
+};
+//#endregion
 //#region ../../runtime/adapters/grok-build/dist/config/grok-build-runtime-config.js
 const DEFAULT_GROK_BUILD_COMMAND = "grok";
 async function resolveInstalledGrokBuildLaunchCandidates(input) {
@@ -26180,6 +26710,7 @@ function listLocalAdapterInstallers() {
 		installCodexAdapter,
 		installCursorAdapter,
 		installGrokBuildAdapter,
+		installGrokBotAdapter,
 		installOpenClawAdapter,
 		installOpenCodeAdapter
 	];
@@ -28568,8 +29099,13 @@ var registry_default = {
 				"adapters": [{
 					"adapterId": "grok-build",
 					"controllerRefMatcher": {
-						"kind": "contains",
-						"values": ["grok", "grok-build"]
+						"kind": "equals",
+						"values": [
+							"grok",
+							"builtin:grok",
+							"grok-build",
+							"builtin:grok-build"
+						]
 					},
 					"transportModes": ["acp"],
 					"capabilityDeclaration": {
@@ -28916,6 +29452,43 @@ var registry_default = {
 				"adapters": []
 			}
 		},
+		{
+			"id": "grok-bot",
+			"displayName": "Grok Bot",
+			"category": "builtin",
+			"skillsDir": ".grok-bot/skills",
+			"globalSkillsDir": "${HOME}/.config/agent-serve",
+			"detection": {
+				"mode": "any",
+				"checks": [{
+					"kind": "commandExists",
+					"value": "bdk"
+				}]
+			},
+			"service": { "skillsInstallable": false },
+			"runtime": {
+				"supported": true,
+				"adapters": [{
+					"adapterId": "grok-bot",
+					"controllerRefMatcher": {
+						"kind": "equals",
+						"values": ["grok-bot", "builtin:grok-bot"]
+					},
+					"transportModes": ["local-cli"],
+					"capabilityDeclaration": {
+						"streamingCapability": "final_only",
+						"runtimeWorkingDirectoryMode": "provider_workspace",
+						"preparationRequirement": "none",
+						"continuationCapability": "standard",
+						"workspaceResumeBehavior": "transparent"
+					}
+				}]
+			},
+			"lifecycle": { "status": "active" },
+			"transportModes": ["local-cli"],
+			"defaultTransportMode": "local-cli",
+			"defaultStreamingMode": "final"
+		},
 		{
 			"id": "openclaw",
 			"displayName": "OpenClaw",
@@ -31432,6 +32005,29 @@ const EMPTY_AGENT_CONTROLLER_INTERFACE_CAPABILITIES = {
 	structuredUserInput: false
 };
 const BUILTIN_AGENT_CONTROLLER_DEFINITIONS = [
+	{
+		adapterId: "grok-bot",
+		agentId: "grok-bot",
+		capabilities: {
+			...EMPTY_AGENT_CONTROLLER_INTERFACE_CAPABILITIES,
+			cancel: true,
+			interrupt: true
+		},
+		conversationOccupancy: {
+			contractVersion: 1,
+			mode: "unsupported"
+		},
+		installResolver: {
+			resolveInstalledLaunchCandidates: (input) => resolveInstalledGrokBotLaunchCandidates({
+				...input,
+				managedRoot: resolveOpenMeldRootDir()
+			}),
+			verifyLaunchContract: verifyGrokBotLaunchContract
+		},
+		nativeInterface: "local-cli",
+		usageLimitSupport: "unsupported",
+		versionMaintenance: { npmPackageName: "@cursor/bdk" }
+	},
 	{
 		adapterId: "antigravity",
 		agentId: "antigravity",
@@ -33531,9 +34127,9 @@ function createModelCatalogReadSession(input) {
 async function readModelCatalogOnce(baseUrl) {
 	try {
 		const [apiClient, baseUrlModule, clientFoundationModule] = await Promise.all([
-			import("./dist-BFz8AKxR.js"),
-			import("./base-url-uwbKIZtP.js"),
-			import("./api-client-foundation-Dye8bbn0.js")
+			import("./dist-DaKpDnJa.js"),
+			import("./base-url-uaTFrave.js"),
+			import("./api-client-foundation-C3A2-JkQ.js")
 		]);
 		if (typeof apiClient.createConfigApi !== "function") throw new Error("config api client is unavailable");
 		const resolvedBaseUrl = baseUrl ?? await baseUrlModule.resolveBaseUrl();
@@ -35377,6 +35973,6 @@ async function prepareProviderRuntime(input, options = {}) {
 	return await preparer(input);
 }
 //#endregion
-export { detectInstalledSkillsAgents as $, buildAgentContextLookupKey as $n, normalizeDispatchPostMessageAction as $t, createExpectedRoutesReadSession as A, readCodexAccountUsageObservation as An, renderTaskKnowledgeIndex as Ar, ensureOpenMeldManagedProfileWorkspace as At, removeAgentCustomTarget as B, buildRuntimeWorkspaceFingerprint as Bn, resolveRouteRegistrationReconcileDecision as Br, describeProfileWorkspacePathValidationFailure as Bt, createModelCatalogReadSession as C, resolveCodexTimeoutMs as Cn, isAgentControllerUsageRefreshUnavailable as Cr, resolveLocalProjectConnectionForPath as Ct, NO_LOCAL_AGENTS_NEED_OPENMELD_SERVICE_REASON as D, resolveCodexAppServerCompletedTurn as Dn, peopleComputerContainsDevice as Dr, resolveRegistryOriginLaunchCommand as Dt, resolveProfileWorkspaceRuntime as E, probeCodexAppServerAccount as En, parseAgentControllerRef as Er, listBuiltinAgentsRegistryEntries as Et, listAgentRegistrations as F, emitDriftDetectedEvidence as Fn, resolveEvidenceSyncHealth as Fr, resolveConfiguredProfileWorkspacePath as Ft, notifyDaemonRouteCatalogChanged as G, removeConversationExecutionState as Gn, applyIntervalJitterMs as Gr, syncDaemonRouteCatalogState as Gt, setAgentRegistrationEnabled as H, appendLedgerHistoryEntry as Hn, MAX_HEARTBEAT_INTERVAL_MS as Hr, createRouteCatalogFromMutableState as Ht, listAgentTargetStates as I, emitReconcileCompletedEvidence as In, resolveNativeAgentControllerPermissionModeForController as Ir, resolveConfiguredProfileWorkspacePathForAccount as It, parseAgentEnabledOption as J, settleInflightTask as Jn, resolveCatalogSyncIntervalMs as Jr, SPACE_ACTION_CONTEXT_GUIDANCE_LINES as Jt, normalizeAgentId as K, resolveConversationExecutionStateByLookupKey as Kn, pruneStaleLeases as Kr, normalizeDispatchThreadAction as Kt, manageAgentRegistrationInstallation as L, emitReconcileStartedEvidence as Ln, resolveSelectableCandidates as Lr, setCustomProfileWorkspace as Lt, addAgentCustomTarget as M, resolveInstalledClaudeCodeLaunchCandidates as Mn, resolveAgentControllerPermissionModeForController as Mr, readProfileWorkspaceConfig as Mt, createRegistrationFromCatalogTarget as N, checkAntigravityAcpAccount as Nn, resolveAgentExecutionStatus as Nr, readProfileWorkspaceConfigForAccount as Nt, syncDeviceRuntimeStateProjection as O, verifyCodexAppServerThread as On, projectPeopleComputersToLegacyLocalRuntimes as Or, resolveRegistryRuntimeAdapterCapabilitySnapshot as Ot, listAgentCustomTargets as P, isAntigravityAcpLaunchContract as Pn, resolveAgentProfileEditCapabilities as Pr, readSavedProfileWorkspaceForAccount as Pt, canManageRegistryAgentSkillTargets as Q, assertLegacyAgentContextAssociation as Qn, buildDispatchReplyContextSummary as Qt, readAgentRuntimeConfigHealth as R, DaemonServiceRunError as Rn, supportsExecutionContextSelection as Rr, setOpenMeldManagedProfileWorkspace as Rt, syncProfileWorkspaceState as S, projectCursorUsageLimits as Sn, isAgentControllerUsageAccountUnavailable as Sr, canonicalizeLocalProjectPath as St, resolveEffectiveProfileWorkingFolderRuntime as T, forkCodexAppServerThread as Tn, listAgentControllerPermissionModeOptions as Tr, withAgentActivityLocalStateLock as Tt, updateAgentCustomTarget as U, commitResolvedAgentContext as Un, MIN_HEARTBEAT_INTERVAL_MS as Ur, replaceMutableRouteCatalogState as Ut, resolveAgentTargetState as V, buildTaskResultEnvelope as Vn, ADAPTIVE_HEARTBEAT_JITTER_RATIO as Vr, createMutableRouteCatalogState as Vt, updateAgentRegistrations as W, loadLedgerState as Wn, applyAcceptedLeases as Wr, summarizeSkippedDaemonProfiles as Wt, repairBuiltinControllerInstall as X, withLedgerStateTransaction as Xn, isDaemonReconcileInProgressError as Xt, sortAgentRegistrations as Y, upsertConversationExecutionState as Yn, __toESM as Yr, SPACE_ACTION_TARGET_GUIDANCE_LINES as Yt, resolveLocalRegistryAgentIdFromAgentControllerRef as Z, buildAuthenticatedControlPlaneResponse as Zn, createSerialAgentInteractionCallback as Zt, loadDaemonRouteCatalog as _, readOpenCode2Inventory as _n, createAgentControllerInterfaceDisplayRows as _r, removeProjectConnection as _t, buildOpenClawSpaceSessionKey as a, createInflightTaskControlRegistry as an, resolveExecutablePathsOnPath as ar, isNpmGlobalCommandPath as at, resolveLocalController as b, probeGrokBuildAcpInterface as bn, getAgentControllerPermissionModeDisplayMetadata as br, setDefaultProjectConnection as bt, findOpenClawAgentById as c, resolveCompatibleAgentContextMatch as cn, DISPATCH_SPACE_ACTION_DELIVERY_ONLY_ENV as cr, ProjectBindingStoreUpdateRequiredError as ct, resolveOpenClawAuthStatus as d, resolveCatalogSyncSkippedProfilesLogState as dn, TASK_KNOWLEDGE_GUIDANCE as dr, isProjectBound as dt, createPendingAgentInteractionRegistry as en, createUnavailableProviderUsageLimits as er, resolveSkillsAgentRegistry as et, resolveOpenClawProviderRuntimeWorkingDirectory as f, createLocalAdapterContainer as fn, areAgentControllerInterfaceAccountsSame as fr, listProjectBindings as ft, writeDaemonRouteCatalogCache as g, forkOpenCodeServerSession as gn, compareAgentControllerVersions as gr, removeMissingProjectConnections as gt, readDaemonRouteCatalogCache as h, parseOpenCodeGoUsageResponse as hn, buildWorkingLanguagePromptPlan as hr, removeAgentActivityBindingsWhileDeliveryLocked as ht, listOpenClawGatewayAgents as i, createLocalExecutionSlots as in, materializeCliLaunchCommand as ir, isHomebrewCommandPath as it, resolveAgentProfilePrimaryAgentControllerReport as j, probeClaudeCodeUsageLimits as jn, renderWorkingLanguagePrompt as jr, normalizeCustomProfileWorkspacePath as jt, createPrimaryBindingReadSession as k, projectCodexUsageObservation as kn, renderInformationProtectionPrompt as kr, resolveRegistryRuntimeAdapterContractByAgentControllerRef as kt, findOpenClawAgentsByWorkspace as l, resolveCompatibleConversationExecutionState as ln, isDispatchSpaceActionDeliveryOnly as lr, bindProject as lt, resolveOpenClawLocalBootstrapPaths as m, parseOpenRouterUsageResponse as mn, buildInformationProtectionPromptPlan as mr, migrateProjectBindingStore as mt, fetchOpenClawGatewayHealth as n, createLocalTaskInterruptSender as nn, resolveDispatchSpaceActionMcpServer as nr, resolveBuiltinAgentControllerDefinition as nt, normalizeOpenClawSpaceIdPrefix as o, resolveDispatchQueueLogMeta as on, listAgentControllerSupervisedProcessIds as or, isPnpmGlobalCommandPath as ot, readOpenClawLocalBootstrapState as p, createLocalAdapterEntries as pn, buildAgentControllerRef as pr, listProjectConnectionsWithStatus as pt, normalizeAgentIds as q, seedLegacyAgentContext as qn, resolveAdaptiveHeartbeatIntervalMs as qr, syncRuntimeEventToInflightTaskControlRegistry as qt, listOpenClawAgents as r, buildLocalServiceDiagnosticsPayload as rn, buildCliLaunchInvocation as rr, isBunGlobalCommandPath as rt, slugifyOpenClawNamePart as s, resolveDispatchContinuityObservation as sn, createProviderOriginalError as sr, ProjectBindingOperationError as st, prepareProviderRuntime as t, mergeOpenClawGatewayVisibility as tn, createUnsupportedProviderUsageLimits as tr, EMPTY_AGENT_CONTROLLER_INTERFACE_CAPABILITIES as tt, matchesExpectedWorkspace as u, resolveLatestScopedConversationExecutionState as un, DEFAULT_TASK_LIFECYCLE_HEARTBEAT_INTERVAL_MS as ur, hasProjectBindingForPath as ut, buildRuntimeRouteTargets as v, resolveInstalledOpenCodeLaunchCandidates as vn, createAgentExecutionStatusDisplayRows as vr, resolveProjectBindingForPath as vt, resolveCurrentEffectiveProfileWorkingFolderRuntime as w, resolveInstalledCodexLaunchCandidates as wn, isAgentExecutionReadyOrConnecting as wr, withAgentActivityDeliveryLock as wt, resolveLocalRuntimeControllerSupport as x, resolveInstalledGrokBuildLaunchCandidates as xn, getAgentControllerPermissionModeFieldLabel as xr, unbindProject as xt, readLocalEnabledControllers as y, GrokBuildAcpTransportError as yn, createAuthorityOpenMeldServiceRuntimeId as yr, runIfAgentActivityBindingGenerationIsCurrent as yt, reconcileNewRunnableBuiltinAgentsForSetup as z, runRuntimeTask as zn, supportsSpaceWorkHandoff as zr, validateCustomProfileWorkspacePath as zt };
+export { canManageRegistryAgentSkillTargets as $, loadLedgerState as $n, applyAcceptedLeases as $r, buildDispatchReplyContextSummary as $t, createExpectedRoutesReadSession as A, resolveInstalledCodexLaunchCandidates as An, getAgentControllerPermissionModeFieldLabel as Ar, resolveRegistryRuntimeAdapterContractByAgentControllerRef as At, reconcileNewRunnableBuiltinAgentsForSetup as B, updateClaudeNativeInstallation as Bn, renderWorkingLanguagePrompt as Br, validateCustomProfileWorkspacePath as Bt, createModelCatalogReadSession as C, installGrokBotTools as Cn, buildInformationProtectionPromptPlan as Cr, canonicalizeLocalProjectPath as Ct, NO_LOCAL_AGENTS_NEED_OPENMELD_SERVICE_REASON as D, supportsGrokBotSetup as Dn, createAgentExecutionStatusDisplayRows as Dr, listBuiltinAgentsRegistryEntries as Dt, resolveProfileWorkspaceRuntime as E, readManagedGrokBotCandidate as En, createAgentControllerInterfaceDisplayRows as Er, withAgentActivityLocalStateLock as Et, listAgentRegistrations as F, projectCodexUsageObservation as Fn, parseAgentControllerRef as Fr, readSavedProfileWorkspaceForAccount as Ft, updateAgentRegistrations as G, emitReconcileCompletedEvidence as Gn, resolveNativeAgentControllerPermissionModeForController as Gr, summarizeSkippedDaemonProfiles as Gt, resolveAgentTargetState as H, checkAntigravityAcpAccount as Hn, resolveAgentExecutionStatus as Hr, createMutableRouteCatalogState as Ht, listAgentTargetStates as I, readCodexAccountUsageObservation as In, peopleComputerContainsDevice as Ir, resolveConfiguredProfileWorkspacePath as It, normalizeAgentIds as J, runRuntimeTask as Jn, supportsSpaceWorkHandoff as Jr, syncRuntimeEventToInflightTaskControlRegistry as Jt, notifyDaemonRouteCatalogChanged as K, emitReconcileStartedEvidence as Kn, resolveSelectableCandidates as Kr, syncDaemonRouteCatalogState as Kt, manageAgentRegistrationInstallation as L, probeClaudeCodeUsageLimits as Ln, projectPeopleComputersToLegacyLocalRuntimes as Lr, resolveConfiguredProfileWorkspacePathForAccount as Lt, addAgentCustomTarget as M, probeCodexAppServerAccount as Mn, isAgentControllerUsageRefreshUnavailable as Mr, normalizeCustomProfileWorkspacePath as Mt, createRegistrationFromCatalogTarget as N, resolveCodexAppServerCompletedTurn as Nn, isAgentExecutionReadyOrConnecting as Nr, readProfileWorkspaceConfig as Nt, syncDeviceRuntimeStateProjection as O, projectCursorUsageLimits as On, createAuthorityOpenMeldServiceRuntimeId as Or, resolveRegistryOriginLaunchCommand as Ot, listAgentCustomTargets as P, verifyCodexAppServerThread as Pn, listAgentControllerPermissionModeOptions as Pr, readProfileWorkspaceConfigForAccount as Pt, resolveLocalRegistryAgentIdFromAgentControllerRef as Q, commitResolvedAgentContext as Qn, MIN_HEARTBEAT_INTERVAL_MS as Qr, createSerialAgentInteractionCallback as Qt, readAgentRuntimeConfigHealth as R, readClaudeNativeVersion as Rn, renderInformationProtectionPrompt as Rr, setCustomProfileWorkspace as Rt, syncProfileWorkspaceState as S, resolveInstalledGrokBuildLaunchCandidates as Sn, buildAgentControllerRef as Sr, unbindProject as St, resolveEffectiveProfileWorkingFolderRuntime as T, loginManagedGrokBot as Tn, compareAgentControllerVersions as Tr, withAgentActivityDeliveryLock as Tt, setAgentRegistrationEnabled as U, isAntigravityAcpLaunchContract as Un, resolveAgentProfileEditCapabilities as Ur, createRouteCatalogFromMutableState as Ut, removeAgentCustomTarget as V, resolveInstalledClaudeCodeLaunchCandidates as Vn, resolveAgentControllerPermissionModeForController as Vr, describeProfileWorkspacePathValidationFailure as Vt, updateAgentCustomTarget as W, emitDriftDetectedEvidence as Wn, resolveEvidenceSyncHealth as Wr, replaceMutableRouteCatalogState as Wt, sortAgentRegistrations as X, buildTaskResultEnvelope as Xn, ADAPTIVE_HEARTBEAT_JITTER_RATIO as Xr, SPACE_ACTION_TARGET_GUIDANCE_LINES as Xt, parseAgentEnabledOption as Y, buildRuntimeWorkspaceFingerprint as Yn, resolveRouteRegistrationReconcileDecision as Yr, SPACE_ACTION_CONTEXT_GUIDANCE_LINES as Yt, repairBuiltinControllerInstall as Z, appendLedgerHistoryEntry as Zn, MAX_HEARTBEAT_INTERVAL_MS as Zr, isDaemonReconcileInProgressError as Zt, loadDaemonRouteCatalog as _, forkOpenCodeServerSession as _n, DISPATCH_SPACE_ACTION_DELIVERY_ONLY_ENV as _r, removeMissingProjectConnections as _t, buildOpenClawSpaceSessionKey as a, createLocalExecutionSlots as an, withLedgerStateTransaction as ar, isHomebrewCommandPath as at, resolveLocalController as b, GrokBuildAcpTransportError as bn, TASK_KNOWLEDGE_GUIDANCE as br, runIfAgentActivityBindingGenerationIsCurrent as bt, findOpenClawAgentById as c, resolveDispatchContinuityObservation as cn, buildAgentContextLookupKey as cr, ProjectBindingOperationError as ct, resolveOpenClawAuthStatus as d, resolveLatestScopedConversationExecutionState as dn, resolveDispatchSpaceActionMcpServer as dr, hasProjectBindingForPath as dt, applyIntervalJitterMs as ei, normalizeDispatchPostMessageAction as en, removeConversationExecutionState as er, detectInstalledSkillsAgents as et, resolveOpenClawProviderRuntimeWorkingDirectory as f, resolveCatalogSyncSkippedProfilesLogState as fn, buildCliLaunchInvocation as fr, isProjectBound as ft, writeDaemonRouteCatalogCache as g, parseOpenCodeGoUsageResponse as gn, createProviderOriginalError as gr, removeAgentActivityBindingsWhileDeliveryLocked as gt, readDaemonRouteCatalogCache as h, parseOpenRouterUsageResponse as hn, listAgentControllerSupervisedProcessIds as hr, migrateProjectBindingStore as ht, listOpenClawGatewayAgents as i, __toESM as ii, buildLocalServiceDiagnosticsPayload as in, upsertConversationExecutionState as ir, isBunGlobalCommandPath as it, resolveAgentProfilePrimaryAgentControllerReport as j, forkCodexAppServerThread as jn, isAgentControllerUsageAccountUnavailable as jr, ensureOpenMeldManagedProfileWorkspace as jt, createPrimaryBindingReadSession as k, resolveCodexTimeoutMs as kn, getAgentControllerPermissionModeDisplayMetadata as kr, resolveRegistryRuntimeAdapterCapabilitySnapshot as kt, findOpenClawAgentsByWorkspace as l, resolveCompatibleAgentContextMatch as ln, createUnavailableProviderUsageLimits as lr, ProjectBindingStoreUpdateRequiredError as lt, resolveOpenClawLocalBootstrapPaths as m, createLocalAdapterEntries as mn, resolveExecutablePathsOnPath as mr, listProjectConnectionsWithStatus as mt, fetchOpenClawGatewayHealth as n, resolveAdaptiveHeartbeatIntervalMs as ni, mergeOpenClawGatewayVisibility as nn, seedLegacyAgentContext as nr, EMPTY_AGENT_CONTROLLER_INTERFACE_CAPABILITIES as nt, normalizeOpenClawSpaceIdPrefix as o, createInflightTaskControlRegistry as on, buildAuthenticatedControlPlaneResponse as or, isNpmGlobalCommandPath as ot, readOpenClawLocalBootstrapState as p, createLocalAdapterContainer as pn, materializeCliLaunchCommand as pr, listProjectBindings as pt, normalizeAgentId as q, DaemonServiceRunError as qn, supportsExecutionContextSelection as qr, normalizeDispatchThreadAction as qt, listOpenClawAgents as r, resolveCatalogSyncIntervalMs as ri, createLocalTaskInterruptSender as rn, settleInflightTask as rr, resolveBuiltinAgentControllerDefinition as rt, slugifyOpenClawNamePart as s, resolveDispatchQueueLogMeta as sn, assertLegacyAgentContextAssociation as sr, isPnpmGlobalCommandPath as st, prepareProviderRuntime as t, pruneStaleLeases as ti, createPendingAgentInteractionRegistry as tn, resolveConversationExecutionStateByLookupKey as tr, resolveSkillsAgentRegistry as tt, matchesExpectedWorkspace as u, resolveCompatibleConversationExecutionState as un, createUnsupportedProviderUsageLimits as ur, bindProject as ut, buildRuntimeRouteTargets as v, readOpenCode2Inventory as vn, isDispatchSpaceActionDeliveryOnly as vr, removeProjectConnection as vt, resolveCurrentEffectiveProfileWorkingFolderRuntime as w, isManagedGrokBotSignedIn as wn, buildWorkingLanguagePromptPlan as wr, resolveLocalProjectConnectionForPath as wt, resolveLocalRuntimeControllerSupport as x, probeGrokBuildAcpInterface as xn, areAgentControllerInterfaceAccountsSame as xr, setDefaultProjectConnection as xt, readLocalEnabledControllers as y, resolveInstalledOpenCodeLaunchCandidates as yn, DEFAULT_TASK_LIFECYCLE_HEARTBEAT_INTERVAL_MS as yr, resolveProjectBindingForPath as yt, reconcileNewRunnableBuiltinAgentRegistrations as z, resolveClaudeNativeUpdateCommand as zn, renderTaskKnowledgeIndex as zr, setOpenMeldManagedProfileWorkspace as zt };
 
-//# sourceMappingURL=prepare-provider-runtime-BYKiQArk.js.map
+//# sourceMappingURL=prepare-provider-runtime-B0gBhnir.js.map