@agentconnect.md/daemon 1.0.0-rc.60 → 1.0.0-rc.62

package/dist/index.js

@@ -7595,7 +7595,7 @@ function cachedRuntimeNames(root) {
 }
 /**
 * Runtime versions (registry id -> `version`) read from the local cache. Used to
-* stamp the `facts/runtime-profile` the daemon reports per installed runtime.
+* stamp each entry of the `facts/daemon-runtimes` snapshot the daemon reports.
 * Entries with no `version` are omitted (callers fall back to ''). `{}` when no
 * cached registry doc exists.
 */
@@ -13254,6 +13254,74 @@ const SessionHistoryPage = object({
 	nextCursor: string().optional()
 });
 //#endregion
+//#region ../protocol/dist/frames/telemetry.js
+/**
+* Telemetry & facts (D→C) — protocol §7.
+*
+* The dashboard's real-time source. `event/session` is the converged milestone
+* feed (NOT the message stream); `facts/daemon-runtimes` is the observed runtime
+* capability feed; `heartbeat` drives the watchdog.
+*/
+const Heartbeat = object({
+	load: object({
+		cpu: number(),
+		mem: number(),
+		agents: number().int()
+	}),
+	health: _enum(["ok", "degraded"]),
+	activeSessions: number().int(),
+	degradedScopes: array(string()).default([])
+});
+/** Converged session lifecycle milestone — protocol §7.2. NOT the message stream. */
+const EventSession = object({
+	sessionId: string().uuid(),
+	agentId: string().uuid(),
+	launchId: string().uuid(),
+	phase: _enum([
+		"start",
+		"plan",
+		"problem",
+		"end"
+	]),
+	link: string().optional(),
+	summary: string().optional(),
+	ts: string().datetime()
+});
+/**
+* Per-session token-usage report — D→C EVT. The daemon meters usage from the
+* agent's ACP stream and reports the session's CUMULATIVE snapshot (latest-wins)
+* so the CP can persist it for the console's historical usage aggregates. This is
+* dashboard metadata (token counts + cost), never the message stream. Idempotent
+* by `sessionId`: re-sending the same snapshot is a no-op upsert on the CP.
+*/
+const UsageReport = object({
+	sessionId: string(),
+	agentId: string().uuid(),
+	platform: string().optional(),
+	channel: string().optional(),
+	lastActivityAt: string(),
+	usage: SessionUsage
+});
+/**
+* Observed capabilities of an installed runtime — protocol §7.3. The element
+* type of the `facts/daemon-runtimes` snapshot. As a standalone per-runtime
+* frame (`facts/runtime-profile`, upsert-only) it is DEPRECATED: current
+* daemons report the full snapshot instead; the CP keeps accepting the old
+* frame from older daemons.
+*/
+const FactsRuntimeProfile = object({
+	runtime: string(),
+	version: string(),
+	models: array(string()),
+	contextWindow: number().int().optional(),
+	acpSupport: _enum([
+		"full",
+		"partial",
+		"none"
+	]),
+	toolCalling: boolean()
+});
+//#endregion
 //#region ../protocol/dist/frame.js
 /**
 * The single source of truth for the wire: `type` string → payload zod schema.
@@ -13271,16 +13339,7 @@ const FRAME_SCHEMAS = {
 	"auth/ok": AuthOk,
 	register: RegisterReq,
 	"register/ok": RegisterOk,
-	heartbeat: object({
-		load: object({
-			cpu: number(),
-			mem: number(),
-			agents: number().int()
-		}),
-		health: _enum(["ok", "degraded"]),
-		activeSessions: number().int(),
-		degradedScopes: array(string()).default([])
-	}),
+	heartbeat: Heartbeat,
 	"agent/launch": AgentLaunch,
 	"agent/launched": AgentLaunched,
 	"agent/stop": AgentStop,
@@ -13306,40 +13365,10 @@ const FRAME_SCHEMAS = {
 	"secrets/renew": SecretsRenew,
 	"secrets/revoke": SecretsRevoke,
 	"scope-attestation": ScopeAttestation,
-	"event/session": object({
-		sessionId: string().uuid(),
-		agentId: string().uuid(),
-		launchId: string().uuid(),
-		phase: _enum([
-			"start",
-			"plan",
-			"problem",
-			"end"
-		]),
-		link: string().optional(),
-		summary: string().optional(),
-		ts: string().datetime()
-	}),
-	"usage/report": object({
-		sessionId: string(),
-		agentId: string().uuid(),
-		platform: string().optional(),
-		channel: string().optional(),
-		lastActivityAt: string(),
-		usage: SessionUsage
-	}),
-	"facts/runtime-profile": object({
-		runtime: string(),
-		version: string(),
-		models: array(string()),
-		contextWindow: number().int().optional(),
-		acpSupport: _enum([
-			"full",
-			"partial",
-			"none"
-		]),
-		toolCalling: boolean()
-	}),
+	"event/session": EventSession,
+	"usage/report": UsageReport,
+	"facts/runtime-profile": FactsRuntimeProfile,
+	"facts/daemon-runtimes": object({ runtimes: array(FactsRuntimeProfile) }),
 	"session/list": SessionListReq,
 	"session/list/page": SessionListPage,
 	"session/history": SessionHistoryReq,
@@ -13434,6 +13463,7 @@ discriminatedUnion("type", [
 	frame("event/session", FRAME_SCHEMAS["event/session"]),
 	frame("usage/report", FRAME_SCHEMAS["usage/report"]),
 	frame("facts/runtime-profile", FRAME_SCHEMAS["facts/runtime-profile"]),
+	frame("facts/daemon-runtimes", FRAME_SCHEMAS["facts/daemon-runtimes"]),
 	frame("session/list", FRAME_SCHEMAS["session/list"]),
 	frame("session/list/page", FRAME_SCHEMAS["session/list/page"]),
 	frame("session/history", FRAME_SCHEMAS["session/history"]),
@@ -81880,13 +81910,14 @@ async function probeRuntime(id, rt, cwd, opts = {}) {
 		return host.modelOptions();
 	};
 	try {
-		const models = await Promise.race([run(), timeout]);
-		opts.log?.info(`probe: ${id} ok (models: ${models?.models.length ? models.models.join(", ") : "none advertised"})`);
+		const opt = await Promise.race([run(), timeout]);
+		const models = (opt?.models ?? []).filter((m) => m !== "default");
+		opts.log?.info(`probe: ${id} ok (models: ${models.length ? models.join(", ") : "none advertised"})`);
 		return {
 			runtime: id,
 			ok: true,
-			models: models?.models ?? [],
-			currentModel: models?.current
+			models,
+			currentModel: opt?.current
 		};
 	} catch (err) {
 		const error = err.message;
@@ -82136,17 +82167,19 @@ var CpClient = class {
 		this.heartbeatMs = ok.heartbeatSec > 0 ? ok.heartbeatSec * 1e3 : this.deps.heartbeatDefaultMs;
 		this.armHeartbeat();
 		this.deps.log.info(`cp: READY (epoch=${this.sessionEpoch}, routingEpoch=${this.routingEpoch})`);
-		for (const profile of this.deps.runtimeProfiles()) this.emitRuntimeProfile(profile);
+		this.emitDaemonRuntimes(this.deps.runtimeProfiles());
 		this.deps.onReady?.();
 	}
 	/**
-	* Push a single runtime profile mid-session (D→C EVT, fire-and-forget). No-op
-	* unless connected and READY/DRAINING — the CP only accepts control frames
-	* there, and a reconnect's handshake re-emits the latest profiles anyway.
+	* Push the full runtime snapshot (D→C `facts/daemon-runtimes` EVT,
+	* fire-and-forget) — sent on each register and again when a probe sweep
+	* completes. REPLACE semantics on the CP: it reconciles the daemon's stored
+	* runtime list to exactly this snapshot, pruning runtimes that are no longer
+	* installed. No-op unless READY/DRAINING.
 	*/
-	emitRuntimeProfile(profile) {
+	emitDaemonRuntimes(runtimes) {
 		if (this.state !== "READY" && this.state !== "DRAINING") return;
-		this.transport?.send(encode(buildEnvelope("facts/runtime-profile", profile)));
+		this.transport?.send(encode(buildEnvelope("facts/daemon-runtimes", { runtimes })));
 	}
 	/**
 	* Report a session's cumulative token usage (D→C `usage/report` EVT,
@@ -83900,8 +83933,9 @@ var Daemon = class Daemon {
 		this.cpClient.start();
 		this.log.info(`cp: connecting to ${url}…`);
 	}
-	/** Build the current `facts/runtime-profile` for a runtime, folding in any
-	*  models learned by the probe sweep. */
+	/** Build the current profile entry for a runtime (one element of the
+	*  `facts/daemon-runtimes` snapshot), folding in any models learned by the
+	*  probe sweep. */
 	runtimeProfileFor(id) {
 		return {
 			runtime: id,
@@ -83916,8 +83950,8 @@ var Daemon = class Daemon {
 	static PROBE_TTL_MS = 5 * 6e4;
 	/**
 	* Probe every installed runtime in the background (launch → initialize →
-	* session/new → read models → tear down), then emit a refreshed
-	* `facts/runtime-profile` per runtime once the whole sweep completes.
+	* session/new → read models → tear down), then emit one `facts/daemon-runtimes`
+	* snapshot once the whole sweep completes so the CP replaces its runtime list.
 	*
 	* Triggered on each CP (re)connect. Deduped while in flight; skipped (with a
 	* cached re-emit) when the last sweep is still fresh, so a reconnect storm can't
@@ -83930,7 +83964,7 @@ var Daemon = class Daemon {
 		if (ids.length === 0) return;
 		if (this.probing) return;
 		if (this.lastProbeAtMs > 0 && Date.now() - this.lastProbeAtMs < Daemon.PROBE_TTL_MS) {
-			for (const id of ids) this.cpClient?.emitRuntimeProfile(this.runtimeProfileFor(id));
+			this.cpClient?.emitDaemonRuntimes(ids.map((id) => this.runtimeProfileFor(id)));
 			return;
 		}
 		this.probing = true;
@@ -83941,7 +83975,7 @@ var Daemon = class Daemon {
 			this.lastProbeAtMs = Date.now();
 			const okCount = results.filter((r) => r.ok).length;
 			this.log.info(`probe: sweep complete — ${okCount}/${results.length} runtime(s) reachable`);
-			for (const id of ids) this.cpClient?.emitRuntimeProfile(this.runtimeProfileFor(id));
+			this.cpClient?.emitDaemonRuntimes(ids.map((id) => this.runtimeProfileFor(id)));
 		} catch (err) {
 			this.log.warn(`probe: sweep failed: ${formatErr(err)}`);
 		} finally {