@agentconnect.md/daemon 1.0.0-rc.280 → 1.0.0-rc.282

package/dist/{run-foreground-1y1IF3Dc.js → run-foreground-BV2scayf.js}

@@ -3,9 +3,9 @@ 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-Amic2B8b.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-DzCnR0cj.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-CrjtbS3A.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-C-4zFhF8.js";
 import { i as GitCredentialCache, n as gitcredSocketPath, r as writeGitcredShim, t as GitCredServer } from "./gitcred-server-CMC80O_1.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";
@@ -4516,6 +4516,9 @@ var CpClient = class {
 			case "relay/roster":
 				this.deps.configApply.applyRelayRoster(frame.payload.relays);
 				return;
+			case "collaboration/routes":
+				this.deps.configApply.applyCollabRoutes(frame.payload);
+				return;
 			case "agent/upsert": {
 				const u = frame.payload;
 				this.deps.configApply.applyAgentUpsert(u.agentId, u.spec);
@@ -197213,6 +197216,18 @@ var RelayClient = class {
 	isReady() {
 		return this.state === "READY";
 	}
+	/**
+	* Send a cross-daemon agent-call to the relay (`rd/agentmsg` REQ, agent-collaboration
+	* §2.3/§6.4) and resolve with the relay's admission verdict. `claimedFromAgentId` is
+	* this daemon's trusted caller — the relay re-validates it against the socket's
+	* authenticated daemonId. Rejects (retryable) if the socket isn't READY.
+	*/
+	async sendAgentMsg(payload) {
+		if (this.state !== "READY") throw new WireError("INTERNAL", `rd link not ready (${this.state})`, true);
+		const rep = await this.sendRequest(buildRelayDaemonFrame("rd/agentmsg", payload));
+		if (rep.type !== "rd/agentmsg/ack") throw new WireError("INTERNAL", `expected rd/agentmsg/ack, got ${rep.type}`, false);
+		return rep.payload;
+	}
 	async attemptConnect() {
 		if (this.stopped || this.fatal) return;
 		const daemonId = this.deps.daemonId();
@@ -197264,6 +197279,10 @@ var RelayClient = class {
 			this.handleMsg(frame.id, frame.payload);
 			return;
 		}
+		if (frame.type === "rd/agentmsg/fwd") {
+			this.handleAgentMsgFwd(frame.id, frame.payload);
+			return;
+		}
 		this.deps.log.debug(`relay(${this.relayId}): ignoring ${frame.type}`);
 	}
 	/** An inbound rd/msg: dispatch it, reply `rd/ack`; only a webchat op streams
@@ -197274,7 +197293,22 @@ var RelayClient = class {
 		const ack = this.deps.onRelayMsg(msg, chat);
 		this.transport?.send(JSON.stringify(buildRelayDaemonFrame("rd/ack", ack, { corr: reqId })));
 	}
-	/** Send one reply chunk back over THIS relay's socket, stamping the per-chat `seq`. */
+	/** A forwarded cross-daemon agent-call: terminal-verify + dispatch, reply the typed
+	*  admission verdict (`rd/agentmsg/ack`, corr = the relay's fwd id). */
+	async handleAgentMsgFwd(reqId, msg) {
+		let ack;
+		try {
+			ack = await this.deps.onRelayAgentMsg(msg);
+		} catch (err) {
+			this.deps.log.error(`relay(${this.relayId}): rd/agentmsg/fwd handler threw: ${err.message}`);
+			ack = {
+				deliveryId: msg.deliveryId,
+				delivered: false,
+				reason: "offline"
+			};
+		}
+		this.transport?.send(JSON.stringify(buildRelayDaemonFrame("rd/agentmsg/ack", ack, { corr: reqId })));
+	}
 	sendChat(chatId, event) {
 		const seq = (this.seqByChat.get(chatId) ?? 0) + 1;
 		this.seqByChat.set(chatId, seq);
@@ -197346,6 +197380,45 @@ var RelayManager = class {
 	size() {
 		return this.clients.size;
 	}
+	/**
+	* Send a cross-daemon agent-call over ANY READY relay (agent-collaboration §2.3/§6.4).
+	* The all-to-all roster means any relay this daemon holds can route the call to the
+	* target's owning daemon via the CP's collaboration snapshot — so we pick the first
+	* READY client. Throws if none is READY (the caller reports the call undeliverable).
+	*/
+	async sendAgentMsg(payload) {
+		for (const client of this.clients.values()) if (client.isReady()) return client.sendAgentMsg(payload);
+		throw new Error("no READY relay to route agent-call");
+	}
+};
+//#endregion
+//#region src/cp/cp-collab-routes.ts
+var CpCollabRoutes = class {
+	generation = -1;
+	channels = /* @__PURE__ */ new Map();
+	key(orgId, platform, channelId) {
+		return orgId + "\0" + platform + "\0" + channelId;
+	}
+	/** FULL-REPLACE from a CP snapshot (converge-don't-diff); ignore an older generation.
+	*  Tolerates an absent snapshot (a pre-collab CP / hand-built test fixture) as a no-op. */
+	replace(snap) {
+		if (!snap) return;
+		if (snap.generation < this.generation) return;
+		this.generation = snap.generation;
+		this.channels.clear();
+		for (const ch of snap.channels) {
+			const byAgent = /* @__PURE__ */ new Map();
+			for (const a of ch.agents) byAgent.set(a.agentId, {
+				...a,
+				orgId: ch.orgId
+			});
+			this.channels.set(this.key(ch.orgId, ch.platform, ch.channelId), byAgent);
+		}
+	}
+	/** The placement of `agentId` in `(orgId,platform,channel)`, or undefined. */
+	resolve(orgId, platform, channelId, agentId) {
+		return this.channels.get(this.key(orgId, platform, channelId))?.get(agentId);
+	}
 };
 //#endregion
 //#region src/slack/permalink.ts
@@ -213861,6 +213934,26 @@ function formatErr(err) {
 	return e?.stack ?? String(err);
 }
 const MAX_QUEUED_PER_SESSION = 10;
+/** Thrown to a `dispatch()` caller when the per-session admission queue is at its depth
+*  cap (§4.4 backpressure): the message is fast-failed, not buffered. Carries a stable
+*  `reason` so an agent-call source (P1/P2) can surface a typed `queue_full`. */
+var QueueFullError = class extends Error {
+	reason = "queue_full";
+	constructor(sessionKey) {
+		super(`admission queue full for session ${sessionKey}`);
+		this.name = "QueueFullError";
+	}
+};
+/** Thrown to the `dispatch()` callers of the messages still queued behind a turn that
+*  FAILED (§6.9 #378 fail-stop): the daemon does not auto-run buffered work onto a broken
+*  session, so each follow-up is rejected rather than silently dropped or force-run. */
+var FailStopError = class extends Error {
+	reason = "fail_stop";
+	constructor(sessionKey) {
+		super(`turn failed for session ${sessionKey}; queued messages were not auto-run`);
+		this.name = "FailStopError";
+	}
+};
 const SELECT_KIND_CODE = {
 	model: "m",
 	effort: "e",
@@ -213897,6 +213990,10 @@ const IDLE_FLUSH_MS = 2e3;
 /** Public Web App console origin used for session deep links when neither a local
 *  `webAppUrl` config nor a CP-provided one is set — so "View session" always resolves. */
 const DEFAULT_WEB_APP_URL = "https://app.agentconnect.md";
+/** Per-in-flight-turn rendering state, keyed by ACP sessionId in `this.pending`. */
+/** Cap on agent→agent hop depth (design §2.4/§4.5) — reject a `messageAgent` that
+*  would push the outgoing hopCount past this, so an A↔B wake loop can't run away. */
+const MAX_AGENT_CALL_HOPS = 8;
 /** Build the wire SessionKey (protocol §5) for a pending turn — what `drain/done`
 *  reports as released so the CP may reassign it. Uses the real `thread` (absent for
 *  a channel-root message), NOT `statusThread` (which falls back to msgId): the CP
@@ -213972,6 +214069,7 @@ var Daemon = class Daemon {
 	cpIntegrations;
 	botUserIds = {};
 	cpRouting;
+	cpCollab = new CpCollabRoutes();
 	clock;
 	requestExit;
 	draining = false;
@@ -214871,8 +214969,10 @@ var Daemon = class Daemon {
 	*  NO mute) shared by the Slack status-bar Cancel button. No-op if nothing is running. */
 	cancelSessionByKey(key) {
 		const rec = this.store.getSession(key);
-		if (!rec?.acpSessionId || !this.pending.has(rec.acpSessionId)) return;
-		this.interruptTurn(rec.agentId, rec.acpSessionId, key, "cancel");
+		if (!this.inflight.has(key)) return;
+		const agentId = rec?.agentId ?? this.serialQueue.get(key)?.[0]?.agentId;
+		if (!agentId) return;
+		this.interruptTurn(agentId, key, "cancel", rec?.acpSessionId ?? void 0);
 	}
 	/** Switch a session's reasoning effort by its local key — the effort counterpart of
 	*  {@link setModelByKey}. Records the sticky override and, if the ACP session is warm,
@@ -214944,9 +215044,16 @@ var Daemon = class Daemon {
 	*  Resolved by conversationId (the op carries no agentId). No-op when idle. */
 	handleWebchatCancel(conversationId) {
 		for (const [acpSessionId, p] of this.pending) if (p.webchat?.conversationId === conversationId) {
-			this.interruptTurn(p.agentId, acpSessionId, p.sessionKey, "cancel");
+			this.interruptTurn(p.agentId, p.sessionKey, "cancel", acpSessionId);
 			return;
 		}
+		for (const [key, entries] of this.serialQueue) {
+			const hit = entries.find((e) => e.webchat?.conversationId === conversationId);
+			if (hit) {
+				this.interruptTurn(hit.agentId, key, "cancel");
+				return;
+			}
+		}
 		this.log.debug(`webchat cancel: no in-flight turn for conversation ${conversationId}`);
 	}
 	relayMsgAcks = /* @__PURE__ */ new Map();
@@ -214998,6 +215105,74 @@ var Daemon = class Daemon {
 			accepted: true
 		};
 	}
+	relayAgentMsgAcks = /* @__PURE__ */ new Map();
+	/**
+	* TARGET side of a cross-daemon `messageAgent` (agent-collaboration §2.3/§6.2, P2) —
+	* the mirror of {@link handleRelayIm} for a relay-forwarded `rd/agentmsg/fwd`. The
+	* relay already validated the caller and minted a TRUSTED claim
+	* (`trustedFromAgentId` + org/channel assertion), but we TERMINAL-VERIFY it against
+	* our OWN local snapshot/spec (defense in depth, §2.5 #4) before dispatching — never
+	* blindly trusting the relay. The ACK is returned on durable ADMISSION (the P4-gate
+	* enqueue), NOT after the model turn (§6.4).
+	*/
+	async handleRelayAgentMsg(msg) {
+		const nak = (reason) => ({
+			deliveryId: msg.deliveryId,
+			delivered: false,
+			...reason ? { reason } : {}
+		});
+		const dedupKey = `${msg.trustedFromAgentId}:${msg.deliveryId}`;
+		const prior = this.relayAgentMsgAcks.get(dedupKey);
+		if (prior) return prior;
+		const record = (ack) => {
+			if (this.relayAgentMsgAcks.size >= 2e3) this.relayAgentMsgAcks.clear();
+			this.relayAgentMsgAcks.set(dedupKey, ack);
+			return ack;
+		};
+		if (msg.hopCount > MAX_AGENT_CALL_HOPS) return record(nak("hop_limit"));
+		const { platform, channel, thread } = msg.coords;
+		if (!this.agents.get(msg.toAgentId)) return record(nak("not_found"));
+		const target = this.cpCollab.resolve(msg.orgId, platform, channel, msg.toAgentId);
+		const caller = this.cpCollab.resolve(msg.orgId, platform, channel, msg.trustedFromAgentId);
+		if (!target || !caller) {
+			this.log.warn(`relay: rd/agentmsg/fwd terminal-verify failed (no placement) for ${msg.toAgentId} — fail closed`);
+			return record(nak("not_allowed"));
+		}
+		if (target.callPolicy === "selected" && !target.allowedCallerAgentIds.includes(msg.trustedFromAgentId)) {
+			this.log.info(`relay: rd/agentmsg/fwd not_allowed — ${msg.trustedFromAgentId} → ${msg.toAgentId} (selected)`);
+			return record(nak("not_allowed"));
+		}
+		const callMeta = {
+			callFrom: msg.trustedFromAgentId,
+			...msg.correlationId !== void 0 ? { correlationId: msg.correlationId } : {},
+			hopCount: msg.hopCount,
+			deliveryId: msg.deliveryId
+		};
+		const narrowed = this.narrowPlatform(platform);
+		const resolved = this.resolveCpAgent(msg.toAgentId);
+		const integrationId = msg.integrationId ?? resolved?.integrationId;
+		const normalized = {
+			msgId: `agentcall:${channel}:${msg.deliveryId}`,
+			traceId: msg.deliveryId,
+			source: "agent",
+			platform: narrowed,
+			channel,
+			...thread !== void 0 ? { thread } : {},
+			sender: {
+				id: msg.trustedFromAgentId,
+				isBot: true
+			},
+			text: `@${msg.trustedFromAgentId} asked:\n${msg.text}`,
+			mentionedBots: resolved?.botUserId ? [resolved.botUserId] : [],
+			isDm: false
+		};
+		this.dispatch(msg.toAgentId, normalized, integrationId, void 0, callMeta).catch((err) => this.log.error(`relay agentmsg dispatch failed for agent "${msg.toAgentId}": ${formatErr(err)}`));
+		this.log.info(`relay: rd/agentmsg/fwd ${msg.trustedFromAgentId} → ${msg.toAgentId} delivery=${msg.deliveryId}`);
+		return record({
+			deliveryId: msg.deliveryId,
+			delivered: true
+		});
+	}
 	/**
 	* Same-daemon agent→agent delivery — the impl behind the `messageAgent` MCP tool
 	* (design §2.2/§2.3, P1). Wakes `toAgentId` by constructing a NormalizedMessage at
@@ -215032,11 +215207,16 @@ var Daemon = class Daemon {
 			return result;
 		};
 		const target = this.agents.get(req.toAgentId);
-		if (!target) return record({
-			delivered: false,
-			targetSession,
-			reason: "not_local"
-		});
+		if (!target) {
+			const coordPlatform = platform === "hook" ? "slack" : platform;
+			return record(await this.routeAgentMsgCrossDaemon(req, {
+				platform: coordPlatform,
+				channel,
+				thread,
+				deliveryId,
+				targetSession
+			}));
+		}
 		if (target.callPolicy === "selected" && !target.allowedCallerAgentIds.includes(req.callerAgentId)) {
 			this.log.info(`messageAgent: ${req.callerAgentId} not allowed to call ${req.toAgentId} (policy=selected)`);
 			return record({
@@ -215077,6 +215257,53 @@ var Daemon = class Daemon {
 			targetSession
 		});
 	}
+	/**
+	* Route a cross-daemon `messageAgent` over the relay data plane (agent-collaboration
+	* §2.3/§6.2/§6.4, P2) and map the relay's typed admission verdict to a
+	* {@link MessageAgentResult}. The `claimedFromAgentId` is our trusted caller — the
+	* relay re-validates it against our authenticated daemonId (a forged claim is
+	* rejected there). `hopCount` is the source turn's depth (0 in P1's minimal
+	* cross-turn model); the relay increments it (+1, cap 8). The body never touches
+	* the CP — only the relay.
+	*/
+	async routeAgentMsgCrossDaemon(req, ctx) {
+		if (!this.relays) return {
+			delivered: false,
+			targetSession: ctx.targetSession,
+			reason: "not_local"
+		};
+		try {
+			const ack = await this.relays.sendAgentMsg({
+				claimedFromAgentId: req.callerAgentId,
+				toAgentId: req.toAgentId,
+				text: req.text,
+				coords: {
+					platform: ctx.platform,
+					channel: ctx.channel,
+					...ctx.thread !== void 0 ? { thread: ctx.thread } : {}
+				},
+				...req.correlationId !== void 0 ? { correlationId: req.correlationId } : {},
+				hopCount: 0,
+				deliveryId: ctx.deliveryId
+			});
+			if (ack.delivered) return {
+				delivered: true,
+				targetSession: ctx.targetSession
+			};
+			return {
+				delivered: false,
+				targetSession: ctx.targetSession,
+				...ack.reason ? { reason: ack.reason } : {}
+			};
+		} catch (err) {
+			this.log.warn(`messageAgent: cross-daemon route failed for ${req.toAgentId}: ${formatErr(err)}`);
+			return {
+				delivered: false,
+				targetSession: ctx.targetSession,
+				reason: "offline"
+			};
+		}
+	}
 	/** Narrow the trusted session-context platform string to the NormalizedMessage union;
 	*  falls back to 'slack' for an unrecognized value (coords still resolve — the union is
 	*  a routing/key detail, not the trust basis). */
@@ -215308,7 +215535,8 @@ var Daemon = class Daemon {
 			};
 		});
 	}
-	queued = /* @__PURE__ */ new Map();
+	inflight = /* @__PURE__ */ new Set();
+	serialQueue = /* @__PURE__ */ new Map();
 	/**
 	* Resolve a command's target from the channel's latest session when the routing ladder
 	* couldn't (no mention entity / thread / dm rule matched — e.g. a group `/status@bot`).
@@ -215357,7 +215585,7 @@ var Daemon = class Daemon {
 			}
 		}
 		const acpSessionId = rec?.acpSessionId;
-		const inflight = !!(acpSessionId && this.pending.has(acpSessionId));
+		const inflight = this.inflight.has(key);
 		const tgReplyTo = this.telegramReplyTarget(msg);
 		const reply = (text) => {
 			if (!conn) return;
@@ -215371,7 +215599,7 @@ var Daemon = class Daemon {
 				reply(rec ? `🔇 Nothing is running. ${muteNote}` : "Nothing is running to stop.");
 				return;
 			}
-			this.interruptTurn(target.agentId, acpSessionId, key, "stop");
+			this.interruptTurn(target.agentId, key, "stop", acpSessionId ?? void 0);
 			reply(`🛑 Stopped. ${muteNote}`);
 			return;
 		}
@@ -215380,7 +215608,7 @@ var Daemon = class Daemon {
 				reply("Nothing is running to cancel.");
 				return;
 			}
-			this.interruptTurn(target.agentId, acpSessionId, key, "cancel");
+			this.interruptTurn(target.agentId, key, "cancel", acpSessionId ?? void 0);
 			reply("🛑 Cancelled.");
 			return;
 		}
@@ -215446,21 +215674,23 @@ var Daemon = class Daemon {
 			text: command.text,
 			thread
 		};
-		if (!inflight) {
-			this.log.info(`command: queue → agent "${target.agentId}" idle, dispatching now`);
-			this.dispatch(target.agentId, payload, target.integrationId).catch((err) => this.log.error(`queued dispatch failed for agent "${target.agentId}": ${err.stack ?? err}`));
-			return;
-		}
-		const q = this.queued.get(acpSessionId) ?? [];
-		if (q.length >= MAX_QUEUED_PER_SESSION) {
-			this.log.warn(`command: queue → agent "${target.agentId}" session ${acpSessionId} full (${q.length}), rejected`);
+		if (inflight && (this.serialQueue.get(key)?.length ?? 0) >= MAX_QUEUED_PER_SESSION) {
+			this.log.warn(`command: queue → agent "${target.agentId}" session ${key} full, rejected`);
 			reply(`Queue is full (${MAX_QUEUED_PER_SESSION} pending) — wait for the current turn to finish.`);
 			return;
 		}
-		q.push(payload);
-		this.queued.set(acpSessionId, q);
-		this.log.info(`command: queue → agent "${target.agentId}" session ${acpSessionId} (depth ${q.length})`);
-		reply(`📥 Queued (#${q.length}) — will run when the current turn finishes.`);
+		this.dispatch(target.agentId, payload, target.integrationId, void 0, void 0, { isQueueCmd: true }).catch((err) => {
+			if (err instanceof QueueFullError) return;
+			this.log.error(`queued dispatch failed for agent "${target.agentId}": ${err.stack ?? err}`);
+		});
+		if (!inflight) {
+			this.log.info(`command: queue → agent "${target.agentId}" idle, dispatching now`);
+			reply(`▶️ Running now — the session was idle.`);
+		} else {
+			const depth = this.serialQueue.get(key)?.length ?? 0;
+			this.log.info(`command: queue → agent "${target.agentId}" session ${key} (depth ${depth})`);
+			reply(`📥 Queued (#${depth}) — will run when the current turn finishes.`);
+		}
 	}
 	selectLabel(kind) {
 		return kind === "model" ? "Model" : kind === "effort" ? "Reasoning effort" : "Permission mode";
@@ -215591,15 +215821,6 @@ var Daemon = class Daemon {
 			acpSessionId: latest.acpSessionId ?? void 0
 		};
 	}
-	/** Drain one buffered message for a session whose turn just finished (FIFO). */
-	flushQueued(agentId, sessionId, integrationId) {
-		const q = this.queued.get(sessionId);
-		if (!q || q.length === 0) return;
-		const next = q.shift();
-		if (q.length === 0) this.queued.delete(sessionId);
-		this.log.info(`queue: dispatching buffered message to agent "${agentId}" session ${sessionId} (${q.length} left)`);
-		this.dispatch(agentId, next, integrationId).catch((err) => this.log.error(`queued dispatch failed for agent "${agentId}": ${err.stack ?? err}`));
-	}
 	/** Local layer (agent.json) ∪ resolved CP layer; unservable CP rules are dropped + warn-logged. */
 	mergedRules() {
 		const local = [...this.agents.values()].flatMap((a) => rulesFromAgent(a, this.botUserIds));
@@ -215646,21 +215867,116 @@ var Daemon = class Daemon {
 			ctx.replyConn.postMessage(ctx.channel, `⚠️ Agent failed to respond: ${reason}`, ctx.thread);
 		}
 	}
-	async dispatch(agentId, msg, integrationId, webchat, callMeta) {
-		if (this.draining || this.drainingAgents.has(agentId)) {
-			this.log.debug(`dispatch: skipped for agent "${agentId}" (draining)`);
-			return null;
+	/**
+	* Terminate a QUEUED entry's webchat sink when it is gate-dropped/rejected without ever
+	* entering dispatchOne (drain/pause gate-drop, fail-stop of the queued rest, `!cancel`/`!stop`
+	* queue drop, shutdown). A webchat turn signals its client via the WebchatSink terminal
+	* `done` frame, NOT the dispatch() promise — so settling the promise alone leaves the browser
+	* UI spinning forever. Mirrors surfaceTurnFailure's webchat branch. No-op for non-webchat
+	* entries. Pass an `error` for reject/cancel/shutdown; omit it for a clean gate-drop.
+	*/
+	terminateQueuedSink(entry, error) {
+		if (!entry.webchat) return;
+		entry.webchat.sink.done({
+			conversationId: entry.webchat.conversationId,
+			turnId: entry.webchat.turnId,
+			...error ? { error } : {}
+		});
+	}
+	dispatch(agentId, msg, integrationId, webchat, callMeta, opts) {
+		return new Promise((resolve, reject) => {
+			if (this.draining || this.drainingAgents.has(agentId)) {
+				this.log.debug(`dispatch: skipped for agent "${agentId}" (draining)`);
+				resolve(null);
+				return;
+			}
+			if (this.agents.get(agentId).pause) {
+				this.log.info(`dispatch: skipped for agent "${agentId}" (paused)`);
+				resolve(null);
+				return;
+			}
+			const key = sessionKey(msg.platform, msg.channel, msg.thread ?? msg.msgId, agentId);
+			const entry = {
+				agentId,
+				msg,
+				...integrationId !== void 0 ? { integrationId } : {},
+				...webchat ? { webchat } : {},
+				...callMeta ? { callMeta } : {},
+				...opts?.isQueueCmd ? { isQueueCmd: true } : {},
+				resolve,
+				reject
+			};
+			if (this.inflight.has(key)) {
+				const q = this.serialQueue.get(key) ?? [];
+				if (q.length >= MAX_QUEUED_PER_SESSION) {
+					this.log.warn(`dispatch: queue full for session ${key} (${q.length}) — rejecting (queue_full)`);
+					reject(new QueueFullError(key));
+					return;
+				}
+				q.push(entry);
+				this.serialQueue.set(key, q);
+				this.log.debug(`dispatch: queued behind in-flight turn for session ${key} (depth ${q.length})`);
+				return;
+			}
+			this.inflight.add(key);
+			this.runLoop(key, entry);
+		});
+	}
+	/**
+	* Own a sessionKey's serial gate: run its head turn to completion, settle that entry's
+	* own promise, then drain the queue in FIFO order WITHOUT releasing ownership between
+	* turns (§6.9 #390 — deleting `inflight` then dequeuing would reopen the FIFO race).
+	* Ownership is released only once the queue is confirmed empty in the same synchronous
+	* tick. Fail-stop is the default (§6.9 #378): if a turn throws, the rest of the queue is
+	* NOT auto-run — each remaining entry is rejected with a notice and the queue cleared,
+	* so buffered work never chains onto a broken session.
+	*/
+	paused(agentId) {
+		return this.agents.get(agentId)?.pause === true;
+	}
+	async runLoop(key, firstEntry) {
+		let entry = firstEntry;
+		while (entry) {
+			if (entry !== firstEntry && (this.draining || this.drainingAgents.has(entry.agentId) || this.paused(entry.agentId))) {
+				this.terminateQueuedSink(entry);
+				entry.resolve(null);
+				const rest = this.serialQueue.get(key) ?? [];
+				this.serialQueue.delete(key);
+				for (const e of rest) {
+					this.terminateQueuedSink(e);
+					e.resolve(null);
+				}
+				this.inflight.delete(key);
+				return;
+			}
+			try {
+				const sessionId = await this.dispatchOne(entry, key);
+				entry.resolve(sessionId);
+			} catch (err) {
+				entry.reject(err);
+				const rest = this.serialQueue.get(key) ?? [];
+				this.serialQueue.delete(key);
+				for (const e of rest) {
+					const failStop = new FailStopError(key);
+					this.terminateQueuedSink(e, failStop.message);
+					e.reject(failStop);
+				}
+				this.inflight.delete(key);
+				return;
+			}
+			const q = this.serialQueue.get(key);
+			entry = q?.shift();
+			if (q && q.length === 0) this.serialQueue.delete(key);
 		}
+		this.inflight.delete(key);
+	}
+	async dispatchOne(entry, key) {
+		const { agentId, msg, integrationId, webchat, callMeta } = entry;
 		const agent = this.agents.get(agentId);
-		if (agent.pause) {
-			this.log.info(`dispatch: skipped for agent "${agentId}" (paused)`);
-			return null;
-		}
 		const rec = new TranscriptRecorder();
 		const replyConn = msg.headless || webchat ? void 0 : this.replyConnFor(agentId, integrationId);
 		const wasRunning = this.hostStarts.has(agentId);
 		const statusThread = msg.thread ?? msg.msgId;
-		const key = sessionKey(msg.platform, msg.channel, statusThread, agentId);
 		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…");
@@ -215799,18 +216115,28 @@ var Daemon = class Daemon {
 			this.clearCancelBackstop(sessionId);
 			p.resolveDone();
 		}
-		this.flushQueued(agentId, sessionId, integrationId);
 		return sessionId;
 	}
-	/** Interrupt an in-flight turn (shared by `!stop`, `!cancel`, and webchat cancel):
-	*  drop anything queued behind it, mark the session `cancelling`, send ACP
-	*  `session/cancel`, and arm the force backstop. Muting is the CALLER's concern —
-	*  `!stop` mutes, `!cancel`/webchat-cancel do not. `reason` is just for the log line. */
-	interruptTurn(agentId, acpSessionId, key, reason) {
-		this.queued.delete(acpSessionId);
+	/** Interrupt a session by its LOGICAL sessionKey (shared by `!stop`, `!cancel`, and
+	*  webchat cancel): reject+drop anything queued behind it in the serial gate, then — if
+	*  a turn is actually in flight (ACP session live) — release any unanswered cards, mark
+	*  it `cancelling`, send ACP `session/cancel`, and arm the force backstop. Works for a
+	*  queued-but-not-yet-started or cold session too (§6.9 #390): draining the queue is
+	*  enough, no ACP id required. Muting is the CALLER's concern — `!stop` mutes,
+	*  `!cancel`/webchat-cancel do not. */
+	interruptTurn(agentId, key, reason, acpSessionId) {
+		const queued = this.serialQueue.get(key);
+		if (queued && queued.length > 0) {
+			this.serialQueue.delete(key);
+			for (const e of queued) {
+				this.terminateQueuedSink(e, reason);
+				e.reject(new FailStopError(key));
+			}
+		}
+		this.log.info(`command: ${reason} → agent "${agentId}" session ${key}${acpSessionId ? ` (${acpSessionId})` : ""}`);
+		if (!acpSessionId || !this.pending.has(acpSessionId)) return;
 		this.releasePermissions(acpSessionId);
 		this.releaseElicits(acpSessionId);
-		this.log.info(`command: ${reason} → agent "${agentId}" session ${acpSessionId}`);
 		this.store.setSessionState(key, "cancelling", this.clock.now());
 		this.hosts.get(agentId)?.cancel(acpSessionId).catch((err) => this.log.error(`command ${reason}: cancel failed: ${err.message}`));
 		this.armCancelBackstop(agentId, acpSessionId, key);
@@ -216723,13 +217049,24 @@ var Daemon = class Daemon {
 	async drainForShutdown() {
 		this.draining = true;
 		const live = [...this.pending.values()];
-		if (live.length === 0) return;
-		const deadlineMs = this.cfg.limits.shutdownDrainMs;
-		this.log.info(`shutdown: draining ${live.length} in-flight turn(s) (deadline ${Math.round(deadlineMs / 1e3)}s)`);
-		if (await this.raceDeadline(Promise.all(live.map((p) => p.done)), deadlineMs) === "timeout") {
-			this.log.warn(`shutdown: deadline hit with ${this.pending.size} turn(s) still in flight — cancelling`);
-			for (const [sid, p] of this.pending) await this.hosts.get(p.agentId)?.cancel(sid).catch(() => {});
+		if (live.length > 0) {
+			const deadlineMs = this.cfg.limits.shutdownDrainMs;
+			this.log.info(`shutdown: draining ${live.length} in-flight turn(s) (deadline ${Math.round(deadlineMs / 1e3)}s)`);
+			if (await this.raceDeadline(Promise.all(live.map((p) => p.done)), deadlineMs) === "timeout") {
+				this.log.warn(`shutdown: deadline hit with ${this.pending.size} turn(s) still in flight — cancelling`);
+				for (const [sid, p] of this.pending) await this.hosts.get(p.agentId)?.cancel(sid).catch(() => {});
+			}
+		}
+		this.settleQueuedForShutdown();
+	}
+	/** Reject and clear every entry still in the serial gate's queues (shutdown/teardown),
+	*  so no admitted-but-unrun message leaves an unsettled dispatch() promise. */
+	settleQueuedForShutdown() {
+		for (const [key, entries] of this.serialQueue) for (const e of entries) {
+			this.terminateQueuedSink(e, "daemon shutting down");
+			e.reject(new FailStopError(key));
 		}
+		this.serialQueue.clear();
 	}
 	/** daemon/restart + daemon/upgrade (§8.3): ack now, then drain + stop + exit so
 	*  the supervisor relaunches (the new binary, for upgrade). */
@@ -216762,6 +217099,7 @@ var Daemon = class Daemon {
 				this.cpAgents?.converge(snap.agents);
 				this.cpIntegrations?.converge(snap.integrations);
 				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.cpRouting?.converge({
@@ -216790,6 +217128,7 @@ var Daemon = class Daemon {
 			applyRouteAssign: (a) => this.cpRouting?.upsertAssign(a),
 			applyRouteUpdate: (u) => this.cpRouting?.applyUpdate(u),
 			applyRelayRoster: (relays) => this.convergeRelays(relays),
+			applyCollabRoutes: (snap) => this.cpCollab.replace(snap),
 			applyAgentLaunch: async (launch) => {
 				const agent = this.agents.get(launch.agentId);
 				if (!agent) throw new Error(`agent/launch: unknown agent ${launch.agentId}`);
@@ -216926,7 +217265,8 @@ var Daemon = class Daemon {
 				path: RELAY_DAEMON_WS_PATH
 			}),
 			log: this.log,
-			onRelayMsg: (msg, chat) => this.handleRelayMsg(msg, chat)
+			onRelayMsg: (msg, chat) => this.handleRelayMsg(msg, chat),
+			onRelayAgentMsg: (msg) => this.handleRelayAgentMsg(msg)
 		});
 		if (this.cfg.relays.length) this.relays.converge(this.cfg.relays);
 		this.cpClient = new CpClient({
@@ -217133,4 +217473,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-1y1IF3Dc.js.map
+//# sourceMappingURL=run-foreground-BV2scayf.js.map