@agentconnect.md/daemon 1.0.0-rc.318 → 1.0.0-rc.319

package/dist/{run-foreground-Ce7nBe9z.js → run-foreground-BRT8VM8Q.js}

@@ -6,7 +6,7 @@ import { C as _coercedNumber, T as NEVER, a as array, d as literal, f as looseOb
 import { a as RELAY_DAEMON_WS_PATH, c as SHARED_CONFIG_ACTION_ID, d as encode, f as MAX_FRAME_BYTES, g as ZodIssueCode, h as RESERVED_MCP_SERVER_NAME, i as RELAY_DAEMON_SUBPROTOCOL, l as buildEnvelope, n as gitRepoLabel, o as buildRelayDaemonFrame, r as normalizeGitUrl, s as decodeRelayDaemonFrame, u as decodeEnvelope } from "./dist-BG425zHm.js";
 import { a as agentChildEnv, c as persistRelays, i as selectAgent, n as findAgentFiles, o as loadConfig, r as loadAgents, s as persistDaemonId } from "./load-agents-CROyMyq9.js";
 import { l as resolveRoot, o as mcpSocketPath, u as statePath } from "./paths-DEcUO8lC.js";
-import { C as cachedRuntimeVersions, S as cachedRuntimeNames, _ as resolveInMemoryDir, a as prepareWorkspace, b as MEMORY_TOOL_NAMES, c as sessionGitEnv, d as memoryKindOf, f as memoryProviderFor, g as listMemory, h as MemoryTooLargeError, i as prefetchWorkspace, l as simpleGit, m as MemoryPathError, n as turnFailureReason, o as initGitInjection, p as MemoryConflictError, r as installedRuntimes, s as probeGitVersion, t as AcpHost, u as createMemoryProvider, v as writeMemoryFile, w as resolveRuntimes, x as toolsForIntegrations, y as ALL_TOOL_NAMES } from "./acp-host-4pA0zUPK.js";
+import { C as cachedRuntimeVersions, S as cachedRuntimeNames, _ as resolveInMemoryDir, a as prepareWorkspace, b as MEMORY_TOOL_NAMES, c as sessionGitEnv, d as memoryKindOf, f as memoryProviderFor, g as listMemory, h as MemoryTooLargeError, i as prefetchWorkspace, l as simpleGit, m as MemoryPathError, n as turnFailureReason, o as initGitInjection, p as MemoryConflictError, r as installedRuntimes, s as probeGitVersion, t as AcpHost, u as createMemoryProvider, v as writeMemoryFile, w as resolveRuntimes, x as toolsForIntegrations, y as ALL_TOOL_NAMES } from "./acp-host-Dsm0i9DH.js";
 import { i as GitCredentialCache, n as gitcredSocketPath, r as writeGitcredShim, t as GitCredServer } from "./gitcred-server-Bu-Svl7L.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 { createRequire } from "node:module";
@@ -6581,6 +6581,11 @@ var LocalStore = class {
 	getSessionByAcpId(acpSessionId) {
 		return this.db.prepare("SELECT * FROM sessions WHERE acpSessionId = ?").get(acpSessionId);
 	}
+	/** Agent-scoped ACP id lookup for callbacks from one runtime process. ACP ids
+	*  are runtime-owned and need not be globally unique across agents. */
+	getSessionByAcpIdForAgent(agentId, acpSessionId) {
+		return this.db.prepare("SELECT * FROM sessions WHERE agentId = ? AND acpSessionId = ?").get(agentId, acpSessionId);
+	}
 	/**
 	* One newest-first page of a thread's full transcript (all kinds), for `session/history`.
 	* Pages backward via `beforeSeq` (the lowest seq already seen; null ⇒ newest page).
@@ -6656,7 +6661,7 @@ var LocalStore = class {
 			throw err;
 		}
 	}
-	/** Human-facing session title from the runtime's `session_info_update` (latest
+	/** Human-facing session title from ACP or the AgentConnect title tool (latest
 	*  wins; null clears per ACP semantics). No-op on an unknown key. */
 	setSessionTitle(key, title) {
 		this.db.prepare("UPDATE sessions SET title = ? WHERE key = ?").run(title, key);
@@ -6841,10 +6846,10 @@ var LocalStore = class {
 		return this.db.prepare("SELECT * FROM transcript WHERE channel = ? AND thread = ? AND kind = 'text' AND ts > ? ORDER BY ts ASC").all(channel, thread, sinceTs);
 	}
 	/** The earliest inbound (non-agent) `text` message in a thread — the triggering user
-	*  message. Used as a session-title fallback when the runtime never pushed one
-	*  (`setSessionTitle`): many runtimes don't (e.g. the webchat/playground path), so
-	*  without this the console shows only "Session <id>". Returns undefined when the
-	*  thread holds no non-agent text row yet. Indexed by (channel, thread, seq). */
+	*  message. Used as a session-title fallback when neither ACP nor the title tool
+	*  supplied one. Before the first meaningful request, this avoids showing only
+	*  "Session <id>". Returns undefined when the thread holds no non-agent text row
+	*  yet. Indexed by (channel, thread, seq). */
 	firstMessageText(channel, thread, agentId) {
 		return this.db.prepare("SELECT text FROM transcript WHERE channel = ? AND thread = ? AND kind = 'text' AND sender != ? ORDER BY seq ASC LIMIT 1").get(channel, thread, agentId)?.text;
 	}
@@ -7275,7 +7280,7 @@ var SessionManager = class {
 		const dormant = this.deps.store.closedSessionAgents(channel, thread);
 		return dormant.length === 1 ? dormant[0] : null;
 	}
-	async handle(agentId, msg, signal) {
+	async handle(agentId, msg, signal, integrationId) {
 		const agent = this.deps.agentById(agentId);
 		if (!agent) throw new Error(`unknown agent ${agentId}`);
 		this.deps.memory.ensure({ agentId }, agent.name);
@@ -7306,7 +7311,12 @@ You keep a persistent memory across sessions; below is its INDEX. Your context i
 			`- Source: ${msg.platform}`,
 			`- Channel: ${msg.channel}`,
 			...channelName ? [`- Channel name: ${channelName}`] : [],
-			...agent.description ? ["", agent.description] : []
+			...agent.description ? ["", agent.description] : [],
+			...this.deps.mcpServersFor ? [
+				"",
+				"# Session naming",
+				"Before sending your first substantive answer, after you understand the first meaningful user request (not a greeting or acknowledgement), call `setSessionTitle` with a concise, specific title. Call it again only if the task focus materially changes. Do not mention this housekeeping action."
+			] : []
 		].join("\n");
 		const sessionContext = [
 			agentMeta,
@@ -7322,7 +7332,9 @@ You keep a persistent memory across sessions; below is its INDEX. Your context i
 				agent,
 				platform: msg.platform,
 				channel: msg.channel,
-				thread
+				thread,
+				...integrationId !== void 0 ? { integrationId } : {},
+				isDm: msg.isDm
 			}) ?? [];
 			const acpSessionId = await abortable(() => host.newSession(cwd, mcpServers, effortOverride, metaContext), signal);
 			created = true;
@@ -7346,7 +7358,9 @@ You keep a persistent memory across sessions; below is its INDEX. Your context i
 				agent,
 				platform: msg.platform,
 				channel: msg.channel,
-				thread
+				thread,
+				...integrationId !== void 0 ? { integrationId } : {},
+				isDm: msg.isDm
 			}) ?? [];
 			let resumed = false;
 			if (host.loadSupported?.()) {
@@ -7565,6 +7579,21 @@ function guessMimeFromUrl(url) {
 */
 async function executeTool(ctx, name, args, deps) {
 	if (deps.canRun && !deps.canRun(ctx)) throw new Error("this agent turn has been stopped");
+	if (name === "setSessionTitle") {
+		const title = requireString(args, "title").replace(/\s+/g, " ").trim();
+		if (!title) throw new Error("missing required string argument: title");
+		if ([...title].length > 80) throw new Error("session title must be at most 80 characters");
+		await deps.setSessionTitle({
+			agentId: ctx.agentId,
+			platform: ctx.platform,
+			...ctx.integrationId !== void 0 ? { integrationId: ctx.integrationId } : {},
+			isDm: ctx.isDm,
+			channel: ctx.channel,
+			thread: ctx.thread,
+			title
+		});
+		return { mcpContent: [] };
+	}
 	if (name === "listMemory" || name === "readMemory" || name === "writeMemory") {
 		const scope = { agentId: ctx.agentId };
 		try {
@@ -215484,7 +215513,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`. */
+/** ACP session ids are scoped to one agent runtime, not globally unique. */
+function pendingTurnKey(agentId, acpSessionId) {
+	return JSON.stringify([agentId, acpSessionId]);
+}
 /** 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;
@@ -215616,6 +215648,9 @@ var Daemon = class Daemon {
 	activeDispatchesByAgent = /* @__PURE__ */ new Map();
 	activeDispatchDoneByKey = /* @__PURE__ */ new Map();
 	activeReplyConnectionUses = /* @__PURE__ */ new Map();
+	sessionDeliveryBindings = /* @__PURE__ */ new Map();
+	sessionInitializationsByAgent = /* @__PURE__ */ new Map();
+	earlySessionMetadata = /* @__PURE__ */ new Map();
 	hostStopping = /* @__PURE__ */ new Map();
 	idleSweepTimer;
 	cancelTimers = /* @__PURE__ */ new Map();
@@ -215739,6 +215774,7 @@ var Daemon = class Daemon {
 				const active = this.activeGateEntries.get(key);
 				return !this.paused(ctx.agentId) && active !== void 0 && !active.cancelledReason;
 			},
+			setSessionTitle: (req) => this.setSessionTitleFromTool(req),
 			gatewayFor: (integrationId) => this.connByIntegration.get(integrationId) ?? this.tgConnByIntegration.get(integrationId) ?? this.dcConnByIntegration.get(integrationId),
 			channelAgents: (req) => {
 				const client = this.cpClient;
@@ -215767,16 +215803,16 @@ var Daemon = class Daemon {
 			hostFor: (agentId) => this.ensureHostAsync(agentId),
 			agentById: (id) => this.agents.get(id),
 			memory: this.memory,
-			mcpServersFor: ({ agent, platform, channel, thread }) => {
+			mcpServersFor: ({ agent, platform, channel, thread, integrationId, isDm }) => {
 				const servers = [];
 				let tools = toolsForIntegrations(agent.integrations);
 				if (memoryKindOf(agent) === "native") tools = tools.filter((t) => !MEMORY_TOOL_NAMES.has(t.name));
-				const integrationId = agent.integrations[0]?.id;
 				if (tools.length > 0) {
 					const token = this.mcp.register({
 						agentId: agent.id,
 						platform,
 						...integrationId ? { integrationId } : {},
+						isDm,
 						channel,
 						thread,
 						tools
@@ -216677,7 +216713,7 @@ var Daemon = class Daemon {
 		const host = this.hosts.get(rec.agentId);
 		if (!acpSessionId || !host?.hasSession(acpSessionId)) return;
 		host.setSessionModel(acpSessionId, model).then((applied) => {
-			const p = this.pending.get(acpSessionId);
+			const p = this.pending.get(pendingTurnKey(rec.agentId, acpSessionId));
 			if (applied && p) this.emitStatusBar(p);
 		}).catch((err) => this.log.warn(`set-model failed: ${err.message}`));
 	}
@@ -216743,7 +216779,7 @@ var Daemon = class Daemon {
 	*  (model / effort / fast) is reflected. No-op when the session is idle. */
 	refreshStatusBarForKey(key) {
 		const rec = this.store.getSession(key);
-		const p = rec?.acpSessionId ? this.pending.get(rec.acpSessionId) : void 0;
+		const p = rec?.acpSessionId ? this.pending.get(pendingTurnKey(rec.agentId, rec.acpSessionId)) : void 0;
 		if (p) this.emitStatusBar(p);
 	}
 	/** Set a session's Slack output verbosity by its local key. Purely daemon-side (no ACP):
@@ -216759,8 +216795,8 @@ var Daemon = class Daemon {
 	*  the conversation's in-flight turn like `!cancel` (no mute; follow-ups still dispatch).
 	*  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, p.sessionKey, "cancel", acpSessionId);
+		for (const p of this.pending.values()) if (p.webchat?.conversationId === conversationId) {
+			this.interruptTurn(p.agentId, p.sessionKey, "cancel", p.acpSessionId);
 			return;
 		}
 		for (const [key, entry] of this.activeGateEntries) if (entry.webchat?.conversationId === conversationId) {
@@ -218062,9 +218098,9 @@ var Daemon = class Daemon {
 			entry.cancelledReason = "loop protection";
 			targets.set(key, { agentId: entry.agentId });
 		}
-		for (const [acpSessionId, pending] of this.pending) if (pending.loopGuardScope === scope) targets.set(pending.sessionKey, {
+		for (const pending of this.pending.values()) if (pending.loopGuardScope === scope) targets.set(pending.sessionKey, {
 			agentId: pending.agentId,
-			acpSessionId
+			acpSessionId: pending.acpSessionId
 		});
 		for (const [key, queued] of this.serialQueue) {
 			const entry = queued.find((candidate) => loopGuardScope(candidate.msg) === scope);
@@ -218371,10 +218407,26 @@ var Daemon = class Daemon {
 		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);
+		const previousDeliveryBinding = this.sessionDeliveryBindings.get(key);
+		const deliveryBinding = {
+			agentId,
+			platform: msg.platform,
+			...integrationId !== void 0 ? { integrationId } : {},
+			isDm: msg.isDm
+		};
+		this.sessionDeliveryBindings.set(key, deliveryBinding);
+		this.sessionInitializationsByAgent.set(agentId, (this.sessionInitializationsByAgent.get(agentId) ?? 0) + 1);
+		const restoreDeliveryBinding = () => {
+			if (this.sessionDeliveryBindings.get(key) !== deliveryBinding) return;
+			if (previousDeliveryBinding) this.sessionDeliveryBindings.set(key, previousDeliveryBinding);
+			else this.sessionDeliveryBindings.delete(key);
+		};
 		let handled;
 		try {
-			handled = await this.sessions.handle(agentId, msg, entry.initAbort.signal);
+			handled = await this.sessions.handle(agentId, msg, entry.initAbort.signal, integrationId);
 		} catch (err) {
+			this.finishSessionInitialization(agentId);
+			restoreDeliveryBinding();
 			const interrupted = this.dispatchGateReason(entry);
 			try {
 				this.store.setSessionState(key, "idle", this.clock.now());
@@ -218398,6 +218450,8 @@ var Daemon = class Daemon {
 		const { sessionId, blocks, created } = handled;
 		const initializedGate = this.dispatchGateReason(entry);
 		if (initializedGate) {
+			this.finishSessionInitialization(agentId);
+			restoreDeliveryBinding();
 			const interruptedSession = this.store.getSession(key);
 			if (created && interruptedSession?.acpSessionId === sessionId) this.store.upsertSession({
 				...interruptedSession,
@@ -218421,6 +218475,7 @@ var Daemon = class Daemon {
 			channel: msg.channel,
 			thread: statusThread
 		});
+		this.finishSessionInitialization(agentId, sessionId);
 		let resolveDone;
 		const done = new Promise((r) => resolveDone = r);
 		const pendingWebchat = webchat ? Object.assign(webchat, {
@@ -218453,7 +218508,7 @@ var Daemon = class Daemon {
 				deferredFinalTranscript: false
 			} } : {}
 		};
-		this.pending.set(sessionId, p);
+		this.pending.set(pendingTurnKey(agentId, sessionId), p);
 		if (callMeta) this.activeTurnCallMeta.set(key, callMeta);
 		let finalPhase = "end";
 		try {
@@ -218572,12 +218627,12 @@ var Daemon = class Daemon {
 			}
 			throw err;
 		} finally {
-			this.clearCancelBackstop(sessionId);
+			this.clearCancelBackstop(agentId, sessionId);
 			if (p.outputSuppressed) await p.applyChain.catch(() => {});
 			releaseReplyConn();
 			this.clearIdle(p);
-			this.releasePermissions(sessionId);
-			this.releaseElicits(sessionId);
+			this.releasePermissions(agentId, sessionId);
+			this.releaseElicits(agentId, sessionId);
 			if (callMeta) this.activeTurnCallMeta.delete(key);
 			const githubFinal = p.github && !p.outputSuppressed && finalPhase === "end" ? p.github.collector.finalText(true) : void 0;
 			if (p.github?.deferredFinalTranscript && githubFinal?.trim()) this.store.appendTranscript({
@@ -218589,7 +218644,7 @@ var Daemon = class Daemon {
 				text: githubFinal
 			});
 			if (p.github && !p.outputSuppressed) await p.github.poster.publish(githubFinal).catch((err) => this.log.warn(`github poster: final publish failed (${formatErr(err)})`));
-			this.pending.delete(sessionId);
+			this.pending.delete(pendingTurnKey(agentId, sessionId));
 			this.store.setSessionState(key, "idle", this.clock.now());
 			this.emitSessionMetadataSnapshot({
 				sessionId,
@@ -218627,9 +218682,8 @@ var Daemon = class Daemon {
 				else e.reject(new FailStopError(key));
 			}
 		}
-		const livePair = acpSessionId ? [acpSessionId, this.pending.get(acpSessionId)] : [...this.pending.entries()].find(([, pending]) => pending.sessionKey === key);
-		const liveSessionId = livePair?.[0];
-		const live = livePair?.[1];
+		const live = acpSessionId ? this.pending.get(pendingTurnKey(agentId, acpSessionId)) : [...this.pending.values()].find((pending) => pending.sessionKey === key);
+		const liveSessionId = acpSessionId ?? live?.acpSessionId;
 		if (live) {
 			live.outputSuppressed ??= reason;
 			this.clearIdle(live);
@@ -218652,8 +218706,8 @@ var Daemon = class Daemon {
 			if (activeEntry && active) this.armColdCancelBackstop(agentId, key, reason, active);
 			return;
 		}
-		this.releasePermissions(liveSessionId);
-		this.releaseElicits(liveSessionId);
+		this.releasePermissions(agentId, liveSessionId);
+		this.releaseElicits(agentId, liveSessionId);
 		this.store.setSessionState(key, "cancelling", this.clock.now());
 		this.hosts.get(agentId)?.cancel(liveSessionId).catch((err) => this.log.error(`command ${reason}: cancel failed: ${err.message}`));
 		this.armCancelBackstop(agentId, liveSessionId, key, reason);
@@ -218670,7 +218724,7 @@ var Daemon = class Daemon {
 			entry.cancelledReason = reason;
 			targets.set(key, void 0);
 		}
-		for (const [acpSessionId, p] of this.pending) if (p.agentId === agentId) targets.set(p.sessionKey, acpSessionId);
+		for (const p of this.pending.values()) if (p.agentId === agentId) targets.set(p.sessionKey, p.acpSessionId);
 		for (const [key, queued] of this.serialQueue) if (queued.some((entry) => entry.agentId === agentId) && !targets.has(key)) targets.set(key, this.store.getSession(key)?.acpSessionId ?? void 0);
 		if (targets.size > 0) this.log.info(`${reason}: interrupting ${targets.size} active session(s) for agent "${agentId}"`);
 		for (const [key, acpSessionId] of targets) this.interruptTurn(agentId, key, reason, acpSessionId, { dropQueued: true });
@@ -218681,21 +218735,23 @@ var Daemon = class Daemon {
 	*  can't be stuck in `cancelling` forever. dispatch's finally clears this timer
 	*  the moment the turn yields on its own. */
 	armCancelBackstop(agentId, acpSessionId, key, reason) {
-		this.clearCancelBackstop(acpSessionId);
+		this.clearCancelBackstop(agentId, acpSessionId);
 		const ms = this.cfg.limits.cancelBackstopMs;
-		this.cancelTimers.set(acpSessionId, this.clock.setTimeout(() => {
-			this.cancelTimers.delete(acpSessionId);
-			if (!this.pending.has(acpSessionId)) return;
+		const pendingKey = pendingTurnKey(agentId, acpSessionId);
+		this.cancelTimers.set(pendingKey, this.clock.setTimeout(() => {
+			this.cancelTimers.delete(pendingKey);
+			if (!this.pending.has(pendingKey)) return;
 			this.log.warn(`${reason}: agent "${agentId}" ignored session/cancel for ${ms}ms — force-stopping host (session ${acpSessionId})`);
 			this.stopHost(agentId, 0).catch((err) => this.log.error(`${reason}: force-stop failed for agent "${agentId}": ${formatErr(err)}`));
 			this.store.setSessionState(key, "idle", this.clock.now());
 		}, ms));
 	}
-	clearCancelBackstop(acpSessionId) {
-		const t = this.cancelTimers.get(acpSessionId);
+	clearCancelBackstop(agentId, acpSessionId) {
+		const key = pendingTurnKey(agentId, acpSessionId);
+		const t = this.cancelTimers.get(key);
 		if (t !== void 0) {
 			this.clock.clearTimeout(t);
-			this.cancelTimers.delete(acpSessionId);
+			this.cancelTimers.delete(key);
 		}
 	}
 	armColdCancelBackstop(agentId, key, reason, active) {
@@ -219024,7 +219080,7 @@ var Daemon = class Daemon {
 		if (row?.threadUrl !== void 0) event.threadUrl = row.threadUrl;
 		const agent = this.agents.get(input.agentId);
 		if (agent?.runtime) event.runtime = agent.runtime;
-		const storeKey = this.store.getSessionByAcpId(input.sessionId)?.key;
+		const storeKey = this.store.getSessionByAcpIdForAgent(input.agentId, input.sessionId)?.key;
 		const model = (storeKey ? this.store.getModelOverride(storeKey) : void 0) ?? agent?.runtimeOverrides?.model;
 		if (model !== void 0) event.model = model;
 		const effort = (storeKey ? this.store.getEffortOverride(storeKey) : void 0) ?? agent?.reasoningEffort;
@@ -219177,6 +219233,7 @@ var Daemon = class Daemon {
 		if (p.idleTimer) clearTimeout(p.idleTimer);
 		p.idleTimer = void 0;
 	}
+	/** In-flight rendering state keyed by (agentId, ACP sessionId). */
 	pending = /* @__PURE__ */ new Map();
 	/**
 	* DAEMON-PRIVATE trusted call metadata of the CURRENTLY in-flight turn, keyed by the
@@ -219199,7 +219256,7 @@ var Daemon = class Daemon {
 	* promise stays pending until the user taps a button (handlePermissionChoice) or the
 	* turn is cancelled/ends (releasePermissions).
 	*/
-	async onAcpPermission(_agentId, sessionId, params) {
+	async onAcpPermission(agentId, sessionId, params) {
 		if (isBuiltinSystemTool(params)) {
 			const allow = params.options.find((o) => o.kind === "allow_always" || o.kind === "allow_once");
 			if (allow) return { outcome: {
@@ -219207,7 +219264,7 @@ var Daemon = class Daemon {
 				optionId: allow.optionId
 			} };
 		}
-		const p = this.pending.get(sessionId);
+		const p = this.pending.get(pendingTurnKey(agentId, sessionId));
 		if (!p) return void 0;
 		if (p.outputSuppressed) return { outcome: { outcome: "cancelled" } };
 		const conn = p.conn;
@@ -219218,6 +219275,7 @@ var Daemon = class Daemon {
 		let resolveResult;
 		const result = new Promise((resolve) => resolveResult = resolve);
 		this.pendingPerms.set(requestId, {
+			agentId,
 			sessionId,
 			params,
 			conn,
@@ -219256,9 +219314,9 @@ var Daemon = class Daemon {
 	/** Resolve every outstanding permission request for a session as `cancelled` — ACP
 	*  requires this when a prompt turn is cancelled, and it also unblocks a turn whose
 	*  card the user abandoned. Edits each card to a neutral cancelled state. */
-	releasePermissions(sessionId) {
+	releasePermissions(agentId, sessionId) {
 		for (const [id, rec] of this.pendingPerms) {
-			if (rec.sessionId !== sessionId) continue;
+			if (rec.agentId !== agentId || rec.sessionId !== sessionId) continue;
 			this.pendingPerms.delete(id);
 			if (rec.ts) rec.conn.updateBlocks(rec.channel, rec.ts, buildPermissionResolvedCard(rec.params, "Cancelled", void 0), "Permission cancelled").catch(() => {});
 			rec.resolve({ outcome: { outcome: "cancelled" } });
@@ -219273,8 +219331,8 @@ var Daemon = class Daemon {
 	* Slack, or the form has no field we can render inline. Stays pending until the user
 	* taps a button (handleElicitChoice) or the turn ends/cancels (releaseElicits).
 	*/
-	async onAcpElicit(_agentId, sessionId, params) {
-		const p = this.pending.get(sessionId);
+	async onAcpElicit(agentId, sessionId, params) {
+		const p = this.pending.get(pendingTurnKey(agentId, sessionId));
 		if (!p) return void 0;
 		if (p.outputSuppressed) return { action: "cancel" };
 		const conn = p.conn;
@@ -219288,6 +219346,7 @@ var Daemon = class Daemon {
 		let resolveResult;
 		const result = new Promise((resolve) => resolveResult = resolve);
 		this.pendingElicits.set(requestId, {
+			agentId,
 			sessionId,
 			params,
 			propName: target.propName,
@@ -219335,9 +219394,9 @@ var Daemon = class Daemon {
 	}
 	/** Resolve every outstanding elicitation for a session as `cancel` — ACP's cancellation
 	*  contract, and it unblocks a turn whose card the user abandoned. */
-	releaseElicits(sessionId) {
+	releaseElicits(agentId, sessionId) {
 		for (const [id, rec] of this.pendingElicits) {
-			if (rec.sessionId !== sessionId) continue;
+			if (rec.agentId !== agentId || rec.sessionId !== sessionId) continue;
 			this.pendingElicits.delete(id);
 			if (rec.ts) rec.conn.updateBlocks(rec.channel, rec.ts, buildElicitationResolvedCard(rec.params, ":hourglass: Cancelled"), "Cancelled").catch(() => {});
 			rec.resolve({ action: "cancel" });
@@ -219361,11 +219420,105 @@ var Daemon = class Daemon {
 			this.log.debug(`${late ? "late " : ""}usage report emit failed (session ${sessionId}): ${err.message}`);
 		}
 	}
-	onAcpUpdate(_agentId, sessionId, update) {
-		const p = this.pending.get(sessionId);
+	bufferEarlySessionMetadata(agentId, sessionId, update) {
+		if ((this.sessionInitializationsByAgent.get(agentId) ?? 0) === 0) return false;
+		const key = pendingTurnKey(agentId, sessionId);
+		const entry = this.earlySessionMetadata.get(key) ?? {
+			agentId,
+			sessionId,
+			updates: []
+		};
+		const previous = entry.updates.findIndex((candidate) => candidate.sessionUpdate === update.sessionUpdate);
+		if (previous >= 0) entry.updates[previous] = update;
+		else entry.updates.push(update);
+		this.earlySessionMetadata.set(key, entry);
+		return true;
+	}
+	/** Complete one SessionManager initialization and replay any metadata the ACP
+	*  adapter emitted before its local session row existed. Leftover unknown ids
+	*  are discarded once the agent has no other initialization in flight. */
+	finishSessionInitialization(agentId, sessionId) {
+		if (sessionId) {
+			const key = pendingTurnKey(agentId, sessionId);
+			const entry = this.earlySessionMetadata.get(key);
+			this.earlySessionMetadata.delete(key);
+			if (entry) for (const update of entry.updates) this.onAcpUpdate(agentId, sessionId, update);
+		}
+		const remaining = Math.max(0, (this.sessionInitializationsByAgent.get(agentId) ?? 1) - 1);
+		if (remaining > 0) {
+			this.sessionInitializationsByAgent.set(agentId, remaining);
+			return;
+		}
+		this.sessionInitializationsByAgent.delete(agentId);
+		for (const [key, entry] of this.earlySessionMetadata) if (entry.agentId === agentId) this.earlySessionMetadata.delete(key);
+	}
+	/** Persist one authoritative title and push the CP metadata projection. */
+	persistSessionTitle(rec, title) {
+		this.store.setSessionTitle(rec.key, title);
+		if (!rec.acpSessionId) return;
+		this.emitSessionMetadataSnapshot({
+			sessionId: rec.acpSessionId,
+			agentId: rec.agentId,
+			phase: "plan",
+			platform: rec.platform,
+			channel: rec.channel,
+			thread: rec.thread
+		});
+	}
+	/** Rename a Slack app-DM through the exact integration that delivered this
+	*  session. The connection lease prevents reconcile from closing it mid-call. */
+	async setSlackTitleForBinding(rec, binding, title) {
+		if (binding.agentId !== rec.agentId || binding.platform !== "slack" || rec.platform !== "slack" || !binding.isDm || !binding.integrationId || !title) return;
+		const conn = this.connByIntegration.get(binding.integrationId);
+		if (!conn) return;
+		const release = this.holdReplyConnection(conn);
+		try {
+			await conn.setTitle(rec.channel, rec.thread, title);
+		} catch (err) {
+			this.log.debug(`session title: Slack update failed (${formatErr(err)})`);
+		} finally {
+			release();
+		}
+	}
+	/** MCP callback for runtimes (notably Codex ACP) that do not generate semantic
+	*  ACP session titles themselves. The tool input contains only the title; every
+	*  coordinate and delivery route was captured in the trusted SessionContext. */
+	async setSessionTitleFromTool(req) {
+		const key = sessionKey(req.platform, req.channel, req.thread, req.agentId);
+		const rec = this.store.getSession(key);
+		if (!rec?.acpSessionId) throw new Error("the current session is not addressable yet");
+		const binding = this.sessionDeliveryBindings.get(key) ?? {
+			agentId: req.agentId,
+			platform: req.platform,
+			...req.integrationId !== void 0 ? { integrationId: req.integrationId } : {},
+			isDm: req.isDm
+		};
+		this.persistSessionTitle(rec, req.title);
+		const p = this.pending.get(pendingTurnKey(rec.agentId, rec.acpSessionId));
+		if (p && p.sessionKey === key && !p.outputSuppressed) {
+			if (p.webchat) this.emitWebchatUpdate(p, {
+				sessionUpdate: "session_info_update",
+				title: req.title
+			});
+			if (p.platform === "slack" && p.isDm && p.conn) {
+				this.enqueueApply(p, {
+					kind: "set-title",
+					text: req.title
+				});
+				await p.applyChain;
+				return;
+			}
+		}
+		await this.setSlackTitleForBinding(rec, binding, req.title);
+	}
+	onAcpUpdate(agentId, sessionId, update) {
+		const p = this.pending.get(pendingTurnKey(agentId, sessionId));
 		if (p?.outputSuppressed) return;
+		const isEarlyMetadata = update?.sessionUpdate === "usage_update" || update?.sessionUpdate === "session_info_update" && update.title !== void 0;
+		const detachedRec = !p && isEarlyMetadata ? this.store.getSessionByAcpIdForAgent(agentId, sessionId) : void 0;
+		if (!p && isEarlyMetadata && !detachedRec && this.bufferEarlySessionMetadata(agentId, sessionId, update)) return;
 		if (update?.sessionUpdate === "usage_update") {
-			const rec = p ? void 0 : this.store.getSessionByAcpId(sessionId);
+			const rec = p ? void 0 : detachedRec;
 			const key = p?.sessionKey ?? rec?.key;
 			if (key) {
 				if (p && update.cost?.amount !== void 0) p.runtimeCostReported = true;
@@ -219381,23 +219534,22 @@ var Daemon = class Daemon {
 				} else if (rec) this.emitStoredUsageReport(sessionId, rec.agentId, rec.platform, rec.channel, key, true);
 			}
 		}
-		if (!p) return;
 		if (update?.sessionUpdate === "session_info_update" && update.title !== void 0) {
-			this.store.setSessionTitle(p.sessionKey, update.title);
-			this.emitSessionMetadataSnapshot({
-				sessionId,
-				agentId: p.agentId,
-				phase: "plan",
-				platform: p.platform,
-				channel: p.channel,
-				thread: p.statusThread
-			});
-			const slackTitle = typeof update.title === "string" ? update.title.trim() : "";
-			if (p.platform === "slack" && p.isDm && slackTitle) this.enqueueApply(p, {
-				kind: "set-title",
-				text: slackTitle
-			});
+			const rec = p ? this.store.getSession(p.sessionKey) : detachedRec;
+			if (rec?.agentId === agentId && rec.acpSessionId === sessionId) {
+				this.persistSessionTitle(rec, update.title);
+				const slackTitle = typeof update.title === "string" ? update.title.trim() : "";
+				if (p?.platform === "slack" && p.isDm && slackTitle) this.enqueueApply(p, {
+					kind: "set-title",
+					text: slackTitle
+				});
+				else if (!p && slackTitle) {
+					const binding = this.sessionDeliveryBindings.get(rec.key);
+					if (binding) this.setSlackTitleForBinding(rec, binding, slackTitle);
+				}
+			}
 		}
+		if (!p) return;
 		const isHeadlessGithubFinal = p.github !== void 0 && p.platform === "hook" && update?.sessionUpdate === "agent_message_chunk" && update?._meta?.codex?.phase === "final_answer";
 		if (p.github) {
 			p.github.collector.onUpdate(update);
@@ -219617,12 +219769,22 @@ var Daemon = class Daemon {
 		const host = this.hosts.get(agentId);
 		this.hosts.delete(agentId);
 		this.hostStartedAt.delete(agentId);
-		if (!host) return;
+		const clearDeliveryBindings = () => {
+			for (const [key, binding] of this.sessionDeliveryBindings) if (binding.agentId === agentId) this.sessionDeliveryBindings.delete(key);
+		};
+		if (!host) {
+			clearDeliveryBindings();
+			return;
+		}
 		const stop = Promise.resolve(host.stop(deadlineMs)).finally(() => {
 			if (this.hostStopping.get(agentId) === stop) this.hostStopping.delete(agentId);
 		});
 		this.hostStopping.set(agentId, stop);
-		await stop;
+		try {
+			await stop;
+		} finally {
+			clearDeliveryBindings();
+		}
 	}
 	/** Recurring idle sweep (§7.2/§7.3): reap idle adapter children and TTL-close
 	*  idle sessions. Driven by the injected Clock so a FakeClock advances it in tests. */
@@ -219715,10 +219877,10 @@ var Daemon = class Daemon {
 		})));
 		const res = await this.raceDeadline(work, deadlineMs);
 		settled = true;
-		if (res === "timeout") for (const [sid, p] of this.pending) {
+		if (res === "timeout") for (const p of this.pending.values()) {
 			if (!match(p)) continue;
-			this.log.warn(`drain[${scope.kind}]: cancelling straggler turn (session ${sid})`);
-			await this.hosts.get(p.agentId)?.cancel(sid).catch(() => {});
+			this.log.warn(`drain[${scope.kind}]: cancelling straggler turn (session ${p.acpSessionId})`);
+			await this.hosts.get(p.agentId)?.cancel(p.acpSessionId).catch(() => {});
 		}
 		return {
 			matched: [...matched.values()],
@@ -219827,11 +219989,11 @@ var Daemon = class Daemon {
 					entry.initAbort.abort(/* @__PURE__ */ new Error("daemon shutdown deadline"));
 					forceAgents.add(entry.agentId);
 				}
-				for (const [sid, p] of this.pending) {
+				for (const p of this.pending.values()) {
 					p.outputSuppressed ??= "shutdown";
-					this.releasePermissions(sid);
-					this.releaseElicits(sid);
-					this.hosts.get(p.agentId)?.cancel(sid).catch(() => {});
+					this.releasePermissions(p.agentId, p.acpSessionId);
+					this.releaseElicits(p.agentId, p.acpSessionId);
+					this.hosts.get(p.agentId)?.cancel(p.acpSessionId).catch(() => {});
 				}
 				const forceStops = [...forceAgents].filter((id) => !coldAgents.has(id)).map(stopFailClosed);
 				await Promise.all([
@@ -220511,4 +220673,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-Ce7nBe9z.js.map
+//# sourceMappingURL=run-foreground-BRT8VM8Q.js.map