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

package/dist/index.js

@@ -7567,6 +7567,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({
@@ -16741,6 +16744,9 @@ var AcpHost = class {
 	opts;
 	child;
 	conn;
+	live = /* @__PURE__ */ new Set();
+	loadingSessions = /* @__PURE__ */ new Set();
+	canLoad = false;
 	constructor(runtime, opts) {
 		this.runtime = runtime;
 		this.opts = opts;
@@ -16764,6 +16770,7 @@ var AcpHost = class {
 		const stream = ndJsonStream(Writable.toWeb(child.stdin), Readable.toWeb(child.stdout));
 		const self = this;
 		this.conn = client({ name: "agentconnect" }).onNotification(methods.client.session.update, (ctx) => {
+			if (self.loadingSessions.has(ctx.params.sessionId)) return;
 			self.opts.onUpdate(ctx.params.sessionId, ctx.params.update);
 		}).onRequest(methods.client.session.requestPermission, (ctx) => {
 			const optionId = (ctx.params.options.find((o) => o.kind === "allow_once" || o.kind === "allow_always") ?? ctx.params.options[0])?.optionId;
@@ -16772,19 +16779,52 @@ var AcpHost = class {
 				optionId
 			} : { outcome: "cancelled" } };
 		}).connect(stream);
-		await this.conn.agent.request(methods.agent.initialize, {
+		const init = await this.conn.agent.request(methods.agent.initialize, {
 			protocolVersion: PROTOCOL_VERSION,
 			clientCapabilities: { fs: {
 				readTextFile: false,
 				writeTextFile: false
 			} }
 		});
+		this.canLoad = init.agentCapabilities?.loadSession ?? false;
+		this.opts.log?.debug(`acp: agent initialized (loadSession capability=${this.canLoad})`);
 	}
 	async newSession(cwd) {
-		return (await this.conn.agent.request(methods.agent.session.new, {
+		const res = await this.conn.agent.request(methods.agent.session.new, {
 			cwd,
 			mcpServers: []
-		})).sessionId;
+		});
+		this.live.add(res.sessionId);
+		return res.sessionId;
+	}
+	/** True iff THIS agent process created or loaded `sessionId` in its current lifetime. */
+	hasSession(sessionId) {
+		return this.live.has(sessionId);
+	}
+	/** Whether the agent advertised the `loadSession` capability (session/load is usable). */
+	loadSupported() {
+		return this.canLoad;
+	}
+	/** Resume a previously-created session by id (ACP `session/load`). The agent
+	*  restores its own history server-side; its replayed session/update stream is
+	*  suppressed so it isn't re-posted. Throws if the agent can't load the id
+	*  (caller falls back to newSession). */
+	async loadSession(sessionId, cwd) {
+		this.loadingSessions.add(sessionId);
+		try {
+			await this.conn.agent.request(methods.agent.session.load, {
+				sessionId,
+				cwd,
+				mcpServers: []
+			});
+			this.live.add(sessionId);
+			this.opts.log?.info(`acp: resumed session ${sessionId} via session/load`);
+		} catch (err) {
+			this.opts.log?.debug(`acp: session/load failed for ${sessionId} (${err.message}) — will recreate`);
+			throw err;
+		} finally {
+			this.loadingSessions.delete(sessionId);
+		}
 	}
 	async prompt(sessionId, blocks) {
 		return (await this.conn.agent.request(methods.agent.session.prompt, {
@@ -21140,7 +21180,7 @@ const defaultExec = (cmd, args) => new Promise((resolve) => {
 /** macOS launchd controller. Writes a LaunchAgent plist that runs
 *  `<node> <cli-entry> run`, and drives it with `launchctl bootstrap/bootout`
 *  (falling back to legacy `load/unload` on older macOS). */
-const LABEL = "co.sentio.agentconnect";
+const LABEL = "md.agentconnect.daemon";
 function buildPlist(a) {
 	const env = a.includeRootEnv ? `  <key>EnvironmentVariables</key>\n  <dict>\n    <key>AGENTCONNECT_ROOT</key>\n    <string>${a.root}</string>\n  </dict>\n` : "";
 	return `<?xml version="1.0" encoding="UTF-8"?>
@@ -22948,12 +22988,75 @@ 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
-function diffAgents(desired, actualIds) {
+/** Stable identity-free signature of an agent's effective config. Excludes the
+*  loader-only `dir`/`env` fields (present on `LoadedAgent`) so the comparison is
+*  over the agent's behaviour, not where it was found. Both sides are the LOADED
+*  form (interpolated, path-absolutized), so this is apples-to-apples and stable
+*  across re-serialization (zod key order is fixed by the schema). */
+function signature(a) {
+	const { dir, env, ...rest } = a;
+	return JSON.stringify(rest);
+}
+/**
+* Diff desired (freshly loaded active agents) against the running set.
+* - `toStart`   — desired ids not currently running.
+* - `toStop`    — running ids no longer desired.
+* - `toRestart` — same id, changed config (runtime/workspace/integrations/…): the
+*   host must be evicted so the next session picks up fresh config (design §5.2).
+*   Without this, an in-place edit to an existing agent.json is silently a no-op.
+*/
+function diffAgents(desired, actual) {
 	const desiredIds = new Set(desired.map((a) => a.id));
+	const toStart = [];
+	const toRestart = [];
+	for (const a of desired) {
+		const cur = actual.get(a.id);
+		if (!cur) toStart.push(a);
+		else if (signature(cur) !== signature(a)) toRestart.push(a);
+	}
 	return {
-		toStart: desired.filter((a) => !actualIds.includes(a.id)),
-		toStop: actualIds.filter((id) => !desiredIds.has(id))
+		toStart,
+		toStop: [...actual.keys()].filter((id) => !desiredIds.has(id)),
+		toRestart
 	};
 }
 //#endregion
@@ -22980,6 +23083,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) {
@@ -23013,6 +23120,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();
 	}
@@ -23057,6 +23171,24 @@ var SessionManager = class {
 				updatedAt: Date.now()
 			};
 			this.deps.store.upsertSession(rec);
+		} else if (host.hasSession?.(rec.acpSessionId) === false) {
+			const cwd = await prepareWorkspace(agent);
+			let resumed = false;
+			if (host.loadSupported?.()) try {
+				await host.loadSession(rec.acpSessionId, cwd);
+				resumed = true;
+			} catch {}
+			if (!resumed) {
+				const acpSessionId = await host.newSession(cwd);
+				rec = {
+					...rec,
+					acpSessionId,
+					state: "idle",
+					lastDeliveredTs: null,
+					updatedAt: Date.now()
+				};
+				this.deps.store.upsertSession(rec);
+			}
 		}
 		const gap = this.deps.store.transcriptSince(msg.channel, thread, rec.lastDeliveredTs);
 		const blocks = [];
@@ -23128,11 +23260,8 @@ function routeRules(msg, rules, threadOwner) {
 	if (msg.thread) {
 		const owner = threadOwner(msg.channel, msg.thread);
 		if (owner) {
-			const reachable = new Set(scopeCandidates.map((r) => r.agentId));
-			if (reachable.has(owner)) {
-				if (reachable.size === 1) return pickRule(scopeCandidates.find((x) => x.agentId === owner));
-				return null;
-			}
+			const ownerRule = scopeCandidates.find((x) => x.agentId === owner);
+			if (ownerRule) return pickRule(ownerRule);
 		}
 	}
 	const layer = kindCandidates.some((r) => r.source === "cp" && r.scope.channel === msg.channel && (r.scope.thread === void 0 || r.scope.thread === msg.thread)) ? kindCandidates.filter((r) => r.source === "cp") : kindCandidates;
@@ -80456,6 +80585,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":
@@ -80509,6 +80646,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",
@@ -80577,16 +80754,23 @@ var SystemClock = class {
 const systemClock = new SystemClock();
 //#endregion
 //#region src/daemon.ts
-const LOADING_MSGS = [
-	"Working on it…",
-	"Crunching through it…",
-	"Hang tight…"
-];
+/** Format an error for logs, surfacing a JSON-RPC/ACP RequestError's `code` and
+*  `data` — for an agent-side `Internal error` the actionable detail (the adapter's
+*  underlying exception) lives in `data`, which a bare `.stack` discards. */
+function formatErr(err) {
+	const e = err;
+	if (e && typeof e.code === "number") {
+		const data = e.data === void 0 ? "" : ` data=${typeof e.data === "string" ? e.data : JSON.stringify(e.data)}`;
+		return `${e.name ?? "Error"}: ${e.message ?? ""} (code=${e.code})${data}`;
+	}
+	return e?.stack ?? String(err);
+}
 const MAX_QUEUED_PER_SESSION = 10;
 var Daemon = class {
 	opts;
 	store;
 	agents = /* @__PURE__ */ new Map();
+	fileAgents = /* @__PURE__ */ new Map();
 	hosts = /* @__PURE__ */ new Map();
 	connections = [];
 	scheduler;
@@ -80603,6 +80787,7 @@ var Daemon = class {
 	runtimeNames = {};
 	cpClient;
 	cpCrons;
+	cpAgents;
 	botUserIds = {};
 	cpRouting;
 	constructor(opts = {}) {
@@ -80627,7 +80812,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, {
@@ -80651,13 +80836,21 @@ 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.sessions = new SessionManager({
 			store: this.store,
 			hostFor: (agentId) => this.ensureHostAsync(agentId),
 			agentById: (id) => this.agents.get(id)
 		});
 		this.scheduler = new Scheduler({
-			onFire: (agentId, msg) => void this.dispatch(agentId, msg).catch((err) => this.log.error(`cron dispatch failed for agent "${agentId}": ${err.stack ?? err}`)),
+			onFire: (agentId, msg) => void this.dispatch(agentId, msg).catch((err) => this.log.error(`cron dispatch failed for agent "${agentId}": ${formatErr(err)}`)),
 			newTraceId: () => randomUUID()
 		});
 		const groups = consolidate(agents);
@@ -80706,8 +80899,54 @@ 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 { toStart, toStop } = diffAgents(this.loadAgentList(), [...this.agents.keys()]);
+		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))`);
 		for (const id of toStop) {
 			const host = this.hosts.get(id);
 			if (host) {
@@ -80717,6 +80956,15 @@ var Daemon = class {
 			this.hostStarts.delete(id);
 			this.agents.delete(id);
 		}
+		for (const a of toRestart) {
+			const host = this.hosts.get(a.id);
+			if (host) {
+				await host.stop();
+				this.hosts.delete(a.id);
+			}
+			this.hostStarts.delete(a.id);
+			this.agents.set(a.id, a);
+		}
 		for (const a of toStart) this.agents.set(a.id, a);
 	}
 	ensureHost(agentId, cfg) {
@@ -80730,7 +80978,11 @@ 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
 			});
 		}
 		this.hosts.set(agentId, host);
@@ -80755,7 +81007,7 @@ var Daemon = class {
 			return;
 		}
 		this.log.info(`routing: ch=${msg.channel} → agent "${result.agentId}" (integration ${result.integrationId})`);
-		this.dispatch(result.agentId, msg, result.integrationId).catch((err) => this.log.error(`dispatch failed for agent "${result.agentId}": ${err.stack ?? err}`));
+		this.dispatch(result.agentId, msg, result.integrationId).catch((err) => this.log.error(`dispatch failed for agent "${result.agentId}": ${formatErr(err)}`));
 	}
 	queued = /* @__PURE__ */ new Map();
 	/**
@@ -80833,10 +81085,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) {
@@ -80844,7 +81101,7 @@ var Daemon = class {
 		const replyConn = this.replyConnFor(agentId, integrationId);
 		const wasRunning = this.hostStarts.has(agentId);
 		const statusThread = msg.thread ?? msg.msgId;
-		replyConn?.setStatus(msg.channel, statusThread, wasRunning ? "is thinking…" : "is starting up…", LOADING_MSGS);
+		replyConn?.setStatus(msg.channel, statusThread, wasRunning ? "is thinking…" : "is starting up…");
 		const { sessionId, blocks } = await this.sessions.handle(agentId, msg);
 		this.pending.set(sessionId, {
 			conv,
@@ -80854,7 +81111,7 @@ var Daemon = class {
 		});
 		try {
 			const host = await this.ensureHostAsync(agentId);
-			if (!wasRunning) replyConn?.setStatus(msg.channel, statusThread, "is thinking…", LOADING_MSGS);
+			if (!wasRunning) replyConn?.setStatus(msg.channel, statusThread, "is thinking…");
 			await host.prompt(sessionId, blocks);
 			for (const action of conv.onFinal(`local://session/${sessionId}`)) await this.applyAction(action, replyConn, msg.channel, statusThread);
 		} finally {
@@ -80862,10 +81119,10 @@ var Daemon = class {
 		}
 		this.flushQueued(agentId, sessionId, integrationId);
 	}
-	/** Route a converger action: set-status → setStatus (loading_messages only when not clearing); else postMessage. */
+	/** Route a converger action: set-status → setStatus (status text only; '' clears); else postMessage. */
 	async applyAction(action, conn, channel, thread) {
 		if (action.kind === "set-status") {
-			if (conn && thread) await conn.setStatus(channel, thread, action.text, action.text ? LOADING_MSGS : void 0);
+			if (conn && thread) await conn.setStatus(channel, thread, action.text);
 			return;
 		}
 		await conn?.postMessage(channel, action.text, thread);
@@ -80900,6 +81157,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,
@@ -80907,7 +81165,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),