@agentconnect.md/daemon 1.0.0-rc.101 → 1.0.0-rc.103

package/dist/index.js

@@ -7670,7 +7670,8 @@ const CronDefSchema = object({
 	schedule: string(),
 	target: object({
 		platform: literal("slack"),
-		channel: string()
+		channel: string(),
+		integrationId: string().optional()
 	}).optional(),
 	trigger: string(),
 	enabled: boolean().default(true),
@@ -12935,7 +12936,8 @@ const DrainDone = object({ released: array(SessionKey) });
 */
 const CronTarget = object({
 	platform: _enum(["slack", "telegram"]).default("slack"),
-	channel: string()
+	channel: string(),
+	integrationId: string().uuid().optional()
 });
 const CronUpsert = object({
 	cronId: string().uuid(),
@@ -12946,6 +12948,36 @@ const CronUpsert = object({
 	enabled: boolean().default(true)
 });
 const CronRemove = object({ cronId: string().uuid() });
+/**
+* `cron/report` (D→C EVT, fire-and-forget) — one CP-owned cron fired. The
+* daemon stamps the fire into its local store first (it stays authoritative,
+* §5.4) and reports it here so the console's `lastRunAt` converges; the CP
+* upsert is latest-wins, so the daemon re-asserting its stored stamps on
+* reconnect (fires while the CP was unreachable) is idempotent and can never
+* regress the value. Hand-authored (no-origin) crons are never reported.
+*
+* Two reports per fire, keyed by `(cronId, firedAt)`: the FIRE report (no
+* `status`) opens the run, and the COMPLETION report (with `status` + outcome
+* fields) closes it once the dispatched turn ends — feeding the console's
+* per-schedule run history. A completion without a prior fire report (CP was
+* down at fire time) still creates the run row.
+*/
+const CronRunStatus = _enum(["success", "failed"]);
+const CronReport = object({
+	cronId: string().uuid(),
+	agentId: string().uuid(),
+	firedAt: string().datetime(),
+	status: CronRunStatus.optional(),
+	durationMs: number().int().nonnegative().optional(),
+	sessionId: string().optional(),
+	reason: string().optional()
+});
+/**
+* `cron/run` (C→D REQ → ack) — fire one CP-owned cron NOW (console "Run now").
+* The daemon accepts (`ok:true`) and runs the fire asynchronously — outcome
+* arrives as normal `cron/report`s; `ok:false` when it holds no such cron.
+*/
+const CronRunNow = object({ cronId: string().uuid() });
 //#endregion
 //#region ../protocol/dist/frames/secrets.js
 /**
@@ -13546,6 +13578,8 @@ const FRAME_SCHEMAS = {
 	"drain/done": DrainDone,
 	"cron/upsert": CronUpsert,
 	"cron/remove": CronRemove,
+	"cron/report": CronReport,
+	"cron/run": CronRunNow,
 	"integration/upsert": IntegrationUpsert,
 	"integration/remove": IntegrationRemove,
 	"integration/channels": IntegrationChannels,
@@ -13651,6 +13685,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("cron/report", FRAME_SCHEMAS["cron/report"]),
+	frame("cron/run", FRAME_SCHEMAS["cron/run"]),
 	frame("integration/upsert", FRAME_SCHEMAS["integration/upsert"]),
 	frame("integration/remove", FRAME_SCHEMAS["integration/remove"]),
 	frame("integration/channels", FRAME_SCHEMAS["integration/channels"]),
@@ -81280,7 +81316,8 @@ var SlackConnection = class {
 			id: c.id ?? channel,
 			name: c.name,
 			isIm: c.is_im,
-			isPrivate: c.is_private
+			isPrivate: c.is_private,
+			user: c.user
 		};
 	}
 	async listMembers(channel) {
@@ -81450,6 +81487,11 @@ var SlackNameResolver = class {
 		try {
 			const info = await conn.getChannelInfo(channel);
 			if (info.name) this.save(channel, info.name);
+			else if (info.isIm && info.user) {
+				const p = await conn.getUserProfile(info.user);
+				const name = p.realName || p.name;
+				if (name) this.save(channel, `@${name}`);
+			}
 		} catch (err) {
 			this.nextAttemptAt.set(channel, this.now() + FAIL_TTL_MS);
 			this.log?.debug(`slack: name lookup failed for channel ${channel}: ${err.message}`);
@@ -83008,6 +83050,17 @@ var CpClient = class {
 		if (this.state !== "READY" && this.state !== "DRAINING") return;
 		this.transport?.send(encode(buildEnvelope("integration/channels", snapshot)));
 	}
+	/**
+	* Report a CP-owned cron fire (D→C `cron/report` EVT, fire-and-forget) so the
+	* console's `lastRunAt` converges. The local D11 stamp stays authoritative and
+	* the CP upsert is latest-wins, so re-asserting stored stamps on each
+	* (re)connect (see onReady in daemon.ts) makes a dropped report only a delay,
+	* never a loss. No-op unless READY/DRAINING.
+	*/
+	emitCronReport(report) {
+		if (this.state !== "READY" && this.state !== "DRAINING") return;
+		this.transport?.send(encode(buildEnvelope("cron/report", report)));
+	}
 	request(type, payload) {
 		const frame = buildEnvelope(type, payload);
 		return this.correlator.request(frame, (e) => this.transport.send(e));
@@ -83094,6 +83147,9 @@ var CpClient = class {
 				this.deps.configApply.removeCron(frame.payload.cronId);
 				this.reply(frame, "ack", { ok: true });
 				return;
+			case "cron/run":
+				this.reply(frame, "ack", this.deps.configApply.runCron(frame.payload.cronId));
+				return;
 			case "route/assign": {
 				const a = frame.payload;
 				this.deps.configApply.applyRouteAssign(a);
@@ -83719,7 +83775,8 @@ function toCronDef(cron) {
 		schedule: cron.schedule,
 		...cron.target && cron.target.platform === "slack" ? { target: {
 			platform: "slack",
-			channel: cron.target.channel
+			channel: cron.target.channel,
+			...cron.target.integrationId ? { integrationId: cron.target.integrationId } : {}
 		} } : {},
 		trigger: cron.trigger,
 		enabled: cron.enabled !== false,
@@ -84663,7 +84720,7 @@ var Daemon = class Daemon {
 	async dispatch(agentId, msg, integrationId) {
 		if (this.draining || this.drainingAgents.has(agentId)) {
 			this.log.debug(`dispatch: skipped for agent "${agentId}" (draining)`);
-			return;
+			return null;
 		}
 		const conv = new OutputConverger(this.agents.get(agentId).output.mode);
 		const rec = new TranscriptRecorder();
@@ -84735,6 +84792,7 @@ var Daemon = class Daemon {
 			p.resolveDone();
 		}
 		this.flushQueued(agentId, sessionId, integrationId);
+		return sessionId;
 	}
 	/** After `!stop` sends session/cancel, give the agent `cancelBackstopMs` to yield.
 	*  If the turn is still in flight when the timer fires, the agent ignored the
@@ -85086,6 +85144,7 @@ var Daemon = class Daemon {
 			applyIntegrationRemove: (integrationId) => this.cpIntegrations?.remove(integrationId),
 			upsertCron: (cron) => this.cpCrons.upsert(cron),
 			removeCron: (cronId) => this.cpCrons.remove(cronId),
+			runCron: (cronId) => this.runCronNow(cronId),
 			applyRouteAssign: (a) => this.cpRouting?.upsertAssign(a),
 			applyRouteUpdate: (u) => this.cpRouting?.applyUpdate(u),
 			applyAgentLaunch: async (launch) => {
@@ -85119,9 +85178,15 @@ var Daemon = class Daemon {
 	* additionally suppresses all platform output in dispatch.
 	*/
 	async onCronFire(agentId, msg, cron) {
-		this.store.setCronLastRun(`${agentId}:${cron.id}`, this.clock.now());
+		const firedAt = this.clock.now();
+		this.store.setCronLastRun(`${agentId}:${cron.id}`, firedAt);
+		if (cron.origin === "cp") this.cpClient?.emitCronReport({
+			cronId: cron.id,
+			agentId,
+			firedAt: new Date(firedAt).toISOString()
+		});
 		if (cron.target?.channel) {
-			const conn = this.replyConnFor(agentId);
+			const conn = this.replyConnFor(agentId, cron.target.integrationId);
 			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}`);
@@ -85133,7 +85198,43 @@ var Daemon = class Daemon {
 				this.log.warn(`cron "${cron.id}": failed to post trigger to ${cron.target.channel} (${formatErr(err)}) — running without anchor`);
 			}
 		}
-		await this.dispatch(agentId, msg);
+		try {
+			const sessionId = await this.dispatch(agentId, msg, cron.target?.integrationId);
+			if (cron.origin === "cp" && sessionId !== null) this.cpClient?.emitCronReport({
+				cronId: cron.id,
+				agentId,
+				firedAt: new Date(firedAt).toISOString(),
+				status: "success",
+				durationMs: Math.max(0, this.clock.now() - firedAt),
+				sessionId
+			});
+		} catch (err) {
+			if (cron.origin === "cp") this.cpClient?.emitCronReport({
+				cronId: cron.id,
+				agentId,
+				firedAt: new Date(firedAt).toISOString(),
+				status: "failed",
+				durationMs: Math.max(0, this.clock.now() - firedAt),
+				reason: err.message?.slice(0, 300) || "dispatch failed"
+			});
+			throw err;
+		}
+	}
+	/** Console "Run now" (`cron/run` REQ): fire one CP cron immediately. The fire
+	*  runs asynchronously — the ack only says whether the cron exists here; the
+	*  outcome arrives as normal `cron/report`s. */
+	runCronNow(cronId) {
+		for (const a of this.effectiveAgents()) {
+			const cron = a.crons.find((c) => c.id === cronId && c.origin === "cp");
+			if (!cron) continue;
+			const { msg } = buildSyntheticMessage(a.id, cron, randomUUID());
+			this.onCronFire(a.id, msg, cron).catch((err) => this.log.error(`cron/run dispatch failed for agent "${a.id}": ${formatErr(err)}`));
+			return { ok: true };
+		}
+		return {
+			ok: false,
+			reason: "unknown cron"
+		};
 	}
 	/** 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
@@ -85180,6 +85281,15 @@ var Daemon = class Daemon {
 					integrationId,
 					channels
 				});
+				for (const a of this.effectiveAgents()) for (const c of a.crons) {
+					if (c.origin !== "cp") continue;
+					const at = this.store.getCronLastRun(`${a.id}:${c.id}`);
+					if (at !== void 0) this.cpClient?.emitCronReport({
+						cronId: c.id,
+						agentId: a.id,
+						firedAt: new Date(at).toISOString()
+					});
+				}
 			},
 			localState: () => ({
 				assignments: [],