relay-dsh-plugin-events 0.2.1 → 0.2.2

package/lib/host-plugin.js

@@ -75,10 +75,18 @@ function validateMonitorProvider(provider) {
 	for (const method of ["prepare", "checkMonitor"]) if (typeof provider[method] !== "function") throw new TypeError(`monitor provider requires ${method}()`);
 	return provider;
 }
+function validateBoundEventSourceProvider(provider) {
+	if (!provider || typeof provider !== "object") throw new TypeError("bound Event source provider is required");
+	if (!/^[a-z][a-z0-9._-]{0,63}$/u.test(provider.id ?? "")) throw new TypeError("bound Event source provider requires a lowercase stable id");
+	if (!Array.isArray(provider.sources) || provider.sources.length === 0) throw new TypeError("bound Event source provider requires at least one source");
+	for (const source of provider.sources) if (typeof source !== "string" || source.length === 0 || source.length > 128) throw new TypeError("bound Event source provider has an invalid source");
+	if (new Set(provider.sources).size !== provider.sources.length) throw new TypeError("bound Event source provider sources must be unique");
+	return provider;
+}
 //#endregion
 //#region src/runtime/runtime.mjs
 var RelayRuntime = class {
-	constructor({ store, router, inbox, monitorRegistrar = null, workerId = `relay-dispatcher-${randomUUID()}`, leaseMs = 6e4, maxDispatchBatches = 100 }) {
+	constructor({ store, router, inbox, monitorRegistrar = null, workerId = `relay-dispatcher-${randomUUID()}`, leaseMs = 6e4, maxDispatchBatches = 100, routingFailureLimit = 3, deliveryFailureLimit = 5, deliveryRetryBaseMs = 1e3 }) {
 		assert.ok(store, "store is required");
 		assert.equal(typeof router?.route, "function", "router.route is required");
 		assert.equal(typeof inbox?.deliver, "function", "inbox.deliver is required");
@@ -90,16 +98,22 @@ var RelayRuntime = class {
 		this.workerId = workerId;
 		this.leaseMs = leaseMs;
 		this.maxDispatchBatches = maxDispatchBatches;
+		assert.ok(Number.isSafeInteger(routingFailureLimit) && routingFailureLimit > 0, "routingFailureLimit must be positive");
+		this.routingFailureLimit = routingFailureLimit;
+		assert.ok(Number.isSafeInteger(deliveryFailureLimit) && deliveryFailureLimit > 0, "deliveryFailureLimit must be positive");
+		assert.ok(Number.isSafeInteger(deliveryRetryBaseMs) && deliveryRetryBaseMs > 0, "deliveryRetryBaseMs must be positive");
+		this.deliveryFailureLimit = deliveryFailureLimit;
+		this.deliveryRetryBaseMs = deliveryRetryBaseMs;
 	}
 	async registerWaits({ sessionId, taskSummary, context = {}, waits, monitors = [], monitorRearms = [] }) {
-		validateWaitRegistration({
+		waits = validateWaitRegistration({
 			sessionId,
 			taskSummary,
 			context,
 			waits,
 			monitors,
 			monitorRearms
-		});
+		}).waits;
 		let preparedMonitors = monitors;
 		if (monitors.length > 0) {
 			assert.ok(this.monitorRegistrar, "monitor proposals require a monitorRegistrar");
@@ -124,8 +138,54 @@ var RelayRuntime = class {
 		return this.store.listWaitRegistrations();
 	}
 	async handleEvent(eventInput) {
+		return this.handleUnboundEvent(eventInput, { allowCorrelation: false });
+	}
+	async handleTrustedEvent(eventInput, { providerId } = {}) {
+		assert.equal(typeof providerId, "string", "trusted Event provider id is required");
+		return this.handleUnboundEvent(eventInput, { allowCorrelation: true });
+	}
+	async handleTrustedDismissal(eventInput, { providerId, summary = "The trusted Connector dismissed an unsupported Event." } = {}) {
+		validateEventInput(eventInput);
+		assert.equal(typeof providerId, "string", "trusted Event provider id is required");
+		assert.equal(typeof summary, "string", "trusted dismissal summary is required");
+		assert.ok(summary.length > 0 && summary.length <= 2e3, "trusted dismissal summary is invalid");
+		const ingestion = this.store.ingestEvent(eventInput, { allowCorrelation: true });
+		const eventId = ingestion.event.event_id;
+		let currentEvent = this.store.inspectEvent(eventId);
+		if (currentEvent.state === "received" || currentEvent.state === "routing") {
+			const snapshot = this.store.beginRouting(eventId);
+			if (!snapshot.alreadyRouted) {
+				const decision = {
+					disposition: "dismiss",
+					actionable: false,
+					deliveries: [],
+					evidence: [`trusted provider ${providerId} classified the Event as unsupported`],
+					summary
+				};
+				validateRoutingDecision({
+					decision,
+					sessions: snapshot.sessions,
+					label: `trusted dismissal ${eventId}`
+				});
+				this.store.recordRoutingAttempt({
+					eventId,
+					router: `dismiss:${providerId}`,
+					output: decision
+				});
+				this.store.commitRouting(snapshot, decision);
+			}
+		}
+		currentEvent = this.store.inspectEvent(eventId);
+		return {
+			duplicate: ingestion.duplicate,
+			event: currentEvent,
+			registrations: [],
+			dispatchResults: []
+		};
+	}
+	async handleUnboundEvent(eventInput, { allowCorrelation }) {
 		validateEventInput(eventInput);
-		const ingestion = this.store.ingestEvent(eventInput);
+		const ingestion = this.store.ingestEvent(eventInput, { allowCorrelation });
 		const eventId = ingestion.event.event_id;
 		let currentEvent = this.store.inspectEvent(eventId);
 		let sessionIds = [];
@@ -140,6 +200,41 @@ var RelayRuntime = class {
 			dispatchResults
 		};
 	}
+	async handleBoundEvent(eventInput, binding, { providerId } = {}) {
+		validateEventInput(eventInput);
+		validateTrustedBinding(binding);
+		assert.equal(typeof providerId, "string", "bound Event provider id is required");
+		const ingestion = this.store.ingestEvent(eventInput, { allowCorrelation: true });
+		const eventId = ingestion.event.event_id;
+		let currentEvent = this.store.inspectEvent(eventId);
+		let sessionIds = [];
+		if (currentEvent.state === "received" || currentEvent.state === "routing") {
+			const snapshot = this.store.beginRouting(eventId);
+			if (snapshot.alreadyRouted) sessionIds = snapshot.result.sessionIds;
+			else {
+				const decision = boundRoutingDecision(snapshot.sessions, binding, providerId);
+				validateRoutingDecision({
+					decision,
+					sessions: snapshot.sessions,
+					label: `bound event ${eventId}`
+				});
+				this.store.recordRoutingAttempt({
+					eventId,
+					router: `bound:${providerId}`,
+					output: decision
+				});
+				sessionIds = this.store.commitRouting(snapshot, decision).sessionIds;
+			}
+		} else if (currentEvent.state === "dispatched") sessionIds = [...new Set(currentEvent.deliveries.filter((delivery) => delivery.state === "queued").map((delivery) => delivery.session_id))];
+		const dispatchResults = await Promise.all(sessionIds.map((sessionId) => this.dispatchSession(sessionId)));
+		currentEvent = this.store.inspectEvent(eventId);
+		return {
+			duplicate: ingestion.duplicate,
+			event: currentEvent,
+			registrations: sessionIds.map((sessionId) => this.store.inspectWaitRegistration(sessionId)),
+			dispatchResults
+		};
+	}
 	async routeEvent(eventId) {
 		const snapshot = this.store.beginRouting(eventId);
 		if (snapshot.alreadyRouted) return snapshot.result;
@@ -172,6 +267,16 @@ var RelayRuntime = class {
 				output: routed?.decision ?? routed ?? null,
 				error: error.stack ?? error.message
 			});
+			if (this.store.countRoutingAttempts(eventId) >= this.routingFailureLimit) {
+				const terminal = {
+					disposition: "escalate",
+					actionable: true,
+					deliveries: [],
+					evidence: [`Router ${this.router.name ?? "anonymous-router"} exhausted its failure budget.`],
+					summary: "Relay could not safely route this actionable Event."
+				};
+				return this.store.commitRouting(snapshot, terminal);
+			}
 			throw error;
 		}
 	}
@@ -195,12 +300,17 @@ var RelayRuntime = class {
 				registration = this.store.completeDispatch(sessionId, started.activation.activation_id, this.workerId);
 				activationIds.push(started.activation.activation_id);
 			} catch (error) {
-				this.store.failDispatch(sessionId, started.activation.activation_id, this.workerId, error.stack ?? error.message);
+				const failure = this.store.failDispatch(sessionId, started.activation.activation_id, this.workerId, error.stack ?? error.message, {
+					failureLimit: this.deliveryFailureLimit,
+					baseDelayMs: this.deliveryRetryBaseMs
+				});
 				return {
-					status: "retry",
+					status: failure.status,
 					activationId: started.activation.activation_id,
 					activationIds,
-					error: error.stack ?? error.message
+					error: error.stack ?? error.message,
+					eventIds: failure.eventIds,
+					activation: failure.activation
 				};
 			}
 		}
@@ -223,6 +333,10 @@ function validateWaitRegistration({ sessionId, taskSummary, context, waits, moni
 		assert.ok(Array.isArray(wait.entities), "wait entities must be an array");
 		assert.equal(typeof wait.prior_exchange, "string", "wait prior_exchange is required");
 	}
+	const normalizedWaits = waits.map((wait) => ({
+		...wait,
+		continuation: normalizeContinuation(wait.continuation)
+	}));
 	assert.ok(Array.isArray(monitors), "monitors must be an array");
 	const monitorIds = monitors.map((monitor) => monitor.monitor_id);
 	assert.equal(new Set(monitorIds).size, monitorIds.length, "monitor IDs must be unique");
@@ -240,16 +354,93 @@ function validateWaitRegistration({ sessionId, taskSummary, context, waits, moni
 		sessionId,
 		taskSummary,
 		context,
-		waits,
+		waits: normalizedWaits,
 		monitors,
 		monitorRearms
 	};
 }
+function normalizeContinuation(value) {
+	const input = value ?? {};
+	assert.ok(input && typeof input === "object" && !Array.isArray(input), "wait continuation must be an object");
+	const version = input.version ?? 1;
+	assert.equal(version, 1, "wait continuation version must be 1");
+	const continuation = {
+		version,
+		next_action: boundedString(input.next_action ?? "", "continuation next_action", 8e3),
+		success_condition: boundedString(input.success_condition ?? "", "continuation success_condition", 4e3),
+		constraints: boundedStringArray(input.constraints ?? [], "continuation constraints", 32, 2e3),
+		artifacts: normalizeArtifacts(input.artifacts ?? []),
+		on_failure: boundedString(input.on_failure ?? "", "continuation on_failure", 4e3),
+		on_timeout: boundedString(input.on_timeout ?? "", "continuation on_timeout", 4e3)
+	};
+	assert.ok(JSON.stringify(continuation).length <= 32e3, "wait continuation exceeds 32000 characters");
+	return continuation;
+}
+function normalizeArtifacts(value) {
+	assert.ok(Array.isArray(value), "continuation artifacts must be an array");
+	assert.ok(value.length <= 32, "continuation artifacts exceeds 32 items");
+	return value.map((artifact, index) => {
+		assert.ok(artifact && typeof artifact === "object" && !Array.isArray(artifact), `continuation artifact ${index} must be an object`);
+		const normalized = {
+			kind: boundedString(artifact.kind, `continuation artifact ${index} kind`, 64, true),
+			id: boundedString(artifact.id, `continuation artifact ${index} id`, 2048, true)
+		};
+		if (artifact.label != null) normalized.label = boundedString(artifact.label, `continuation artifact ${index} label`, 512);
+		if (artifact.url != null) normalized.url = boundedString(artifact.url, `continuation artifact ${index} url`, 4096);
+		return normalized;
+	});
+}
+function boundedStringArray(value, label, maxItems, maxLength) {
+	assert.ok(Array.isArray(value), `${label} must be an array`);
+	assert.ok(value.length <= maxItems, `${label} exceeds ${maxItems} items`);
+	return value.map((item, index) => boundedString(item, `${label} item ${index}`, maxLength));
+}
+function boundedString(value, label, maxLength, required = false) {
+	assert.equal(typeof value, "string", `${label} must be a string`);
+	if (required) assert.ok(value.length > 0, `${label} is required`);
+	assert.ok(value.length <= maxLength, `${label} exceeds ${maxLength} characters`);
+	return value;
+}
 function validateEventInput(input) {
 	assert.ok(input && typeof input === "object", "event input is required");
 	assert.equal(typeof input.source, "string", "event source is required");
 	assert.equal(typeof input.fingerprint, "string", "event fingerprint is required");
 }
+function validateTrustedBinding(binding) {
+	assert.ok(binding && typeof binding === "object" && !Array.isArray(binding), "trusted binding is required");
+	assert.equal(typeof binding.session_id, "string", "trusted binding session_id is required");
+	assert.equal(typeof binding.wait_id, "string", "trusted binding wait_id is required");
+	if (binding.wait_version != null) assert.ok(Number.isSafeInteger(binding.wait_version) && binding.wait_version >= 0, "trusted binding wait_version is invalid");
+	if (binding.source_subject != null) {
+		assert.equal(typeof binding.source_subject, "string", "trusted binding source_subject must be a string");
+		assert.ok(binding.source_subject.length <= 2048, "trusted binding source_subject exceeds 2048 characters");
+	}
+}
+function boundRoutingDecision(sessions, binding, providerId) {
+	const session = sessions.find((candidate) => candidate.session_id === binding.session_id);
+	const wait = session?.waits.find((candidate) => candidate.wait_id === binding.wait_id);
+	const reason = !session ? `bound Session ${binding.session_id} is not routable` : !wait ? `bound Wait ${binding.wait_id} does not belong to active Session ${binding.session_id}` : wait.status !== "active" ? `bound Wait ${binding.wait_id} is ${wait.status}` : binding.wait_version != null && wait.version !== binding.wait_version ? `bound Wait ${binding.wait_id} version changed` : null;
+	if (reason) return {
+		disposition: "escalate",
+		actionable: true,
+		deliveries: [],
+		evidence: [`trusted provider ${providerId}: ${reason}`],
+		summary: "A trusted Event binding is stale or invalid."
+	};
+	const subject = binding.source_subject ? ` for ${binding.source_subject}` : "";
+	return {
+		disposition: "deliver",
+		actionable: true,
+		deliveries: [{
+			session_id: session.session_id,
+			wait_ids: [wait.wait_id],
+			relation: `validated binding from ${providerId}${subject}`,
+			confidence: 1
+		}],
+		evidence: [`trusted provider ${providerId} bound the Event to Wait ${wait.wait_id}`],
+		summary: `Deliver the trusted bound Event to Session ${session.session_id}.`
+	};
+}
 //#endregion
 //#region src/runtime/schema.mjs
 const SCHEMA_SQL = `
@@ -289,6 +480,10 @@ const SCHEMA_SQL = `
     lease_expires_at TEXT,
     accepted_at TEXT,
     last_error TEXT,
+    attempt_count INTEGER NOT NULL DEFAULT 0,
+    next_attempt_at TEXT,
+    terminal_reason_code TEXT,
+    terminal_at TEXT,
     committed_at TEXT,
     created_at TEXT NOT NULL,
     updated_at TEXT NOT NULL
@@ -339,6 +534,7 @@ const SCHEMA_SQL = `
     source TEXT NOT NULL,
     source_event_id TEXT,
     fingerprint TEXT NOT NULL,
+    correlation_key TEXT,
     payload_json TEXT NOT NULL,
     state TEXT NOT NULL CHECK (state IN (
       'received', 'routing', 'dispatched', 'resolved'
@@ -355,6 +551,10 @@ const SCHEMA_SQL = `
   CREATE UNIQUE INDEX IF NOT EXISTS events_source_fingerprint
     ON events(source, fingerprint);
 
+  CREATE UNIQUE INDEX IF NOT EXISTS events_trusted_correlation
+    ON events(correlation_key)
+    WHERE correlation_key IS NOT NULL;
+
   CREATE TABLE IF NOT EXISTS routing_attempts (
     id TEXT PRIMARY KEY,
     event_id TEXT NOT NULL REFERENCES events(id),
@@ -394,6 +594,8 @@ const SCHEMA_SQL = `
   CREATE TABLE IF NOT EXISTS delivery_waits (
     delivery_id TEXT NOT NULL REFERENCES deliveries(id),
     wait_id TEXT NOT NULL REFERENCES waits(id),
+    ordinal INTEGER NOT NULL DEFAULT 0,
+    wait_snapshot_json TEXT,
     PRIMARY KEY (delivery_id, wait_id)
   ) STRICT;
 
@@ -420,6 +622,11 @@ const SCHEMA_SQL = `
     capabilities_json TEXT NOT NULL,
     next_check_at TEXT,
     consecutive_failures INTEGER NOT NULL DEFAULT 0,
+    paused INTEGER NOT NULL DEFAULT 0 CHECK (paused IN (0, 1)),
+    terminal_reason_code TEXT,
+    terminal_reason_detail TEXT,
+    terminal_actor TEXT,
+    terminal_at TEXT,
     version INTEGER NOT NULL DEFAULT 0,
     lease_owner TEXT,
     lease_expires_at TEXT,
@@ -478,6 +685,17 @@ const SCHEMA_SQL = `
 
   CREATE INDEX IF NOT EXISTS monitor_checks_monitor_time
     ON monitor_checks(monitor_id, started_at);
+
+  CREATE TABLE IF NOT EXISTS notification_outcomes (
+    event_id TEXT PRIMARY KEY REFERENCES events(id),
+    provider TEXT,
+    state TEXT NOT NULL CHECK (state IN ('delivered', 'unavailable', 'failed')),
+    error_class TEXT,
+    receipt_id TEXT,
+    attempt_count INTEGER NOT NULL DEFAULT 0,
+    attempted_at TEXT NOT NULL,
+    updated_at TEXT NOT NULL
+  ) STRICT;
 `;
 //#endregion
 //#region src/runtime/store.mjs
@@ -491,12 +709,12 @@ var RelayStore = class {
 		this.database.exec("PRAGMA journal_mode = WAL");
 		this.database.exec(SCHEMA_SQL);
 		const schemaVersion = this.database.prepare("SELECT MAX(version) AS version FROM relay_schema").get().version;
-		if (schemaVersion == null) this.database.prepare("INSERT INTO relay_schema (version, applied_at) VALUES (?, ?)").run(4, this.now());
+		if (schemaVersion == null) this.database.prepare("INSERT INTO relay_schema (version, applied_at) VALUES (?, ?)").run(10, this.now());
 		else {
-			assert.ok(schemaVersion <= 4, `unsupported schema version ${schemaVersion}`);
-			if (schemaVersion < 4) {
+			assert.ok(schemaVersion <= 10, `unsupported schema version ${schemaVersion}`);
+			if (schemaVersion < 10) {
 				this.migrateSchema(schemaVersion);
-				this.database.prepare("INSERT INTO relay_schema (version, applied_at) VALUES (?, ?)").run(4, this.now());
+				this.database.prepare("INSERT INTO relay_schema (version, applied_at) VALUES (?, ?)").run(10, this.now());
 			}
 		}
 		this.database.prepare("INSERT OR IGNORE INTO runtime_counters (name, value) VALUES ('routing_epoch', 0)").run();
@@ -555,6 +773,51 @@ var RelayStore = class {
         `);
 			});
 		}
+		if (fromVersion < 5) {
+			const columns = this.database.prepare("PRAGMA table_info(delivery_waits)").all();
+			const names = new Set(columns.map((column) => column.name));
+			if (!names.has("ordinal")) this.database.exec("ALTER TABLE delivery_waits ADD COLUMN ordinal INTEGER NOT NULL DEFAULT 0");
+			if (!names.has("wait_snapshot_json")) this.database.exec("ALTER TABLE delivery_waits ADD COLUMN wait_snapshot_json TEXT");
+		}
+		if (fromVersion < 6) {
+			const columns = this.database.prepare("PRAGMA table_info(monitors)").all();
+			const names = new Set(columns.map((column) => column.name));
+			for (const [name, type] of [
+				["paused", "INTEGER NOT NULL DEFAULT 0 CHECK (paused IN (0, 1))"],
+				["terminal_reason_code", "TEXT"],
+				["terminal_reason_detail", "TEXT"],
+				["terminal_actor", "TEXT"],
+				["terminal_at", "TEXT"]
+			]) if (!names.has(name)) this.database.exec(`ALTER TABLE monitors ADD COLUMN ${name} ${type}`);
+		}
+		if (fromVersion < 7) this.database.exec(`
+        CREATE TABLE IF NOT EXISTS notification_outcomes (
+          event_id TEXT PRIMARY KEY REFERENCES events(id),
+          provider TEXT,
+          state TEXT NOT NULL CHECK (state IN ('delivered', 'unavailable', 'failed')),
+          error_class TEXT,
+          attempted_at TEXT NOT NULL,
+          updated_at TEXT NOT NULL
+        ) STRICT;
+      `);
+		if (fromVersion < 8) {
+			if (!this.database.prepare("PRAGMA table_info(events)").all().some((column) => column.name === "correlation_key")) this.database.exec("ALTER TABLE events ADD COLUMN correlation_key TEXT");
+			this.database.exec("CREATE UNIQUE INDEX IF NOT EXISTS events_trusted_correlation ON events(correlation_key) WHERE correlation_key IS NOT NULL");
+		}
+		if (fromVersion < 9) {
+			const columns = new Set(this.database.prepare("PRAGMA table_info(activations)").all().map((column) => column.name));
+			for (const [name, type] of [
+				["attempt_count", "INTEGER NOT NULL DEFAULT 0"],
+				["next_attempt_at", "TEXT"],
+				["terminal_reason_code", "TEXT"],
+				["terminal_at", "TEXT"]
+			]) if (!columns.has(name)) this.database.exec(`ALTER TABLE activations ADD COLUMN ${name} ${type}`);
+		}
+		if (fromVersion < 10) {
+			const columns = new Set(this.database.prepare("PRAGMA table_info(notification_outcomes)").all().map((column) => column.name));
+			if (!columns.has("receipt_id")) this.database.exec("ALTER TABLE notification_outcomes ADD COLUMN receipt_id TEXT");
+			if (!columns.has("attempt_count")) this.database.exec("ALTER TABLE notification_outcomes ADD COLUMN attempt_count INTEGER NOT NULL DEFAULT 0");
+		}
 	}
 	close() {
 		this.database.close();
@@ -627,15 +890,72 @@ var RelayStore = class {
 		});
 	}
 	listWaitRegistrations() {
-		return this.database.prepare("SELECT * FROM sessions ORDER BY updated_at DESC, id").all().map((row) => ({
-			...hydrateWaitRegistration(row, this.getWaits(row.id)),
-			monitors: this.getMonitors(row.id)
-		})).filter((registration) => registration.waits.some((wait) => wait.status === "active" || wait.status === "claimed") || registration.monitors.some((monitor) => (/* @__PURE__ */ new Set([
+		return this.listAllWaitRegistrations().filter((registration) => registration.waits.some((wait) => wait.status === "active" || wait.status === "claimed") || registration.monitors.some((monitor) => (/* @__PURE__ */ new Set([
 			"active",
+			"paused",
 			"triggered",
 			"degraded"
 		])).has(monitor.state)));
 	}
+	listAllWaitRegistrations() {
+		return this.database.prepare("SELECT * FROM sessions ORDER BY updated_at DESC, id").all().map((row) => ({
+			...hydrateWaitRegistration(row, this.getWaits(row.id)),
+			monitors: this.getMonitors(row.id)
+		}));
+	}
+	listEvents(limit = 100) {
+		return this.listEventsPage({ limit }).items;
+	}
+	listEventsPage({ limit = 20, cursor = null } = {}) {
+		assert.ok(Number.isSafeInteger(limit) && limit > 0 && limit <= 100, "Event history limit is invalid");
+		const boundary = cursor == null ? null : decodeHistoryCursor(cursor);
+		const rows = boundary == null ? this.database.prepare(`
+          SELECT id, received_at FROM events
+          ORDER BY received_at DESC, id DESC LIMIT ?
+        `).all(limit + 1) : this.database.prepare(`
+          SELECT id, received_at FROM events
+          WHERE received_at < ? OR (received_at = ? AND id < ?)
+          ORDER BY received_at DESC, id DESC LIMIT ?
+        `).all(boundary.received_at, boundary.received_at, boundary.id, limit + 1);
+		const hasMore = rows.length > limit;
+		const pageRows = rows.slice(0, limit);
+		const last = pageRows.at(-1);
+		return {
+			items: pageRows.map((row) => this.inspectEvent(row.id)),
+			next_cursor: hasMore && last ? encodeHistoryCursor(last) : null,
+			total: this.database.prepare("SELECT COUNT(*) AS count FROM events").get().count
+		};
+	}
+	getNotificationOutcome(eventId) {
+		const row = this.database.prepare("SELECT * FROM notification_outcomes WHERE event_id = ?").get(eventId);
+		return row ? {
+			event_id: row.event_id,
+			provider: row.provider,
+			state: row.state,
+			error_class: row.error_class,
+			receipt_id: row.receipt_id,
+			attempt_count: row.attempt_count,
+			attempted_at: row.attempted_at,
+			updated_at: row.updated_at
+		} : null;
+	}
+	recordNotificationOutcome(eventId, { provider = null, state, errorClass = null, receiptId = null }) {
+		assert.ok((/* @__PURE__ */ new Set([
+			"delivered",
+			"unavailable",
+			"failed"
+		])).has(state), "notification state is invalid");
+		this.requireEventRow(eventId);
+		const timestamp = this.now();
+		this.database.prepare(`
+      INSERT INTO notification_outcomes (event_id, provider, state, error_class, receipt_id, attempt_count, attempted_at, updated_at)
+      VALUES (?, ?, ?, ?, ?, 1, ?, ?)
+      ON CONFLICT(event_id) DO UPDATE SET provider=excluded.provider, state=excluded.state,
+        error_class=excluded.error_class, receipt_id=excluded.receipt_id,
+        attempt_count=notification_outcomes.attempt_count + 1, updated_at=excluded.updated_at
+    `).run(eventId, provider, state, errorClass, receiptId, timestamp, timestamp);
+		return this.getNotificationOutcome(eventId);
+	}
 	listQueuedDeliverySessionIds() {
 		return this.database.prepare(`
         SELECT DISTINCT session_id
@@ -644,6 +964,18 @@ var RelayStore = class {
         ORDER BY session_id
       `).all().map((row) => row.session_id);
 	}
+	listRoutableEventIds(limit = 100) {
+		return this.database.prepare(`
+        SELECT id
+        FROM events
+        WHERE state IN ('received', 'routing')
+        ORDER BY received_at, id
+        LIMIT ?
+      `).all(limit).map((row) => row.id);
+	}
+	countRoutingAttempts(eventId) {
+		return this.database.prepare("SELECT COUNT(*) AS count FROM routing_attempts WHERE event_id = ?").get(eventId).count;
+	}
 	getActivation(activationId) {
 		const row = this.database.prepare("SELECT * FROM activations WHERE id = ?").get(activationId);
 		return row ? hydrateActivation(row) : null;
@@ -655,6 +987,10 @@ var RelayStore = class {
 			const now = toIso(nowDate);
 			let activationRow = this.database.prepare("SELECT * FROM activations WHERE session_id = ? AND state = 'active'").get(sessionId);
 			if (activationRow?.lease_owner && activationRow.lease_expires_at > now) return { status: "busy" };
+			if (activationRow?.next_attempt_at && activationRow.next_attempt_at > now) return {
+				status: "retry_scheduled",
+				activation: hydrateActivation(activationRow)
+			};
 			let deliveryRows;
 			if (activationRow) deliveryRows = decodeJson(activationRow.delivery_ids_json).map((deliveryId) => {
 				const row = this.database.prepare("SELECT * FROM deliveries WHERE id = ?").get(deliveryId);
@@ -680,7 +1016,8 @@ var RelayStore = class {
 			const leaseExpiresAt = new Date(nowDate.getTime() + leaseMs).toISOString();
 			this.database.prepare(`
           UPDATE activations
-          SET lease_owner = ?, lease_expires_at = ?, last_error = NULL, updated_at = ?
+          SET lease_owner = ?, lease_expires_at = ?, last_error = NULL,
+              next_attempt_at = NULL, updated_at = ?
           WHERE id = ? AND state = 'active'
         `).run(owner, leaseExpiresAt, now, activationRow.id);
 			return {
@@ -740,18 +1077,78 @@ var RelayStore = class {
 			return this.inspectWaitRegistration(sessionId);
 		});
 	}
-	failDispatch(sessionId, activationId, owner, error) {
+	failDispatch(sessionId, activationId, owner, error, { failureLimit = 5, baseDelayMs = 1e3 } = {}) {
 		return this.transaction(() => {
 			const activation = this.database.prepare("SELECT * FROM activations WHERE id = ?").get(activationId);
 			assert.ok(activation, `activation ${activationId} does not exist`);
 			assert.equal(activation.session_id, sessionId, `activation ${activationId} has wrong session`);
 			assert.equal(activation.state, "active", `activation ${activationId} is not active`);
 			assert.equal(activation.lease_owner, owner, `worker does not own activation ${activationId}`);
-			this.database.prepare(`
+			assert.ok(Number.isSafeInteger(failureLimit) && failureLimit > 0, "delivery failure limit must be positive");
+			assert.ok(Number.isSafeInteger(baseDelayMs) && baseDelayMs > 0, "delivery retry base delay must be positive");
+			const attemptCount = (activation.attempt_count ?? 0) + 1;
+			const timestamp = this.now();
+			if (attemptCount < failureLimit) {
+				const delay = Math.min(baseDelayMs * 2 ** (attemptCount - 1), 36e5);
+				const nextAttemptAt = new Date(this.clock().getTime() + delay).toISOString();
+				this.database.prepare(`
           UPDATE activations
-          SET lease_owner = NULL, lease_expires_at = NULL, last_error = ?, updated_at = ?
+          SET lease_owner = NULL, lease_expires_at = NULL, last_error = ?,
+              attempt_count = ?, next_attempt_at = ?, updated_at = ?
           WHERE id = ?
-        `).run(error, this.now(), activationId);
+        `).run(error, attemptCount, nextAttemptAt, timestamp, activationId);
+				return {
+					status: "retry",
+					activation: this.getActivation(activationId),
+					eventIds: []
+				};
+			}
+			const deliveryIds = decodeJson(activation.delivery_ids_json);
+			const eventIds = /* @__PURE__ */ new Set();
+			for (const deliveryId of deliveryIds) {
+				const delivery = this.database.prepare("SELECT * FROM deliveries WHERE id = ?").get(deliveryId);
+				assert.ok(delivery, `delivery ${deliveryId} does not exist`);
+				eventIds.add(delivery.event_id);
+				this.database.prepare("UPDATE deliveries SET state = 'failed', updated_at = ? WHERE id = ?").run(timestamp, deliveryId);
+			}
+			for (const eventId of eventIds) if (this.database.prepare("SELECT COUNT(*) AS count FROM deliveries WHERE event_id = ? AND state IN ('queued', 'running')").get(eventId).count === 0) this.database.prepare("UPDATE events SET state = 'resolved', version = version + 1, updated_at = ? WHERE id = ?").run(timestamp, eventId);
+			this.database.prepare(`
+        UPDATE activations
+        SET state = 'committed', lease_owner = NULL, lease_expires_at = NULL,
+            last_error = ?, attempt_count = ?, next_attempt_at = NULL,
+            terminal_reason_code = 'delivery_retry_exhausted', terminal_at = ?,
+            committed_at = ?, updated_at = ?
+        WHERE id = ?
+      `).run(error, attemptCount, timestamp, timestamp, timestamp, activationId);
+			return {
+				status: "failed",
+				activation: this.getActivation(activationId),
+				eventIds: [...eventIds]
+			};
+		});
+	}
+	retryActivation(activationId) {
+		return this.transaction(() => {
+			const row = this.database.prepare("SELECT * FROM activations WHERE id = ?").get(activationId);
+			assert.ok(row, `activation ${activationId} does not exist`);
+			assert.equal(row.state, "committed", `activation ${activationId} is not terminal`);
+			assert.equal(row.terminal_reason_code, "delivery_retry_exhausted", `activation ${activationId} is not retryable`);
+			const timestamp = this.now();
+			const deliveryIds = decodeJson(row.delivery_ids_json);
+			for (const deliveryId of deliveryIds) {
+				const delivery = this.database.prepare("SELECT * FROM deliveries WHERE id = ?").get(deliveryId);
+				assert.ok(delivery, `delivery ${deliveryId} does not exist`);
+				assert.equal(delivery.state, "failed", `delivery ${deliveryId} is not failed`);
+				this.database.prepare("UPDATE deliveries SET state = 'queued', updated_at = ? WHERE id = ?").run(timestamp, deliveryId);
+				this.database.prepare("UPDATE events SET state = 'dispatched', version = version + 1, updated_at = ? WHERE id = ?").run(timestamp, delivery.event_id);
+			}
+			this.database.prepare(`
+        UPDATE activations
+        SET state = 'active', attempt_count = 0, next_attempt_at = NULL,
+            terminal_reason_code = NULL, terminal_at = NULL, committed_at = NULL,
+            last_error = NULL, updated_at = ?
+        WHERE id = ?
+      `).run(timestamp, activationId);
 			return this.getActivation(activationId);
 		});
 	}
@@ -762,6 +1159,145 @@ var RelayStore = class {
 		const row = this.database.prepare("SELECT * FROM monitors WHERE id = ?").get(monitorId);
 		return row ? this.hydrateMonitor(row) : null;
 	}
+	pauseMonitor(monitorId, { expectedVersion } = {}) {
+		return this.transaction(() => {
+			const row = this.requireMonitorRow(monitorId);
+			if (expectedVersion != null) assert.equal(row.version, expectedVersion, `monitor ${monitorId} version changed`);
+			assert.ok((/* @__PURE__ */ new Set(["active", "degraded"])).has(row.state), `monitor ${monitorId} cannot be paused from ${row.state}`);
+			assert.equal(Boolean(row.paused), false, `monitor ${monitorId} is already paused`);
+			assert.ok(!row.lease_owner || row.lease_expires_at <= this.now(), `monitor ${monitorId} is busy`);
+			this.database.prepare(`
+        UPDATE monitors
+        SET paused = 1, next_check_at = NULL, lease_owner = NULL,
+            lease_expires_at = NULL, version = version + 1, updated_at = ?
+        WHERE id = ?
+      `).run(this.now(), monitorId);
+			return this.inspectMonitor(monitorId);
+		});
+	}
+	resumeMonitor(monitorId, { expectedVersion } = {}) {
+		return this.transaction(() => {
+			const row = this.requireMonitorRow(monitorId);
+			if (expectedVersion != null) assert.equal(row.version, expectedVersion, `monitor ${monitorId} version changed`);
+			assert.equal(Boolean(row.paused), true, `monitor ${monitorId} is not paused`);
+			assert.ok((/* @__PURE__ */ new Set(["active", "degraded"])).has(row.state), `monitor ${monitorId} cannot resume from ${row.state}`);
+			const timestamp = this.now();
+			this.database.prepare(`
+        UPDATE monitors
+        SET paused = 0, next_check_at = ?, version = version + 1, updated_at = ?
+        WHERE id = ?
+      `).run(nextMonitorCheckAt(decodeJson(row.schedule_json), this.clock()), timestamp, monitorId);
+			return this.inspectMonitor(monitorId);
+		});
+	}
+	updateMonitorCadence(monitorId, intervalSeconds, { expectedVersion } = {}) {
+		assert.ok(Number.isSafeInteger(intervalSeconds) && intervalSeconds >= 1 && intervalSeconds <= 86400, "monitor interval_seconds must be a whole number from 1 to 86400");
+		return this.transaction(() => {
+			const row = this.requireMonitorRow(monitorId);
+			if (expectedVersion != null) assert.equal(row.version, expectedVersion, `monitor ${monitorId} version changed`);
+			assert.ok((/* @__PURE__ */ new Set(["active", "degraded"])).has(row.state), `monitor ${monitorId} cannot be updated from ${row.state}`);
+			const schedule = {
+				...decodeJson(row.schedule_json),
+				interval_seconds: intervalSeconds
+			};
+			const timestamp = this.now();
+			this.database.prepare(`
+        UPDATE monitors
+        SET schedule_json = ?, next_check_at = ?, version = version + 1, updated_at = ?
+        WHERE id = ?
+      `).run(encodeJson(schedule), row.paused ? null : nextMonitorCheckAt(schedule, this.clock()), timestamp, monitorId);
+			return this.inspectMonitor(monitorId);
+		});
+	}
+	rebaselineMonitor(monitorId, prepared, { expectedVersion } = {}) {
+		assert.ok(prepared?.baseline_observation && typeof prepared.baseline_observation === "object", "monitor baseline_observation is required");
+		return this.transaction(() => {
+			const row = this.requireMonitorRow(monitorId);
+			if (expectedVersion != null) assert.equal(row.version, expectedVersion, `monitor ${monitorId} version changed`);
+			assert.ok((/* @__PURE__ */ new Set(["active", "degraded"])).has(row.state), `monitor ${monitorId} cannot be updated from ${row.state}`);
+			assert.ok(!row.lease_owner || row.lease_expires_at <= this.now(), `monitor ${monitorId} is busy`);
+			assert.equal(prepared.monitor_id, monitorId, "monitor identity cannot change during rebaseline");
+			assert.equal(prepared.wait_id, row.wait_id, "monitor wait cannot change during rebaseline");
+			const schedule = {
+				interval_seconds: prepared.schedule?.interval_seconds ?? decodeJson(row.schedule_json).interval_seconds,
+				jitter_seconds: prepared.schedule?.jitter_seconds ?? decodeJson(row.schedule_json).jitter_seconds ?? 0
+			};
+			assert.ok(Number.isSafeInteger(schedule.interval_seconds) && schedule.interval_seconds >= 1 && schedule.interval_seconds <= 86400, "monitor interval_seconds must be a whole number from 1 to 86400");
+			assert.ok(Number.isSafeInteger(schedule.jitter_seconds) && schedule.jitter_seconds >= 0 && schedule.jitter_seconds <= Math.min(schedule.interval_seconds, 3600), "monitor jitter_seconds must be a bounded whole number no greater than interval_seconds");
+			const retry = {
+				degraded_after: prepared.retry?.degraded_after ?? decodeJson(row.retry_json).degraded_after,
+				fail_after: prepared.retry?.fail_after ?? decodeJson(row.retry_json).fail_after,
+				backoff_seconds: prepared.retry?.backoff_seconds ?? decodeJson(row.retry_json).backoff_seconds ?? []
+			};
+			assert.ok(Number.isSafeInteger(retry.degraded_after) && retry.degraded_after >= 1 && retry.degraded_after <= 100, "monitor degraded_after must be a whole number from 1 to 100");
+			assert.ok(Number.isSafeInteger(retry.fail_after) && retry.fail_after >= retry.degraded_after && retry.fail_after <= 100, "monitor fail_after must follow degraded_after and be at most 100");
+			assert.ok(Array.isArray(retry.backoff_seconds) && retry.backoff_seconds.length <= 20 && retry.backoff_seconds.every((value) => Number.isSafeInteger(value) && value >= 1 && value <= 86400), "monitor backoff_seconds must contain at most 20 whole-second delays from 1 to 86400");
+			const manifest = {
+				observer: prepared.observer ?? (prepared.detector?.kind === "deadline_reached" ? { provider: "clock" } : null),
+				detector: prepared.detector,
+				schedule,
+				retry,
+				capabilities: prepared.capabilities ?? {},
+				artifact: prepared.artifact ?? { kind: "fixture" }
+			};
+			const versionId = this.idFactory();
+			const timestamp = this.now();
+			const artifactHash = prepared.artifact?.version_sha256 ?? prepared.artifact?.sha256 ?? hashJson(manifest);
+			const existingVersion = this.database.prepare(`
+        SELECT id, manifest_json FROM monitor_versions WHERE monitor_id = ? AND artifact_hash = ?
+      `).get(monitorId, artifactHash);
+			const activeVersionId = existingVersion?.id ?? versionId;
+			if (existingVersion) assert.deepEqual(decodeJson(existingVersion.manifest_json), manifest, `monitor ${monitorId} artifact hash conflicts with different version content`);
+			else this.database.prepare(`
+          INSERT INTO monitor_versions (id, monitor_id, artifact_hash, manifest_json, created_by_run_id, created_at)
+          VALUES (?, ?, ?, ?, ?, ?)
+        `).run(versionId, monitorId, artifactHash, encodeJson(manifest), prepared.created_by_run_id ?? null, timestamp);
+			const checkId = this.idFactory();
+			this.database.prepare(`
+        INSERT INTO monitor_checks (id, monitor_id, version_id, kind, state, started_at, finished_at)
+        VALUES (?, ?, ?, 'baseline', 'succeeded', ?, ?)
+      `).run(checkId, monitorId, activeVersionId, timestamp, timestamp);
+			const sequence = this.database.prepare("SELECT COALESCE(MAX(sequence), -1) + 1 AS sequence FROM observations WHERE monitor_id = ?").get(monitorId).sequence;
+			this.database.prepare(`
+        INSERT INTO observations (id, check_id, monitor_id, sequence, state_hash, data_json, observed_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?)
+      `).run(this.idFactory(), checkId, monitorId, sequence, hashJson(prepared.baseline_observation), encodeJson(prepared.baseline_observation), timestamp);
+			this.database.prepare(`
+        UPDATE monitors
+        SET active_version_id = ?, detector_json = ?, schedule_json = ?, retry_json = ?,
+            capabilities_json = ?, next_check_at = ?, consecutive_failures = 0,
+            state = 'active', version = version + 1, updated_at = ?
+        WHERE id = ?
+      `).run(activeVersionId, encodeJson(prepared.detector), encodeJson(schedule), encodeJson(retry), encodeJson(prepared.capabilities ?? {}), row.paused ? null : nextMonitorCheckAt(schedule, this.clock()), timestamp, monitorId);
+			return this.inspectMonitor(monitorId);
+		});
+	}
+	stopMonitor(monitorId, { expectedVersion, actor = "user", reasonCode = "stopped_by_user", detail = "" } = {}) {
+		assert.ok(typeof actor === "string" && actor.length > 0 && actor.length <= 256, "monitor stop actor is invalid");
+		assert.ok(typeof reasonCode === "string" && /^[a-z][a-z0-9._-]{0,127}$/u.test(reasonCode), "monitor stop reason code is invalid");
+		assert.ok(typeof detail === "string" && detail.length <= 2e3, "monitor stop detail is invalid");
+		return this.transaction(() => {
+			const row = this.requireMonitorRow(monitorId);
+			if (expectedVersion != null) assert.equal(row.version, expectedVersion, `monitor ${monitorId} version changed`);
+			assert.ok(!(/* @__PURE__ */ new Set([
+				"completed",
+				"failed",
+				"expired",
+				"cancelled"
+			])).has(row.state), `monitor ${monitorId} is already terminal`);
+			assert.ok(!row.lease_owner || row.lease_expires_at <= this.now(), `monitor ${monitorId} is busy`);
+			const timestamp = this.now();
+			this.database.prepare(`
+        UPDATE monitors
+        SET state = 'cancelled', paused = 0, next_check_at = NULL,
+            lease_owner = NULL, lease_expires_at = NULL,
+            terminal_reason_code = ?, terminal_reason_detail = ?, terminal_actor = ?, terminal_at = ?,
+            version = version + 1, updated_at = ?
+        WHERE id = ?
+      `).run(reasonCode, detail, actor, timestamp, timestamp, monitorId);
+			return this.inspectMonitor(monitorId);
+		});
+	}
 	getMonitors(sessionId) {
 		return this.database.prepare("SELECT * FROM monitors WHERE session_id = ? ORDER BY created_at, id").all(sessionId).map((row) => this.hydrateMonitor(row));
 	}
@@ -780,9 +1316,12 @@ var RelayStore = class {
 			triggers
 		};
 	}
-	ingestEvent(input) {
+	ingestEvent(input, { allowCorrelation = false } = {}) {
 		return this.transaction(() => {
-			const existing = this.findDuplicateEvent(input);
+			const correlationKey = allowCorrelation && typeof input.correlation_key === "string" && input.correlation_key.length > 0 ? input.correlation_key : null;
+			if (correlationKey != null) assert.ok(correlationKey.length <= 1024, "trusted Event correlation key is too long");
+			const storedInput = correlationKey == null ? Object.fromEntries(Object.entries(input).filter(([key]) => key !== "correlation_key")) : input;
+			const existing = this.findDuplicateEvent(storedInput, correlationKey);
 			if (existing) return {
 				event: hydrateEvent(existing),
 				duplicate: true
@@ -791,10 +1330,10 @@ var RelayStore = class {
 			const timestamp = this.now();
 			this.database.prepare(`
           INSERT INTO events (
-            id, source, source_event_id, fingerprint, payload_json,
+            id, source, source_event_id, fingerprint, correlation_key, payload_json,
             state, version, received_at, updated_at
-          ) VALUES (?, ?, ?, ?, ?, 'received', 0, ?, ?)
-        `).run(eventId, input.source, input.source_event_id ?? null, input.fingerprint, encodeJson(input), timestamp, timestamp);
+          ) VALUES (?, ?, ?, ?, ?, ?, 'received', 0, ?, ?)
+        `).run(eventId, input.source, input.source_event_id ?? null, input.fingerprint, correlationKey, encodeJson(storedInput), timestamp, timestamp);
 			return {
 				event: this.getEvent(eventId),
 				duplicate: false
@@ -811,11 +1350,20 @@ var RelayStore = class {
 		const decisionRow = this.database.prepare("SELECT * FROM routing_decisions WHERE event_id = ?").get(eventId);
 		const deliveries = this.database.prepare("SELECT * FROM deliveries WHERE event_id = ? ORDER BY created_at, id").all(eventId).map((row) => this.hydrateDelivery(row));
 		const routingAttempts = this.database.prepare("SELECT * FROM routing_attempts WHERE event_id = ? ORDER BY created_at, id").all(eventId).map(hydrateRoutingAttempt);
+		const activations = this.database.prepare(`
+      SELECT DISTINCT a.*
+      FROM activations a, json_each(a.delivery_ids_json) ids
+      JOIN deliveries d ON d.id = ids.value
+      WHERE d.event_id = ?
+      ORDER BY a.created_at, a.id
+    `).all(eventId).map(hydrateActivation);
 		return {
 			...event,
 			decision: decisionRow ? hydrateDecision(decisionRow) : null,
 			deliveries,
-			routing_attempts: routingAttempts
+			routing_attempts: routingAttempts,
+			activations,
+			notification: this.getNotificationOutcome(eventId)
 		};
 	}
 	beginRouting(eventId) {
@@ -886,14 +1434,18 @@ var RelayStore = class {
 					});
 					deliveryIds.push(deliveryId);
 					sessionIds.push(delivery.session_id);
-					for (const waitId of delivery.wait_ids) {
+					for (const [ordinal, waitId] of delivery.wait_ids.entries()) {
 						const snapshotWait = snapshotSession.waits.find((wait) => wait.wait_id === waitId);
 						assert.ok(snapshotWait, `unknown snapshot wait ${waitId}`);
 						const waitRow = this.database.prepare("SELECT * FROM waits WHERE id = ?").get(waitId);
 						assert.ok(waitRow, `wait ${waitId} no longer exists`);
 						assert.equal(waitRow.status, "active", `wait ${waitId} is not active`);
 						assert.equal(waitRow.version, snapshotWait.version, `wait ${waitId} version changed`);
-						this.database.prepare("INSERT INTO delivery_waits (delivery_id, wait_id) VALUES (?, ?)").run(deliveryId, waitId);
+						this.database.prepare(`
+                INSERT INTO delivery_waits (
+                  delivery_id, wait_id, ordinal, wait_snapshot_json
+                ) VALUES (?, ?, ?, ?)
+              `).run(deliveryId, waitId, ordinal, encodeJson(snapshotWait));
 						this.database.prepare(`
                 UPDATE waits
                 SET status = 'claimed', version = version + 1, updated_at = ?
@@ -931,15 +1483,57 @@ var RelayStore = class {
 		return this.database.prepare(`
         SELECT * FROM monitors
         WHERE state IN ('active', 'degraded')
+          AND paused = 0
           AND next_check_at IS NOT NULL
           AND next_check_at <= ?
         ORDER BY next_check_at, id
         LIMIT ?
       `).all(toIso(at), limit).map((row) => this.hydrateMonitor(row));
 	}
+	cleanupRetention({ terminalBefore, limit = 1e3 } = {}) {
+		const before = toIso(terminalBefore);
+		assert.ok(Number.isSafeInteger(limit) && limit >= 1 && limit <= 1e4, "retention cleanup limit must be from 1 to 10000");
+		return this.transaction(() => {
+			const rows = this.database.prepare(`
+        SELECT id FROM events
+        WHERE state = 'resolved' AND updated_at < ?
+          AND json_extract(payload_json, '$.__relay_retention_redacted') IS NOT 1
+        ORDER BY updated_at, id
+        LIMIT ?
+      `).all(before, limit);
+			const timestamp = this.now();
+			for (const row of rows) {
+				this.database.prepare(`
+          UPDATE events
+          SET payload_json = ?, version = version + 1, updated_at = ?
+          WHERE id = ? AND state = 'resolved'
+        `).run(encodeJson({
+					__relay_retention_redacted: 1,
+					redacted_at: timestamp
+				}), timestamp, row.id);
+				this.database.prepare(`
+          UPDATE routing_attempts SET output_json = NULL, error = NULL
+          WHERE event_id = ?
+        `).run(row.id);
+			}
+			return {
+				terminal_before: before,
+				scanned: rows.length,
+				redacted_events: rows.length,
+				retained_events: this.database.prepare("SELECT COUNT(*) AS count FROM events").get().count,
+				retained_decisions: this.database.prepare("SELECT COUNT(*) AS count FROM routing_decisions").get().count,
+				retained_deliveries: this.database.prepare("SELECT COUNT(*) AS count FROM deliveries").get().count,
+				retained_activations: this.database.prepare("SELECT COUNT(*) AS count FROM activations").get().count
+			};
+		});
+	}
 	beginMonitorCheck(monitorId, owner, leaseMs, { force = false } = {}) {
 		return this.transaction(() => {
 			let row = this.requireMonitorRow(monitorId);
+			if (row.paused) return {
+				status: "paused",
+				monitor: this.hydrateMonitor(row)
+			};
 			if (!(/* @__PURE__ */ new Set(["active", "degraded"])).has(row.state)) return {
 				status: "inactive",
 				monitor: this.hydrateMonitor(row)
@@ -983,6 +1577,45 @@ var RelayStore = class {
 		assert.ok(Array.isArray(proposedEvents), "proposedEvents must be an array");
 		assert.ok(proposedEvents.length <= 1, "initial Monitor slice emits at most one Event per check");
 		return this.transaction(() => {
+			const current = this.requireMonitorRow(snapshot.monitor.monitor_id);
+			const proposal = proposedEvents[0];
+			const correlationKey = typeof proposal?.correlation_key === "string" && proposal.correlation_key.length > 0 ? proposal.correlation_key : null;
+			const correlated = correlationKey == null ? null : this.database.prepare("SELECT id FROM events WHERE correlation_key = ?").get(correlationKey);
+			if ((current.lease_owner !== owner || current.version !== snapshot.monitor.version || current.active_version_id !== snapshot.monitor.active_version_id) && correlated) {
+				const check = this.database.prepare("SELECT * FROM monitor_checks WHERE id = ?").get(snapshot.check_id);
+				assert.ok(check, `monitor check ${snapshot.check_id} does not exist`);
+				assert.equal(check.state, "running", `monitor check ${snapshot.check_id} is not running`);
+				const timestamp = this.now();
+				const sequence = (this.latestObservationRow(current.id)?.sequence ?? -1) + 1;
+				this.database.prepare(`
+          INSERT INTO observations (id, check_id, monitor_id, sequence, state_hash, data_json, observed_at)
+          VALUES (?, ?, ?, ?, ?, ?, ?)
+        `).run(this.idFactory(), snapshot.check_id, current.id, sequence, hashJson(observation), encodeJson(observation), timestamp);
+				if (!this.database.prepare("SELECT event_id FROM monitor_triggers WHERE monitor_id = ? AND trigger_key = ?").get(current.id, proposal.key)) this.insertBoundMonitorEvent({
+					monitorRow: current,
+					checkId: snapshot.check_id,
+					proposal,
+					claimWait: false,
+					timestamp
+				});
+				const nextState = current.lifecycle === "one_shot" ? "completed" : "triggered";
+				this.database.prepare(`
+          UPDATE monitors
+          SET state = ?, paused = 0, next_check_at = NULL, consecutive_failures = 0,
+              lease_owner = NULL, lease_expires_at = NULL,
+              terminal_reason_code = NULL, terminal_reason_detail = NULL,
+              terminal_actor = NULL, terminal_at = NULL,
+              version = version + 1, updated_at = ?
+          WHERE id = ?
+        `).run(nextState, timestamp, current.id);
+				this.database.prepare("UPDATE monitor_checks SET state = 'succeeded', finished_at = ? WHERE id = ? AND state = 'running'").run(timestamp, snapshot.check_id);
+				return {
+					status: "converged",
+					monitor: this.inspectMonitor(current.id),
+					eventIds: [correlated.id],
+					sessionIds: []
+				};
+			}
 			const row = this.requireMonitorCommit(snapshot, owner);
 			const timestamp = this.now();
 			const sequence = (this.latestObservationRow(row.id)?.sequence ?? -1) + 1;
@@ -1082,6 +1715,43 @@ var RelayStore = class {
 			};
 		});
 	}
+	expireMonitorCheck(snapshot, owner) {
+		return this.transaction(() => {
+			const row = this.requireMonitorCommit(snapshot, owner);
+			const timestamp = this.now();
+			this.database.prepare(`
+        UPDATE monitor_checks
+        SET state = 'failed', error_class = 'bundle_expired',
+            error = 'custom Monitor Bundle expired', finished_at = ?
+        WHERE id = ? AND state = 'running'
+      `).run(timestamp, snapshot.check_id);
+			this.database.prepare(`
+        UPDATE monitors
+        SET state = 'expired', paused = 0, next_check_at = NULL,
+            consecutive_failures = 0, lease_owner = NULL, lease_expires_at = NULL,
+            terminal_reason_code = 'bundle_expired',
+            terminal_reason_detail = 'The custom Monitor Bundle reached its declared expiry.',
+            terminal_actor = 'relay.monitors', terminal_at = ?,
+            version = version + 1, updated_at = ?
+        WHERE id = ?
+      `).run(timestamp, timestamp, row.id);
+			this.database.prepare(`
+        UPDATE waits SET status = 'cancelled', version = version + 1, updated_at = ?
+        WHERE id = ? AND status = 'active'
+      `).run(timestamp, row.wait_id);
+			if (!this.database.prepare("SELECT 1 FROM waits WHERE session_id = ? AND status IN ('active', 'claimed') LIMIT 1").get(row.session_id)) this.database.prepare(`
+          UPDATE sessions SET state = 'created', lease_owner = NULL, lease_expires_at = NULL,
+              version = version + 1, updated_at = ? WHERE id = ?
+        `).run(timestamp, row.session_id);
+			this.bumpRoutingEpoch();
+			return {
+				status: "expired",
+				monitor: this.inspectMonitor(row.id),
+				eventIds: [],
+				sessionIds: []
+			};
+		});
+	}
 	getRoutingEpoch() {
 		return this.database.prepare("SELECT value FROM runtime_counters WHERE name = 'routing_epoch'").get().value;
 	}
@@ -1117,7 +1787,8 @@ var RelayStore = class {
 				caused_by: wait.caused_by,
 				actors: wait.actors ?? [],
 				entities: wait.entities ?? [],
-				prior_exchange: wait.prior_exchange
+				prior_exchange: wait.prior_exchange,
+				continuation: wait.continuation
 			};
 			this.database.prepare(`
           INSERT INTO waits (
@@ -1144,14 +1815,16 @@ var RelayStore = class {
 				interval_seconds: monitor.schedule?.interval_seconds ?? 60,
 				jitter_seconds: monitor.schedule?.jitter_seconds ?? 0
 			};
-			assert.ok(schedule.interval_seconds > 0, "monitor interval_seconds must be positive");
+			assert.ok(Number.isSafeInteger(schedule.interval_seconds) && schedule.interval_seconds >= 1 && schedule.interval_seconds <= 86400, "monitor interval_seconds must be a whole number from 1 to 86400");
+			assert.ok(Number.isSafeInteger(schedule.jitter_seconds) && schedule.jitter_seconds >= 0 && schedule.jitter_seconds <= Math.min(schedule.interval_seconds, 3600), "monitor jitter_seconds must be a bounded whole number no greater than interval_seconds");
 			const retry = {
 				degraded_after: monitor.retry?.degraded_after ?? 1,
 				fail_after: monitor.retry?.fail_after ?? 3,
 				backoff_seconds: monitor.retry?.backoff_seconds ?? []
 			};
-			assert.ok(retry.degraded_after > 0, "monitor degraded_after must be positive");
-			assert.ok(retry.fail_after >= retry.degraded_after, "monitor fail_after must follow degraded_after");
+			assert.ok(Number.isSafeInteger(retry.degraded_after) && retry.degraded_after >= 1 && retry.degraded_after <= 100, "monitor degraded_after must be a whole number from 1 to 100");
+			assert.ok(Number.isSafeInteger(retry.fail_after) && retry.fail_after >= retry.degraded_after && retry.fail_after <= 100, "monitor fail_after must follow degraded_after and be at most 100");
+			assert.ok(Array.isArray(retry.backoff_seconds) && retry.backoff_seconds.length <= 20 && retry.backoff_seconds.every((value) => Number.isSafeInteger(value) && value >= 1 && value <= 86400), "monitor backoff_seconds must contain at most 20 whole-second delays from 1 to 86400");
 			const versionId = this.idFactory();
 			const manifest = {
 				observer: monitor.observer ?? (monitor.detector.kind === "deadline_reached" ? { provider: "clock" } : null),
@@ -1161,7 +1834,7 @@ var RelayStore = class {
 				capabilities: monitor.capabilities ?? {},
 				artifact: monitor.artifact ?? { kind: "fixture" }
 			};
-			const artifactHash = monitor.artifact?.sha256 ?? hashJson(manifest);
+			const artifactHash = monitor.artifact?.version_sha256 ?? monitor.artifact?.sha256 ?? hashJson(manifest);
 			this.database.prepare(`
           INSERT INTO monitors (
             id, session_id, wait_id, state, lifecycle, fire_on_initial_match,
@@ -1239,14 +1912,25 @@ var RelayStore = class {
 		return deliveryId;
 	}
 	hydrateDelivery(row, includeEvent = false) {
-		const waitIds = this.database.prepare("SELECT wait_id FROM delivery_waits WHERE delivery_id = ? ORDER BY wait_id").all(row.id).map((item) => item.wait_id);
+		const matchedWaitRows = this.database.prepare(`
+        SELECT dw.wait_id, dw.ordinal, dw.wait_snapshot_json, w.*
+        FROM delivery_waits dw
+        JOIN waits w ON w.id = dw.wait_id
+        WHERE dw.delivery_id = ?
+        ORDER BY dw.ordinal, dw.wait_id
+      `).all(row.id);
+		const waitIds = matchedWaitRows.map((item) => item.wait_id);
+		const matchedWaits = matchedWaitRows.map((item) => item.wait_snapshot_json == null ? hydrateWait(item) : decodeJson(item.wait_snapshot_json));
+		const decision = this.database.prepare("SELECT evidence_json FROM routing_decisions WHERE event_id = ?").get(row.event_id);
 		const delivery = {
 			delivery_id: row.id,
 			event_id: row.event_id,
 			session_id: row.session_id,
 			state: row.state,
 			wait_ids: waitIds,
+			matched_waits: matchedWaits,
 			relation: row.relation,
+			routing_evidence: decision ? decodeJson(decision.evidence_json) : [],
 			confidence: row.confidence,
 			created_at: row.created_at,
 			updated_at: row.updated_at
@@ -1254,10 +1938,17 @@ var RelayStore = class {
 		if (includeEvent) delivery.event = this.getEvent(row.event_id)?.payload ?? null;
 		return delivery;
 	}
-	findDuplicateEvent(input) {
+	findDuplicateEvent(input, correlationKey = null) {
 		if (input.source_event_id != null) {
 			const bySourceId = this.database.prepare("SELECT * FROM events WHERE source = ? AND source_event_id = ?").get(input.source, input.source_event_id);
-			if (bySourceId) return bySourceId;
+			if (bySourceId) {
+				assert.equal(bySourceId.fingerprint, input.fingerprint, `source Event identity ${input.source}/${input.source_event_id} was reused with conflicting content`);
+				return bySourceId;
+			}
+		}
+		if (correlationKey != null) {
+			const correlated = this.database.prepare("SELECT * FROM events WHERE correlation_key = ?").get(correlationKey);
+			if (correlated) return correlated;
 		}
 		return this.database.prepare("SELECT * FROM events WHERE source = ? AND fingerprint = ?").get(input.source, input.fingerprint);
 	}
@@ -1292,12 +1983,14 @@ var RelayStore = class {
 	hydrateMonitor(row) {
 		const versionRow = this.database.prepare("SELECT * FROM monitor_versions WHERE id = ?").get(row.active_version_id);
 		const observationRow = this.latestObservationRow(row.id);
+		const checkRow = this.database.prepare("SELECT * FROM monitor_checks WHERE monitor_id = ? ORDER BY started_at DESC, id DESC LIMIT 1").get(row.id);
+		const triggerRow = this.database.prepare("SELECT * FROM monitor_triggers WHERE monitor_id = ? ORDER BY created_at DESC, id DESC LIMIT 1").get(row.id);
 		const manifest = decodeJson(versionRow?.manifest_json) ?? {};
 		return {
 			monitor_id: row.id,
 			session_id: row.session_id,
 			wait_id: row.wait_id,
-			state: row.state,
+			state: row.paused ? "paused" : row.state,
 			lifecycle: row.lifecycle,
 			fire_on_initial_match: Boolean(row.fire_on_initial_match),
 			active_version_id: row.active_version_id,
@@ -1310,10 +2003,18 @@ var RelayStore = class {
 			capabilities: decodeJson(row.capabilities_json),
 			next_check_at: row.next_check_at,
 			consecutive_failures: row.consecutive_failures,
+			terminal_reason: row.terminal_reason_code == null ? null : {
+				code: row.terminal_reason_code,
+				detail: row.terminal_reason_detail ?? "",
+				actor: row.terminal_actor,
+				at: row.terminal_at
+			},
 			version: row.version,
 			lease_owner: row.lease_owner,
 			lease_expires_at: row.lease_expires_at,
+			last_check: checkRow ? hydrateMonitorCheck(checkRow) : null,
 			last_observation: observationRow ? hydrateObservation(observationRow) : null,
+			last_trigger: triggerRow ? hydrateMonitorTrigger(triggerRow) : null,
 			created_at: row.created_at,
 			updated_at: row.updated_at
 		};
@@ -1323,6 +2024,18 @@ var RelayStore = class {
 		assert.equal(typeof proposal.key, "string", "monitor trigger key is required");
 		const existing = this.database.prepare("SELECT event_id FROM monitor_triggers WHERE monitor_id = ? AND trigger_key = ?").get(monitorRow.id, proposal.key);
 		if (existing) return existing.event_id;
+		const correlationKey = typeof proposal.correlation_key === "string" && proposal.correlation_key.length > 0 ? proposal.correlation_key : null;
+		if (correlationKey != null) {
+			assert.ok(correlationKey.length <= 1024, "Monitor correlation key is too long");
+			const correlated = this.database.prepare("SELECT id FROM events WHERE correlation_key = ?").get(correlationKey);
+			if (correlated) {
+				this.database.prepare(`
+          INSERT INTO monitor_triggers (id, monitor_id, check_id, trigger_key, event_id, created_at)
+          VALUES (?, ?, ?, ?, ?, ?)
+        `).run(this.idFactory(), monitorRow.id, checkId, proposal.key, correlated.id, timestamp);
+				return correlated.id;
+			}
+		}
 		const waitRow = this.database.prepare("SELECT * FROM waits WHERE id = ?").get(monitorRow.wait_id);
 		assert.ok(waitRow, `monitor wait ${monitorRow.wait_id} does not exist`);
 		assert.equal(waitRow.session_id, monitorRow.session_id, "monitor binding owner changed");
@@ -1337,6 +2050,7 @@ var RelayStore = class {
 				monitor_id: monitorRow.id,
 				trigger_key: proposal.key
 			}),
+			...correlationKey ? { correlation_key: correlationKey } : {},
 			channel: "monitor",
 			type: proposal.type,
 			monitor_id: monitorRow.id,
@@ -1345,10 +2059,10 @@ var RelayStore = class {
 		};
 		this.database.prepare(`
         INSERT INTO events (
-          id, source, source_event_id, fingerprint, payload_json,
+          id, source, source_event_id, fingerprint, correlation_key, payload_json,
           state, version, received_at, updated_at
-        ) VALUES (?, 'relay-monitor', ?, ?, ?, 'dispatched', 1, ?, ?)
-      `).run(eventId, sourceEventId, payload.fingerprint, encodeJson(payload), timestamp, timestamp);
+        ) VALUES (?, 'relay-monitor', ?, ?, ?, ?, 'dispatched', 1, ?, ?)
+      `).run(eventId, sourceEventId, payload.fingerprint, correlationKey, encodeJson(payload), timestamp, timestamp);
 		const waitIds = claimWait ? [monitorRow.wait_id] : [];
 		const relation = claimWait ? `bound Monitor ${monitorRow.id} detected ${proposal.type}` : `bound Monitor ${monitorRow.id} failed`;
 		const decision = {
@@ -1377,7 +2091,11 @@ var RelayStore = class {
 			timestamp
 		});
 		if (claimWait) {
-			this.database.prepare("INSERT INTO delivery_waits (delivery_id, wait_id) VALUES (?, ?)").run(deliveryId, monitorRow.wait_id);
+			this.database.prepare(`
+          INSERT INTO delivery_waits (
+            delivery_id, wait_id, ordinal, wait_snapshot_json
+          ) VALUES (?, ?, 0, ?)
+        `).run(deliveryId, monitorRow.wait_id, encodeJson(hydrateWait(waitRow)));
 			this.database.prepare(`
           UPDATE waits
           SET status = 'claimed', version = version + 1, updated_at = ?
@@ -1440,6 +2158,7 @@ function hydrateEvent(row) {
 		source: row.source,
 		source_event_id: row.source_event_id,
 		fingerprint: row.fingerprint,
+		correlation_key: row.correlation_key,
 		payload: decodeJson(row.payload_json),
 		state: row.state,
 		version: row.version,
@@ -1470,6 +2189,10 @@ function hydrateActivation(row) {
 		lease_expires_at: row.lease_expires_at ?? null,
 		accepted_at: row.accepted_at ?? null,
 		last_error: row.last_error ?? null,
+		attempt_count: row.attempt_count ?? 0,
+		next_attempt_at: row.next_attempt_at ?? null,
+		terminal_reason_code: row.terminal_reason_code ?? null,
+		terminal_at: row.terminal_at ?? null,
 		committed_at: row.committed_at,
 		created_at: row.created_at,
 		updated_at: row.updated_at
@@ -1531,6 +2254,25 @@ function encodeJson(value) {
 function decodeJson(value) {
 	return value == null ? null : JSON.parse(value);
 }
+function encodeHistoryCursor(row) {
+	return Buffer.from(JSON.stringify({
+		received_at: row.received_at,
+		id: row.id
+	}), "utf8").toString("base64url");
+}
+function decodeHistoryCursor(value) {
+	assert.ok(typeof value === "string" && value.length > 0 && value.length <= 2048, "Event history cursor is invalid");
+	let parsed;
+	try {
+		parsed = JSON.parse(Buffer.from(value, "base64url").toString("utf8"));
+	} catch {
+		assert.fail("Event history cursor is invalid");
+	}
+	assert.ok(parsed && typeof parsed === "object" && Object.keys(parsed).length === 2, "Event history cursor is invalid");
+	assert.ok(typeof parsed.id === "string" && parsed.id.length > 0 && parsed.id.length <= 512, "Event history cursor is invalid");
+	assert.ok(typeof parsed.received_at === "string" && parsed.received_at.length <= 64 && !Number.isNaN(Date.parse(parsed.received_at)), "Event history cursor is invalid");
+	return parsed;
+}
 function toIso(value) {
 	return value instanceof Date ? value.toISOString() : new Date(value).toISOString();
 }
@@ -1538,7 +2280,7 @@ function toIso(value) {
 //#region events-service.js
 var RelayEventsService = class extends Service {
 	apiVersion = 1;
-	constructor(ctx, { databasePath, inbox, dispatchPollIntervalMs = 1e3, clock, idFactory } = {}) {
+	constructor(ctx, { databasePath, inbox, dispatchPollIntervalMs = 1e3, routingFailureLimit = 3, deliveryFailureLimit = 5, deliveryRetryBaseMs = 1e3, globalEventsPerMinute = 600, globalConcurrentEvents = 32, clock, idFactory } = {}) {
 		super(ctx, "relayEvents");
 		assert.equal(typeof inbox?.deliver, "function", "Events requires inbox.deliver()");
 		const resolvedPath = resolveDatabasePath(databasePath);
@@ -1550,7 +2292,16 @@ var RelayEventsService = class extends Service {
 		this.router = createExactEventRouter();
 		this.routerProvider = null;
 		this.monitorProvider = null;
+		this.boundEventSources = /* @__PURE__ */ new Map();
+		this.notificationProvider = null;
+		this.connectorProviders = /* @__PURE__ */ new Map();
+		this.bundleCatalogProvider = null;
 		this.operations = new OperationGate();
+		this.admission = new EventAdmissionGate({
+			eventsPerMinute: globalEventsPerMinute,
+			concurrentEvents: globalConcurrentEvents,
+			clock: () => (clock ? clock() : /* @__PURE__ */ new Date()).getTime()
+		});
 		const service = this;
 		this.runtime = new RelayRuntime({
 			store: this.store,
@@ -1565,7 +2316,10 @@ var RelayEventsService = class extends Service {
 			},
 			inbox,
 			monitorRegistrar: { prepare: (input) => this.prepareMonitors(input) },
-			workerId: "relay-events-dispatcher"
+			workerId: "relay-events-dispatcher",
+			routingFailureLimit,
+			deliveryFailureLimit,
+			deliveryRetryBaseMs
 		});
 		this.stopped = false;
 		this.dispatchTimer = null;
@@ -1600,6 +2354,76 @@ var RelayEventsService = class extends Service {
 			if (this.monitorProvider === provider) this.monitorProvider = null;
 		};
 	}
+	registerBoundEventSource(provider) {
+		if (this.stopped) throw new Error("Relay Events is shutting down");
+		validateBoundEventSourceProvider(provider);
+		if (this.boundEventSources.has(provider.id)) throw new Error(`bound Event source provider ${provider.id} is already registered`);
+		const sources = new Set(provider.sources);
+		for (const active of this.boundEventSources.values()) for (const source of sources) if (active.sources.has(source)) throw new Error(`bound Event source ${source} is already registered by ${active.id}`);
+		const registration = {
+			id: provider.id,
+			sources,
+			active: true
+		};
+		this.boundEventSources.set(provider.id, registration);
+		return {
+			id: provider.id,
+			handleEvent: ({ event, binding }) => {
+				if (!registration.active || this.stopped) throw new Error(`bound Event source provider ${provider.id} is not active`);
+				if (!sources.has(event?.source)) throw new Error(`bound Event source provider ${provider.id} cannot ingest ${event?.source ?? "unknown"}`);
+				return this.admission.run(() => this.operations.run(async () => this.finalizeResult(binding == null ? await this.runtime.handleTrustedEvent(event, { providerId: provider.id }) : await this.runtime.handleBoundEvent(event, binding, { providerId: provider.id }))));
+			},
+			dismissEvent: ({ event, summary }) => {
+				if (!registration.active || this.stopped) throw new Error(`bound Event source provider ${provider.id} is not active`);
+				if (!sources.has(event?.source)) throw new Error(`bound Event source provider ${provider.id} cannot ingest ${event?.source ?? "unknown"}`);
+				return this.admission.run(() => this.operations.run(async () => this.finalizeResult(await this.runtime.handleTrustedDismissal(event, {
+					providerId: provider.id,
+					summary
+				}))));
+			},
+			dispose: () => {
+				if (!registration.active) return;
+				registration.active = false;
+				if (this.boundEventSources.get(provider.id) === registration) this.boundEventSources.delete(provider.id);
+			}
+		};
+	}
+	registerNotificationProvider(provider) {
+		if (this.stopped) throw new Error("Relay Events is shutting down");
+		if (!provider || typeof provider !== "object" || !/^[a-z][a-z0-9._-]{0,63}$/u.test(provider.id ?? "") || typeof provider.notify !== "function") throw new TypeError("notification provider requires a lowercase stable id and notify()");
+		if (this.notificationProvider) throw new Error(`notification provider ${this.notificationProvider.id} is already registered`);
+		this.notificationProvider = provider;
+		let active = true;
+		return () => {
+			if (!active) return;
+			active = false;
+			if (this.notificationProvider === provider) this.notificationProvider = null;
+		};
+	}
+	registerConnectorProvider(provider) {
+		if (this.stopped) throw new Error("Relay Events is shutting down");
+		if (!provider || !/^[a-z][a-z0-9._-]{0,63}$/u.test(provider.id ?? "") || typeof provider.inspect !== "function" || typeof provider.execute !== "function") throw new TypeError("connector provider requires a lowercase stable id, inspect(), and execute()");
+		if (this.connectorProviders.has(provider.id)) throw new Error(`connector provider ${provider.id} is already registered`);
+		this.connectorProviders.set(provider.id, provider);
+		let active = true;
+		return () => {
+			if (!active) return;
+			active = false;
+			if (this.connectorProviders.get(provider.id) === provider) this.connectorProviders.delete(provider.id);
+		};
+	}
+	registerBundleCatalogProvider(provider) {
+		if (this.stopped) throw new Error("Relay Events is shutting down");
+		if (!provider || !/^[a-z][a-z0-9._-]{0,63}$/u.test(provider.id ?? "") || typeof provider.list !== "function") throw new TypeError("Bundle catalog provider requires a lowercase stable id and list()");
+		if (this.bundleCatalogProvider) throw new Error(`Bundle catalog provider ${this.bundleCatalogProvider.id} is already registered`);
+		this.bundleCatalogProvider = provider;
+		let active = true;
+		return () => {
+			if (!active) return;
+			active = false;
+			if (this.bundleCatalogProvider === provider) this.bundleCatalogProvider = null;
+		};
+	}
 	registerWaits(input) {
 		return this.operations.run(() => this.runtime.registerWaits(input));
 	}
@@ -1609,8 +2433,116 @@ var RelayEventsService = class extends Service {
 	listWaits() {
 		return this.operations.run(() => this.runtime.listWaits());
 	}
+	managementSnapshot({ eventCursor = null, eventLimit = 20, bundleCursor = null, bundleLimit = 20, locale = "en-US" } = {}) {
+		return this.operations.run(async () => {
+			assert.ok(Number.isSafeInteger(bundleLimit) && bundleLimit > 0 && bundleLimit <= 100, "Bundle catalog limit is invalid");
+			const eventPage = this.store.listEventsPage({
+				cursor: eventCursor,
+				limit: eventLimit
+			});
+			const providerBundleTypes = this.bundleCatalogProvider ? await this.bundleCatalogProvider.list({ locale: locale === "zh-CN" ? "zh-CN" : "en-US" }) : [];
+			if (!Array.isArray(providerBundleTypes)) throw new TypeError("Bundle catalog provider returned an invalid list");
+			const allBundleTypes = [...providerBundleTypes];
+			allBundleTypes.sort((left, right) => bundleCatalogKey(left).localeCompare(bundleCatalogKey(right), "en"));
+			const after = bundleCursor == null ? null : decodeBundleCatalogCursor(bundleCursor);
+			const remainingBundleTypes = after == null ? allBundleTypes : allBundleTypes.filter((entry) => bundleCatalogKey(entry) > after);
+			const bundleTypes = remainingBundleTypes.slice(0, bundleLimit);
+			return {
+				registrations: this.store.listAllWaitRegistrations(),
+				bundle_types: bundleTypes,
+				bundle_page: {
+					next_cursor: remainingBundleTypes.length > bundleLimit && bundleTypes.length > 0 ? encodeBundleCatalogCursor(bundleCatalogKey(bundleTypes.at(-1))) : null,
+					total: allBundleTypes.length,
+					limit: bundleLimit
+				},
+				events: eventPage.items,
+				event_page: {
+					next_cursor: eventPage.next_cursor,
+					total: eventPage.total,
+					limit: eventLimit
+				},
+				connectors: await Promise.all([...this.connectorProviders.values()].map(async (provider) => ({
+					id: provider.id,
+					...await provider.inspect()
+				})))
+			};
+		});
+	}
+	cleanupRetention(options) {
+		return this.operations.run(() => this.store.cleanupRetention(options));
+	}
+	executeConnectorAction(connectorId, action, input = {}) {
+		return this.operations.run(async () => {
+			const provider = this.connectorProviders.get(connectorId);
+			assert.ok(provider, `connector provider ${connectorId} is not available`);
+			await provider.execute(action, input);
+			return { connector: {
+				id: provider.id,
+				...await provider.inspect()
+			} };
+		});
+	}
+	inspectMonitor(monitorId) {
+		return this.operations.run(() => this.store.inspectMonitor(monitorId));
+	}
+	pauseMonitor(monitorId, options) {
+		return this.operations.run(() => this.store.pauseMonitor(monitorId, options));
+	}
+	resumeMonitor(monitorId, options) {
+		return this.operations.run(() => this.store.resumeMonitor(monitorId, options));
+	}
+	updateMonitorCadence(monitorId, intervalSeconds, options) {
+		return this.operations.run(() => this.store.updateMonitorCadence(monitorId, intervalSeconds, options));
+	}
+	rebaselineMonitor(monitorId, proposal, options = {}) {
+		return this.operations.run(async () => {
+			const current = this.store.inspectMonitor(monitorId);
+			assert.ok(current, `monitor ${monitorId} does not exist`);
+			if (!this.monitorProvider) throw new Error("Relay Monitors plugin is not installed");
+			const wait = this.store.getWaits(current.session_id).find((candidate) => candidate.wait_id === current.wait_id);
+			assert.ok(wait, `monitor wait ${current.wait_id} does not exist`);
+			const [prepared] = await this.monitorProvider.prepare({
+				waits: [wait],
+				monitors: [{
+					monitor_id: monitorId,
+					wait_id: current.wait_id,
+					lifecycle: current.lifecycle,
+					observer: proposal.observer ?? current.observer,
+					artifact: proposal.artifact ?? current.artifact,
+					detector: proposal.detector ?? current.detector,
+					schedule: proposal.schedule ?? current.schedule,
+					retry: proposal.retry ?? current.retry,
+					capabilities: proposal.capabilities ?? current.capabilities
+				}]
+			});
+			return this.store.rebaselineMonitor(monitorId, prepared, options);
+		});
+	}
+	stopMonitor(monitorId, options) {
+		return this.operations.run(() => this.store.stopMonitor(monitorId, options));
+	}
+	retryActivation(activationId) {
+		return this.operations.run(async () => {
+			const activation = this.store.retryActivation(activationId);
+			const result = await this.runtime.dispatchSession(activation.session_id);
+			return {
+				activation: this.store.getActivation(activationId),
+				result
+			};
+		});
+	}
+	retryNotification(eventId) {
+		return this.operations.run(async () => {
+			const event = this.store.inspectEvent(eventId);
+			assert.ok(event, `event ${eventId} does not exist`);
+			assert.ok(event.notification && (/* @__PURE__ */ new Set(["failed", "unavailable"])).has(event.notification.state), `notification for event ${eventId} is not retryable`);
+			if (event.decision?.disposition === "escalate") return this.notifyEscalation(eventId, { force: true });
+			if (event.deliveries?.some((delivery) => delivery.state === "failed")) return this.notifyTerminalFailure(eventId, { force: true });
+			throw new Error(`event ${eventId} has no retryable terminal notification`);
+		});
+	}
 	handleEvent(input) {
-		return this.operations.run(() => this.runtime.handleEvent(input));
+		return this.admission.run(() => this.operations.run(async () => this.finalizeResult(await this.runtime.handleEvent(input))));
 	}
 	dispatchSession(sessionId) {
 		return this.operations.run(() => this.runtime.dispatchSession(sessionId));
@@ -1628,6 +2560,9 @@ var RelayEventsService = class extends Service {
 	failMonitorCheck(...args) {
 		return this.operations.run(() => this.store.failMonitorCheck(...args));
 	}
+	expireMonitorCheck(...args) {
+		return this.operations.run(() => this.store.expireMonitorCheck(...args));
+	}
 	abandonMonitorCheck(...args) {
 		return this.operations.run(() => this.store.abandonMonitorCheck(...args));
 	}
@@ -1641,12 +2576,96 @@ var RelayEventsService = class extends Service {
 	}
 	async recoverQueuedDeliveries() {
 		const sessionIds = this.store.listQueuedDeliverySessionIds();
-		return Promise.all(sessionIds.map((sessionId) => this.runtime.dispatchSession(sessionId)));
+		const results = await Promise.all(sessionIds.map((sessionId) => this.runtime.dispatchSession(sessionId)));
+		for (const result of results) for (const eventId of result.eventIds ?? []) await this.notifyTerminalFailure(eventId);
+		return results;
+	}
+	async recoverPendingWork() {
+		for (const eventId of this.store.listRoutableEventIds()) try {
+			await this.runtime.routeEvent(eventId);
+			await this.notifyEscalation(eventId);
+		} catch (error) {
+			this.ctx.logger?.warn?.(`Relay routing recovery failed for ${eventId}: ${error?.message ?? error}`);
+		}
+		return this.recoverQueuedDeliveries();
+	}
+	async finalizeResult(result) {
+		await this.notifyEscalation(result.event.event_id);
+		if (result.event.deliveries?.some((delivery) => delivery.state === "failed")) await this.notifyTerminalFailure(result.event.event_id);
+		result.event = this.store.inspectEvent(result.event.event_id);
+		return result;
+	}
+	async notifyEscalation(eventId, { force = false } = {}) {
+		const event = this.store.inspectEvent(eventId);
+		if (event?.decision?.disposition !== "escalate") return null;
+		const existing = event.notification;
+		if (existing && !force) return existing;
+		const provider = this.notificationProvider;
+		if (!provider) return this.store.recordNotificationOutcome(eventId, { state: "unavailable" });
+		try {
+			const receipt = await provider.notify({
+				event: {
+					event_id: event.event_id,
+					source: event.source,
+					type: event.payload?.type ?? null
+				},
+				decision: {
+					disposition: "escalate",
+					summary: event.decision.summary,
+					evidence: event.decision.evidence
+				}
+			});
+			return this.store.recordNotificationOutcome(eventId, {
+				provider: provider.id,
+				state: "delivered",
+				receiptId: notificationReceiptId(receipt)
+			});
+		} catch (error) {
+			const errorClass = typeof error?.errorClass === "string" ? error.errorClass.slice(0, 128) : "notification_failed";
+			return this.store.recordNotificationOutcome(eventId, {
+				provider: provider.id,
+				state: "failed",
+				errorClass
+			});
+		}
+	}
+	async notifyTerminalFailure(eventId, { force = false } = {}) {
+		const event = this.store.inspectEvent(eventId);
+		if (!event?.deliveries?.some((delivery) => delivery.state === "failed")) return null;
+		if (event.notification && !force) return event.notification;
+		const provider = this.notificationProvider;
+		if (!provider) return this.store.recordNotificationOutcome(eventId, { state: "unavailable" });
+		try {
+			const receipt = await provider.notify({
+				event: {
+					event_id: event.event_id,
+					source: event.source,
+					type: event.payload?.type ?? null
+				},
+				decision: {
+					disposition: "escalate",
+					summary: "Relay exhausted its Delivery retry budget.",
+					evidence: ["delivery_retry_exhausted"]
+				}
+			});
+			return this.store.recordNotificationOutcome(eventId, {
+				provider: provider.id,
+				state: "delivered",
+				receiptId: notificationReceiptId(receipt)
+			});
+		} catch (error) {
+			const errorClass = typeof error?.errorClass === "string" ? error.errorClass.slice(0, 128) : "notification_failed";
+			return this.store.recordNotificationOutcome(eventId, {
+				provider: provider.id,
+				state: "failed",
+				errorClass
+			});
+		}
 	}
 	scheduleRecovery(delay = this.dispatchPollIntervalMs) {
 		if (this.stopped) return;
 		this.dispatchTimer = setTimeout(() => {
-			this.operations.run(() => this.recoverQueuedDeliveries()).catch((error) => {
+			this.operations.run(() => this.recoverPendingWork()).catch((error) => {
 				this.ctx.logger?.error?.(`Relay delivery recovery failed: ${error?.stack ?? error}`);
 			}).finally(() => this.scheduleRecovery());
 		}, delay);
@@ -1656,9 +2675,35 @@ var RelayEventsService = class extends Service {
 		this.stopped = true;
 		if (this.dispatchTimer) clearTimeout(this.dispatchTimer);
 		await this.operations.stop();
+		for (const registration of this.boundEventSources.values()) registration.active = false;
+		this.boundEventSources.clear();
+		this.notificationProvider = null;
+		this.connectorProviders.clear();
 		this.store.close();
 	}
 };
+function bundleCatalogKey(entry) {
+	return `${entry?.type_id ?? ""}\u0000${String(entry?.bundle_version ?? 0).padStart(12, "0")}\u0000${entry?.artifact_hash ?? ""}`;
+}
+function encodeBundleCatalogCursor(after) {
+	return Buffer.from(JSON.stringify({
+		v: 1,
+		after
+	}), "utf8").toString("base64url");
+}
+function decodeBundleCatalogCursor(cursor) {
+	try {
+		const value = JSON.parse(Buffer.from(cursor, "base64url").toString("utf8"));
+		if (value?.v !== 1 || typeof value.after !== "string" || value.after.length > 1e3) throw new Error();
+		return value.after;
+	} catch {
+		throw new TypeError("Bundle catalog cursor is invalid");
+	}
+}
+function notificationReceiptId(receipt) {
+	const value = typeof receipt === "string" ? receipt : receipt?.receipt_id ?? receipt?.id;
+	return typeof value === "string" && value.trim() ? value.trim().slice(0, 256) : null;
+}
 var OperationGate = class {
 	accepting = true;
 	inFlight = /* @__PURE__ */ new Set();
@@ -1676,6 +2721,45 @@ var OperationGate = class {
 		await Promise.allSettled([...this.inFlight]);
 	}
 };
+var EventAdmissionGate = class {
+	constructor({ eventsPerMinute, concurrentEvents, clock }) {
+		assert.ok(Number.isSafeInteger(eventsPerMinute) && eventsPerMinute > 0 && eventsPerMinute <= 1e6, "globalEventsPerMinute is invalid");
+		assert.ok(Number.isSafeInteger(concurrentEvents) && concurrentEvents > 0 && concurrentEvents <= 1e4, "globalConcurrentEvents is invalid");
+		this.eventsPerMinute = eventsPerMinute;
+		this.concurrentEvents = concurrentEvents;
+		this.clock = clock;
+		this.window = Math.floor(clock() / 6e4);
+		this.used = 0;
+		this.active = 0;
+	}
+	run(operation) {
+		const current = Math.floor(this.clock() / 6e4);
+		if (current !== this.window) {
+			this.window = current;
+			this.used = 0;
+		}
+		if (this.used >= this.eventsPerMinute) throw admissionError("global_rate_limited", 429);
+		if (this.active >= this.concurrentEvents) throw admissionError("global_concurrency_limited", 503);
+		this.used += 1;
+		this.active += 1;
+		let result;
+		try {
+			result = operation();
+		} catch (error) {
+			this.active -= 1;
+			throw error;
+		}
+		return Promise.resolve(result).finally(() => {
+			this.active -= 1;
+		});
+	}
+};
+function admissionError(errorClass, statusCode) {
+	const error = /* @__PURE__ */ new Error(errorClass === "global_rate_limited" ? "Relay global Event rate limit was reached" : "Relay global Event concurrency limit was reached");
+	error.errorClass = errorClass;
+	error.statusCode = statusCode;
+	return error;
+}
 function createExactEventRouter() {
 	return {
 		id: "relay.exact-event-type",
@@ -1693,8 +2777,15 @@ function createExactEventRouter() {
 				evidence: eventType ? [`No active wait expects ${eventType}.`] : ["Event has no type."],
 				summary: "No exact Relay wait matched the event."
 			};
-			const exclusive = matches.find(({ wait }) => wait.exclusive);
-			const selected = exclusive ? [exclusive] : matches;
+			const matchedSessionIds = new Set(matches.map(({ session }) => session.session_id));
+			if (matchedSessionIds.size > 1 && matches.some(({ wait }) => wait.exclusive)) return {
+				disposition: "escalate",
+				actionable: true,
+				deliveries: [],
+				evidence: [`Event type ${eventType} matches conflicting exclusive waits in ${matchedSessionIds.size} sessions.`],
+				summary: `Cannot safely choose one owner for ${eventType}.`
+			};
+			const selected = matches;
 			const deliveries = /* @__PURE__ */ new Map();
 			for (const { session, wait } of selected) {
 				const delivery = deliveries.get(session.session_id) ?? {
@@ -1726,10 +2817,11 @@ function positiveInteger$1(value, fallback) {
 }
 //#endregion
 //#region agent-bridge.js
-function installRelayAgentBridge(ctx, { sessionId, registerWaits, cancelWaits }) {
+function installRelayAgentBridge(ctx, { sessionId, registerWaits, cancelWaits, manageMonitor }) {
 	if (!sessionId) throw new Error("Relay bridge requires the current DSH session id");
 	if (typeof registerWaits !== "function") throw new Error("registerWaits callback is required");
 	if (typeof cancelWaits !== "function") throw new Error("cancelWaits callback is required");
+	if (typeof manageMonitor !== "function") throw new Error("manageMonitor callback is required");
 	const unregisterWaits = ctx.tools.register(defineTool({
 		name: "relay_register_waits",
 		description: "Ask Relay to watch external conditions for this conversation, with optional bound Monitors.",
@@ -1778,6 +2870,43 @@ function installRelayAgentBridge(ctx, { sessionId, registerWaits, cancelWaits })
 						prior_exchange: {
 							type: "string",
 							required: true
+						},
+						continuation: {
+							type: "object",
+							additionalProperties: false,
+							properties: {
+								version: {
+									type: "number",
+									enum: [1]
+								},
+								next_action: { type: "string" },
+								success_condition: { type: "string" },
+								constraints: {
+									type: "array",
+									items: { type: "string" }
+								},
+								artifacts: {
+									type: "array",
+									items: {
+										type: "object",
+										additionalProperties: false,
+										properties: {
+											kind: {
+												type: "string",
+												required: true
+											},
+											id: {
+												type: "string",
+												required: true
+											},
+											label: { type: "string" },
+											url: { type: "string" }
+										}
+									}
+								},
+								on_failure: { type: "string" },
+								on_timeout: { type: "string" }
+							}
 						}
 					}
 				}
@@ -1892,7 +3021,113 @@ function installRelayAgentBridge(ctx, { sessionId, registerWaits, cancelWaits })
 			};
 		}
 	}));
+	const unregisterMonitor = ctx.tools.register(defineTool({
+		name: "relay_manage_monitor",
+		description: "Inspect or control one Relay Monitor owned by this conversation.",
+		parameters: {
+			monitor_id: {
+				type: "string",
+				required: true
+			},
+			action: {
+				type: "string",
+				required: true,
+				enum: [
+					"inspect",
+					"pause",
+					"resume",
+					"run_now",
+					"update_cadence",
+					"update_target",
+					"stop"
+				]
+			},
+			expected_version: { type: "integer" },
+			interval_seconds: { type: "integer" },
+			reason_code: { type: "string" },
+			detail: { type: "string" },
+			observer: {
+				type: "object",
+				additionalProperties: false,
+				properties: { provider: {
+					type: "string",
+					required: true
+				} }
+			},
+			artifact: {
+				type: "object",
+				additionalProperties: true,
+				properties: {}
+			},
+			detector: {
+				type: "object",
+				additionalProperties: true,
+				properties: {}
+			},
+			capabilities: {
+				type: "object",
+				additionalProperties: true,
+				properties: {}
+			}
+		},
+		output: {
+			schema: {
+				type: "object",
+				additionalProperties: false,
+				properties: {
+					applied: {
+						type: "boolean",
+						required: true
+					},
+					sessionId: {
+						type: "string",
+						required: true
+					},
+					monitorId: {
+						type: "string",
+						required: true
+					},
+					action: {
+						type: "string",
+						required: true
+					},
+					result: {
+						type: "object",
+						additionalProperties: true,
+						properties: {},
+						required: true
+					}
+				}
+			},
+			render: (_args, value) => [{
+				type: "text",
+				text: JSON.stringify(value)
+			}]
+		},
+		async execute(args) {
+			const result = await manageMonitor(sessionId, {
+				monitorId: args.monitor_id,
+				action: args.action,
+				...args.expected_version === void 0 ? {} : { expectedVersion: args.expected_version },
+				...args.interval_seconds === void 0 ? {} : { intervalSeconds: args.interval_seconds },
+				...args.reason_code === void 0 ? {} : { reasonCode: args.reason_code },
+				...args.detail === void 0 ? {} : { detail: args.detail },
+				...args.observer === void 0 ? {} : { observer: args.observer },
+				...args.artifact === void 0 ? {} : { artifact: args.artifact },
+				...args.detector === void 0 ? {} : { detector: args.detector },
+				...args.capabilities === void 0 ? {} : { capabilities: args.capabilities }
+			});
+			return {
+				applied: true,
+				sessionId,
+				monitorId: args.monitor_id,
+				action: args.action,
+				result
+			};
+		}
+	}));
 	return () => {
+		unregisterMonitor?.();
 		unregisterCancel?.();
 		unregisterWaits?.();
 	};
@@ -1948,6 +3183,10 @@ function createRelayEventHandler({ relayRuntime, token, maxBodyBytes = 1048576 }
 			writeJson(response, 403, { error: "forbidden" });
 			return;
 		}
+		if (String(request.headers?.["content-encoding"] ?? "identity").trim().toLowerCase() !== "identity") {
+			writeJson(response, 415, { error: "unsupported_content_encoding" });
+			return;
+		}
 		try {
 			const event = normalizeEvent(await readJson(request, maxBodyBytes));
 			const result = await relayRuntime.handleEvent(event);
@@ -1964,14 +3203,21 @@ function createRelayEventHandler({ relayRuntime, token, maxBodyBytes = 1048576 }
 				}))
 			});
 		} catch (error) {
-			const status = error instanceof EventIngressError ? error.statusCode : 500;
+			const status = error instanceof EventIngressError ? error.statusCode : Number.isInteger(error?.statusCode) ? error.statusCode : 500;
+			const publicCode = status === 413 ? "payload_too_large" : status === 429 ? "rate_limited" : status === 503 && error?.errorClass === "global_concurrency_limited" ? "temporarily_overloaded" : status < 500 ? "invalid_event" : "event_delivery_failed";
 			writeJson(response, status, {
-				error: status === 413 ? "payload_too_large" : status < 500 ? "invalid_event" : "event_delivery_failed",
-				message: error?.message ?? String(error)
+				error: publicCode,
+				message: publicErrorMessage(publicCode, error)
 			});
 		}
 	};
 }
+function publicErrorMessage(code, error) {
+	if (code === "rate_limited") return "Relay event admission rate limit exceeded";
+	if (code === "temporarily_overloaded") return "Relay event admission is temporarily overloaded";
+	if (code === "event_delivery_failed") return "Relay could not accept the event";
+	return error?.message ?? String(error);
+}
 function normalizeEvent(body) {
 	if (!body || typeof body !== "object" || Array.isArray(body)) throw new EventIngressError(400, "event body must be a JSON object");
 	const type = requiredString(body.type, "type");
@@ -1997,11 +3243,27 @@ async function readJson(request, maxBodyBytes) {
 		chunks.push(buffer);
 	}
 	if (size === 0) throw new EventIngressError(400, "event body is empty");
+	let value;
 	try {
-		return JSON.parse(Buffer.concat(chunks).toString("utf8"));
+		value = JSON.parse(Buffer.concat(chunks).toString("utf8"));
 	} catch {
 		throw new EventIngressError(400, "event body is not valid JSON");
 	}
+	validateComplexity(value);
+	return value;
+}
+function validateComplexity(value) {
+	let keys = 0;
+	const visit = (node, depth) => {
+		if (depth > 32) throw new EventIngressError(413, "event body nesting is too deep");
+		if (!node || typeof node !== "object") return;
+		for (const child of Object.values(node)) {
+			keys += 1;
+			if (keys > 1e4) throw new EventIngressError(413, "event body has too many fields");
+			visit(child, depth + 1);
+		}
+	};
+	visit(value, 0);
 }
 function authorized(request, token) {
 	if (isLoopback(request.socket?.remoteAddress)) return true;
@@ -2038,6 +3300,16 @@ var EventIngressError = class extends Error {
 	}
 };
 //#endregion
+//#region dsh-compat.mjs
+function sessionEvents(session, from = 0) {
+	if (!Number.isSafeInteger(from) || from < 0) throw new RangeError("session event offset must be a non-negative integer");
+	const snapshot = Reflect.get(session, "snapshotEvents");
+	if (typeof snapshot === "function") return from === 0 ? Reflect.apply(snapshot, session, []) : Reflect.apply(snapshot, session, [from]);
+	const events = Reflect.get(session, "events");
+	if (!Array.isArray(events)) throw new TypeError("DSH Session exposes neither snapshotEvents() nor events");
+	return from === 0 ? events : events.slice(from);
+}
+//#endregion
 //#region inbox-adapter.js
 var DshInboxAdapter = class {
 	constructor({ resolveAgent, awaitDurable, maxInputChars = 1e5, debug = false }) {
@@ -2057,7 +3329,7 @@ var DshInboxAdapter = class {
 			deliveries
 		});
 		this.log(`enqueue ${activationId} into ${sessionId}`);
-		if (!(resolved.agent.session.events ?? []).some((event) => {
+		if (!sessionEvents(resolved.agent.session).some((event) => {
 			return (event.type === "agent/inbox/spliced" ? event.data.inserted ?? [] : event.type === "user/message" ? [event.data] : []).some((message) => message.id === activationId && message.source?.kind === "plugin" && message.source.plugin === "relay");
 		})) resolved.agent.followup({
 			...createUserMessage({
@@ -2091,7 +3363,9 @@ var DshInboxAdapter = class {
 				delivery_id: delivery.delivery_id,
 				event_id: delivery.event_id,
 				wait_ids: delivery.wait_ids,
+				matched_waits: delivery.matched_waits ?? [],
 				relation: delivery.relation,
+				routing_evidence: delivery.routing_evidence ?? [],
 				event: delivery.event
 			}))
 		};
@@ -2116,8 +3390,8 @@ var RelayManagementGateway = class extends TypertRemoteService {
 		super(ctx, "relayManagement");
 		this.relayEvents = relayEvents;
 	}
-	list() {
-		return { registrations: this.relayEvents.listWaits() };
+	list(options = {}) {
+		return this.relayEvents.managementSnapshot(options);
 	}
 	cancel(sessionId) {
 		return { registration: this.relayEvents.cancelWaits(sessionId) };
@@ -2128,6 +3402,35 @@ var RelayManagementGateway = class extends TypertRemoteService {
 			registrations: this.relayEvents.listWaits()
 		};
 	}
+	inspectMonitor(monitorId) {
+		return { monitor: this.relayEvents.inspectMonitor(monitorId) };
+	}
+	pauseMonitor(monitorId, expectedVersion) {
+		return { monitor: this.relayEvents.pauseMonitor(monitorId, { expectedVersion }) };
+	}
+	resumeMonitor(monitorId, expectedVersion) {
+		return { monitor: this.relayEvents.resumeMonitor(monitorId, { expectedVersion }) };
+	}
+	updateMonitorCadence(monitorId, intervalSeconds, expectedVersion) {
+		return { monitor: this.relayEvents.updateMonitorCadence(monitorId, intervalSeconds, { expectedVersion }) };
+	}
+	stopMonitor(monitorId, expectedVersion, reasonCode, detail) {
+		return { monitor: this.relayEvents.stopMonitor(monitorId, {
+			expectedVersion,
+			actor: "management-ui",
+			reasonCode,
+			detail
+		}) };
+	}
+	retryActivation(activationId) {
+		return this.relayEvents.retryActivation(activationId);
+	}
+	retryNotification(eventId) {
+		return { notification: this.relayEvents.retryNotification(eventId) };
+	}
+	connectorAction(connectorId, action, input) {
+		return this.relayEvents.executeConnectorAction(connectorId, action, input);
+	}
 };
 //#endregion
 //#region host-plugin.js
@@ -2151,6 +3454,11 @@ async function apply(ctx, config = {}) {
 	const events = new RelayEventsService(ctx, {
 		databasePath: config.databasePath,
 		dispatchPollIntervalMs: config.dispatchPollIntervalMs,
+		routingFailureLimit: config.routingFailureLimit,
+		deliveryFailureLimit: config.deliveryFailureLimit,
+		deliveryRetryBaseMs: config.deliveryRetryBaseMs,
+		globalEventsPerMinute: config.globalEventsPerMinute,
+		globalConcurrentEvents: config.globalConcurrentEvents,
 		inbox
 	});
 	ctx.effect(() => () => events.stop(), "relayEvents.stop()");
@@ -2172,12 +3480,35 @@ async function apply(ctx, config = {}) {
 		ctx.effect(() => installRelayAgentBridge(agent.ctx, {
 			sessionId: agent.id,
 			registerWaits: (input) => events.registerWaits(input),
-			cancelWaits: (sessionId) => events.cancelWaits(sessionId)
+			cancelWaits: (sessionId) => events.cancelWaits(sessionId),
+			manageMonitor: (sessionId, input) => manageOwnedMonitor(events, sessionId, input)
 		}), "relay events tools");
 	};
 	ctx.effect(() => ctx.on("agent/created", ({ agent }) => attach(agent)), "relay events agent bridge");
 	for (const agent of ctx.agents.roots()) attach(agent);
 }
+async function manageOwnedMonitor(events, sessionId, input) {
+	const monitor = events.inspectMonitor(input.monitorId);
+	if (!monitor || monitor.session_id !== sessionId) throw new Error(`monitor ${input.monitorId} does not belong to this Session`);
+	if (input.action === "inspect") return monitor;
+	if (input.action === "run_now") return events.checkMonitor(input.monitorId, { force: true });
+	if (input.action === "pause") return events.pauseMonitor(input.monitorId, { expectedVersion: input.expectedVersion });
+	if (input.action === "resume") return events.resumeMonitor(input.monitorId, { expectedVersion: input.expectedVersion });
+	if (input.action === "update_cadence") return events.updateMonitorCadence(input.monitorId, input.intervalSeconds, { expectedVersion: input.expectedVersion });
+	if (input.action === "update_target") return events.rebaselineMonitor(input.monitorId, {
+		observer: input.observer,
+		artifact: input.artifact,
+		detector: input.detector,
+		capabilities: input.capabilities
+	}, { expectedVersion: input.expectedVersion });
+	if (input.action === "stop") return events.stopMonitor(input.monitorId, {
+		expectedVersion: input.expectedVersion,
+		actor: `session:${sessionId}`,
+		reasonCode: input.reasonCode ?? "stopped_by_agent",
+		detail: input.detail ?? ""
+	});
+	throw new Error(`unsupported monitor action ${input.action}`);
+}
 function createSharedAgentLookup(ctx) {
 	const lookup = ctx.typert.lookups.get("agent");
 	if (!lookup) throw new Error("Relay requires DSH's configured shared Agent lookup");