@agentconnect.md/daemon 1.0.0-rc.289 → 1.0.0-rc.290

package/dist/{run-foreground-D4TMcwTn.js → run-foreground-BMjqIzg4.js}

@@ -3,19 +3,19 @@ import { n as require_ms, t as require_src$3 } from "./src-DDtlVutj.js";
 import { n as init_esm_shims, t as __dirname } from "./esm-shims-DxGcm4Hw.js";
 import { t as DAEMON_VERSION } from "./version-DGaRXjBK.js";
 import { C as _coercedNumber, T as NEVER, a as array, d as literal, f as looseObject, i as any, m as object, o as boolean, p as number$1, t as ZodNumber, v as string, x as url$4 } from "./schemas-CQkO9hC5.js";
-import { C as ZodIssueCode, S as RESERVED_MCP_SERVER_NAME, _ as buildEnvelope, a as agentChildEnv, b as MAX_FRAME_BYTES, c as persistRelays, d as normalizeGitUrl, f as RELAY_DAEMON_SUBPROTOCOL, g as SHARED_CONFIG_ACTION_ID, h as decodeRelayDaemonFrame, i as selectAgent, m as buildRelayDaemonFrame, n as findAgentFiles, o as loadConfig, p as RELAY_DAEMON_WS_PATH, r as loadAgents, s as persistDaemonId, v as decodeEnvelope, y as encode } from "./load-agents-BLNSM987.js";
+import { C as ZodIssueCode, S as RESERVED_MCP_SERVER_NAME, _ as buildEnvelope, a as agentChildEnv, b as MAX_FRAME_BYTES, c as persistRelays, d as normalizeGitUrl, f as RELAY_DAEMON_SUBPROTOCOL, g as SHARED_CONFIG_ACTION_ID, h as decodeRelayDaemonFrame, i as selectAgent, m as buildRelayDaemonFrame, n as findAgentFiles, o as loadConfig, p as RELAY_DAEMON_WS_PATH, r as loadAgents, s as persistDaemonId, v as decodeEnvelope, y as encode } from "./load-agents-CZJD_fRG.js";
 import { l as resolveRoot, o as mcpSocketPath, u as statePath } from "./paths-DEcUO8lC.js";
-import { S as resolveRuntimes, _ as writeMemoryFile, a as initGitInjection, b as cachedRuntimeNames, c as simpleGit, d as memoryProviderFor, f as MemoryConflictError, g as resolveInMemoryDir, h as listMemory, i as prepareWorkspace, l as createMemoryProvider, m as MemoryTooLargeError, n as installedRuntimes, o as probeGitVersion, p as MemoryPathError, r as prefetchWorkspace, s as sessionGitEnv, t as AcpHost, u as memoryKindOf, v as MEMORY_TOOL_NAMES, x as cachedRuntimeVersions, y as toolsForIntegrations } from "./acp-host-BlkeNrQB.js";
+import { S as resolveRuntimes, _ as writeMemoryFile, a as initGitInjection, b as cachedRuntimeNames, c as simpleGit, d as memoryProviderFor, f as MemoryConflictError, g as resolveInMemoryDir, h as listMemory, i as prepareWorkspace, l as createMemoryProvider, m as MemoryTooLargeError, n as installedRuntimes, o as probeGitVersion, p as MemoryPathError, r as prefetchWorkspace, s as sessionGitEnv, t as AcpHost, u as memoryKindOf, v as MEMORY_TOOL_NAMES, x as cachedRuntimeVersions, y as toolsForIntegrations } from "./acp-host-B91pZ6PG.js";
 import { i as GitCredentialCache, n as gitcredSocketPath, r as writeGitcredShim, t as GitCredServer } from "./gitcred-server-Dhp-tyEI.js";
 import { B as ToolListChangedNotificationSchema, D as ListPromptsResultSchema, E as ListChangedOptionsBaseSchema, F as PromptListChangedNotificationSchema, G as isZ4Schema, H as isJSONRPCRequest, I as ReadResourceResultSchema, J as encodeFrame, K as safeParse, L as ResourceListChangedNotificationSchema, M as ListToolsResultSchema, O as ListResourceTemplatesResultSchema, P as McpError, R as SUPPORTED_PROTOCOL_VERSIONS, S as InitializeResultSchema, T as LATEST_PROTOCOL_VERSION, U as isJSONRPCResultResponse, V as isInitializedNotification, W as getObjectShape, _ as ElicitResultSchema, a as AjvJsonSchemaValidator, b as GetPromptResultSchema, c as mergeCapabilities, d as CompleteResultSchema, f as CreateMessageRequestSchema, g as ElicitRequestSchema, h as CreateTaskResultSchema, i as assertToolsCallTaskCapability, k as ListResourcesResultSchema, m as CreateMessageResultWithToolsSchema, n as serializeMessage, o as require_fast_deep_equal, p as CreateMessageResultSchema, q as decodeFrames, r as assertClientRequestTaskCapability, s as Protocol, t as ReadBuffer, u as CallToolResultSchema, v as EmptyResultSchema, w as JSONRPCMessageSchema, y as ErrorCode } from "./stdio-DnS8WcXi.js";
 import { URL as URL$1 } from "url";
 import * as tls from "tls";
 import * as net$5 from "net";
 import * as path$16 from "node:path";
-import { dirname, join, relative, resolve, sep } from "node:path";
+import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import * as http$8 from "http";
 import { Agent } from "https";
-import { chmodSync, existsSync, mkdirSync, mkdtempSync, promises, readFileSync, rmSync, stat, unwatchFile, watch, watchFile, writeFileSync } from "node:fs";
+import { chmodSync, existsSync, mkdirSync, mkdtempSync, promises, readFileSync, readdirSync, renameSync, rmSync, stat, unwatchFile, watch, watchFile, writeFileSync } from "node:fs";
 import { EventEmitter } from "node:events";
 import process$1 from "node:process";
 import { randomBytes, randomUUID } from "node:crypto";
@@ -4527,6 +4527,12 @@ var CpClient = class {
 			case "agent/remove":
 				this.deps.configApply.applyAgentRemove(frame.payload.agentId);
 				return;
+			case "agent/detach":
+				this.deps.configApply.applyAgentDetach(frame.payload).then((ack) => this.reply(frame, "ack", ack)).catch((err) => this.sendError(frame.id, "INTERNAL", `agent/detach failed: ${err.message}`, false));
+				return;
+			case "agent/activate":
+				this.deps.configApply.applyAgentActivate(frame.payload).then((ack) => this.reply(frame, "ack", ack)).catch((err) => this.sendError(frame.id, "INTERNAL", `agent/activate failed: ${err.message}`, false));
+				return;
 			case "integration/upsert":
 				this.deps.configApply.applyIntegrationUpsert(frame.payload);
 				return;
@@ -198188,6 +198194,227 @@ async function fetchHeadMtime(root) {
 * without the key leaves the local value alone — hand-authored agent.json keeps
 * working).
 */
+const DETACHED_DIR = ".detached";
+const STAGED_DIR = ".staged";
+const DETACHED_DATA_DIR = "agent";
+const DETACHED_META_FILE = "metadata.json";
+const MOVE_META_FILE = "metadata.json";
+/** Stable cold-move archive root. It is hidden, so agent discovery ignores it. */
+function detachedAgentDir(agentsDir, agentId) {
+	return join(agentsDir, DETACHED_DIR, agentId);
+}
+function stagedAgentDir(agentsDir, agentId) {
+	return join(agentsDir, STAGED_DIR, agentId);
+}
+function writeMoveStage(agentsDir, agentId, metadata) {
+	const root = stagedAgentDir(agentsDir, agentId);
+	const file = join(root, MOVE_META_FILE);
+	const temp = join(root, `${MOVE_META_FILE}.tmp`);
+	mkdirSync(root, { recursive: true });
+	try {
+		writeFileSync(temp, JSON.stringify(metadata, null, 2) + "\n");
+		renameSync(temp, file);
+	} catch (err) {
+		rmSync(temp, { force: true });
+		throw err;
+	}
+}
+/** Durable fail-closed tombstone: a new move atomically supersedes the old id/state. */
+function stageAgentMove(agentsDir, agentId, moveId) {
+	writeMoveStage(agentsDir, agentId, {
+		moveId,
+		state: "staging"
+	});
+}
+function readAgentMoveStage(agentsDir, agentId) {
+	const root = stagedAgentDir(agentsDir, agentId);
+	if (!existsSync(root)) return void 0;
+	try {
+		const raw = JSON.parse(readFileSync(join(root, MOVE_META_FILE), "utf8"));
+		if (typeof raw.moveId === "string" && (raw.state === "staging" || raw.state === "committed")) return {
+			moveId: raw.moveId,
+			state: raw.state
+		};
+	} catch {}
+	return {
+		moveId: "",
+		state: "staging"
+	};
+}
+function commitAgentMove(agentsDir, agentId, moveId) {
+	const current = readAgentMoveStage(agentsDir, agentId);
+	if (!current || current.moveId !== moveId) throw new Error(`cannot commit move "${moveId}" for agent "${agentId}": staging fence changed`);
+	if (current.state === "committed") return;
+	writeMoveStage(agentsDir, agentId, {
+		moveId,
+		state: "committed"
+	});
+}
+function clearAgentMoveStage(agentsDir, agentId) {
+	rmSync(stagedAgentDir(agentsDir, agentId), {
+		recursive: true,
+		force: true
+	});
+}
+function agentMoveStages(agentsDir) {
+	const root = join(agentsDir, STAGED_DIR);
+	const out = /* @__PURE__ */ new Map();
+	if (!existsSync(root)) return out;
+	try {
+		for (const entry of readdirSync(root, { withFileTypes: true })) {
+			if (!entry.isDirectory()) continue;
+			const metadata = readAgentMoveStage(agentsDir, entry.name);
+			if (metadata) out.set(entry.name, metadata);
+		}
+	} catch {}
+	return out;
+}
+function detachedDataDir(agentsDir, agentId) {
+	return join(detachedAgentDir(agentsDir, agentId), DETACHED_DATA_DIR);
+}
+function scrubAgentIntegrations(file) {
+	const original = readFileSync(file, "utf8");
+	const raw = JSON.parse(original);
+	if (Array.isArray(raw.integrations) && raw.integrations.length === 0) return original;
+	raw.integrations = [];
+	writeFileSync(file, JSON.stringify(raw, null, 2) + "\n");
+	return original;
+}
+/**
+* Move an active agent root out of the discovery tree without deleting any of
+* its daemon-local state. The metadata preserves custom/nested directory names
+* so a later activate or upsert can restore the exact original location.
+*/
+function archiveAgent(agentsDir, agentId) {
+	const file = findAgentFileById(agentsDir, agentId);
+	const archived = detachedDataDir(agentsDir, agentId);
+	if (!file) {
+		if (!existsSync(archived)) return "missing";
+		const archivedFile = findAgentFileById(archived, agentId);
+		if (!archivedFile) throw new Error(`cannot detach agent "${agentId}": detached archive is incomplete`);
+		scrubAgentIntegrations(archivedFile);
+		return "already-detached";
+	}
+	const base = resolve(agentsDir);
+	const activeDir = resolve(dirname(file));
+	const relativePath = relative(base, activeDir);
+	if (!relativePath || isAbsolute(relativePath) || relativePath === ".." || relativePath.startsWith(`..${sep}`)) throw new Error(`cannot detach agent "${agentId}": its root is not a child of agentsDir`);
+	const archiveRoot = detachedAgentDir(agentsDir, agentId);
+	if (existsSync(archiveRoot)) if (!existsSync(archived)) rmSync(archiveRoot, {
+		recursive: true,
+		force: true
+	});
+	else throw new Error(`cannot detach agent "${agentId}": an archive already exists while the agent is active`);
+	const metadata = {
+		agentId,
+		relativePath
+	};
+	const originalAgentJson = readFileSync(file, "utf8");
+	try {
+		mkdirSync(archiveRoot, { recursive: true });
+		scrubAgentIntegrations(file);
+		writeFileSync(join(archiveRoot, DETACHED_META_FILE), JSON.stringify(metadata, null, 2) + "\n");
+		renameSync(activeDir, archived);
+	} catch (err) {
+		if (existsSync(file)) writeFileSync(file, originalAgentJson);
+		rmSync(archiveRoot, {
+			recursive: true,
+			force: true
+		});
+		throw err;
+	}
+	return "archived";
+}
+/** Restore a cold-move archive to its exact former relative location. */
+function restoreArchivedAgent(agentsDir, agentId) {
+	const archiveRoot = detachedAgentDir(agentsDir, agentId);
+	const archived = detachedDataDir(agentsDir, agentId);
+	if (!existsSync(archiveRoot)) return false;
+	if (!existsSync(archived)) throw new Error(`cannot activate agent "${agentId}": detached archive is incomplete`);
+	let metadata;
+	try {
+		metadata = JSON.parse(readFileSync(join(archiveRoot, DETACHED_META_FILE), "utf8"));
+	} catch {
+		throw new Error(`cannot activate agent "${agentId}": detached archive metadata is invalid`);
+	}
+	if (metadata.agentId !== agentId || typeof metadata.relativePath !== "string" || !metadata.relativePath) throw new Error(`cannot activate agent "${agentId}": detached archive metadata does not match`);
+	const base = resolve(agentsDir);
+	const target = resolve(base, metadata.relativePath);
+	if (target === base || !target.startsWith(base + sep)) throw new Error(`cannot activate agent "${agentId}": detached archive path escapes agentsDir`);
+	if (existsSync(target)) throw new Error(`cannot activate agent "${agentId}": original path is already occupied`);
+	if (!findAgentFileById(archived, agentId)) throw new Error(`cannot activate agent "${agentId}": detached archive does not contain the agent`);
+	mkdirSync(dirname(target), { recursive: true });
+	renameSync(archived, target);
+	rmSync(archiveRoot, {
+		recursive: true,
+		force: true
+	});
+	return true;
+}
+/**
+* Exact-set the CP-owned dependents restored from a move-back archive BEFORE
+* the agent becomes visible to reconcile. CP crons are explicitly tagged and
+* can coexist with hand-authored entries. Integrations historically have no
+* ownership marker, so move activation deliberately treats the CP list as
+* authoritative/fail-closed and removes every non-listed integration; retaining
+* an unknown stale bot credential would be the less safe ambiguity.
+*/
+function pruneMovedAgentDependents(agentsDir, agentId, desired) {
+	const file = findAgentFileById(agentsDir, agentId);
+	if (!file) return false;
+	const raw = JSON.parse(readFileSync(file, "utf8"));
+	const integrationIds = new Set(desired.integrationIds);
+	const cronIds = new Set(desired.cronIds);
+	let changed = false;
+	if (Array.isArray(raw.integrations)) {
+		const seen = /* @__PURE__ */ new Set();
+		const next = raw.integrations.filter((integration) => {
+			if (typeof integration !== "object" || integration === null) return false;
+			const id = integration.id;
+			if (typeof id !== "string" || !integrationIds.has(id) || seen.has(id)) return false;
+			seen.add(id);
+			return true;
+		});
+		if (JSON.stringify(next) !== JSON.stringify(raw.integrations)) {
+			raw.integrations = next;
+			changed = true;
+		}
+	}
+	const localCronCollisions = /* @__PURE__ */ new Set();
+	if (Array.isArray(raw.crons)) {
+		const seenCp = /* @__PURE__ */ new Set();
+		const next = raw.crons.filter((cron) => {
+			if (typeof cron !== "object" || cron === null) return true;
+			const item = cron;
+			if (item.origin !== "cp") {
+				if (typeof item.id === "string" && cronIds.has(item.id)) localCronCollisions.add(item.id);
+				return true;
+			}
+			if (typeof item.id !== "string" || !cronIds.has(item.id) || seenCp.has(item.id)) return false;
+			seenCp.add(item.id);
+			return true;
+		});
+		if (JSON.stringify(next) !== JSON.stringify(raw.crons)) {
+			raw.crons = next;
+			changed = true;
+		}
+	}
+	if (changed) writeFileSync(file, JSON.stringify(raw, null, 2) + "\n");
+	const finalIntegrations = new Set((Array.isArray(raw.integrations) ? raw.integrations : []).flatMap((integration) => {
+		if (typeof integration !== "object" || integration === null) return [];
+		const id = integration.id;
+		return typeof id === "string" ? [id] : [];
+	}));
+	const finalCpCrons = new Set((Array.isArray(raw.crons) ? raw.crons : []).flatMap((cron) => {
+		if (typeof cron !== "object" || cron === null) return [];
+		const item = cron;
+		return item.origin === "cp" && typeof item.id === "string" ? [item.id] : [];
+	}));
+	const missingIntegrations = desired.integrationIds.filter((id) => !finalIntegrations.has(id));
+	const missingCrons = desired.cronIds.filter((id) => !finalCpCrons.has(id));
+	if (missingIntegrations.length || missingCrons.length || localCronCollisions.size) throw new Error(`cannot activate agent "${agentId}": authoritative dependent bundle did not persist (missing integrations: ${missingIntegrations.join(", ") || "none"}; missing crons: ${missingCrons.join(", ") || "none"}; local cron collisions: ${[...localCronCollisions].join(", ") || "none"})`);
+	return changed;
+}
 /** Map a CP workspace mode onto the daemon's AgentSchema workspace mode. */
 function mapWorkspaceMode(mode) {
 	return mode === "scratch" ? "from-scratch" : "git-repo";
@@ -198267,7 +198494,8 @@ function applySpecFields(raw, spec, opts) {
 * from-scratch, path daemon-generated.
 */
 function writeAgentSpec(agentsDir, agentId, spec, deps) {
-	const existingFile = findAgentFileById(agentsDir, agentId);
+	let existingFile = findAgentFileById(agentsDir, agentId);
+	if (!existingFile && restoreArchivedAgent(agentsDir, agentId)) existingFile = findAgentFileById(agentsDir, agentId);
 	if (existingFile) {
 		const raw = JSON.parse(readFileSync(existingFile, "utf8"));
 		applySpecFields(raw, spec, {
@@ -198317,6 +198545,11 @@ function removeAgent(agentsDir, agentId) {
 		recursive: true,
 		force: true
 	});
+	rmSync(detachedAgentDir(agentsDir, agentId), {
+		recursive: true,
+		force: true
+	});
+	clearAgentMoveStage(agentsDir, agentId);
 }
 //#endregion
 //#region src/agents/write-cron.ts
@@ -198461,6 +198694,20 @@ var CpAgentRegistry = class {
 		removeAgent(this.agentsDir, agentId);
 		this.onChange();
 	}
+	/** Non-destructively move an agent root out of the active discovery tree. */
+	detach(agentId) {
+		const result = archiveAgent(this.agentsDir, agentId);
+		if (result !== "missing") this.onChange();
+		return result;
+	}
+	/** Restore a detached root in place. Idempotent while already active. */
+	activate(agentId, desired) {
+		const alreadyActive = !!findAgentFileById(this.agentsDir, agentId);
+		if (!alreadyActive && !restoreArchivedAgent(this.agentsDir, agentId)) return "missing";
+		const pruned = pruneMovedAgentDependents(this.agentsDir, agentId, desired);
+		if (!alreadyActive || pruned) this.onChange();
+		return alreadyActive ? "already-active" : "restored";
+	}
 	/**
 	* Apply the register/ok reconcile roster: create-or-merge EACH entry and
 	* NOTHING else. Never prunes agents absent from the roster (deletion is only
@@ -214428,10 +214675,18 @@ var Daemon = class Daemon {
 	requestExit;
 	draining = false;
 	drainingAgents = /* @__PURE__ */ new Set();
+	moveStagedAgents = /* @__PURE__ */ new Set();
+	moveStageMetadata = /* @__PURE__ */ new Map();
+	activatingAgents = /* @__PURE__ */ new Set();
+	agentMoveTails = /* @__PURE__ */ new Map();
+	agentMoveInFlight = /* @__PURE__ */ new Map();
+	activeDispatchesByAgent = /* @__PURE__ */ new Map();
+	activeReplyConnectionUses = /* @__PURE__ */ new Map();
 	hostStopping = /* @__PURE__ */ new Map();
 	idleSweepTimer;
 	cancelTimers = /* @__PURE__ */ new Map();
 	slackRetryTimers = /* @__PURE__ */ new Map();
+	slackRetryRuns = /* @__PURE__ */ new Map();
 	constructor(opts = {}) {
 		this.opts = opts;
 		this.clock = opts.clock ?? systemClock;
@@ -214476,12 +214731,16 @@ var Daemon = class Daemon {
 		this.log.info(`starting daemon (root=${root})`);
 		this.log.info(`control plane: ${cfg.controlPlane?.enabled ? `enabled (${cfg.controlPlane.url ?? "no url"})` : "disabled — running local"}`);
 		this.agentsDir = cfg.agentsDir;
-		const agents = this.loadAgentList();
-		this.fileAgents = new Map(agents.map((a) => [a.id, a]));
+		this.moveStageMetadata = agentMoveStages(this.agentsDir);
+		this.moveStagedAgents = new Set([...this.moveStageMetadata].filter(([, metadata]) => metadata.state === "staging").map(([agentId]) => agentId));
+		for (const agentId of this.moveStagedAgents) this.drainingAgents.add(agentId);
+		const discoveredAgents = this.loadAgentList();
+		const agents = discoveredAgents.filter((agent) => !this.moveStagedAgents.has(agent.id));
+		this.fileAgents = new Map(discoveredAgents.map((a) => [a.id, a]));
 		this.log.info(`loaded ${agents.length} agent(s) from ${this.agentsDir}${agents.length ? `: ${agents.map((a) => a.id).join(", ")}` : ""}`);
 		this.root = root;
 		const resolvedRuntimes = await resolveRuntimes(cfg, root, {
-			neededRuntimes: agents.map((a) => a.runtime),
+			neededRuntimes: discoveredAgents.map((a) => a.runtime),
 			mode: "cache-first"
 		});
 		this.runtimes = installedRuntimes(resolvedRuntimes);
@@ -214628,7 +214887,7 @@ var Daemon = class Daemon {
 				this.log.warn(`slack: connection failed for appToken — retrying in 60s: ${formatErr(err)}`);
 				const timer = this.clock.setTimeout(() => {
 					if (this.draining) return;
-					this.retrySlackConnection(group).catch((e) => this.log.error(`slack: retry loop error: ${formatErr(e)}`));
+					this.startSlackRetry(group.appToken);
 				}, 6e4);
 				this.slackRetryTimers.set(group.appToken, timer);
 			}
@@ -214642,7 +214901,7 @@ var Daemon = class Daemon {
 		this.watcher = watch$1(this.agentsDir, {
 			ignoreInitial: true,
 			depth: 4,
-			ignored: (p) => /[\\/](node_modules|\.git)([\\/]|$)/.test(p)
+			ignored: (p) => /[\\/](node_modules|\.git|\.detached|\.staged)([\\/]|$)/.test(p)
 		});
 		const debounced = () => {
 			clearTimeout(this.debounceTimer);
@@ -214671,7 +214930,7 @@ var Daemon = class Daemon {
 	* routing (all of which read `agent.integrations`) see one merged view.
 	*/
 	effectiveAgents() {
-		return [...this.fileAgents.values()];
+		return [...this.fileAgents.values()].filter((agent) => !this.moveStagedAgents.has(agent.id));
 	}
 	/**
 	* Converge the running set to the desired effective agents. Driven by both the
@@ -214726,6 +214985,7 @@ var Daemon = class Daemon {
 			this.agents.delete(id);
 			this.scheduler.unregister(id);
 		}
+		let connectionsDirty = toStart.length > 0 || toStop.length > 0;
 		for (const change of toChange) {
 			const a = change.agent;
 			this.agents.set(a.id, a);
@@ -214739,20 +214999,19 @@ var Daemon = class Daemon {
 				this.hostStarts.delete(a.id);
 			}
 			if (change.workspace) this.prefetchClone(a);
-			if (change.integrations) {
-				await this.reconcileSlackConnections();
-				await this.reconcileTelegramConnections();
-				await this.reconcileDiscordConnections();
-			}
+			if (change.integrations) connectionsDirty = true;
 		}
 		for (const a of toStart) {
 			this.agents.set(a.id, a);
 			this.prefetchClone(a);
 			this.scheduler.sync(a.id, a.crons);
 		}
-		if (toStart.some((a) => a.integrations.some((i) => i.platform === "slack")) || toStop.length) await this.reconcileSlackConnections();
-		if (toStart.some((a) => a.integrations.some((i) => i.platform === "telegram")) || toStop.length) await this.reconcileTelegramConnections();
-		if (toStart.some((a) => a.integrations.some((i) => i.platform === "discord")) || toStop.length) await this.reconcileDiscordConnections();
+		if (connectionsDirty) {
+			await this.closeUnusedPlatformConnections();
+			await this.reconcileSlackConnections();
+			await this.reconcileTelegramConnections();
+			await this.reconcileDiscordConnections();
+		}
 	}
 	/**
 	* Fire-and-forget eager clone of a git-repo workspace so the checkout is warm
@@ -214765,6 +215024,93 @@ var Daemon = class Daemon {
 		prefetchWorkspace(agent).catch((err) => this.log.warn(`workspace: prefetch clone for "${agent.id}" failed (will retry at first session): ${formatErr(err)}`));
 	}
 	/**
+	* Close platform clients whose credential key has no reference in the FINAL
+	* active-agent roster, and evict every derived index that points at a removed
+	* or re-keyed integration. Consolidation maps are the reference counts: direct
+	* Slack is keyed by appToken; shared Slack, Telegram and Discord by botToken.
+	*
+	* A captured connection on a live turn is a temporary reference too. Detach
+	* drains its own dispatch leases before reaching this method; the guard also
+	* keeps ordinary concurrent reconcile safe for unrelated in-flight turns.
+	*/
+	async closeUnusedPlatformConnections() {
+		const agents = [...this.agents.values()];
+		const direct = consolidate(agents);
+		const shared = consolidateShared(agents);
+		const telegram = consolidateTelegram(agents);
+		const discord = consolidateDiscord(agents);
+		const directByIntegration = /* @__PURE__ */ new Map();
+		for (const group of direct.values()) for (const { integrationId } of group.integrations) directByIntegration.set(integrationId, {
+			appToken: group.appToken,
+			botToken: group.botToken
+		});
+		const sharedByIntegration = /* @__PURE__ */ new Map();
+		for (const group of shared.values()) for (const { integrationId } of group.integrations) sharedByIntegration.set(integrationId, group.botToken);
+		const telegramByIntegration = /* @__PURE__ */ new Map();
+		for (const group of telegram.values()) for (const { integrationId } of group.integrations) telegramByIntegration.set(integrationId, group.botToken);
+		const discordByIntegration = /* @__PURE__ */ new Map();
+		for (const group of discord.values()) for (const { integrationId } of group.integrations) discordByIntegration.set(integrationId, group.botToken);
+		const allDesiredIds = /* @__PURE__ */ new Set([
+			...directByIntegration.keys(),
+			...sharedByIntegration.keys(),
+			...telegramByIntegration.keys(),
+			...discordByIntegration.keys()
+		]);
+		const dropIdentity = (integrationId) => {
+			delete this.botUserIds[integrationId];
+			this.channelSnapshots.delete(integrationId);
+		};
+		for (const integrationId of Object.keys(this.botUserIds)) if (!allDesiredIds.has(integrationId)) dropIdentity(integrationId);
+		for (const integrationId of [...this.channelSnapshots.keys()]) if (!allDesiredIds.has(integrationId)) this.channelSnapshots.delete(integrationId);
+		for (const [integrationId, conn] of this.connByIntegration) {
+			const expectedDirect = directByIntegration.get(integrationId);
+			const expectedShared = sharedByIntegration.get(integrationId);
+			if (!(expectedDirect ? conn.appToken === expectedDirect.appToken && conn.botToken === expectedDirect.botToken : expectedShared !== void 0 ? conn.appToken === "" && conn.botToken === expectedShared : false)) {
+				this.connByIntegration.delete(integrationId);
+				dropIdentity(integrationId);
+			}
+		}
+		for (const [integrationId, conn] of this.tgConnByIntegration) if (conn.botToken !== telegramByIntegration.get(integrationId)) {
+			this.tgConnByIntegration.delete(integrationId);
+			dropIdentity(integrationId);
+		}
+		for (const [integrationId, conn] of this.dcConnByIntegration) if (conn.botToken !== discordByIntegration.get(integrationId)) {
+			this.dcConnByIntegration.delete(integrationId);
+			dropIdentity(integrationId);
+		}
+		for (const [appToken, timer] of this.slackRetryTimers) {
+			if (direct.has(appToken)) continue;
+			this.clock.clearTimeout(timer);
+			this.slackRetryTimers.delete(appToken);
+		}
+		const retryRuns = [...this.slackRetryRuns].filter(([appToken, run]) => direct.get(appToken)?.botToken !== run.botToken).map(([, run]) => run.promise);
+		if (retryRuns.length) await Promise.all(retryRuns);
+		for (const conn of [...this.connections]) {
+			if (direct.get(conn.appToken)?.botToken === conn.botToken) continue;
+			await this.waitForConnectionUses(conn);
+			await conn.stop();
+			this.connections = this.connections.filter((candidate) => candidate !== conn);
+		}
+		for (const [botToken, conn] of [...this.sharedSlackConns]) {
+			if (shared.has(botToken)) continue;
+			await this.waitForConnectionUses(conn);
+			await conn.stop();
+			this.sharedSlackConns.delete(botToken);
+		}
+		for (const conn of [...this.telegramConns]) {
+			if (telegram.has(conn.botToken)) continue;
+			await this.waitForConnectionUses(conn);
+			await conn.stop();
+			this.telegramConns = this.telegramConns.filter((candidate) => candidate !== conn);
+		}
+		for (const conn of [...this.discordConns]) {
+			if (discord.has(conn.botToken)) continue;
+			await this.waitForConnectionUses(conn);
+			await conn.stop();
+			this.discordConns = this.discordConns.filter((candidate) => candidate !== conn);
+		}
+	}
+	/**
 	* Reconcile the connection-derived Slack state (`botUserIds`, `connByIntegration`,
 	* open sockets) against the live `this.agents` set. Routing itself is rebuilt
 	* implicitly each message (mergedRules reads this.agents) — this only maintains the
@@ -214777,18 +215123,14 @@ var Daemon = class Daemon {
 	*  - NEW integration reusing an ALREADY-OPEN appToken → no socket churn; just
 	*    backfill botUserIds/connByIntegration from the existing conn (mention routing
 	*    for the new bot would otherwise silently never match).
-	*  - REMOVED appToken / close-or-replace of a still-shared socket → NOT performed
-	*    here. Tearing down a socket that other agents or in-flight turns depend on is
-	*    the one genuinely dangerous op; it is left as a logged deferred-close TODO so
-	*    a stale socket simply lingers (harmless) rather than risking the daemon.
+	*  - REMOVED/re-keyed appToken → closed by closeUnusedPlatformConnections first,
+	*    after checking the final roster and captured-turn connection leases.
 	*/
 	async reconcileSlackConnections() {
 		const groups = consolidate([...this.agents.values()]);
-		new Set([...this.connByIntegration.values()].map((c) => c.appToken));
 		for (const group of groups.values()) {
-			const existing = [...this.connByIntegration.values()].find((c) => c.appToken === group.appToken);
+			const existing = this.connections.find((c) => c.appToken === group.appToken && c.botToken === group.botToken);
 			if (existing) {
-				if (existing.botToken !== group.botToken) this.log.warn(`slack: botToken changed for appToken (socket bot user ${existing.botUserId}) — deferred: the live socket keeps the old botToken until it is closed+reopened`);
 				let bound = false;
 				for (const { integrationId } of group.integrations) if (this.connByIntegration.get(integrationId) !== existing) {
 					this.botUserIds[integrationId] = existing.botUserId;
@@ -214848,12 +215190,6 @@ var Daemon = class Daemon {
 	async openSharedSlackConnections(agents) {
 		const groups = consolidateShared(agents);
 		for (const group of groups.values()) {
-			const staleDirect = this.connections.find((c) => c.botToken === group.botToken && c.appToken !== "");
-			if (staleDirect) {
-				this.log.info(`slack: bot flipped to shared — stopping its direct socket (bot ${staleDirect.botUserId})`);
-				await staleDirect.stop().catch(() => {});
-				this.connections = this.connections.filter((c) => c !== staleDirect);
-			}
 			let conn = this.sharedSlackConns.get(group.botToken);
 			if (!conn) {
 				conn = new SlackConnection({
@@ -214892,7 +215228,7 @@ var Daemon = class Daemon {
 	*    tgConnByIntegration for every integrationId on that token. A failed start
 	*    is logged and leaves existing connections intact (never throws out).
 	*  - integration reusing an ALREADY-OPEN token → bind it onto the live conn.
-	*  - REMOVED token → NOT torn down here (same deferred-close reasoning as Slack).
+	*  - REMOVED token → closed by closeUnusedPlatformConnections before this opener.
 	*/
 	async reconcileTelegramConnections() {
 		const groups = consolidateTelegram([...this.agents.values()]);
@@ -214938,8 +215274,7 @@ var Daemon = class Daemon {
 	* Parallel to reconcileTelegramConnections (one Gateway per bot token), but
 	* mention-routing matches the bot's numeric user id (normalize's `mentionedBots`
 	* are Discord user ids). A failed start is logged and leaves other connections
-	* intact (never throws out); a removed token is NOT torn down here (same deferred-
-	* close reasoning as Slack/Telegram).
+	* intact (never throws out); removed tokens are closed by the shared close phase.
 	*/
 	async reconcileDiscordConnections() {
 		const groups = consolidateDiscord([...this.agents.values()]);
@@ -215037,9 +215372,26 @@ var Daemon = class Daemon {
 	* at a slow, fixed interval — never gives up, so a temporary network outage
 	* self-heals without manual daemon restart.
 	*/
-	async retrySlackConnection(group) {
+	startSlackRetry(appToken) {
+		if (this.slackRetryRuns.has(appToken)) return;
+		const group = consolidate([...this.agents.values()]).get(appToken);
+		if (!group) return;
+		const run = this.retrySlackConnection(appToken).catch((err) => this.log.error(`slack: retry loop error: ${formatErr(err)}`)).finally(() => {
+			if (this.slackRetryRuns.get(appToken)?.promise === run) this.slackRetryRuns.delete(appToken);
+		});
+		this.slackRetryRuns.set(appToken, {
+			botToken: group.botToken,
+			promise: run
+		});
+	}
+	async retrySlackConnection(appToken) {
 		if (this.draining) return;
-		if ([...this.connByIntegration.values()].some((c) => c.appToken === group.appToken)) {
+		const group = consolidate([...this.agents.values()]).get(appToken);
+		if (!group) {
+			this.slackRetryTimers.delete(appToken);
+			return;
+		}
+		if (this.connections.some((c) => c.appToken === group.appToken && c.botToken === group.botToken)) {
 			this.slackRetryTimers.delete(group.appToken);
 			return;
 		}
@@ -215061,9 +215413,15 @@ var Daemon = class Daemon {
 		});
 		try {
 			await conn.start();
+			const currentGroup = consolidate([...this.agents.values()]).get(appToken);
+			if (this.draining || !currentGroup || currentGroup.botToken !== group.botToken) {
+				await conn.stop().catch(() => {});
+				this.slackRetryTimers.delete(appToken);
+				return;
+			}
 			this.log.info(`slack: background retry succeeded — connected as bot user ${conn.botUserId}`);
 			this.slackRetryTimers.delete(group.appToken);
-			for (const { integrationId } of group.integrations) {
+			for (const { integrationId } of currentGroup.integrations) {
 				this.botUserIds[integrationId] = conn.botUserId;
 				this.connByIntegration.set(integrationId, conn);
 			}
@@ -215071,10 +215429,14 @@ var Daemon = class Daemon {
 			this.refreshChannels(conn);
 		} catch (err) {
 			await conn.stop().catch(() => {});
+			if (this.draining || !consolidate([...this.agents.values()]).has(appToken)) {
+				this.slackRetryTimers.delete(appToken);
+				return;
+			}
 			this.log.warn(`slack: background retry failed — scheduling next attempt in 60s: ${formatErr(err)}`);
 			const timer = this.clock.setTimeout(() => {
 				if (this.draining) return;
-				this.retrySlackConnection(group).catch((e) => this.log.error(`slack: retry loop error: ${formatErr(e)}`));
+				this.startSlackRetry(appToken);
 			}, 6e4);
 			this.slackRetryTimers.set(group.appToken, timer);
 		}
@@ -216587,6 +216949,45 @@ var Daemon = class Daemon {
 	paused(agentId) {
 		return this.agents.get(agentId)?.pause === true;
 	}
+	beginActiveDispatch(agentId) {
+		let resolveDone;
+		const done = new Promise((resolve) => resolveDone = resolve);
+		const active = this.activeDispatchesByAgent.get(agentId) ?? /* @__PURE__ */ new Set();
+		active.add(done);
+		this.activeDispatchesByAgent.set(agentId, active);
+		let released = false;
+		return () => {
+			if (released) return;
+			released = true;
+			active.delete(done);
+			if (active.size === 0) this.activeDispatchesByAgent.delete(agentId);
+			resolveDone();
+		};
+	}
+	holdReplyConnection(conn) {
+		if (!conn) return () => {};
+		let resolveDone;
+		const done = new Promise((resolve) => resolveDone = resolve);
+		const uses = this.activeReplyConnectionUses.get(conn) ?? /* @__PURE__ */ new Set();
+		uses.add(done);
+		this.activeReplyConnectionUses.set(conn, uses);
+		let released = false;
+		return () => {
+			if (released) return;
+			released = true;
+			uses.delete(done);
+			if (uses.size === 0) this.activeReplyConnectionUses.delete(conn);
+			resolveDone();
+		};
+	}
+	async waitForConnectionUses(conn) {
+		while (true) {
+			const leases = [...this.activeReplyConnectionUses.get(conn) ?? []];
+			const pending = [...this.pending.values()].filter((turn) => turn.conn === conn).map((turn) => turn.done);
+			if (leases.length === 0 && pending.length === 0) return;
+			await Promise.all([...leases, ...pending]);
+		}
+	}
 	async runLoop(key, firstEntry) {
 		let entry = firstEntry;
 		while (entry) {
@@ -216605,7 +217006,13 @@ var Daemon = class Daemon {
 				return;
 			}
 			try {
-				const sessionId = await this.dispatchOne(entry, key);
+				const releaseDispatch = this.beginActiveDispatch(entry.agentId);
+				let sessionId;
+				try {
+					sessionId = await this.dispatchOne(entry, key);
+				} finally {
+					releaseDispatch();
+				}
 				this.removeInbox(entry);
 				entry.resolve(sessionId);
 			} catch (err) {
@@ -216639,18 +217046,23 @@ var Daemon = class Daemon {
 		const mode = this.store.getOutputModeOverride(key) ?? agent.output.mode;
 		const conv = msg.platform === "telegram" ? new TelegramConverger(mode) : msg.platform === "discord" ? new DiscordConverger(mode) : new OutputConverger(mode);
 		this.showActivity(replyConn, msg.channel, statusThread, wasRunning ? "is thinking…" : "is starting up…");
+		const releaseReplyConn = this.holdReplyConnection(replyConn);
 		let handled;
 		try {
 			handled = await this.sessions.handle(agentId, msg);
 		} catch (err) {
-			this.store.setSessionState(key, "idle", this.clock.now());
-			this.surfaceTurnFailure(err, {
-				webchat,
-				replyConn,
-				channel: msg.channel,
-				thread: msg.thread,
-				statusThread
-			});
+			try {
+				this.store.setSessionState(key, "idle", this.clock.now());
+				this.surfaceTurnFailure(err, {
+					webchat,
+					replyConn,
+					channel: msg.channel,
+					thread: msg.thread,
+					statusThread
+				});
+			} finally {
+				releaseReplyConn();
+			}
 			throw err;
 		}
 		const { sessionId, blocks, created } = handled;
@@ -216760,6 +217172,7 @@ var Daemon = class Daemon {
 			finalPhase = "problem";
 			throw err;
 		} finally {
+			releaseReplyConn();
 			this.clearIdle(p);
 			this.releasePermissions(sessionId);
 			this.releaseElicits(sessionId);
@@ -217722,6 +218135,50 @@ var Daemon = class Daemon {
 			agentId
 		}, this.cfg.limits.shutdownDrainMs);
 		await this.stopHost(agentId);
+		while (this.activeDispatchesByAgent.get(agentId)?.size) await Promise.all([...this.activeDispatchesByAgent.get(agentId)]);
+		await this.stopHost(agentId);
+	}
+	/** Await the single-flight reconcile and any coalesced trailing pass. Registry
+	*  callbacks fire a background reconcile before lifecycle handlers explicitly
+	*  await it, so one plain `await reconcile()` can otherwise observe only the
+	*  current pass rather than the queued final-roster pass. */
+	async flushReconcile() {
+		await this.reconcile();
+		await Promise.resolve();
+		while (this.reconcileRun || this.reconcilePending) {
+			if (this.reconcileRun) await this.reconcileRun;
+			else await this.reconcile();
+			await Promise.resolve();
+		}
+	}
+	queueAgentMove(kind, agentId, moveId, work) {
+		const key = `${kind}:${agentId}:${moveId}`;
+		const duplicate = this.agentMoveInFlight.get(key);
+		if (duplicate) return duplicate;
+		const run = (this.agentMoveTails.get(agentId) ?? Promise.resolve()).catch(() => {}).then(work);
+		const tail = run.then(() => void 0, () => void 0);
+		this.agentMoveInFlight.set(key, run);
+		this.agentMoveTails.set(agentId, tail);
+		run.then(() => {
+			if (this.agentMoveInFlight.get(key) === run) this.agentMoveInFlight.delete(key);
+			if (this.agentMoveTails.get(agentId) === tail) this.agentMoveTails.delete(agentId);
+		}, () => {
+			if (this.agentMoveInFlight.get(key) === run) this.agentMoveInFlight.delete(key);
+			if (this.agentMoveTails.get(agentId) === tail) this.agentMoveTails.delete(agentId);
+		});
+		return run;
+	}
+	activationCapabilityError(agent) {
+		const model = agent.runtimeOverrides?.model;
+		const offeredModels = this.runtimeModels.get(agent.runtime) ?? [];
+		if (model && offeredModels.length > 0 && !offeredModels.includes(model)) return `model "${model}" is not offered by runtime "${agent.runtime}"`;
+		const caps = this.runtimeMcpCaps.get(agent.runtime);
+		for (const name of agent.mcpServers) {
+			if (name === "agentconnect") return `MCP server name "${name}" is reserved`;
+			const def = this.mcpServerDefs[name];
+			if (!def) return `MCP server "${name}" is not configured on this daemon`;
+			if (def.transport !== "stdio" && caps && !caps[def.transport]) return `MCP server "${name}" needs unsupported ${def.transport} transport on runtime "${agent.runtime}"`;
+		}
 	}
 	/** §2.5 SIGTERM / daemon shutdown: gate new turns, then await in-flight turns up
 	*  to `shutdownDrainMs`, cancelling stragglers. Safe to call repeatedly. */
@@ -217818,12 +218275,12 @@ var Daemon = class Daemon {
 				if (ignored.length) this.log.warn(`cp: ignored config keys: ${ignored.join(", ")}`);
 			},
 			applyReconcileSnapshot: (snap) => {
-				this.cpAgents?.converge(snap.agents);
-				this.cpIntegrations?.converge(snap.integrations);
+				this.cpAgents?.converge((snap.agents ?? []).filter((agent) => !this.moveStagedAgents.has(agent.agentId)));
+				this.cpIntegrations?.converge((snap.integrations ?? []).filter((integration) => !this.moveStagedAgents.has(integration.agentId)));
 				this.convergeRelays(snap.relays);
 				this.cpCollab.replace(snap.collabRoutes);
 				for (const id of snap.drop.crons) this.cpCrons?.remove(id);
-				this.cpCrons?.converge(snap.crons);
+				this.cpCrons?.converge((snap.crons ?? []).filter((cron) => !this.moveStagedAgents.has(cron.agentId)));
 				this.cpRouting?.converge({
 					routingEpoch: snap.routingEpoch,
 					assignments: snap.assignments,
@@ -217835,16 +218292,164 @@ var Daemon = class Daemon {
 				if (snap.integrations?.length) this.log.debug(`cp: converged ${snap.integrations.length} integration(s)`);
 			},
 			applyAgentUpsert: (agentId, spec) => {
+				if (this.moveStagedAgents.has(agentId)) return;
 				this.gitCreds?.clearDenied(agentId);
 				this.cpAgents?.upsert(agentId, spec);
 			},
 			applyAgentRemove: (agentId) => {
 				this.gitCreds?.remove(agentId);
 				this.cpAgents?.remove(agentId);
+				this.moveStageMetadata.delete(agentId);
+				this.moveStagedAgents.delete(agentId);
+				this.drainingAgents.delete(agentId);
+			},
+			applyAgentDetach: (detach) => {
+				const { agentId, moveId } = detach;
+				return this.queueAgentMove("detach", agentId, moveId, async () => {
+					if (this.opts.agentName) return {
+						ok: false,
+						reason: "agent move is unavailable in --agent single-agent mode"
+					};
+					const previous = this.moveStageMetadata.get(agentId);
+					if (previous?.moveId === moveId && previous.state === "committed") return { ok: true };
+					stageAgentMove(this.agentsDir, agentId, moveId);
+					this.moveStageMetadata.set(agentId, {
+						moveId,
+						state: "staging"
+					});
+					this.moveStagedAgents.add(agentId);
+					this.drainingAgents.add(agentId);
+					await this.stopAgent(agentId);
+					const fence = this.moveStageMetadata.get(agentId);
+					if (fence?.moveId !== moveId || fence.state !== "staging") return {
+						ok: false,
+						reason: "agent/detach: move was superseded"
+					};
+					this.gitCreds?.remove(agentId);
+					this.cpAgents?.detach(agentId);
+					await this.flushReconcile();
+					await this.closeUnusedPlatformConnections();
+					const finalFence = this.moveStageMetadata.get(agentId);
+					if (finalFence?.moveId !== moveId || finalFence.state !== "staging") return {
+						ok: false,
+						reason: "agent/detach: move was superseded"
+					};
+					return { ok: true };
+				});
+			},
+			applyAgentActivate: (activate) => {
+				const { agentId } = activate;
+				return this.queueAgentMove("activate", agentId, activate.moveId, async () => {
+					if (this.opts.agentName) return {
+						ok: false,
+						reason: "agent move is unavailable in --agent single-agent mode"
+					};
+					const stage = this.moveStageMetadata.get(agentId);
+					if (stage?.moveId === activate.moveId && stage.state === "committed") return { ok: true };
+					if (stage?.moveId !== activate.moveId || stage.state !== "staging" || !this.moveStagedAgents.has(agentId) || !this.drainingAgents.has(agentId)) return {
+						ok: false,
+						reason: "agent/activate: staging fence is missing or superseded"
+					};
+					const capacityUsed = this.agents.size + this.activatingAgents.size;
+					if (this.cfg.limits.maxAgents > 0 && capacityUsed >= this.cfg.limits.maxAgents) return {
+						ok: false,
+						reason: `agent/activate: daemon capacity ${capacityUsed}/${this.cfg.limits.maxAgents} is full`
+					};
+					this.activatingAgents.add(agentId);
+					try {
+						if (activate.integrations.some((integration) => integration.agentId !== agentId)) return {
+							ok: false,
+							reason: "agent/activate: integration bundle contains a different agentId"
+						};
+						if (activate.crons.some((cron) => cron.agentId !== agentId)) return {
+							ok: false,
+							reason: "agent/activate: cron bundle contains a different agentId"
+						};
+						this.gitCreds?.clearDenied(agentId);
+						this.cpAgents?.upsert(agentId, activate.spec);
+						for (const integration of activate.integrations) this.cpIntegrations?.upsert(integration);
+						for (const cron of activate.crons) this.cpCrons?.upsert(cron);
+						if ((this.cpAgents?.activate(agentId, {
+							integrationIds: activate.integrations.map((integration) => integration.integrationId),
+							cronIds: activate.crons.map((cron) => cron.cronId)
+						}) ?? "missing") === "missing") return {
+							ok: false,
+							reason: `agent/activate: unknown agent ${agentId}`
+						};
+						this.moveStagedAgents.delete(agentId);
+						try {
+							await this.flushReconcile();
+						} catch (err) {
+							this.moveStagedAgents.add(agentId);
+							await this.stopHost(agentId).catch(() => {});
+							await this.flushReconcile().catch(() => {});
+							throw err;
+						}
+						const agent = this.agents.get(agentId);
+						if (!agent) {
+							this.moveStagedAgents.add(agentId);
+							await this.flushReconcile();
+							return {
+								ok: false,
+								reason: `agent/activate: agent ${agentId} did not reconcile`
+							};
+						}
+						if (!this.runtimes[agent.runtime]) {
+							this.moveStagedAgents.add(agentId);
+							await this.flushReconcile();
+							return {
+								ok: false,
+								reason: `agent/activate: runtime "${agent.runtime}" is unavailable`
+							};
+						}
+						const capabilityError = this.activationCapabilityError(agent);
+						if (capabilityError) {
+							this.moveStagedAgents.add(agentId);
+							await this.flushReconcile();
+							return {
+								ok: false,
+								reason: `agent/activate: ${capabilityError}`
+							};
+						}
+						try {
+							await this.ensureHostAsync(agentId);
+						} catch (err) {
+							this.moveStagedAgents.add(agentId);
+							await this.stopHost(agentId).catch(() => {});
+							await this.flushReconcile().catch(() => {});
+							return {
+								ok: false,
+								reason: `agent/activate: ${err.message}`
+							};
+						}
+						try {
+							commitAgentMove(this.agentsDir, agentId, activate.moveId);
+						} catch (err) {
+							this.moveStagedAgents.add(agentId);
+							await this.flushReconcile().catch(() => {});
+							return {
+								ok: false,
+								reason: `agent/activate: failed to commit staging fence: ${err.message}`
+							};
+						}
+						this.moveStageMetadata.set(agentId, {
+							moveId: activate.moveId,
+							state: "committed"
+						});
+						this.drainingAgents.delete(agentId);
+						return { ok: true };
+					} finally {
+						this.activatingAgents.delete(agentId);
+					}
+				});
+			},
+			applyIntegrationUpsert: (spec) => {
+				if (!this.moveStagedAgents.has(spec.agentId)) this.cpIntegrations?.upsert(spec);
 			},
-			applyIntegrationUpsert: (spec) => this.cpIntegrations?.upsert(spec),
 			applyIntegrationRemove: (integrationId) => this.cpIntegrations?.remove(integrationId),
-			upsertCron: (cron) => this.cpCrons.upsert(cron),
+			upsertCron: (cron) => {
+				if (!this.moveStagedAgents.has(cron.agentId)) this.cpCrons.upsert(cron);
+			},
 			removeCron: (cronId) => this.cpCrons.remove(cronId),
 			runCron: (cronId) => this.runCronNow(cronId),
 			applyRouteAssign: (a) => this.cpRouting?.upsertAssign(a),
@@ -217852,6 +218457,7 @@ var Daemon = class Daemon {
 			applyRelayRoster: (relays) => this.convergeRelays(relays),
 			applyCollabRoutes: (snap) => this.cpCollab.replace(snap),
 			applyAgentLaunch: async (launch) => {
+				if (this.moveStagedAgents.has(launch.agentId)) throw new Error(`agent/launch: agent ${launch.agentId} is staged for a daemon move`);
 				const agent = this.agents.get(launch.agentId);
 				if (!agent) throw new Error(`agent/launch: unknown agent ${launch.agentId}`);
 				this.drainingAgents.delete(launch.agentId);
@@ -218031,7 +218637,7 @@ var Daemon = class Daemon {
 				],
 				runtimes: Object.keys(this.runtimes).map((id) => this.runtimeNames[id] ?? id),
 				acp: true,
-				features: []
+				features: this.opts.agentName ? [] : ["agent-move-v1"]
 			}),
 			runtimeProfiles: () => Object.keys(this.runtimes).map((id) => this.runtimeProfileFor(id)),
 			mcpServerFacts: () => this.mcpServerFacts,
@@ -218165,7 +218771,9 @@ var Daemon = class Daemon {
 		this.scheduler?.stop();
 		await Promise.resolve(this.cpClient?.stop()).catch((e) => errors.push(e));
 		await Promise.resolve(this.relays?.stop()).catch((e) => errors.push(e));
+		for (const run of [...this.slackRetryRuns.values()]) await Promise.resolve(run.promise).catch((e) => errors.push(e));
 		for (const c of this.connections) await Promise.resolve(c.stop()).catch((e) => errors.push(e));
+		for (const c of this.sharedSlackConns.values()) await Promise.resolve(c.stop()).catch((e) => errors.push(e));
 		for (const c of this.telegramConns) await Promise.resolve(c.stop()).catch((e) => errors.push(e));
 		for (const c of this.discordConns) await Promise.resolve(c.stop()).catch((e) => errors.push(e));
 		for (const h of this.hosts.values()) await Promise.resolve(h.stop()).catch((e) => errors.push(e));
@@ -218208,4 +218816,4 @@ async function runForeground(opts, deps = {}) {
 //#endregion
 export { ClientTransport as i, CP_SUBPROTOCOL as n, CP_WS_PATH as r, runForeground as t };
 
-//# sourceMappingURL=run-foreground-D4TMcwTn.js.map
+//# sourceMappingURL=run-foreground-BMjqIzg4.js.map