@agentconnect.md/daemon 1.0.0-rc.48 → 1.0.0-rc.49

package/dist/index.js

@@ -16889,6 +16889,128 @@ AGENT_METHODS.session_cancel, AGENT_METHODS.nes_accept, AGENT_METHODS.nes_reject
 CLIENT_METHODS.session_request_permission, CLIENT_METHODS.fs_write_text_file, CLIENT_METHODS.fs_read_text_file, CLIENT_METHODS.terminal_create, CLIENT_METHODS.terminal_output, CLIENT_METHODS.terminal_release, CLIENT_METHODS.terminal_wait_for_exit, CLIENT_METHODS.terminal_kill, CLIENT_METHODS.elicitation_create;
 CLIENT_METHODS.session_update, CLIENT_METHODS.elicitation_complete;
 //#endregion
+//#region src/runtimes/probe.ts
+/**
+* Host-availability probing for runtimes.
+*
+* `resolveRuntimes()` produces a runtime for every ACP-registry entry that has a
+* distribution for this platform — but that says nothing about whether the tool
+* is actually runnable *here*. This module answers that question so the daemon
+* only advertises genuinely-installed runtimes in `RegisterReq.capabilities`.
+*
+* Two layers:
+*  1. A generic launcher check — is the runtime's `command` resolvable? For a
+*     runtime distributed as a real binary (`command` is the tool's own
+*     executable) this is a meaningful signal: the binary on `$PATH` means it's
+*     installed.
+*  2. For runtimes distributed via a package launcher (`npx`/`uvx`), (1) is
+*     meaningless — the launcher fetches on demand, so "npx exists" is true on
+*     virtually every dev host and tells us nothing about the wrapped agent. For
+*     those we REQUIRE a per-runtime custom probe (`CUSTOM_PROBES`) that looks for
+*     the wrapped CLI's own config/state dir, which appears once the user has
+*     installed and run/initialized it. A launcher-distributed runtime with no
+*     probe is treated as NOT installed — otherwise every npx/uvx agent in the
+*     ACP registry would be falsely advertised just because `npx` is on `$PATH`.
+*
+* The custom probes test for the config *directory* (the "installed & initialized
+* on this host" signal). A stricter "is logged in" check would look for the auth
+* file instead (e.g. `~/.codex/auth.json`), but that yields false negatives for
+* users who authenticate via an API-key env var, so directory presence is the
+* pragmatic signal. Paths verified against each tool's docs (June 2026).
+*/
+const isWin = process.platform === "win32";
+function isExecutableFile(p) {
+	try {
+		accessSync(p, isWin ? constants.F_OK : constants.X_OK);
+		return true;
+	} catch {
+		return false;
+	}
+}
+/**
+* Resolve a launcher command the way a shell would. A command containing a path
+* separator is treated as a literal path; a bare name is searched across `$PATH`
+* (trying `$PATHEXT` extensions on Windows).
+*/
+function isCommandAvailable(command, env = process.env) {
+	return resolveCommandPath(command, env) !== void 0;
+}
+/**
+* Resolve a launcher/command to its absolute path the way a shell would — a path
+* containing a separator is checked literally; a bare name is searched across
+* `$PATH` (trying `$PATHEXT` extensions on Windows). Returns undefined if not found.
+*/
+function resolveCommandPath(command, env = process.env) {
+	const exts = isWin ? ["", ...(env.PATHEXT ?? ".EXE;.CMD;.BAT;.COM").split(";")] : [""];
+	if (command.includes("/") || isWin && command.includes("\\")) return exts.map((ext) => command + ext).find(isExecutableFile);
+	const dirs = (env.PATH ?? "").split(delimiter).filter(Boolean);
+	for (const dir of dirs) for (const ext of exts) {
+		const p = join(dir, command) + ext;
+		if (isExecutableFile(p)) return p;
+	}
+}
+function home(env) {
+	return (isWin ? env.USERPROFILE : env.HOME) || homedir();
+}
+function xdgConfigHome(env) {
+	return env.XDG_CONFIG_HOME || join(home(env), ".config");
+}
+function xdgDataHome(env) {
+	return env.XDG_DATA_HOME || join(home(env), ".local", "share");
+}
+function pathExists(p) {
+	return !!p && existsSync(p);
+}
+/** True if any candidate path exists (undefined candidates are skipped). */
+function anyExists(...candidates) {
+	return candidates.some(pathExists);
+}
+/**
+* Custom probes keyed by ACP-registry runtime id. Add an entry here whenever the
+* launcher-on-PATH check is too weak to mean "actually installed & set up".
+* Each tests for the tool's home/XDG config dir (or, where the dir is ambiguous,
+* a tool-specific file), honoring the documented env overrides.
+*/
+const CUSTOM_PROBES = {
+	"claude-acp": (env) => anyExists(join(home(env), ".claude"), join(home(env), ".claude.json")),
+	"codex-acp": (env) => anyExists(env.CODEX_HOME, join(home(env), ".codex")),
+	gemini: (env) => pathExists(join(home(env), ".gemini")),
+	"qwen-code": (env) => pathExists(join(home(env), ".qwen")),
+	"github-copilot-cli": (env) => anyExists(env.COPILOT_HOME, join(home(env), ".copilot")),
+	cursor: (env) => anyExists(env.CURSOR_CONFIG_DIR ? join(env.CURSOR_CONFIG_DIR, "cli-config.json") : void 0, join(home(env), ".cursor", "cli-config.json")),
+	opencode: (env) => anyExists(join(xdgConfigHome(env), "opencode"), join(xdgDataHome(env), "opencode", "auth.json")),
+	goose: (env) => pathExists(join(xdgConfigHome(env), "goose")),
+	"amp-acp": (env) => anyExists(env.AMP_SETTINGS_FILE, join(xdgConfigHome(env), "amp")),
+	auggie: (env) => pathExists(join(home(env), ".augment")),
+	cline: (env) => anyExists(env.CLINE_DATA_DIR, join(home(env), ".cline")),
+	"grok-build": (env) => pathExists(join(home(env), ".grok")),
+	kimi: (env) => anyExists(env.KIMI_CODE_HOME, join(home(env), ".kimi"), join(home(env), ".kimi-code")),
+	"factory-droid": (env) => pathExists(join(home(env), ".factory")),
+	devin: (env) => anyExists(join(xdgConfigHome(env), "devin"), join(xdgDataHome(env), "devin"))
+};
+/**
+* Package launchers that fetch-and-run on demand. When a runtime is launched via
+* one of these, the launcher being on `$PATH` says nothing about whether the
+* wrapped agent is installed, so such runtimes require a custom probe to count.
+*/
+const PACKAGE_LAUNCHERS = /* @__PURE__ */ new Set(["npx", "uvx"]);
+/** Is this runtime actually usable on this host? */
+function isRuntimeAvailable(id, rt, env = process.env) {
+	if (!isCommandAvailable(rt.command, env)) return false;
+	const custom = CUSTOM_PROBES[id];
+	if (custom) return custom(env);
+	return !PACKAGE_LAUNCHERS.has(rt.command);
+}
+/**
+* Filter a runtime map down to those installed on this host — what the daemon
+* should report to the Control Plane and is able to launch.
+*/
+function installedRuntimes(runtimes, env = process.env) {
+	const out = {};
+	for (const [id, rt] of Object.entries(runtimes)) if (isRuntimeAvailable(id, rt, env)) out[id] = rt;
+	return out;
+}
+//#endregion
 //#region src/acp/acp-host.ts
 const PROTOCOL_VERSION = 1;
 /**
@@ -16920,19 +17042,32 @@ var AcpHost = class {
 		this.runtime = runtime;
 		this.opts = opts;
 	}
+	/** A Claude Code runtime (its command/args reference `claude`) — these embed the
+	*  @anthropic-ai/claude-agent-sdk, which needs a Claude Code executable. */
+	isClaudeRuntime() {
+		return [this.runtime.command, ...this.runtime.args].join(" ").toLowerCase().includes("claude");
+	}
 	async start() {
 		if (this.child) throw new Error("AcpHost: already started");
+		const env = {
+			...process.env,
+			...Object.fromEntries(this.runtime.env.map((e) => [e.name, e.value])),
+			...this.opts.env ?? {}
+		};
+		if (!env.CLAUDE_CODE_EXECUTABLE && this.isClaudeRuntime()) {
+			const claude = resolveCommandPath("claude", env);
+			if (claude) {
+				env.CLAUDE_CODE_EXECUTABLE = claude;
+				this.opts.log?.info(`acp: CLAUDE_CODE_EXECUTABLE not set — using claude on PATH (${claude})`);
+			}
+		}
 		const child = spawn(this.runtime.command, this.runtime.args, {
 			stdio: [
 				"pipe",
 				"pipe",
 				"inherit"
 			],
-			env: {
-				...process.env,
-				...Object.fromEntries(this.runtime.env.map((e) => [e.name, e.value])),
-				...this.opts.env ?? {}
-			}
+			env
 		});
 		this.child = child;
 		if (!child.stdin || !child.stdout) throw new Error("AcpHost: subprocess stdin/stdout are not piped");
@@ -17398,6 +17533,61 @@ const AgentScopeDenied = object({
 	capability: string()
 });
 //#endregion
+//#region ../protocol/dist/frames/integration.js
+/**
+* Platform integration distribution (C→D) — the Slack "install" flow.
+*
+* The Control Plane is the source of truth for platform integrations and pushes
+* them to the daemon that owns the integration's agent (`integration/upsert`, and
+* the reconcile snapshot `RegisterOk.integrations[]`). The daemon opens the Socket
+* Mode connection from the delivered config (see slack/connection.ts).
+*
+* SECURITY: `integration/upsert` and `RegisterOk.integrations[]` carry PLAINTEXT
+* platform tokens (botToken/appToken). These payloads MUST NEVER be logged — no
+* body dump on decode error, no register/ok snapshot debug dump.
+*
+* `signingSecret` is intentionally absent: Socket Mode authenticates with the
+* app-level token, so the daemon never needs a signing secret.
+*/
+/** Trigger match — mirrors the daemon BindRuleConfig.match (agents/agent-schema.ts). */
+const BindMatch = discriminatedUnion("kind", [
+	object({ kind: literal("mention") }),
+	object({ kind: literal("dm") }),
+	object({
+		kind: literal("keyword"),
+		value: string()
+	}),
+	object({ kind: literal("auto") })
+]);
+/** One channel/thread trigger binding — mirrors the daemon BindRuleConfig. */
+const IntegrationBindRule = object({
+	channel: string().optional(),
+	thread: string().optional(),
+	match: BindMatch
+});
+/** The Slack config the daemon needs to open + route a socket (no signingSecret). */
+const IntegrationSlackConfig = object({
+	botToken: string(),
+	appToken: string(),
+	allowedUserIds: array(string()).default([]),
+	notificationChannelId: string().optional(),
+	bindRules: array(IntegrationBindRule).default([])
+});
+/**
+* One platform integration, owned by exactly one agent. Also the element type of
+* `RegisterOk.integrations[]` (the per-daemon reconcile set).
+*/
+const IntegrationSpec = object({
+	integrationId: string().uuid(),
+	agentId: string().uuid(),
+	platform: literal("slack"),
+	slack: IntegrationSlackConfig
+});
+/** C→D EVT — install/update an integration on the owning agent's daemon. */
+const IntegrationUpsert = IntegrationSpec;
+/** C→D EVT — remove an integration from the daemon. */
+const IntegrationRemove = object({ integrationId: string().uuid() });
+//#endregion
 //#region ../protocol/dist/frames/register.js
 /**
 * Capability upload + the reconcile snapshot — protocol §3.3.
@@ -17426,6 +17616,7 @@ const RegisterOk = object({
 	assignments: array(RouteAssign),
 	agents: array(AgentSpec.extend({ agentId: string().uuid() })).default([]),
 	crons: array(CronUpsert),
+	integrations: array(IntegrationSpec).default([]),
 	leases: array(SecretsGrant),
 	drop: object({
 		assignments: array(string()),
@@ -17527,6 +17718,8 @@ const FRAME_SCHEMAS = {
 	"drain/done": DrainDone,
 	"cron/upsert": CronUpsert,
 	"cron/remove": CronRemove,
+	"integration/upsert": IntegrationUpsert,
+	"integration/remove": IntegrationRemove,
 	"secrets/request": SecretsRequest,
 	"secrets/grant": SecretsGrant,
 	"secrets/renew": SecretsRenew,
@@ -17641,6 +17834,8 @@ discriminatedUnion("type", [
 	frame("drain/done", FRAME_SCHEMAS["drain/done"]),
 	frame("cron/upsert", FRAME_SCHEMAS["cron/upsert"]),
 	frame("cron/remove", FRAME_SCHEMAS["cron/remove"]),
+	frame("integration/upsert", FRAME_SCHEMAS["integration/upsert"]),
+	frame("integration/remove", FRAME_SCHEMAS["integration/remove"]),
 	frame("secrets/request", FRAME_SCHEMAS["secrets/request"]),
 	frame("secrets/grant", FRAME_SCHEMAS["secrets/grant"]),
 	frame("secrets/renew", FRAME_SCHEMAS["secrets/renew"]),
@@ -81451,116 +81646,6 @@ var Scheduler = class {
 	}
 };
 //#endregion
-//#region src/runtimes/probe.ts
-/**
-* Host-availability probing for runtimes.
-*
-* `resolveRuntimes()` produces a runtime for every ACP-registry entry that has a
-* distribution for this platform — but that says nothing about whether the tool
-* is actually runnable *here*. This module answers that question so the daemon
-* only advertises genuinely-installed runtimes in `RegisterReq.capabilities`.
-*
-* Two layers:
-*  1. A generic launcher check — is the runtime's `command` resolvable? For a
-*     runtime distributed as a real binary (`command` is the tool's own
-*     executable) this is a meaningful signal: the binary on `$PATH` means it's
-*     installed.
-*  2. For runtimes distributed via a package launcher (`npx`/`uvx`), (1) is
-*     meaningless — the launcher fetches on demand, so "npx exists" is true on
-*     virtually every dev host and tells us nothing about the wrapped agent. For
-*     those we REQUIRE a per-runtime custom probe (`CUSTOM_PROBES`) that looks for
-*     the wrapped CLI's own config/state dir, which appears once the user has
-*     installed and run/initialized it. A launcher-distributed runtime with no
-*     probe is treated as NOT installed — otherwise every npx/uvx agent in the
-*     ACP registry would be falsely advertised just because `npx` is on `$PATH`.
-*
-* The custom probes test for the config *directory* (the "installed & initialized
-* on this host" signal). A stricter "is logged in" check would look for the auth
-* file instead (e.g. `~/.codex/auth.json`), but that yields false negatives for
-* users who authenticate via an API-key env var, so directory presence is the
-* pragmatic signal. Paths verified against each tool's docs (June 2026).
-*/
-const isWin = process.platform === "win32";
-function isExecutableFile(p) {
-	try {
-		accessSync(p, isWin ? constants.F_OK : constants.X_OK);
-		return true;
-	} catch {
-		return false;
-	}
-}
-/**
-* Resolve a launcher command the way a shell would. A command containing a path
-* separator is treated as a literal path; a bare name is searched across `$PATH`
-* (trying `$PATHEXT` extensions on Windows).
-*/
-function isCommandAvailable(command, env = process.env) {
-	const exts = isWin ? ["", ...(env.PATHEXT ?? ".EXE;.CMD;.BAT;.COM").split(";")] : [""];
-	if (command.includes("/") || isWin && command.includes("\\")) return exts.some((ext) => isExecutableFile(command + ext));
-	return (env.PATH ?? "").split(delimiter).filter(Boolean).some((dir) => exts.some((ext) => isExecutableFile(join(dir, command) + ext)));
-}
-function home(env) {
-	return (isWin ? env.USERPROFILE : env.HOME) || homedir();
-}
-function xdgConfigHome(env) {
-	return env.XDG_CONFIG_HOME || join(home(env), ".config");
-}
-function xdgDataHome(env) {
-	return env.XDG_DATA_HOME || join(home(env), ".local", "share");
-}
-function pathExists(p) {
-	return !!p && existsSync(p);
-}
-/** True if any candidate path exists (undefined candidates are skipped). */
-function anyExists(...candidates) {
-	return candidates.some(pathExists);
-}
-/**
-* Custom probes keyed by ACP-registry runtime id. Add an entry here whenever the
-* launcher-on-PATH check is too weak to mean "actually installed & set up".
-* Each tests for the tool's home/XDG config dir (or, where the dir is ambiguous,
-* a tool-specific file), honoring the documented env overrides.
-*/
-const CUSTOM_PROBES = {
-	"claude-acp": (env) => anyExists(join(home(env), ".claude"), join(home(env), ".claude.json")),
-	"codex-acp": (env) => anyExists(env.CODEX_HOME, join(home(env), ".codex")),
-	gemini: (env) => pathExists(join(home(env), ".gemini")),
-	"qwen-code": (env) => pathExists(join(home(env), ".qwen")),
-	"github-copilot-cli": (env) => anyExists(env.COPILOT_HOME, join(home(env), ".copilot")),
-	cursor: (env) => anyExists(env.CURSOR_CONFIG_DIR ? join(env.CURSOR_CONFIG_DIR, "cli-config.json") : void 0, join(home(env), ".cursor", "cli-config.json")),
-	opencode: (env) => anyExists(join(xdgConfigHome(env), "opencode"), join(xdgDataHome(env), "opencode", "auth.json")),
-	goose: (env) => pathExists(join(xdgConfigHome(env), "goose")),
-	"amp-acp": (env) => anyExists(env.AMP_SETTINGS_FILE, join(xdgConfigHome(env), "amp")),
-	auggie: (env) => pathExists(join(home(env), ".augment")),
-	cline: (env) => anyExists(env.CLINE_DATA_DIR, join(home(env), ".cline")),
-	"grok-build": (env) => pathExists(join(home(env), ".grok")),
-	kimi: (env) => anyExists(env.KIMI_CODE_HOME, join(home(env), ".kimi"), join(home(env), ".kimi-code")),
-	"factory-droid": (env) => pathExists(join(home(env), ".factory")),
-	devin: (env) => anyExists(join(xdgConfigHome(env), "devin"), join(xdgDataHome(env), "devin"))
-};
-/**
-* Package launchers that fetch-and-run on demand. When a runtime is launched via
-* one of these, the launcher being on `$PATH` says nothing about whether the
-* wrapped agent is installed, so such runtimes require a custom probe to count.
-*/
-const PACKAGE_LAUNCHERS = /* @__PURE__ */ new Set(["npx", "uvx"]);
-/** Is this runtime actually usable on this host? */
-function isRuntimeAvailable(id, rt, env = process.env) {
-	if (!isCommandAvailable(rt.command, env)) return false;
-	const custom = CUSTOM_PROBES[id];
-	if (custom) return custom(env);
-	return !PACKAGE_LAUNCHERS.has(rt.command);
-}
-/**
-* Filter a runtime map down to those installed on this host — what the daemon
-* should report to the Control Plane and is able to launch.
-*/
-function installedRuntimes(runtimes, env = process.env) {
-	const out = {};
-	for (const [id, rt] of Object.entries(runtimes)) if (isRuntimeAvailable(id, rt, env)) out[id] = rt;
-	return out;
-}
-//#endregion
 //#region src/runtimes/runtime-prober.ts
 const DEFAULT_TIMEOUT_MS = 3e4;
 const DEFAULT_CONCURRENCY = 3;
@@ -81963,6 +82048,12 @@ var CpClient = class {
 			case "agent/remove":
 				this.deps.configApply.applyAgentRemove(frame.payload.agentId);
 				return;
+			case "integration/upsert":
+				this.deps.configApply.applyIntegrationUpsert(frame.payload);
+				return;
+			case "integration/remove":
+				this.deps.configApply.applyIntegrationRemove(frame.payload.integrationId);
+				return;
 			case "agent/launch": {
 				const launch = frame.payload;
 				this.deps.configApply.applyAgentLaunch(launch).then((launched) => this.reply(frame, "agent/launched", launched)).catch((err) => this.sendError(frame.id, "INTERNAL", `agent/launch failed: ${err.message}`, false));
@@ -82259,6 +82350,59 @@ var CpAgentRegistry = class {
 	}
 };
 //#endregion
+//#region src/cp/cp-integration-registry.ts
+/** Map the wire spec to the daemon's `Integration` shape (agent-schema). */
+function toIntegration(spec) {
+	return {
+		id: spec.integrationId,
+		platform: "slack",
+		slack: {
+			botToken: spec.slack.botToken,
+			appToken: spec.slack.appToken,
+			allowedUserIds: spec.slack.allowedUserIds,
+			...spec.slack.notificationChannelId ? { notificationChannelId: spec.slack.notificationChannelId } : {},
+			bindRules: spec.slack.bindRules
+		}
+	};
+}
+var CpIntegrationRegistry = class {
+	onChange;
+	byId = /* @__PURE__ */ new Map();
+	constructor(onChange) {
+		this.onChange = onChange;
+	}
+	/** Add or replace one CP integration (integration/upsert EVT). */
+	upsert(spec) {
+		this.byId.set(spec.integrationId, spec);
+		this.onChange();
+	}
+	/** Drop one CP integration (integration/remove EVT). */
+	remove(integrationId) {
+		if (this.byId.delete(integrationId)) this.onChange();
+	}
+	/**
+	* Replace the whole CP-owned set from the `register/ok` reconcile roster (the CP
+	* is authoritative and the roster is already filtered to THIS daemon).
+	*/
+	converge(specs) {
+		this.byId = new Map((specs ?? []).map((s) => [s.integrationId, s]));
+		this.onChange();
+	}
+	/** CP integrations grouped by owning agentId, as daemon `Integration[]`. */
+	byAgent() {
+		const out = /* @__PURE__ */ new Map();
+		for (const spec of this.byId.values()) {
+			const list = out.get(spec.agentId) ?? [];
+			list.push(toIntegration(spec));
+			out.set(spec.agentId, list);
+		}
+		return out;
+	}
+	get size() {
+		return this.byId.size;
+	}
+};
+//#endregion
 //#region src/cp/config-apply.ts
 const LOG_LEVELS = /* @__PURE__ */ new Set([
 	"trace",
@@ -82399,6 +82543,8 @@ var Daemon = class Daemon {
 	cpClient;
 	cpCrons;
 	cpAgents;
+	cpIntegrations;
+	warnedOrphanIntegrations = /* @__PURE__ */ new Set();
 	botUserIds = {};
 	cpRouting;
 	clock;
@@ -82461,6 +82607,7 @@ var Daemon = class Daemon {
 			knownRuntimes: Object.keys(this.runtimes),
 			warn: (m) => this.log.warn(m)
 		}, () => void this.reconcile().catch((err) => this.log.error(`cp: agent reconcile failed: ${err.stack ?? err}`)));
+		this.cpIntegrations = new CpIntegrationRegistry(() => void this.reconcile().catch((err) => this.log.error(`cp: integration reconcile failed: ${err.stack ?? err}`)));
 		for (const a of this.effectiveAgents()) {
 			this.agents.set(a.id, a);
 			this.prefetchClone(a);
@@ -82559,13 +82706,50 @@ var Daemon = class Daemon {
 		return this.opts.agentName ? [selectAgent(this.agentsDir, this.opts.agentName)] : loadAgents(this.agentsDir);
 	}
 	/**
-	* Effective agent set = the on-disk `agent.json` files verbatim. The CP spec is
-	* no longer overlaid in memory — `agent/upsert` writes it straight to disk (see
-	* cp/cp-agent-registry.ts → agents/write-agent.ts), so the loaded file already
-	* carries the CP-owned fields.
+	* Effective agent set = the on-disk `agent.json` files, with the CP-owned
+	* integrations overlaid in memory. Agent SPECS are no longer overlaid — `agent/
+	* upsert` writes those straight to disk (cp/cp-agent-registry.ts). INTEGRATIONS,
+	* however, carry plaintext tokens and are kept in memory only (cp/cp-integration-
+	* registry.ts); they are merged onto the matching file agent's `integrations[]`
+	* HERE — the single seam so consolidate, routing rules, tool injection, and reply
+	* routing (all of which read `agent.integrations`) see one merged view.
 	*/
 	effectiveAgents() {
-		return [...this.fileAgents.values()];
+		const files = [...this.fileAgents.values()];
+		const cpByAgent = this.cpIntegrations?.byAgent();
+		if (!cpByAgent || cpByAgent.size === 0) return files;
+		return files.map((a) => {
+			const cp = cpByAgent.get(a.id);
+			if (!cp || cp.length === 0) return a;
+			const byId = new Map(a.integrations.map((i) => [i.id, i]));
+			for (const i of cp) byId.set(i.id, i);
+			return {
+				...a,
+				integrations: [...byId.values()]
+			};
+		});
+	}
+	/**
+	* Warn (once per orphan) about CP integrations whose owning agent is absent /
+	* inactive on disk: they are held in the registry but overlaid onto no agent, so
+	* no socket opens. Self-heals when the agent appears (a later reconcile connects
+	* it). Logs integrationId + agentId ONLY — never the token material.
+	*/
+	warnOrphanIntegrations() {
+		const cpByAgent = this.cpIntegrations?.byAgent();
+		if (!cpByAgent) return;
+		const live = /* @__PURE__ */ new Set();
+		for (const [agentId, ints] of cpByAgent) {
+			if (this.fileAgents.has(agentId)) continue;
+			for (const int of ints) {
+				live.add(int.id);
+				if (!this.warnedOrphanIntegrations.has(int.id)) {
+					this.warnedOrphanIntegrations.add(int.id);
+					this.log.warn(`slack: integration ${int.id} references missing/inactive agent ${agentId} — not connected`);
+				}
+			}
+		}
+		for (const id of this.warnedOrphanIntegrations) if (!live.has(id)) this.warnedOrphanIntegrations.delete(id);
 	}
 	/**
 	* Converge the running set to the desired effective agents. Driven by both the
@@ -82599,6 +82783,7 @@ var Daemon = class Daemon {
 	async runReconcile() {
 		const files = this.loadAgentList();
 		this.fileAgents = new Map(files.map((a) => [a.id, a]));
+		this.warnOrphanIntegrations();
 		const desired = this.effectiveAgents();
 		const { toStart, toStop, toChange } = diffAgents(desired, this.agents);
 		if (toStart.length || toStop.length || toChange.length) this.log.info(`reconcile: ${desired.length} desired agent(s) from ${this.agentsDir}; start=[${toStart.map((a) => a.id).join(", ")}] stop=[${toStop.join(", ")}] change=[${toChange.map((c) => {
@@ -83250,6 +83435,7 @@ var Daemon = class Daemon {
 			applyReconcileSnapshot: (snap) => {
 				this.cpCrons?.converge(snap.crons);
 				this.cpAgents?.converge(snap.agents);
+				this.cpIntegrations?.converge(snap.integrations);
 				this.cpRouting?.converge({
 					routingEpoch: snap.routingEpoch,
 					assignments: snap.assignments,
@@ -83258,9 +83444,12 @@ var Daemon = class Daemon {
 				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)`);
+				if (snap.integrations?.length) this.log.debug(`cp: converged ${snap.integrations.length} integration(s)`);
 			},
 			applyAgentUpsert: (agentId, spec) => this.cpAgents?.upsert(agentId, spec),
 			applyAgentRemove: (agentId) => this.cpAgents?.remove(agentId),
+			applyIntegrationUpsert: (spec) => this.cpIntegrations?.upsert(spec),
+			applyIntegrationRemove: (integrationId) => this.cpIntegrations?.remove(integrationId),
 			upsertCron: (cron) => this.cpCrons.upsert(cron),
 			removeCron: (cronId) => this.cpCrons.remove(cronId),
 			applyRouteAssign: (a) => this.cpRouting?.upsertAssign(a),
@@ -83670,6 +83859,9 @@ program.name("agentconnect").description("AgentConnect daemon — edge message +
 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();
+	process.on("unhandledRejection", (reason) => {
+		console.error(`agentconnect: unhandled rejection (continuing): ${reason instanceof Error ? reason.stack ?? reason.message : String(reason)}`);
+	});
 	let lock;
 	try {
 		lock = acquireSingletonLock(resolveRoot(opts.root));