@agentconnect.md/daemon 1.0.0-rc.25 → 1.0.0-rc.27

package/dist/index.js

@@ -4,7 +4,7 @@ import { EventEmitter } from "node:events";
 import childProcess, { execFile, spawn } from "node:child_process";
 import * as sp from "node:path";
 import path, { delimiter, dirname, isAbsolute, join, normalize, relative, resolve, sep } from "node:path";
-import fs, { accessSync, constants, existsSync, mkdirSync, readFileSync, readdirSync, rmSync, stat, unwatchFile, watch, watchFile, writeFileSync } from "node:fs";
+import fs, { accessSync, chmodSync, constants, existsSync, mkdirSync, readFileSync, readdirSync, rmSync, stat, unlinkSync, unwatchFile, watch, watchFile, writeFileSync } from "node:fs";
 import process$1 from "node:process";
 import { stripVTControlCharacters } from "node:util";
 import { fileURLToPath } from "node:url";
@@ -12,9 +12,10 @@ import { createInterface } from "node:readline";
 import { freemem, homedir, hostname, loadavg, totalmem, type } from "node:os";
 import { spawn as spawn$1 } from "child_process";
 import { Readable, Writable } from "node:stream";
-import { randomUUID } from "node:crypto";
+import { randomBytes, randomUUID } from "node:crypto";
 import { lstat, open, readdir, realpath, stat as stat$1 } from "node:fs/promises";
 import { DatabaseSync } from "node:sqlite";
+import net from "node:net";
 //#region \0rolldown/runtime.js
 var __create = Object.create;
 var __defProp$1 = Object.defineProperty;
@@ -3599,6 +3600,7 @@ const string$1 = (params) => {
 const integer = /^-?\d+$/;
 const number$1 = /^-?\d+(?:\.\d+)?$/;
 const boolean$1 = /^(?:true|false)$/i;
+const _null$2 = /^null$/i;
 const lowercase = /^[^A-Z]*$/;
 const uppercase = /^[^a-z]*$/;
 //#endregion
@@ -4411,6 +4413,22 @@ const $ZodBoolean = /*@__PURE__*/ $constructor("$ZodBoolean", (inst, def) => {
 		return payload;
 	};
 });
+const $ZodNull = /*@__PURE__*/ $constructor("$ZodNull", (inst, def) => {
+	$ZodType.init(inst, def);
+	inst._zod.pattern = _null$2;
+	inst._zod.values = /* @__PURE__ */ new Set([null]);
+	inst._zod.parse = (payload, _ctx) => {
+		const input = payload.value;
+		if (input === null) return payload;
+		payload.issues.push({
+			expected: "null",
+			code: "invalid_type",
+			input,
+			inst
+		});
+		return payload;
+	};
+});
 const $ZodUnknown = /*@__PURE__*/ $constructor("$ZodUnknown", (inst, def) => {
 	$ZodType.init(inst, def);
 	inst._zod.parse = (payload) => payload;
@@ -5240,6 +5258,9 @@ function handlePipeResult(left, next, ctx) {
 		fallback: left.fallback
 	}, ctx);
 }
+const $ZodPreprocess = /*@__PURE__*/ $constructor("$ZodPreprocess", (inst, def) => {
+	$ZodPipe.init(inst, def);
+});
 const $ZodReadonly = /*@__PURE__*/ $constructor("$ZodReadonly", (inst, def) => {
 	$ZodType.init(inst, def);
 	defineLazy(inst._zod, "propValues", () => def.innerType._zod.propValues);
@@ -5633,6 +5654,13 @@ function _boolean(Class, params) {
 	});
 }
 // @__NO_SIDE_EFFECTS__
+function _null$1(Class, params) {
+	return new Class({
+		type: "null",
+		...normalizeParams(params)
+	});
+}
+// @__NO_SIDE_EFFECTS__
 function _unknown(Class) {
 	return new Class({ type: "unknown" });
 }
@@ -5799,6 +5827,17 @@ function _array(Class, element, params) {
 	});
 }
 // @__NO_SIDE_EFFECTS__
+function _custom(Class, fn, _params) {
+	const norm = normalizeParams(_params);
+	norm.abort ?? (norm.abort = true);
+	return new Class({
+		type: "custom",
+		check: "custom",
+		fn,
+		...norm
+	});
+}
+// @__NO_SIDE_EFFECTS__
 function _refine(Class, fn, _params) {
 	return new Class({
 		type: "custom",
@@ -6181,6 +6220,13 @@ const numberProcessor = (schema, ctx, _json, _params) => {
 const booleanProcessor = (_schema, _ctx, json, _params) => {
 	json.type = "boolean";
 };
+const nullProcessor = (_schema, ctx, json, _params) => {
+	if (ctx.target === "openapi-3.0") {
+		json.type = "string";
+		json.nullable = true;
+		json.enum = [null];
+	} else json.type = "null";
+};
 const neverProcessor = (_schema, _ctx, json, _params) => {
 	json.not = {};
 };
@@ -6874,6 +6920,14 @@ const ZodBoolean = /*@__PURE__*/ $constructor("ZodBoolean", (inst, def) => {
 function boolean(params) {
 	return /* @__PURE__ */ _boolean(ZodBoolean, params);
 }
+const ZodNull = /*@__PURE__*/ $constructor("ZodNull", (inst, def) => {
+	$ZodNull.init(inst, def);
+	ZodType.init(inst, def);
+	inst._zod.processJSONSchema = (ctx, json, params) => nullProcessor(inst, ctx, json, params);
+});
+function _null(params) {
+	return /* @__PURE__ */ _null$1(ZodNull, params);
+}
 const ZodUnknown = /*@__PURE__*/ $constructor("ZodUnknown", (inst, def) => {
 	$ZodUnknown.init(inst, def);
 	ZodType.init(inst, def);
@@ -6987,6 +7041,14 @@ function object(shape, params) {
 		...normalizeParams(params)
 	});
 }
+function looseObject(shape, params) {
+	return new ZodObject({
+		type: "object",
+		shape,
+		catchall: unknown(),
+		...normalizeParams(params)
+	});
+}
 const ZodUnion = /*@__PURE__*/ $constructor("ZodUnion", (inst, def) => {
 	$ZodUnion.init(inst, def);
 	ZodType.init(inst, def);
@@ -7241,6 +7303,10 @@ function pipe(in_, out) {
 		out
 	});
 }
+const ZodPreprocess = /*@__PURE__*/ $constructor("ZodPreprocess", (inst, def) => {
+	ZodPipe.init(inst, def);
+	$ZodPreprocess.init(inst, def);
+});
 const ZodReadonly = /*@__PURE__*/ $constructor("ZodReadonly", (inst, def) => {
 	$ZodReadonly.init(inst, def);
 	ZodType.init(inst, def);
@@ -7258,12 +7324,22 @@ const ZodCustom = /*@__PURE__*/ $constructor("ZodCustom", (inst, def) => {
 	ZodType.init(inst, def);
 	inst._zod.processJSONSchema = (ctx, json, params) => customProcessor(inst, ctx, json, params);
 });
+function custom(fn, _params) {
+	return /* @__PURE__ */ _custom(ZodCustom, fn ?? (() => true), _params);
+}
 function refine(fn, _params = {}) {
 	return /* @__PURE__ */ _refine(ZodCustom, fn, _params);
 }
 function superRefine(fn, params) {
 	return /* @__PURE__ */ _superRefine(fn, params);
 }
+function preprocess(fn, schema) {
+	return new ZodPreprocess({
+		type: "pipe",
+		in: transform(fn),
+		out: schema
+	});
+}
 //#endregion
 //#region src/config/config-schema.ts
 const RuntimeDefSchema = object({
@@ -7328,9 +7404,21 @@ function registryCachePath(root) {
 function logsDir(root) {
 	return join(root, "logs");
 }
+/**
+* Unix-domain socket the daemon's MCP control server listens on. The stdio
+* `agentconnect mcp-bridge` subprocess (spawned by the agent harness) connects
+* here to forward tool calls back to the daemon. Kept short (macOS caps UDS
+* paths at ~104 bytes) and under `run/` so it's separate from durable state.
+*/
+function mcpSocketPath(root) {
+	return join(root, "run", "mcp.sock");
+}
 function daemonLogPath(root) {
 	return join(root, "logs", "daemon.log");
 }
+function lockPath(root) {
+	return join(root, "daemon.lock");
+}
 //#endregion
 //#region src/config/load-config.ts
 function loadConfig(opts = {}) {
@@ -16789,10 +16877,10 @@ var AcpHost = class {
 		this.canLoad = init.agentCapabilities?.loadSession ?? false;
 		this.opts.log?.debug(`acp: agent initialized (loadSession capability=${this.canLoad})`);
 	}
-	async newSession(cwd) {
+	async newSession(cwd, mcpServers = []) {
 		const res = await this.conn.agent.request(methods.agent.session.new, {
 			cwd,
-			mcpServers: []
+			mcpServers
 		});
 		this.live.add(res.sessionId);
 		return res.sessionId;
@@ -17104,6 +17192,22 @@ const NormalizedMessageRef = object({
 	seenUpToSeq: number().int()
 });
 /**
+* Where the agent runs. Two modes; the **path is always daemon-generated** —
+* never specified by the caller (UX picks the mode, the machine owns the dir).
+*
+* - `scratch`: a fresh empty working dir on the machine, no repo.
+* - `github`: the daemon clones `gitRepo` @ `branch` and runs the agent in
+*   `agentDir` (a subdir of the repo, repo-root if omitted). **Multiple agents
+*   may share one repo** — they differ by `agentDir`, so the repo is not an
+*   owned entity, just shared config on each agent.
+*/
+const AgentWorkspace = discriminatedUnion("mode", [object({ mode: literal("scratch") }), object({
+	mode: literal("github"),
+	gitRepo: string(),
+	branch: string().default("main"),
+	agentDir: string().optional()
+})]);
+/**
 * The editable agent definition the CP owns and the daemon needs to run it:
 * prompt + runtime selection. Raft ships this in the launch config and the
 * daemon synthesizes the system prompt locally; `description` IS the prompt.
@@ -17114,6 +17218,7 @@ const AgentSpec = object({
 	model: string().optional(),
 	reasoningEffort: string().optional(),
 	executionMode: string().optional(),
+	workspace: AgentWorkspace.optional(),
 	env: record(string(), string()).optional()
 });
 const AgentLaunch = object({
@@ -19499,9 +19604,9 @@ var require_websocket = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	const EventEmitter$3 = __require("events");
 	const https$3 = __require("https");
 	const http$7 = __require("http");
-	const net = __require("net");
+	const net$1 = __require("net");
 	const tls = __require("tls");
-	const { randomBytes, createHash: createHash$1 } = __require("crypto");
+	const { randomBytes: randomBytes$1, createHash: createHash$1 } = __require("crypto");
 	const { Duplex: Duplex$2, Readable: Readable$1 } = __require("stream");
 	const { URL: URL$1 } = __require("url");
 	const PerMessageDeflate = require_permessage_deflate();
@@ -20068,7 +20173,7 @@ var require_websocket = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 			}
 		}
 		const defaultPort = isSecure ? 443 : 80;
-		const key = randomBytes(16).toString("base64");
+		const key = randomBytes$1(16).toString("base64");
 		const request = isSecure ? https$3.request : http$7.request;
 		const protocolSet = /* @__PURE__ */ new Set();
 		let perMessageDeflate;
@@ -20245,7 +20350,7 @@ var require_websocket = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	*/
 	function netConnect(options) {
 		options.path = options.socketPath;
-		return net.connect(options);
+		return net$1.connect(options);
 	}
 	/**
 	* Create a `tls.TLSSocket` and initiate a connection.
@@ -20256,7 +20361,7 @@ var require_websocket = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	*/
 	function tlsConnect(options) {
 		options.path = void 0;
-		if (!options.servername && options.servername !== "") options.servername = net.isIP(options.host) ? "" : options.host;
+		if (!options.servername && options.servername !== "") options.servername = net$1.isIP(options.host) ? "" : options.host;
 		return tls.connect(options);
 	}
 	/**
@@ -23158,7 +23263,12 @@ var SessionManager = class {
 		const host = await this.deps.hostFor(agentId);
 		if (!rec || !rec.acpSessionId) {
 			const cwd = await prepareWorkspace(agent);
-			const acpSessionId = await host.newSession(cwd);
+			const mcpServers = this.deps.mcpServersFor?.({
+				agent,
+				channel: msg.channel,
+				thread
+			}) ?? [];
+			const acpSessionId = await host.newSession(cwd, mcpServers);
 			rec = {
 				key,
 				agentId,
@@ -23179,7 +23289,12 @@ var SessionManager = class {
 				resumed = true;
 			} catch {}
 			if (!resumed) {
-				const acpSessionId = await host.newSession(cwd);
+				const mcpServers = this.deps.mcpServersFor?.({
+					agent,
+					channel: msg.channel,
+					thread
+				}) ?? [];
+				const acpSessionId = await host.newSession(cwd, mcpServers);
 				rec = {
 					...rec,
 					acpSessionId,
@@ -23192,7 +23307,7 @@ var SessionManager = class {
 		}
 		const gap = this.deps.store.transcriptSince(msg.channel, thread, rec.lastDeliveredTs);
 		const blocks = [];
-		const context = gap.slice(0, -1);
+		const context = gap.slice(0, -1).filter((e) => e.sender !== agentId);
 		if (context.length > 0) {
 			const ctxText = context.map((e) => `[${e.sender}] ${e.text}`).join("\n");
 			blocks.push({
@@ -23219,6 +23334,306 @@ function tsOf(msg) {
 	return parts[parts.length - 1] ?? "0";
 }
 //#endregion
+//#region src/mcp/ipc.ts
+/** Frame a message for the wire: compact JSON + a single trailing newline. */
+function encodeFrame(msg) {
+	return JSON.stringify(msg) + "\n";
+}
+/**
+* Split a buffer of newline-delimited frames into parsed objects plus the
+* trailing partial line. Callers keep `rest` and prepend it to the next chunk.
+*
+* Per-line tolerant: a malformed (non-JSON) line is skipped, not thrown — so one
+* bad frame can't crash a stream reader or discard the good frames batched
+* alongside it in the same chunk. `onError` lets callers log dropped lines.
+*/
+function decodeFrames(buf, onError) {
+	const parts = buf.split("\n");
+	const rest = parts.pop() ?? "";
+	const messages = [];
+	for (const line of parts) {
+		const trimmed = line.trim();
+		if (!trimmed) continue;
+		try {
+			messages.push(JSON.parse(trimmed));
+		} catch (err) {
+			onError?.(trimmed, err);
+		}
+	}
+	return {
+		messages,
+		rest
+	};
+}
+//#endregion
+//#region src/mcp/ops.ts
+/**
+* Execute one tool call inside the daemon and return a plain result object (the
+* bridge wraps it into an MCP `CallToolResult`). Throws on bad input or a
+* missing connection — the caller turns that into an MCP `isError` result.
+*/
+async function executeTool(ctx, name, args, deps) {
+	const gw = deps.gatewayFor(ctx.integrationId);
+	if (!gw) throw new Error(`no live Slack connection for integration ${ctx.integrationId}`);
+	switch (name) {
+		case "sendSlackMessage": {
+			const text = requireString(args, "text");
+			const channel = optionalString(args, "channel") ?? ctx.channel;
+			const thread = "thread" in args ? optionalString(args, "thread") || void 0 : ctx.thread;
+			const ts = await gw.postMessage(channel, text, thread) ?? `local-${deps.now()}`;
+			deps.recordOutbound(ctx, channel, thread, text, ts);
+			return {
+				ok: true,
+				channel,
+				thread: thread ?? null,
+				ts
+			};
+		}
+		case "getCurrentChannel": {
+			const info = await gw.getChannelInfo(ctx.channel).catch(() => void 0);
+			return {
+				channel: ctx.channel,
+				thread: ctx.thread,
+				name: info?.name ?? null,
+				isIm: info?.isIm ?? null
+			};
+		}
+		case "listChannelMembers": {
+			const channel = optionalString(args, "channel") ?? ctx.channel;
+			return {
+				channel,
+				members: await gw.listMembers(channel)
+			};
+		}
+		case "listChannels": return { channels: await gw.listChannels() };
+		case "getUserProfile": {
+			const user = requireString(args, "user");
+			return await gw.getUserProfile(user);
+		}
+		default: throw new Error(`unknown tool: ${name}`);
+	}
+}
+function requireString(args, key) {
+	const v = args[key];
+	if (typeof v !== "string" || v.length === 0) throw new Error(`missing required string argument: ${key}`);
+	return v;
+}
+function optionalString(args, key) {
+	const v = args[key];
+	if (v === void 0 || v === null) return void 0;
+	if (typeof v !== "string") throw new Error(`argument ${key} must be a string`);
+	return v;
+}
+//#endregion
+//#region src/mcp/control-server.ts
+/**
+* The daemon-hosted half of MCP. It owns all tool logic, the registry of live
+* sessions, and the Unix-domain socket the `mcp-bridge` subprocesses connect to.
+* "The MCP server is the daemon itself" — the bridge is only a stdio↔socket pipe.
+*/
+var McpControlServer = class {
+	deps;
+	server;
+	sessions = /* @__PURE__ */ new Map();
+	conns = /* @__PURE__ */ new Set();
+	constructor(deps) {
+		this.deps = deps;
+	}
+	/**
+	* Register a session's tool set and return an opaque token. The token is
+	* embedded in the bridge's env at `session/new`; the bridge presents it on
+	* every IPC request so we can resolve the channel/thread/agent binding.
+	*/
+	register(ctx) {
+		const token = randomBytes(18).toString("base64url");
+		this.sessions.set(token, ctx);
+		return token;
+	}
+	unregister(token) {
+		this.sessions.delete(token);
+	}
+	async start() {
+		if (this.server) return;
+		const path = this.deps.socketPath;
+		const dir = dirname(path);
+		mkdirSync(dir, {
+			recursive: true,
+			mode: 448
+		});
+		try {
+			chmodSync(dir, 448);
+		} catch {}
+		rmSync(path, { force: true });
+		const server = net.createServer((socket) => this.onConnection(socket));
+		this.server = server;
+		await new Promise((resolve, reject) => {
+			const onStartupError = (err) => reject(err);
+			server.once("error", onStartupError);
+			server.listen(path, () => {
+				server.off("error", onStartupError);
+				server.on("error", (err) => this.deps.log?.error(`mcp: control server error: ${err.message}`));
+				resolve();
+			});
+		});
+		try {
+			chmodSync(path, 384);
+		} catch {}
+		this.deps.log?.info(`mcp: control socket listening at ${path}`);
+	}
+	onConnection(socket) {
+		socket.setEncoding("utf8");
+		this.conns.add(socket);
+		let buf = "";
+		socket.on("data", (chunk) => {
+			buf += chunk;
+			const { messages, rest } = decodeFrames(buf, (line) => this.deps.log?.debug(`mcp: dropping malformed frame: ${line.slice(0, 120)}`));
+			buf = rest;
+			for (const req of messages) this.handle(req, socket);
+		});
+		socket.on("error", (err) => this.deps.log?.debug(`mcp: socket error: ${err.message}`));
+		socket.on("close", () => this.conns.delete(socket));
+	}
+	async handle(req, socket) {
+		const reply = (res) => {
+			if (!socket.destroyed) socket.write(encodeFrame(res));
+		};
+		const ctx = this.sessions.get(req.token);
+		if (!ctx) return reply({
+			id: req.id,
+			ok: false,
+			error: "unknown or expired session token"
+		});
+		try {
+			if (req.op === "listTools") {
+				reply({
+					id: req.id,
+					ok: true,
+					result: { tools: ctx.tools }
+				});
+				return;
+			}
+			const result = await executeTool(ctx, req.name, req.args ?? {}, this.deps);
+			reply({
+				id: req.id,
+				ok: true,
+				result
+			});
+		} catch (err) {
+			reply({
+				id: req.id,
+				ok: false,
+				error: err.message
+			});
+		}
+	}
+	async stop() {
+		this.sessions.clear();
+		const server = this.server;
+		if (!server) return;
+		this.server = void 0;
+		for (const s of this.conns) s.destroy();
+		this.conns.clear();
+		await new Promise((resolve) => server.close(() => resolve()));
+		rmSync(this.deps.socketPath, { force: true });
+	}
+};
+//#endregion
+//#region src/mcp/inject.ts
+/**
+* Build the `mcpServers` entry that makes the agent harness spawn our stdio
+* bridge. We reuse the *current* interpreter + CLI entry (so it works under both
+* `tsx` in dev and plain `node` in prod) and invoke the hidden `mcp-bridge`
+* subcommand. The socket path and per-session token travel via env — they reach
+* only the harness-spawned subprocess, never the model.
+*/
+function buildMcpServers(opts) {
+	return [{
+		name: "agentconnect",
+		command: process.execPath,
+		args: [
+			...process.execArgv,
+			opts.cliEntry,
+			"mcp-bridge"
+		],
+		env: [{
+			name: "AC_MCP_ENDPOINT",
+			value: opts.socketPath
+		}, {
+			name: "AC_MCP_TOKEN",
+			value: opts.token
+		}]
+	}];
+}
+//#endregion
+//#region src/mcp/tools.ts
+const obj = (properties, required = []) => ({
+	type: "object",
+	properties,
+	required,
+	additionalProperties: false
+});
+/**
+* Tools injected when an agent has a Slack integration. `sendSlackMessage` is
+* the active-messaging tool from the design (token held by the daemon, invisible
+* to the model); the rest are channel/user read helpers.
+*/
+const SLACK_TOOLS = [
+	{
+		name: "sendSlackMessage",
+		description: "Send a message to a Slack channel. Omit `channel` to post in the channel this conversation is happening in. Omit `thread` to reply in the current thread; pass an empty string to post to the channel root instead.",
+		inputSchema: obj({
+			text: {
+				type: "string",
+				description: "Message body, in Slack mrkdwn."
+			},
+			channel: {
+				type: "string",
+				description: "Target channel ID (e.g. C0123ABC). Defaults to the current channel."
+			},
+			thread: {
+				type: "string",
+				description: "Thread timestamp to reply under. Defaults to the current thread; \"\" posts to the channel root."
+			}
+		}, ["text"])
+	},
+	{
+		name: "getCurrentChannel",
+		description: "Return the Slack channel (and thread) this conversation is bound to, including the channel name when available.",
+		inputSchema: obj({})
+	},
+	{
+		name: "listChannelMembers",
+		description: "List the users and bots in a channel (id, name, is_bot). Omit `channel` to list members of the current channel.",
+		inputSchema: obj({ channel: {
+			type: "string",
+			description: "Channel ID. Defaults to the current channel."
+		} })
+	},
+	{
+		name: "listChannels",
+		description: "List the public/private channels the bot is a member of and can post to.",
+		inputSchema: obj({})
+	},
+	{
+		name: "getUserProfile",
+		description: "Look up a Slack user or bot by id, returning their display name, real name, and bot flag.",
+		inputSchema: obj({ user: {
+			type: "string",
+			description: "User ID (e.g. U0123ABC)."
+		} }, ["user"])
+	}
+];
+SLACK_TOOLS.map((t) => t.name);
+/**
+* The default MCP tool set for an agent, gated by its integrations. Today only
+* Slack is supported, so an agent with no Slack integration gets no tools.
+*/
+function toolsForIntegrations(integrations) {
+	const tools = [];
+	if (integrations.some((i) => i.platform === "slack")) tools.push(...SLACK_TOOLS);
+	return tools;
+}
+//#endregion
 //#region src/router/routing-table.ts
 const KIND_ORDER = [
 	"mention",
@@ -79273,6 +79688,8 @@ function consolidate(agents) {
 	}
 	return groups;
 }
+/** Cap on members enriched per `listChannelMembers` call (bounds users.info fan-out). */
+const MEMBER_ENRICH_CAP = 50;
 var SlackConnection = class {
 	deps;
 	app;
@@ -79318,11 +79735,51 @@ var SlackConnection = class {
 		log?.debug("slack: app.start resolved → socket established");
 	}
 	async postMessage(channel, text, threadTs) {
-		await this.app.client.chat.postMessage({
+		return (await this.app.client.chat.postMessage({
 			channel,
 			text,
 			thread_ts: threadTs
-		});
+		}))?.ts;
+	}
+	async getChannelInfo(channel) {
+		const c = (await this.app.client.conversations.info({ channel })).channel ?? {};
+		return {
+			id: c.id ?? channel,
+			name: c.name,
+			isIm: c.is_im,
+			isPrivate: c.is_private
+		};
+	}
+	async listMembers(channel) {
+		const ids = ((await this.app.client.conversations.members({
+			channel,
+			limit: 200
+		})).members ?? []).slice(0, MEMBER_ENRICH_CAP);
+		return Promise.all(ids.map((id) => this.getUserProfile(id).then((p) => ({
+			id: p.id,
+			name: p.name,
+			isBot: p.isBot
+		})).catch(() => ({ id }))));
+	}
+	async listChannels() {
+		return ((await this.app.client.conversations.list({
+			types: "public_channel,private_channel",
+			exclude_archived: true,
+			limit: 200
+		})).channels ?? []).map((c) => ({
+			id: c.id ?? "",
+			name: c.name,
+			isPrivate: c.is_private
+		}));
+	}
+	async getUserProfile(user) {
+		const u = (await this.app.client.users.info({ user })).user ?? {};
+		return {
+			id: u.id ?? user,
+			name: u.name,
+			realName: u.real_name ?? u.profile?.real_name,
+			isBot: u.is_bot
+		};
 	}
 	/**
 	* Best-effort assistant loading status (assistant.threads.setStatus).
@@ -79347,9 +79804,18 @@ var SlackConnection = class {
 };
 //#endregion
 //#region src/slack/render.ts
+const THINKING = "is thinking…";
+const MAX_ACTIVITY = 10;
+const MAX_LABEL = 100;
+function clampLabel(s) {
+	const t = s.trim();
+	return t.length > MAX_LABEL ? `${t.slice(0, MAX_LABEL - 1)}…` : t;
+}
 var OutputConverger = class {
 	mode;
 	buf = "";
+	activity = [];
+	toolTitles = /* @__PURE__ */ new Map();
 	constructor(mode) {
 		this.mode = mode;
 	}
@@ -79365,6 +79831,31 @@ var OutputConverger = class {
 			text
 		}];
 	}
+	/**
+	* Record an activity label and build the loading-status action carrying the rolling
+	* window as `loading_messages`. Consecutive repeats collapse to nothing (returns []),
+	* which throttles streamed thought chunks down to one status update per thinking run.
+	*/
+	pushActivity(raw) {
+		const label = clampLabel(raw);
+		if (this.activity[this.activity.length - 1] === label) return [];
+		this.activity.push(label);
+		if (this.activity.length > MAX_ACTIVITY) this.activity.shift();
+		return [{
+			kind: "set-status",
+			text: label,
+			loadingMessages: [...this.activity]
+		}];
+	}
+	/** Resolve a tool call's display label, reusing a known title when an update omits it. */
+	toolLabel(update) {
+		const id = update.toolCallId;
+		if (update.title) {
+			if (id) this.toolTitles.set(id, update.title);
+			return update.title;
+		}
+		return (id && this.toolTitles.get(id)) ?? id ?? "tool";
+	}
 	onUpdate(update) {
 		switch (update.sessionUpdate) {
 			case "agent_message_chunk": {
@@ -79373,42 +79864,53 @@ var OutputConverger = class {
 				return [];
 			}
 			case "agent_thought_chunk": {
-				if (this.mode === "low") return [...this.flush(), {
-					kind: "set-status",
-					text: "is thinking…"
-				}];
-				if (this.mode !== "high") return [];
-				const content = update.content;
-				return [...this.flush(), {
-					kind: "update-main",
-					text: `_thinking: ${content?.text ?? ""}_`
-				}];
+				const status = this.pushActivity(THINKING);
+				if (this.mode === "high") {
+					const content = update.content;
+					return [
+						...this.flush(),
+						...status,
+						{
+							kind: "update-main",
+							text: `_thinking: ${content?.text ?? ""}_`
+						}
+					];
+				}
+				if (this.mode === "low") return [...this.flush(), ...status];
+				return status;
 			}
 			case "tool_call":
 			case "tool_call_update": {
-				const title = update.title ?? update.toolCallId ?? "tool";
-				if (this.mode === "low") return [...this.flush(), {
-					kind: "set-status",
-					text: title
-				}];
-				return [...this.flush(), {
-					kind: "update-main",
-					text: `:hammer_and_wrench: ${title}`
-				}];
+				const label = this.toolLabel(update);
+				const status = this.pushActivity(label);
+				if (this.mode === "low") return [...this.flush(), ...status];
+				return [
+					...this.flush(),
+					...status,
+					{
+						kind: "update-main",
+						text: `:hammer_and_wrench: ${label}`
+					}
+				];
 			}
 			case "usage_update": return [];
 			default: return [];
 		}
 	}
 	onFinal(link) {
-		if (this.mode === "low") return [...this.flush(), {
+		const clear = {
 			kind: "set-status",
 			text: ""
-		}];
-		return [...this.flush(), {
-			kind: "post",
-			text: `:white_check_mark: done — <${link}|details>`
-		}];
+		};
+		if (this.mode === "low") return [...this.flush(), clear];
+		return [
+			...this.flush(),
+			clear,
+			{
+				kind: "post",
+				text: `:white_check_mark: done — <${link}|details>`
+			}
+		];
 	}
 };
 //#endregion
@@ -80769,6 +81271,7 @@ const MAX_QUEUED_PER_SESSION = 10;
 var Daemon = class {
 	opts;
 	store;
+	mcp;
 	agents = /* @__PURE__ */ new Map();
 	fileAgents = /* @__PURE__ */ new Map();
 	hosts = /* @__PURE__ */ new Map();
@@ -80844,10 +81347,42 @@ var Daemon = class {
 			save: (s) => this.store.setCpAgents(JSON.stringify(s))
 		}, () => void this.reconcile().catch((err) => this.log.error(`cp: agent reconcile failed: ${err.stack ?? err}`)));
 		for (const a of this.effectiveAgents()) this.agents.set(a.id, a);
+		this.mcp = new McpControlServer({
+			socketPath: mcpSocketPath(root),
+			log: this.log,
+			now: () => Date.now(),
+			gatewayFor: (integrationId) => this.connByIntegration.get(integrationId),
+			recordOutbound: (ctx, channel, thread, text, ts) => this.store.appendTranscript({
+				channel,
+				thread: thread ?? ctx.thread,
+				ts,
+				sender: ctx.agentId,
+				text
+			})
+		});
+		await this.mcp.start();
+		const cliEntry = process.argv[1] ?? "";
 		this.sessions = new SessionManager({
 			store: this.store,
 			hostFor: (agentId) => this.ensureHostAsync(agentId),
-			agentById: (id) => this.agents.get(id)
+			agentById: (id) => this.agents.get(id),
+			mcpServersFor: ({ agent, channel, thread }) => {
+				const tools = toolsForIntegrations(agent.integrations);
+				const integrationId = agent.integrations.find((i) => i.platform === "slack")?.id;
+				if (tools.length === 0 || !integrationId) return [];
+				const token = this.mcp.register({
+					agentId: agent.id,
+					integrationId,
+					channel,
+					thread,
+					tools
+				});
+				return buildMcpServers({
+					socketPath: mcpSocketPath(root),
+					token,
+					cliEntry
+				});
+			}
 		});
 		this.scheduler = new Scheduler({
 			onFire: (agentId, msg) => void this.dispatch(agentId, msg).catch((err) => this.log.error(`cron dispatch failed for agent "${agentId}": ${formatErr(err)}`)),
@@ -81119,10 +81654,11 @@ var Daemon = class {
 		}
 		this.flushQueued(agentId, sessionId, integrationId);
 	}
-	/** Route a converger action: set-status → setStatus (status text only; '' clears); else postMessage. */
+	/** Route a converger action: set-status → setStatus (status + rotating loading_messages;
+	*  '' clears); else postMessage. */
 	async applyAction(action, conn, channel, thread) {
 		if (action.kind === "set-status") {
-			if (conn && thread) await conn.setStatus(channel, thread, action.text);
+			if (conn && thread) await conn.setStatus(channel, thread, action.text, action.loadingMessages);
 			return;
 		}
 		await conn?.postMessage(channel, action.text, thread);
@@ -81253,6 +81789,7 @@ var Daemon = class {
 		this.cpCrons?.stop();
 		for (const c of this.connections) 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));
+		await Promise.resolve(this.mcp?.stop()).catch((e) => errors.push(e));
 		this.store?.close();
 		if (errors.length) throw new AggregateError(errors, "stop: partial failure");
 	}
@@ -81423,12 +81960,78 @@ async function runLogin(opts, partial = {}) {
 	await deps.runForeground();
 }
 //#endregion
+//#region src/lock.ts
+/**
+* Thrown when a foreground daemon is started while another live daemon already
+* holds the per-root lock. Two daemons sharing one Slack app token each open a
+* Socket Mode connection; Slack round-robins events across connections (it does
+* not broadcast), so each instance receives only a fraction of messages and the
+* rest appear silently dropped — no error, no log on the instance you're watching.
+*/
+var DaemonAlreadyRunningError = class extends Error {
+	pid;
+	lockFile;
+	constructor(pid, lockFile) {
+		super(`another agentconnect daemon is already running (pid ${pid}; lock ${lockFile}). Stop it first — two daemons sharing one Slack app token split Socket Mode events between them, so messages appear to be silently dropped.`);
+		this.pid = pid;
+		this.lockFile = lockFile;
+		this.name = "DaemonAlreadyRunningError";
+	}
+};
+/** True if a process with `pid` exists. EPERM ⇒ it exists but is owned by another user. */
+function pidAlive(pid) {
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch (err) {
+		return err.code === "EPERM";
+	}
+}
+/**
+* Best-effort single-instance guard for the foreground daemon, keyed by `root`.
+* A lock file holding a live pid blocks (throws DaemonAlreadyRunningError); a
+* stale lock (dead pid, garbage, or absent) is reclaimed. `release()` removes the
+* file only if we still own it. There is a small TOCTOU window — this guards
+* against accidental double-starts (the launchd service + a manual `run`), not a
+* determined concurrent race.
+*
+* Scoped per-root, not per-app-token: the common collision is two daemons sharing
+* one `~/.agentconnect`. Distinct roots that happen to carry the same token would
+* still collide on Slack but not here.
+*/
+function acquireSingletonLock(root, deps = {}) {
+	const file = lockPath(root);
+	const myPid = deps.pid ?? process.pid;
+	try {
+		const prev = Number.parseInt(readFileSync(file, "utf8").trim(), 10);
+		if (Number.isInteger(prev) && prev !== myPid && pidAlive(prev)) throw new DaemonAlreadyRunningError(prev, file);
+	} catch (err) {
+		if (err instanceof DaemonAlreadyRunningError) throw err;
+	}
+	writeFileSync(file, `${myPid}\n`, "utf8");
+	let released = false;
+	return { release() {
+		if (released) return;
+		released = true;
+		try {
+			if (Number.parseInt(readFileSync(file, "utf8").trim(), 10) === myPid) unlinkSync(file);
+		} catch {}
+	} };
+}
+//#endregion
 //#region src/index.ts
 const program = new Command();
 program.name("agentconnect").description("AgentConnect daemon — edge message + agent execution unit").version(DAEMON_VERSION);
 program.option("--config <path>", "path to config.json (default ~/.agentconnect/config.json)").option("--root <dir>", "override ~/.agentconnect root directory").option("--cp-url <url>", "override controlPlane.url").option("--cp-key <key>", "override controlPlane.key (the CP API key)").option("--no-cp", "run fully local, do not connect to the Control Plane").option("--daemon-id <id>", "override daemon identity").option("--log-level <level>", "trace|debug|info|warn|error").option("--agents-dir <dir>", "override agents directory").option("--max-agents <n>", "max agents this daemon advertises / enforces").option("--dry-run", "load + validate config and print the reconcile plan, then exit").option("--agent <name>", "select a single agent by id (run/chat)");
 program.command("run").description("Run the daemon in the foreground").action(async () => {
 	const opts = program.opts();
+	let lock;
+	try {
+		lock = acquireSingletonLock(resolveRoot(opts.root));
+	} catch (err) {
+		console.error(`agentconnect run: ${err.message}`);
+		process.exit(1);
+	}
 	try {
 		await runForeground({
 			root: opts.root,
@@ -81443,12 +82046,18 @@ program.command("run").description("Run the daemon in the foreground").action(as
 				maxAgents: opts.maxAgents ? Number(opts.maxAgents) : void 0
 			}
 		});
+		lock.release();
 		process.exit(0);
 	} catch (err) {
+		lock.release();
 		console.error(`agentconnect run: ${err.message}`);
 		process.exit(1);
 	}
 });
+program.command("mcp-bridge", { hidden: true }).description("internal: stdio MCP bridge to the running daemon").action(async () => {
+	const { runBridge } = await import("./bridge-Dj8U1Jp7.js");
+	await runBridge();
+});
 const controller = () => resolveController({ root: program.opts().root });
 const requireInstalled = (c) => {
 	if (!c.isInstalled()) {
@@ -81580,6 +82189,6 @@ program.command("chat [message]").description("Discover an agent under --agents-
 });
 program.parse();
 //#endregion
-export {};
+export { __commonJSMin as C, safeParse$1 as S, record as _, _null as a, unknown as b, custom as c, literal as d, looseObject as f, preprocess as g, optional as h, _enum as i, discriminatedUnion as l, object as m, encodeFrame as n, array as o, number as p, DAEMON_VERSION as r, boolean as s, decodeFrames as t, intersection as u, string as v, __toESM as w, datetime as x, union as y };
 
 //# sourceMappingURL=index.js.map