@agentconnect.md/daemon 1.0.0-rc.24 → 1.0.0-rc.26

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 = {}) {
@@ -7567,6 +7655,9 @@ const AgentSchema = object({
 		"paused"
 	]).default("active"),
 	runtime: string(),
+	description: string().optional(),
+	reasoningEffort: string().optional(),
+	executionMode: string().optional(),
 	runtimeOverrides: object({
 		model: string().optional(),
 		env: array(object({
@@ -16786,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;
@@ -19496,9 +19587,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();
@@ -20065,7 +20156,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;
@@ -20242,7 +20333,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.
@@ -20253,7 +20344,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);
 	}
 	/**
@@ -22985,6 +23076,44 @@ function watch$1(paths, options = {}) {
 	return watcher;
 }
 //#endregion
+//#region src/agents/cp-overlay.ts
+/** Apply a CP `AgentSpec` onto a local agent, returning a new overlaid agent. */
+function overlayCpSpec(base, spec) {
+	const envMap = new Map((base.runtimeOverrides?.env ?? []).map((e) => [e.name, e.value]));
+	for (const [name, value] of Object.entries(spec.env ?? {})) envMap.set(name, value);
+	const env = [...envMap].map(([name, value]) => ({
+		name,
+		value
+	}));
+	return {
+		...base,
+		name: spec.name,
+		...spec.description !== void 0 ? { description: spec.description } : {},
+		...spec.reasoningEffort !== void 0 ? { reasoningEffort: spec.reasoningEffort } : {},
+		...spec.executionMode !== void 0 ? { executionMode: spec.executionMode } : {},
+		runtimeOverrides: {
+			...base.runtimeOverrides,
+			...spec.model !== void 0 ? { model: spec.model } : {},
+			env
+		}
+	};
+}
+/**
+* Runtime config the daemon can only surface to an ACP child as environment
+* variables: ACP `session/new`/`initialize` carry no model or system-prompt
+* field (SDK v1), so model / reasoning / prompt are exposed under `AGENTCONNECT_*`
+* for runtimes that read them. (`runtimeOverrides.env` is applied separately by
+* `agentChildEnv`.) Only emits a key when the value is set.
+*/
+function cpRuntimeEnv(agent) {
+	const out = {};
+	if (agent.runtimeOverrides?.model) out.AGENTCONNECT_MODEL = agent.runtimeOverrides.model;
+	if (agent.reasoningEffort) out.AGENTCONNECT_REASONING_EFFORT = agent.reasoningEffort;
+	if (agent.executionMode) out.AGENTCONNECT_EXECUTION_MODE = agent.executionMode;
+	if (agent.description) out.AGENTCONNECT_SYSTEM_PROMPT = agent.description;
+	return out;
+}
+//#endregion
 //#region src/reconciler/reconciler.ts
 /** Stable identity-free signature of an agent's effective config. Excludes the
 *  loader-only `dir`/`env` fields (present on `LoadedAgent`) so the comparison is
@@ -23042,6 +23171,10 @@ var LocalStore = class {
         id INTEGER PRIMARY KEY CHECK (id = 1),
         routingEpoch INTEGER, assignments TEXT, globalRules TEXT
       );
+      CREATE TABLE IF NOT EXISTS cp_agents (
+        id INTEGER PRIMARY KEY CHECK (id = 1),
+        specs TEXT
+      );
     `);
 	}
 	getSession(key) {
@@ -23075,6 +23208,13 @@ var LocalStore = class {
 			globalRules
 		});
 	}
+	getCpAgents() {
+		return this.db.prepare("SELECT specs FROM cp_agents WHERE id = 1").get();
+	}
+	setCpAgents(specs) {
+		this.db.prepare(`INSERT INTO cp_agents (id, specs) VALUES (1, @specs)
+         ON CONFLICT(id) DO UPDATE SET specs=excluded.specs`).run({ specs });
+	}
 	close() {
 		this.db.close();
 	}
@@ -23106,7 +23246,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,
@@ -23127,7 +23272,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,
@@ -23140,7 +23290,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({
@@ -23167,6 +23317,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",
@@ -79221,6 +79671,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;
@@ -79266,11 +79718,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).
@@ -79295,9 +79787,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;
 	}
@@ -79313,6 +79814,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": {
@@ -79321,42 +79847,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
@@ -80533,6 +81070,14 @@ var CpClient = class {
 			case "route/update":
 				this.deps.configApply.applyRouteUpdate(frame.payload);
 				return;
+			case "agent/upsert": {
+				const u = frame.payload;
+				this.deps.configApply.applyAgentUpsert(u.agentId, u.spec);
+				return;
+			}
+			case "agent/remove":
+				this.deps.configApply.applyAgentRemove(frame.payload.agentId);
+				return;
 			case "agent/launch":
 			case "agent/stop":
 			case "agent/prompt":
@@ -80586,6 +81131,46 @@ var CpCronRegistry = class {
 	}
 };
 //#endregion
+//#region src/cp/cp-agent-registry.ts
+var CpAgentRegistry = class {
+	io;
+	onChange;
+	specs = /* @__PURE__ */ new Map();
+	constructor(io, onChange) {
+		this.io = io;
+		this.onChange = onChange;
+		const s = io.load();
+		if (s) this.specs = new Map(Object.entries(s));
+	}
+	/** Add or replace one agent's spec (agent/upsert EVT). */
+	upsert(agentId, spec) {
+		this.specs.set(agentId, spec);
+		this.changed();
+	}
+	/** Drop one agent's spec (agent/remove EVT). No-op if absent. */
+	remove(agentId) {
+		if (this.specs.delete(agentId)) this.changed();
+	}
+	/** Make the live set exactly `roster` (register/ok reconcile snapshot). */
+	converge(roster) {
+		const next = /* @__PURE__ */ new Map();
+		for (const { agentId, ...spec } of roster) next.set(agentId, spec);
+		this.specs = next;
+		this.changed();
+	}
+	get(agentId) {
+		return this.specs.get(agentId);
+	}
+	/** agentIds the CP currently wants present. */
+	ids() {
+		return [...this.specs.keys()];
+	}
+	changed() {
+		this.io.save(Object.fromEntries(this.specs));
+		this.onChange();
+	}
+};
+//#endregion
 //#region src/cp/config-apply.ts
 const LOG_LEVELS = /* @__PURE__ */ new Set([
 	"trace",
@@ -80669,7 +81254,9 @@ const MAX_QUEUED_PER_SESSION = 10;
 var Daemon = class {
 	opts;
 	store;
+	mcp;
 	agents = /* @__PURE__ */ new Map();
+	fileAgents = /* @__PURE__ */ new Map();
 	hosts = /* @__PURE__ */ new Map();
 	connections = [];
 	scheduler;
@@ -80686,6 +81273,7 @@ var Daemon = class {
 	runtimeNames = {};
 	cpClient;
 	cpCrons;
+	cpAgents;
 	botUserIds = {};
 	cpRouting;
 	constructor(opts = {}) {
@@ -80710,7 +81298,7 @@ var Daemon = class {
 		this.log.info(`control plane: ${cfg.controlPlane?.enabled ? `enabled (${cfg.controlPlane.url ?? "no url"})` : "disabled — running local"}`);
 		this.agentsDir = cfg.agentsDir;
 		const agents = this.loadAgentList();
-		for (const a of agents) this.agents.set(a.id, a);
+		this.fileAgents = new Map(agents.map((a) => [a.id, a]));
 		this.log.info(`loaded ${agents.length} agent(s) from ${this.agentsDir}${agents.length ? `: ${agents.map((a) => a.id).join(", ")}` : ""}`);
 		this.root = root;
 		const resolvedRuntimes = await resolveRuntimes(cfg, root, {
@@ -80734,10 +81322,50 @@ var Daemon = class {
 			},
 			save: (s) => this.store.setCpRouting(s.routingEpoch, JSON.stringify(s.assignments), JSON.stringify(s.globalRules))
 		});
+		this.cpAgents = new CpAgentRegistry({
+			load: () => {
+				const row = this.store.getCpAgents();
+				return row ? JSON.parse(row.specs) : void 0;
+			},
+			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)}`)),
@@ -80789,8 +81417,51 @@ var Daemon = class {
 	loadAgentList() {
 		return this.opts.agentName ? [selectAgent(this.agentsDir, this.opts.agentName)] : loadAgents(this.agentsDir);
 	}
+	/**
+	* Effective agent set = on-disk `agent.json` base with the CP spec overlaid
+	* (joined by id; CP owns name/description/model/reasoning/execution/env, the
+	* file owns runtime/workspace). CP-only ids with no local base are skipped —
+	* not runnable — and surfaced via cpDegradedScopes().
+	*/
+	effectiveAgents() {
+		return [...this.fileAgents.values()].map((base) => {
+			const spec = this.cpAgents?.get(base.id);
+			return spec ? overlayCpSpec(base, spec) : base;
+		});
+	}
+	/**
+	* Converge the running set to the desired effective agents. Driven by both the
+	* `agents/**` file-watch AND CP convergence (agent/upsert, agent/remove, the
+	* register/ok roster, via the registry's onChange). `diffAgents` detects a
+	* changed effective config (runtime/workspace/model/prompt/env/…) and restarts
+	* the host lazily so the next session picks up fresh config.
+	*
+	* Single-flight: overlapping triggers (e.g. a burst of CP frames, or a file
+	* event landing mid-reconcile) coalesce into one trailing re-run so we never
+	* run two passes concurrently and double-evict a host.
+	*/
+	reconcileRun;
+	reconcilePending = false;
 	async reconcile() {
-		const desired = this.loadAgentList();
+		if (this.reconcileRun) {
+			this.reconcilePending = true;
+			return this.reconcileRun;
+		}
+		this.reconcileRun = this.runReconcile();
+		try {
+			await this.reconcileRun;
+		} finally {
+			this.reconcileRun = void 0;
+		}
+		if (this.reconcilePending) {
+			this.reconcilePending = false;
+			await this.reconcile();
+		}
+	}
+	async runReconcile() {
+		const files = this.loadAgentList();
+		this.fileAgents = new Map(files.map((a) => [a.id, a]));
+		const desired = this.effectiveAgents();
 		const { toStart, toStop, toRestart } = diffAgents(desired, this.agents);
 		if (toStart.length || toStop.length || toRestart.length) this.log.info(`reconcile: ${desired.length} desired agent(s) from ${this.agentsDir}; start=[${toStart.map((a) => a.id).join(", ")}] stop=[${toStop.join(", ")}] restart=[${toRestart.map((a) => a.id).join(", ")}]`);
 		else this.log.debug(`reconcile: no changes (${desired.length} desired agent(s))`);
@@ -80825,7 +81496,10 @@ var Daemon = class {
 			if (!runtime) throw new Error(`runtime "${agent.runtime}" not available: not installed on this host, or absent from config.runtimes / the ACP registry`);
 			host = new AcpHost(runtime, {
 				onUpdate,
-				env: agentChildEnv(agent),
+				env: {
+					...agentChildEnv(agent),
+					...cpRuntimeEnv(agent)
+				},
 				log: this.log
 			});
 		}
@@ -80929,10 +81603,15 @@ var Daemon = class {
 	resolveCpAgent(agentId) {
 		return resolveAgentIntegration(this.agents.get(agentId), this.botUserIds);
 	}
-	/** agentIds of CP rules that currently resolve to null (no servable Slack integration). */
+	/**
+	* agentIds the daemon can't fully serve: CP routing rules with no servable
+	* Slack integration, plus CP agent specs with no on-disk base (no runtime /
+	* workspace to materialize — the spec alone can't be run).
+	*/
 	cpDegradedScopes() {
 		const out = /* @__PURE__ */ new Set();
 		for (const cpRule of this.cpRouting?.effectiveRules() ?? []) if (!this.resolveCpAgent(cpRule.agentId)) out.add(cpRule.agentId);
+		for (const id of this.cpAgents?.ids() ?? []) if (!this.fileAgents.has(id)) out.add(id);
 		return [...out];
 	}
 	async dispatch(agentId, msg, integrationId) {
@@ -80958,10 +81637,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);
@@ -80996,6 +81676,7 @@ var Daemon = class {
 			},
 			applyReconcileSnapshot: (snap) => {
 				this.cpCrons?.converge(snap.crons);
+				this.cpAgents?.converge(snap.agents);
 				this.cpRouting?.converge({
 					routingEpoch: snap.routingEpoch,
 					assignments: snap.assignments,
@@ -81003,7 +81684,10 @@ var Daemon = class {
 				});
 				if (snap.leases.length) this.log.debug(`cp: ${snap.leases.length} lease(s) noted (secrets handled later)`);
 				if (snap.assignments.length) this.log.debug(`cp: converged ${snap.assignments.length} assignment(s)`);
+				if (snap.agents.length) this.log.debug(`cp: converged ${snap.agents.length} agent spec(s)`);
 			},
+			applyAgentUpsert: (agentId, spec) => this.cpAgents?.upsert(agentId, spec),
+			applyAgentRemove: (agentId) => this.cpAgents?.remove(agentId),
 			upsertCron: (cron) => this.cpCrons.upsert(cron),
 			removeCron: (cronId) => this.cpCrons.remove(cronId),
 			applyRouteAssign: (a) => this.cpRouting?.upsertAssign(a),
@@ -81088,6 +81772,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");
 	}
@@ -81258,12 +81943,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,
@@ -81278,12 +82029,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()) {
@@ -81415,6 +82172,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