@agentconnect.md/daemon 1.0.0-rc.100 → 1.0.0-rc.102

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"]),
@@ -24896,7 +24932,7 @@ const SLACK_TOOLS = [
 		inputSchema: obj({
 			text: {
 				type: "string",
-				description: "Message body, in Slack mrkdwn."
+				description: "Message body, in standard Markdown (CommonMark/GFM). Use `**bold**`, `~~strikethrough~~`, `# headings`, tables, etc. — Slack renders standard Markdown natively (do NOT use single-char Slack mrkdwn like `*bold*` or `~strike~`)."
 			},
 			channel: {
 				type: "string",
@@ -80973,7 +81009,7 @@ var import_dist = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((expor
 		}
 	});
 })))(), 1);
-const MENTION_RE = /<@([A-Z0-9]+)>/g;
+const MENTION_RE$1 = /<@([A-Z0-9]+)>/g;
 /** Map a Slack file element to a NormalizedMessage Attachment, dropping any
 *  without a usable id + fetch URL (e.g. external/tombstoned files). Tolerates a
 *  malformed (null / non-object) element off the wire without throwing. */
@@ -80991,7 +81027,7 @@ function toAttachment(f) {
 }
 function normalizeSlackEvent(event, ctx) {
 	const text = event.text ?? "";
-	const mentionedBots = [...text.matchAll(MENTION_RE)].map((m) => m[1]);
+	const mentionedBots = [...text.matchAll(MENTION_RE$1)].map((m) => m[1]);
 	const attachments = (event.files ?? []).map(toAttachment).filter((a) => a !== null);
 	return {
 		msgId: `slack:${event.channel}:${event.ts}`,
@@ -81098,6 +81134,21 @@ function consolidate(agents) {
 }
 /** Cap on members enriched per `listChannelMembers` call (bounds users.info fan-out). */
 const MEMBER_ENRICH_CAP = 50;
+/**
+* Build a chat.postMessage/update payload that renders the body as a Block Kit
+* `markdown` block — Slack renders standard CommonMark there natively, so the agent's
+* markdown is sent verbatim (no markdown→mrkdwn conversion). `text` is kept as the
+* notification/accessibility fallback. Callers pre-chunk to SLACK_MARKDOWN_BLOCK_LIMIT.
+*/
+function markdownBlock(text) {
+	return {
+		text,
+		blocks: [{
+			type: "markdown",
+			text
+		}]
+	};
+}
 var SlackConnection = class {
 	deps;
 	app;
@@ -81170,8 +81221,8 @@ var SlackConnection = class {
 		return this.queue.enqueue(async () => {
 			return (await this.app.client.chat.postMessage({
 				channel,
-				text,
-				thread_ts: threadTs
+				thread_ts: threadTs,
+				...markdownBlock(text)
 			}))?.ts;
 		});
 	}
@@ -81183,7 +81234,7 @@ var SlackConnection = class {
 				await this.app.client.chat.update({
 					channel,
 					ts,
-					text
+					...markdownBlock(text)
 				});
 			} catch (err) {
 				this.deps.log?.debug(`slack: chat.update failed (ch=${channel} ts=${ts}): ${err.message}`);
@@ -81356,6 +81407,31 @@ var SlackConnection = class {
 	}
 };
 //#endregion
+//#region src/slack/mentions.ts
+/**
+* Slack `<@U…>` user-mention helpers, shared by the name-resolver (which warms the
+* display-name cache for mentioned users) and the session reader (which rewrites
+* mentions to `@name` for read-back). Slack encodes a user mention as `<@U123>` or
+* `<@U123|label>`; the id is a `U…`/`W…` user id (resolvable via users.info even for
+* a bot's user id, unlike a bot SENDER's `B…` id).
+*/
+const MENTION_RE = /<@([UW][A-Z0-9]+)(?:\|[^>]*)?>/g;
+/** Distinct `U…/W…` user ids mentioned in a message body (empty for none/nullish). */
+function mentionedUserIds(text) {
+	if (!text) return [];
+	const ids = /* @__PURE__ */ new Set();
+	for (const m of text.matchAll(MENTION_RE)) ids.add(m[1]);
+	return [...ids];
+}
+/** Rewrite `<@U123>` / `<@U123|x>` to `@<display name>` when the id is known; an
+*  unknown id is left as the raw token so the web renderer's own fallback applies. */
+function substituteUserMentions(text, names) {
+	return text.replace(MENTION_RE, (raw, id) => {
+		const name = names.get(id);
+		return name ? `@${name}` : raw;
+	});
+}
+//#endregion
 //#region src/slack/name-resolver.ts
 /**
 * Resolves Slack ids (channel "C…", user "U…/W…") to human display names off the
@@ -81385,10 +81461,14 @@ var SlackNameResolver = class {
 		this.log = log;
 		this.now = now;
 	}
-	/** Kick off (cached) resolution for a message's channel + human sender. */
+	/** Kick off (cached) resolution for a message's channel, human sender, and any
+	*  `<@U…>` user mentions in its body — so session read-back can render mentions
+	*  as `@name` (not the raw id). Mention ids use the `U…/W…` user id (resolvable
+	*  via users.info even for a bot's user id), unlike a bot SENDER's `B…` id. */
 	noteMessage(conn, msg) {
 		this.resolveChannel(conn, msg.channel);
 		if (!msg.sender.isBot && /^[UW]/.test(msg.sender.id)) this.resolveUser(conn, msg.sender.id);
+		for (const id of mentionedUserIds(msg.text)) this.resolveUser(conn, id);
 	}
 	claim(id) {
 		const at = this.nextAttemptAt.get(id);
@@ -81426,61 +81506,22 @@ var SlackNameResolver = class {
 //#endregion
 //#region src/slack/formatter.ts
 /**
-* Last-mile Slack formatting (§9.1 / §9.3). Two pure helpers:
-*  - markdownToMrkdwn: convert the agent's CommonMark-ish output to Slack mrkdwn.
-*  - splitIntoSections: break a message into <= maxLen sections (Slack ~3000/section).
-* Both are platform-specific; the upstream convergence (ACP->IR) stays platform-agnostic.
-*/
-/** Slack section soft cap (§9.3: Slack splits at ~3000 chars per section). */
-const SLACK_SECTION_LIMIT = 3e3;
-const CODE_SENTINEL = "\0";
-const BOLD = "
";
-/** Replace fenced ```code``` and inline `code` with placeholders so inline
-*  formatting rules never fire inside them; returns the masked text + restorer. */
-function protectCode(input) {
-	const spans = [];
-	const masked = input.replace(/```[\s\S]*?```|`[^`\n]*`/g, (m) => {
-		return `${CODE_SENTINEL}${spans.push(m) - 1}${CODE_SENTINEL}`;
-	});
-	const restore = (s) => s.replace(new RegExp(`${CODE_SENTINEL}(\\d+)${CODE_SENTINEL}`, "g"), (_, i) => spans[Number(i)] ?? "");
-	return {
-		masked,
-		restore
-	};
-}
-/**
-* Convert common Markdown to Slack mrkdwn. Handled: bold (`**`/`__` -> `*`),
-* italic (`*` -> `_`; bare `_` is already valid mrkdwn italic and left alone to
-* avoid mangling snake_case), strikethrough (`~~` -> `~`), links (`[t](u)` ->
-* `<u|t>`), ATX headings (`# H` -> `*H*`), and `-`/`*`/`+` bullets -> `•`. Code
-* spans and fences are preserved verbatim.
+* Last-mile Slack formatting (§9.1 / §9.3). One pure helper:
+*  - splitIntoSections: break a message into <= maxLen sections.
 *
-* Best-effort, not a full CommonMark parser: pathological overlapping emphasis
-* (e.g. `***a** b*`, or a lone `*` inside `**bold**`) can still render imperfectly.
-* Such inputs are rare in agent output and only affect cosmetics — never content.
+* The daemon posts the agent's reply as a Block Kit `markdown` block (which renders
+* standard CommonMark natively), so NO markdown→mrkdwn conversion happens here — the
+* agent's text is sent verbatim. We only chunk it: a single `markdown` block caps at
+* 12000 chars, so a long body is split across blocks/messages on line boundaries.
 */
-function markdownToMrkdwn(input) {
-	if (!input) return input;
-	const { masked, restore } = protectCode(input);
-	let out = masked;
-	out = out.replace(/^[ \t]*#{1,6}[ \t]+(.+?)[ \t]*#*$/gm, (_m, h) => `${BOLD}${h.replace(/\*+|__/g, "")}${BOLD}`);
-	out = out.replace(/^([ \t]*)[-*+][ \t]+/gm, "$1• ");
-	out = out.replace(/\[([^\]]+)\]\((https?:\/\/[^)\s]+)\)/g, "<$2|$1>");
-	out = out.replace(/\*\*\*(?!\s)([^\n]+?)(?<!\s)\*\*\*/g, `${BOLD}_$1_${BOLD}`);
-	out = out.replace(/___(?!\s)([^\n]+?)(?<!\s)___/g, `${BOLD}_$1_${BOLD}`);
-	out = out.replace(/\*\*(?!\s)([^\n]+?)(?<!\s)\*\*/g, `${BOLD}$1${BOLD}`);
-	out = out.replace(/__(?!\s)([^\n]+?)(?<!\s)__/g, `${BOLD}$1${BOLD}`);
-	out = out.replace(/\*(?!\s)([^*\n]+?)(?<!\s)\*/g, "_$1_");
-	out = out.split(BOLD).join("*");
-	out = out.replace(/~~([^\n]+?)~~/g, "~$1~");
-	return restore(out);
-}
+/** Slack `markdown` block hard cap (12000 chars per block). */
+const SLACK_MARKDOWN_BLOCK_LIMIT = 12e3;
 /**
 * Split text into sections no longer than maxLen, preferring line boundaries;
 * a single line longer than maxLen is hard-cut. Whitespace-only input yields no
 * sections. Content is never lost across sections.
 */
-function splitIntoSections(text, maxLen = SLACK_SECTION_LIMIT) {
+function splitIntoSections(text, maxLen = SLACK_MARKDOWN_BLOCK_LIMIT) {
 	if (!text.trim()) return [];
 	if (text.length <= maxLen) return [text];
 	const sections = [];
@@ -81520,9 +81561,10 @@ function planIcon(status) {
 	if (status === "in_progress") return ":hourglass_flowing_sand:";
 	return ":white_large_square:";
 }
-/** Render an ACP plan (full entry list, resent on every update) as a compact summary. */
+/** Render an ACP plan (full entry list, resent on every update) as a compact summary.
+*  Posted as a `markdown` block, so emphasis is CommonMark (`**bold**`), not mrkdwn. */
 function renderPlan(entries) {
-	return [":clipboard: *Plan*", ...entries.map((e) => `${planIcon(e.status)} ${clampLabel(e.content ?? "")}`)].join("\n");
+	return [":clipboard: **Plan**", ...entries.map((e) => `${planIcon(e.status)} ${clampLabel(e.content ?? "")}`)].join("\n");
 }
 var OutputConverger = class {
 	mode;
@@ -81537,8 +81579,9 @@ var OutputConverger = class {
 	hasBuffered() {
 		return this.buf.trim().length > 0;
 	}
-	/** Flush the buffered body: markdown→mrkdwn, then split into ≤3000-char sections,
-	*  one `post` per section (§9.1/§9.3). Public so the daemon's idle timer can call it. */
+	/** Flush the buffered body: split the agent's verbatim markdown into ≤block-limit
+	*  sections, one `post` per section (each posted as a Block Kit `markdown` block, so
+	*  no mrkdwn conversion). Public so the daemon's idle timer can call it. */
 	flushBuffered() {
 		return this.flush();
 	}
@@ -81546,7 +81589,7 @@ var OutputConverger = class {
 		const text = this.buf;
 		this.buf = "";
 		if (!text.trim()) return [];
-		return splitIntoSections(markdownToMrkdwn(text)).map((t) => ({
+		return splitIntoSections(text).map((t) => ({
 			kind: "post",
 			text: t
 		}));
@@ -81637,7 +81680,7 @@ var OutputConverger = class {
 		if (this.mode === "low") return [...this.flush(), clear];
 		const footer = link ? [{
 			kind: "notice",
-			text: `:white_check_mark: done — <${link}|details>`
+			text: `:white_check_mark: done — [details](${link})`
 		}] : [];
 		return [
 			...this.flush(),
@@ -83001,6 +83044,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));
@@ -83087,6 +83141,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);
@@ -83293,11 +83350,16 @@ function createSessionReader(store) {
 	return {
 		list(req) {
 			const rows = store.listSessions(req.agentId);
-			const names = store.getDisplayNames(rows.flatMap((r) => [r.channel, ...r.triggeredBy ? [r.triggeredBy] : []]));
+			const names = store.getDisplayNames(rows.flatMap((r) => [
+				r.channel,
+				...r.triggeredBy ? [r.triggeredBy] : [],
+				...mentionedUserIds(r.title)
+			]));
 			return { sessions: rows.map((r) => {
 				const usage = parseUsage(r.usage);
 				const channelName = names.get(r.channel);
 				const triggeredByName = r.triggeredBy ? names.get(r.triggeredBy) : void 0;
+				const title = r.title ? substituteUserMentions(r.title, names) : void 0;
 				return {
 					sessionId: r.acpSessionId,
 					sessionKey: {
@@ -83309,7 +83371,7 @@ function createSessionReader(store) {
 					status: r.state,
 					lastActivityAt: new Date(r.updatedAt).toISOString(),
 					...usage ? { usage } : {},
-					...r.title ? { title: r.title } : {},
+					...title ? { title } : {},
 					...r.triggeredBy ? { triggeredBy: r.triggeredBy } : {},
 					...channelName ? { channelName } : {},
 					...triggeredByName ? { triggeredByName } : {}
@@ -83325,7 +83387,7 @@ function createSessionReader(store) {
 			const before = req.cursor != null && Number.isFinite(Number(req.cursor)) ? Number(req.cursor) : null;
 			const { rows, hasMore } = store.transcriptPage(rec.channel, rec.thread, before, req.limit);
 			const ordered = rows.slice().reverse();
-			const names = store.getDisplayNames(ordered.map((r) => r.sender));
+			const names = store.getDisplayNames(ordered.flatMap((r) => [r.sender, ...mentionedUserIds(r.text)]));
 			const built = ordered.map((r) => {
 				const senderName = names.get(r.sender);
 				const base = {
@@ -83334,7 +83396,7 @@ function createSessionReader(store) {
 					...senderName ? { senderName } : {},
 					ts: r.ts,
 					kind: r.kind,
-					text: r.text
+					text: substituteUserMentions(r.text, names)
 				};
 				if (r.kind !== "tool" || !r.body) return base;
 				let full;
@@ -83707,7 +83769,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,
@@ -84651,7 +84714,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();
@@ -84723,6 +84786,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
@@ -85074,6 +85138,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) => {
@@ -85107,9 +85172,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}`);
@@ -85121,7 +85192,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
@@ -85168,6 +85275,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: [],