@agentconnect.md/daemon 1.0.0-rc.76 → 1.0.0-rc.78

package/dist/index.js

@@ -7659,14 +7659,22 @@ const IntegrationSchema = object({
 	platform: literal("slack"),
 	slack: SlackConfigSchema
 });
+/** A scheduled trigger for THIS agent: every `schedule` tick, prompt the agent
+*  with `trigger`. `target` is optional output routing — when present the daemon
+*  posts the trigger into that channel and the session replies in its thread;
+*  absent ⇒ headless fire (no platform output). `origin:"cp"` marks CP-pushed
+*  entries (written by cron/upsert, pruned by drop.crons); hand-authored entries
+*  have no origin and are never touched by the CP. */
 const CronDefSchema = object({
 	id: string(),
 	schedule: string(),
 	target: object({
 		platform: literal("slack"),
 		channel: string()
-	}),
-	trigger: string()
+	}).optional(),
+	trigger: string(),
+	enabled: boolean().default(true),
+	origin: literal("cp").optional()
 });
 const AgentSchema = object({
 	id: string(),
@@ -12912,13 +12920,27 @@ const DrainDone = object({ released: array(SessionKey) });
 /**
 * Cron sinks to the daemon (D5) — protocol §5.4.
 *
-* The CP owns the definition; the daemon owns firing + last-run persistence so
-* crons fire even when the CP is down.
+* A cron periodically triggers ONE AGENT with a synthetic prompt (`trigger`) to
+* carry out some work. The CP owns the definition; the daemon owns firing +
+* last-run persistence, so crons fire even when the CP is down. On receipt the
+* daemon persists the def into the owning agent's `agent.json` `crons[]` (the
+* single source of truth, same model as integrations) — surviving a restart
+* with the CP down.
+*
+* `target` is OPTIONAL output routing: when present, the daemon posts the
+* trigger as a real message in that channel and the agent's session replies in
+* its thread; when absent the fire is headless (the agent works with no
+* platform output).
 */
+const CronTarget = object({
+	platform: _enum(["slack", "telegram"]).default("slack"),
+	channel: string()
+});
 const CronUpsert = object({
 	cronId: string().uuid(),
+	agentId: string().uuid(),
 	schedule: string(),
-	target: object({ channel: string() }),
+	target: CronTarget.optional(),
 	trigger: string(),
 	enabled: boolean().default(true)
 });
@@ -23846,6 +23868,11 @@ var LocalStore = class {
         id INTEGER PRIMARY KEY CHECK (id = 1),
         routingEpoch INTEGER, assignments TEXT, globalRules TEXT
       );
+      -- Authoritative last-run per cron (protocol §5.4 — missed-fire compensation).
+      -- key = "<agentId>:<cronId>" (cron defs themselves live in agent.json).
+      CREATE TABLE IF NOT EXISTS cron_runs (
+        key TEXT PRIMARY KEY, lastRunAt INTEGER NOT NULL
+      );
     `);
 		this.migrateSessionUsage();
 	}
@@ -24046,6 +24073,17 @@ var LocalStore = class {
 			globalRules
 		});
 	}
+	/** Stamp a cron fire (key = `<agentId>:<cronId>`). */
+	setCronLastRun(key, lastRunAt) {
+		this.db.prepare(`INSERT INTO cron_runs (key, lastRunAt) VALUES (@key, @lastRunAt)
+         ON CONFLICT(key) DO UPDATE SET lastRunAt=excluded.lastRunAt`).run({
+			key,
+			lastRunAt
+		});
+	}
+	getCronLastRun(key) {
+		return this.db.prepare("SELECT lastRunAt FROM cron_runs WHERE key = ?").get(key)?.lastRunAt;
+	}
 	close() {
 		this.db.close();
 	}
@@ -82082,7 +82120,7 @@ function buildSyntheticMessage(agentId, cron, traceId) {
 			traceId,
 			source: "cron",
 			platform: "slack",
-			channel: cron.target.channel,
+			channel: cron.target?.channel ?? `cron:${cron.id}`,
 			thread: `cron:${cron.id}:${traceId}`,
 			sender: {
 				id: `cron:${cron.id}`,
@@ -82091,25 +82129,52 @@ function buildSyntheticMessage(agentId, cron, traceId) {
 			text: cron.trigger,
 			mentionedBots: [],
 			isDm: false,
-			trigger: "cron"
+			trigger: "cron",
+			...cron.target ? {} : { headless: true }
 		}
 	};
 }
+/**
+* Local scheduler for `agent.json.crons[]` (D5). Jobs are keyed per agent so the
+* reconciler can converge them on any agent change (design §5.2: crons change →
+* Scheduler upsert/remove) — `sync` replaces an agent's whole job set, `unregister`
+* drops it. A malformed schedule skips that one cron (warned), never the rest.
+*/
 var Scheduler = class {
 	deps;
-	jobs = [];
+	jobs = /* @__PURE__ */ new Map();
 	constructor(deps) {
 		this.deps = deps;
 	}
-	register(agentId, cron) {
-		this.jobs.push(new E(cron.schedule, () => {
-			const { msg } = buildSyntheticMessage(agentId, cron, this.deps.newTraceId());
-			this.deps.onFire(agentId, msg);
-		}));
+	/** Converge one agent's job set to its current `crons[]` (replace-all, idempotent).
+	*  Disabled crons stay on disk but are not scheduled. */
+	sync(agentId, crons) {
+		this.unregister(agentId);
+		const jobs = [];
+		for (const cron of crons) {
+			if (cron.enabled === false) continue;
+			try {
+				jobs.push(new E(cron.schedule, () => {
+					const { msg } = buildSyntheticMessage(agentId, cron, this.deps.newTraceId());
+					this.deps.onFire(agentId, msg, cron);
+				}));
+			} catch (err) {
+				this.deps.warn?.(`scheduler: skipping cron "${cron.id}" of agent "${agentId}": ${err.message}`);
+			}
+		}
+		if (jobs.length) this.jobs.set(agentId, jobs);
+	}
+	/** Stop and drop an agent's jobs (agent removed / deactivated). */
+	unregister(agentId) {
+		for (const j of this.jobs.get(agentId) ?? []) j.stop();
+		this.jobs.delete(agentId);
+	}
+	/** Live job count for one agent (0 when none). */
+	count(agentId) {
+		return this.jobs.get(agentId)?.length ?? 0;
 	}
 	stop() {
-		for (const j of this.jobs) j.stop();
-		this.jobs = [];
+		for (const agentId of [...this.jobs.keys()]) this.unregister(agentId);
 	}
 };
 //#endregion
@@ -83061,41 +83126,6 @@ async function fetchHeadMtime(root) {
 	}
 }
 //#endregion
-//#region src/cp/cp-cron.ts
-/**
-* `CpCronRegistry` — the daemon's set of CP-pushed crons, keyed by `cronId`
-* (distinct from per-agent `agent.crons`). On fire it calls `onFire(cron)`; the
-* daemon resolves `cron.target.channel` to an owning agent and dispatches.
-* `converge` makes the live set exactly a register/ok snapshot.
-*/
-var CpCronRegistry = class {
-	deps;
-	jobs = /* @__PURE__ */ new Map();
-	constructor(deps) {
-		this.deps = deps;
-	}
-	upsert(cron) {
-		this.remove(cron.cronId);
-		if (cron.enabled === false) return;
-		this.jobs.set(cron.cronId, new E(cron.schedule, () => this.deps.onFire(cron)));
-	}
-	remove(cronId) {
-		this.jobs.get(cronId)?.stop();
-		this.jobs.delete(cronId);
-	}
-	converge(crons) {
-		const keep = new Set(crons.map((c) => c.cronId));
-		for (const id of [...this.jobs.keys()]) if (!keep.has(id)) this.remove(id);
-		for (const c of crons) this.upsert(c);
-	}
-	ids() {
-		return [...this.jobs.keys()];
-	}
-	stop() {
-		for (const id of [...this.jobs.keys()]) this.remove(id);
-	}
-};
-//#endregion
 //#region src/agents/write-agent.ts
 /**
 * Persist CP-owned agent spec onto the daemon's on-disk `agent.json`, which is
@@ -83228,6 +83258,127 @@ function removeAgent(agentsDir, agentId) {
 	});
 }
 //#endregion
+//#region src/agents/write-cron.ts
+/**
+* Persist CP-owned crons onto the owning agent's on-disk `agent.json` `crons[]`,
+* which is the SINGLE SOURCE OF TRUTH (same model as write-integration.ts) — so
+* CP crons survive a daemon restart with the Control Plane down: the Scheduler
+* re-registers them from disk alone at start.
+*
+* CP entries are marked `origin:"cp"` so they coexist with hand-authored crons:
+* the CP replaces/removes only its own entries and never touches user ones.
+*
+* CRITICAL: like write-agent.ts, we operate on the RAW JSON TEXT (readFileSync →
+* JSON.parse → mutate only `crons[]` → writeFileSync). We never serialize the
+* parsed/interpolated `LoadedAgent` — that has `${VAR}` already substituted and
+* `workspace.path` rewritten absolute. Editing the raw file preserves both.
+*/
+/** Map the wire def to the agent.json `CronDef` shape (agent-schema). */
+function toCronDef(cron) {
+	return {
+		id: cron.cronId,
+		schedule: cron.schedule,
+		...cron.target && cron.target.platform === "slack" ? { target: {
+			platform: "slack",
+			channel: cron.target.channel
+		} } : {},
+		trigger: cron.trigger,
+		enabled: cron.enabled !== false,
+		origin: "cp"
+	};
+}
+/**
+* Upsert one CP cron into the owning agent's `agent.json` `crons[]` (replace the
+* `origin:"cp"` entry with that `id`, else append). Returns whether the file
+* CHANGED — an identical re-apply (every register/ok converge re-sends the full
+* set) skips the write so the file-watcher doesn't churn a reconcile per
+* reconnect. Returns false (with a warn) when no agent with `cron.agentId`
+* exists on disk — an orphan cron is not persisted; it self-heals when the
+* agent spec lands and the CP re-sends.
+*
+* The replace slot is matched by `id` AND `origin:"cp"` (mirroring
+* {@link removeCronDef}): a hand-authored entry that happens to share the id is
+* NEVER overwritten — the CP touches only its own entries. Such a collision is
+* skipped with a warn rather than silently converting a user cron into a CP one.
+*/
+function writeCronDef(agentsDir, cron, deps) {
+	const file = findAgentFileById(agentsDir, cron.agentId);
+	if (!file) {
+		deps.warn?.(`cp: cron ${cron.cronId} references missing agent ${cron.agentId} — not persisted (will retry on next push)`);
+		return false;
+	}
+	const raw = JSON.parse(readFileSync(file, "utf8"));
+	const list = Array.isArray(raw.crons) ? raw.crons : [];
+	const next = toCronDef(cron);
+	const at = (c) => typeof c === "object" && c !== null && c.id === next.id;
+	if (list.find((c) => at(c) && c.origin !== "cp")) {
+		deps.warn?.(`cp: cron ${cron.cronId} collides with a hand-authored cron of the same id on agent ${cron.agentId} — not persisted`);
+		return false;
+	}
+	const idx = list.findIndex((c) => at(c) && c.origin === "cp");
+	if (idx >= 0) {
+		if (JSON.stringify(list[idx]) === JSON.stringify(next)) return false;
+		list[idx] = next;
+	} else list.push(next);
+	raw.crons = list;
+	writeFileSync(file, JSON.stringify(raw, null, 2) + "\n");
+	return true;
+}
+/**
+* Remove one CP cron (by id) from whichever agent.json holds it. Scans all agent
+* files since the owning agent is not part of `cron/remove`. Only `origin:"cp"`
+* entries are eligible — a hand-authored cron that happens to share the id is
+* never deleted. Returns whether an entry was removed.
+*/
+function removeCronDef(agentsDir, cronId) {
+	for (const file of findAgentFiles(agentsDir)) {
+		let raw;
+		try {
+			raw = JSON.parse(readFileSync(file, "utf8"));
+		} catch {
+			continue;
+		}
+		if (!Array.isArray(raw.crons)) continue;
+		const list = raw.crons;
+		const idx = list.findIndex((c) => typeof c === "object" && c !== null && c.id === cronId && c.origin === "cp");
+		if (idx === -1) continue;
+		list.splice(idx, 1);
+		writeFileSync(file, JSON.stringify(raw, null, 2) + "\n");
+		return true;
+	}
+	return false;
+}
+//#endregion
+//#region src/cp/cp-cron.ts
+var CpCronRegistry = class {
+	agentsDir;
+	deps;
+	onChange;
+	constructor(agentsDir, deps, onChange) {
+		this.agentsDir = agentsDir;
+		this.deps = deps;
+		this.onChange = onChange;
+	}
+	/** Add or replace one CP cron on the owning agent's disk file (cron/upsert REQ). */
+	upsert(cron) {
+		if (writeCronDef(this.agentsDir, cron, this.deps)) this.onChange();
+	}
+	/** Splice one CP cron out of whichever agent.json holds it (cron/remove REQ). */
+	remove(cronId) {
+		if (removeCronDef(this.agentsDir, cronId)) this.onChange();
+	}
+	/**
+	* Apply the register/ok snapshot: upsert EACH entry (identical re-applies skip
+	* the write, so a reconnect with an unchanged set is a no-op). Stale ids
+	* arrive separately via `drop.crons[]` → {@link remove}.
+	*/
+	converge(crons) {
+		let changed = false;
+		for (const cron of crons ?? []) if (writeCronDef(this.agentsDir, cron, this.deps)) changed = true;
+		if (changed) this.onChange();
+	}
+};
+//#endregion
 //#region src/cp/cp-agent-registry.ts
 var CpAgentRegistry = class {
 	agentsDir;
@@ -83575,6 +83726,7 @@ var Daemon = class Daemon {
 			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(this.agentsDir, { warn: (m) => this.log.warn(m) }, () => void this.reconcile().catch((err) => this.log.error(`cp: integration reconcile failed: ${err.stack ?? err}`)));
+		this.cpCrons = new CpCronRegistry(this.agentsDir, { warn: (m) => this.log.warn(m) }, () => void this.reconcile().catch((err) => this.log.error(`cp: cron reconcile failed: ${err.stack ?? err}`)));
 		for (const a of this.effectiveAgents()) {
 			this.agents.set(a.id, a);
 			this.prefetchClone(a);
@@ -83622,8 +83774,9 @@ var Daemon = class Daemon {
 			fetchThreadHistory: (agentId, channel, threadTs) => this.fetchThreadHistory(agentId, channel, threadTs)
 		});
 		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)}`)),
-			newTraceId: () => randomUUID()
+			onFire: (agentId, msg, cron) => void this.onCronFire(agentId, msg, cron).catch((err) => this.log.error(`cron dispatch failed for agent "${agentId}": ${formatErr(err)}`)),
+			newTraceId: () => randomUUID(),
+			warn: (m) => this.log.warn(m)
 		});
 		const groups = consolidate(agents);
 		this.botUserIds = {};
@@ -83651,11 +83804,8 @@ var Daemon = class Daemon {
 			this.connections.push(conn);
 			this.refreshChannels(conn);
 		}
-		let cronCount = 0;
-		for (const a of agents) for (const c of a.crons) {
-			this.scheduler.register(a.id, c);
-			cronCount++;
-		}
+		for (const a of agents) this.scheduler.sync(a.id, a.crons);
+		const cronCount = agents.reduce((n, a) => n + this.scheduler.count(a.id), 0);
 		if (cronCount) this.log.info(`registered ${cronCount} cron(s)`);
 		this.watcher = watch$1(this.agentsDir, {
 			ignoreInitial: true,
@@ -83740,10 +83890,12 @@ var Daemon = class Daemon {
 			}
 			this.hostStarts.delete(id);
 			this.agents.delete(id);
+			this.scheduler.unregister(id);
 		}
 		for (const change of toChange) {
 			const a = change.agent;
 			this.agents.set(a.id, a);
+			this.scheduler.sync(a.id, a.crons);
 			if (change.hostRespawn || change.workspace) {
 				const host = this.hosts.get(a.id);
 				if (host) {
@@ -83758,6 +83910,7 @@ var Daemon = class Daemon {
 		for (const a of toStart) {
 			this.agents.set(a.id, a);
 			this.prefetchClone(a);
+			this.scheduler.sync(a.id, a.crons);
 		}
 		if (toStart.some((a) => a.integrations.some((i) => i.platform === "slack")) || toStop.length) await this.reconcileSlackConnections();
 	}
@@ -84069,7 +84222,7 @@ var Daemon = class Daemon {
 		}
 		const conv = new OutputConverger(this.agents.get(agentId).output.mode);
 		const rec = new TranscriptRecorder();
-		const replyConn = this.replyConnFor(agentId, integrationId);
+		const replyConn = msg.headless ? void 0 : this.replyConnFor(agentId, integrationId);
 		const wasRunning = this.hostStarts.has(agentId);
 		const statusThread = msg.thread ?? msg.msgId;
 		const key = sessionKey(msg.platform, msg.channel, statusThread, agentId);
@@ -84270,6 +84423,13 @@ var Daemon = class Daemon {
 		const intId = integrationId ?? this.agents.get(agentId)?.integrations[0]?.id;
 		return intId ? this.connByIntegration.get(intId) : void 0;
 	}
+	/** The CP-owned cron ids currently on disk (register `localState.crons` — the
+	*  CP computes `drop.crons` against this; hand-authored crons are not reported). */
+	cpCronIds() {
+		const out = [];
+		for (const a of this.effectiveAgents()) for (const c of a.crons) if (c.origin === "cp") out.push(c.id);
+		return out;
+	}
 	/** Stop and evict an ACP adapter child, returning the agent to `provisioned`
 	*  (config kept; the next message lazily re-spawns it). Idempotent. The teardown
 	*  is registered in `hostStopping` so a concurrent ensureHostAsync waits for it
@@ -84444,9 +84604,10 @@ var Daemon = class Daemon {
 				if (ignored.length) this.log.warn(`cp: ignored config keys: ${ignored.join(", ")}`);
 			},
 			applyReconcileSnapshot: (snap) => {
-				this.cpCrons?.converge(snap.crons);
 				this.cpAgents?.converge(snap.agents);
 				this.cpIntegrations?.converge(snap.integrations);
+				for (const id of snap.drop.crons) this.cpCrons?.remove(id);
+				this.cpCrons?.converge(snap.crons);
 				this.cpRouting?.converge({
 					routingEpoch: snap.routingEpoch,
 					assignments: snap.assignments,
@@ -84486,26 +84647,31 @@ var Daemon = class Daemon {
 			applyDaemonUpgrade: (req) => this.scheduleFleetExit("upgrade", req.targetVersion)
 		};
 	}
-	/** A CP cron fired: build a synthetic message and run it through the normal routing path. */
-	onCpCronFire(cron) {
-		const traceId = randomUUID();
-		const msg = {
-			msgId: `cpcron:${cron.cronId}:${traceId}`,
-			traceId,
-			source: "cron",
-			platform: "slack",
-			channel: cron.target.channel,
-			thread: `cpcron:${cron.cronId}:${traceId}`,
-			sender: {
-				id: `cpcron:${cron.cronId}`,
-				isBot: false
-			},
-			text: cron.trigger,
-			mentionedBots: [],
-			isDm: false,
-			trigger: "cron"
-		};
-		this.onInbound(msg);
+	/**
+	* A cron fired for `agentId` (§8.6 bypass — the cron names its agent; no
+	* routing). The fire is stamped into D11 first (the daemon owns last-run,
+	* protocol §5.4). With a target channel, the trigger text is posted there as a
+	* real ANCHOR message and the session threads its replies under it —
+	* equivalent to a user posting the trigger in-channel. Without one (or when
+	* the anchor can't be posted) the turn still runs; a `headless` fire
+	* additionally suppresses all platform output in dispatch.
+	*/
+	async onCronFire(agentId, msg, cron) {
+		this.store.setCronLastRun(`${agentId}:${cron.id}`, this.clock.now());
+		if (cron.target?.channel) {
+			const conn = this.replyConnFor(agentId);
+			if (!conn) this.log.warn(`cron "${cron.id}": agent "${agentId}" has no live slack connection — running without output`);
+			else try {
+				const ts = await conn.postMessage(cron.target.channel, `⏰ ${cron.trigger}`);
+				if (ts) msg = {
+					...msg,
+					thread: ts
+				};
+			} catch (err) {
+				this.log.warn(`cron "${cron.id}": failed to post trigger to ${cron.target.channel} (${formatErr(err)}) — running without anchor`);
+			}
+		}
+		await this.dispatch(agentId, msg);
 	}
 	/** Real CPU utilization (0..1) across all cores since the previous call — the busy
 	*  fraction of the time delta. Called once per heartbeat, so it reflects load over the
@@ -84525,7 +84691,6 @@ var Daemon = class Daemon {
 			return;
 		}
 		const echoDaemonId = this.opts.overrides?.daemonId;
-		this.cpCrons = new CpCronRegistry({ onFire: (cron) => this.onCpCronFire(cron) });
 		const url = cp.url;
 		this.cpClient = new CpClient({
 			url,
@@ -84556,7 +84721,7 @@ var Daemon = class Daemon {
 			},
 			localState: () => ({
 				assignments: [],
-				crons: this.cpCrons?.ids() ?? [],
+				crons: this.cpCronIds(),
 				leases: []
 			}),
 			loadSnapshot: () => ({
@@ -84640,7 +84805,6 @@ var Daemon = class Daemon {
 		const errors = [];
 		this.scheduler?.stop();
 		await Promise.resolve(this.cpClient?.stop()).catch((e) => errors.push(e));
-		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));