@xopcai/xopc 0.0.267 → 0.0.269

package/dist/src/proactive/inbox/digest.js

@@ -0,0 +1,112 @@
+import { getSqliteDatabase, runSqliteWriteTransaction } from "../../storage/sqlite/transaction.js";
+import { effectiveProactivePolicy, localProactiveDay, nextDigestTime, proactivePreferences, quietHoursEnd } from "../policy/service.js";
+import { viewingProactiveCards } from "../policy/presence.js";
+import { insightSourcesAuthorized } from "../execution/authorization.js";
+import { getInboxItem } from "./repository.js";
+import { getCard } from "./cards.js";
+import { randomUUID } from "node:crypto";
+//#region src/proactive/inbox/digest.ts
+function queueDigest(item, mode, dueAt) {
+	const policy = effectiveProactivePolicy(item.subscriptionId);
+	getSqliteDatabase().prepare(`INSERT INTO proactive_digest_queue(inbox_item_id, workspace_id, notification_revision, mode, due_at)
+    VALUES (?, ?, ?, ?, ?) ON CONFLICT(inbox_item_id) DO UPDATE SET notification_revision = excluded.notification_revision,
+    mode = excluded.mode, due_at = excluded.due_at, consumed_at = NULL
+    WHERE proactive_digest_queue.notification_revision <> excluded.notification_revision`).run(item.id, policy.workspaceId, item.notificationRevision, mode, dueAt.toISOString());
+}
+function digestCards(id, workspaceId) {
+	const digest = getSqliteDatabase().prepare("SELECT * FROM proactive_digests WHERE digest_id = ? AND workspace_id = ?").get(id, workspaceId);
+	if (!digest) throw new Error("Digest not found");
+	return getSqliteDatabase().prepare("SELECT inbox_item_id, notification_revision FROM proactive_digest_members WHERE digest_id = ?").all(id).flatMap((member) => {
+		const item = getInboxItem(member.inbox_item_id);
+		if (!item || !eligibleDigestItem(item, digest.occurrence_key.startsWith("daily:") ? "daily" : "quiet") || item.notificationRevision !== member.notification_revision) return [];
+		const card = getCard(item.id, workspaceId);
+		return card.status === "withdrawn" ? [] : [card];
+	});
+}
+function eligibleDigestItem(item, mode) {
+	const policy = effectiveProactivePolicy(item.subscriptionId);
+	const daily = policy.preferences.digestEnabled || policy.settings.delivery === "digest";
+	if (mode === "daily" ? !daily : policy.level === "quiet" && !daily) return false;
+	return Boolean(policy.enabled && policy.settings.delivery !== "inbox" && !item.withdrawnAt && !["resolved", "snoozed"].includes(item.status) && (!item.expiresAt || Date.parse(item.expiresAt) > Date.now()) && insightSourcesAuthorized(item.insightId));
+}
+function reserveWorkspaceAttention(workspaceId, key, now = /* @__PURE__ */ new Date()) {
+	const db = getSqliteDatabase();
+	const preferences = proactivePreferences(workspaceId);
+	if (preferences.level === "off" || preferences.pausedUntil && Date.parse(preferences.pausedUntil) > now.getTime()) return false;
+	if (db.prepare("SELECT 1 FROM proactive_notification_budget WHERE dedupe_key = ?").get(key)) return true;
+	const day = localProactiveDay(now, preferences.timezone);
+	const { count } = db.prepare("SELECT COUNT(*) AS count FROM proactive_notification_budget WHERE workspace_id = ? AND local_day = ?").get(workspaceId, day);
+	if (count >= preferences.dailyNotificationLimit) return false;
+	db.prepare("INSERT INTO proactive_notification_budget VALUES (?, ?, ?, ?)").run(key, workspaceId, day, now.toISOString());
+	return true;
+}
+function flushDueDigests(persist, now = /* @__PURE__ */ new Date()) {
+	return runSqliteWriteTransaction((db) => {
+		const groups = db.prepare(`SELECT workspace_id, mode FROM proactive_digest_queue WHERE consumed_at IS NULL AND due_at <= ? GROUP BY workspace_id, mode LIMIT 20`).all(now.toISOString());
+		const notifications = [];
+		for (const group of groups) {
+			const preferences = proactivePreferences(group.workspace_id);
+			const until = quietHoursEnd(preferences, now);
+			if (until) {
+				db.prepare("UPDATE proactive_digest_queue SET due_at = ? WHERE workspace_id = ? AND mode = ? AND consumed_at IS NULL").run(until.toISOString(), group.workspace_id, group.mode);
+				continue;
+			}
+			const queued = db.prepare("SELECT inbox_item_id FROM proactive_digest_queue WHERE workspace_id = ? AND mode = ? AND consumed_at IS NULL AND due_at <= ? ORDER BY due_at LIMIT 500").all(group.workspace_id, group.mode, now.toISOString());
+			const seen = /* @__PURE__ */ new Set();
+			const items = queued.flatMap((row) => {
+				const item = getInboxItem(row.inbox_item_id);
+				if (!item || !eligibleDigestItem(item, group.mode)) return [];
+				const key = item.correlationKey ?? item.id;
+				if (seen.has(key)) return [];
+				seen.add(key);
+				return [item];
+			});
+			const occurrence = `${group.mode}:${localProactiveDay(now, preferences.timezone)}`;
+			if (db.prepare("SELECT 1 FROM proactive_digests WHERE workspace_id = ? AND occurrence_key = ?").get(group.workspace_id, occurrence) && items.length) {
+				const tomorrow = nextDigestTime(preferences, new Date(now.getTime() + 6e4));
+				db.prepare("UPDATE proactive_digest_queue SET due_at = ? WHERE workspace_id = ? AND mode = ? AND consumed_at IS NULL").run(tomorrow.toISOString(), group.workspace_id, group.mode);
+				continue;
+			}
+			if (!items.length || preferences.suppressWhileViewing && viewingProactiveCards(group.workspace_id, now.getTime())) {
+				for (const row of queued) db.prepare("UPDATE proactive_digest_queue SET consumed_at = ? WHERE inbox_item_id = ?").run(now.toISOString(), row.inbox_item_id);
+				continue;
+			}
+			const key = `proactive.digest:${group.workspace_id}:${occurrence}`;
+			if (!reserveWorkspaceAttention(group.workspace_id, key, now)) {
+				db.prepare("UPDATE proactive_digest_queue SET due_at = ? WHERE workspace_id = ? AND mode = ? AND consumed_at IS NULL").run(nextDigestTime(preferences, new Date(now.getTime() + 6e4)).toISOString(), group.workspace_id, group.mode);
+				continue;
+			}
+			const id = randomUUID();
+			db.prepare("INSERT INTO proactive_digests(digest_id, workspace_id, occurrence_key, created_at) VALUES (?, ?, ?, ?)").run(id, group.workspace_id, occurrence, now.toISOString());
+			for (const item of items) db.prepare("INSERT INTO proactive_digest_members VALUES (?, ?, ?)").run(id, item.id, item.notificationRevision);
+			const notification = persist({
+				dedupeKey: key,
+				notification: {
+					type: "proactive.insight",
+					target: {
+						kind: "proactive_digest",
+						digestId: id
+					},
+					priority: "normal",
+					title: {
+						en: "Your work digest is ready",
+						zh: "你的工作摘要已就绪"
+					},
+					body: {
+						en: `${items.length} updates to review in xopc.`,
+						zh: `有 ${items.length} 项变化，打开 xopc 查看。`
+					},
+					payload: { digestId: id }
+				}
+			});
+			if (notification) {
+				db.prepare("UPDATE proactive_digests SET notification_id = ? WHERE digest_id = ?").run(notification.id, id);
+				notifications.push(notification);
+			}
+			for (const row of queued) db.prepare("UPDATE proactive_digest_queue SET consumed_at = ? WHERE inbox_item_id = ?").run(now.toISOString(), row.inbox_item_id);
+		}
+		return notifications;
+	});
+}
+//#endregion
+export { digestCards, flushDueDigests, nextDigestTime, queueDigest, reserveWorkspaceAttention };

package/dist/src/proactive/inbox/lifecycle.d.ts

@@ -0,0 +1,4 @@
+export declare function withdrawCard(id: string, now?: Date): void;
+/** Conservative correlation: the same scope, evidence subjects and requested outcome. */
+export declare function insightCorrelation(insightId: string): string;
+export declare function reconcileCards(now?: Date): number;

package/dist/src/proactive/inbox/lifecycle.js

@@ -0,0 +1,58 @@
+import { getSqliteDatabase, runSqliteWriteTransaction } from "../../storage/sqlite/transaction.js";
+import { insightSourcesAuthorized } from "../execution/authorization.js";
+import { createHash } from "node:crypto";
+//#region src/proactive/inbox/lifecycle.ts
+function withdrawCard(id, now = /* @__PURE__ */ new Date()) {
+	runSqliteWriteTransaction((db) => {
+		db.prepare("UPDATE proactive_inbox_items SET withdrawn_at = ?, updated_at = ? WHERE inbox_item_id = ? AND withdrawn_at IS NULL").run(now.toISOString(), now.toISOString(), id);
+		db.prepare("UPDATE proactive_delivery_outbox SET status = 'delivered', error_message = 'source_withdrawn' WHERE inbox_item_id = ? AND status <> 'delivered'").run(id);
+		db.prepare("UPDATE proactive_insights SET action_status = 'rejected', action_error = 'source_withdrawn' WHERE insight_id = (SELECT insight_id FROM proactive_inbox_items WHERE inbox_item_id = ?) AND action_status IN ('pending', 'approval_required', 'failed')").run(id);
+		db.prepare(`UPDATE notification_events SET title_en = 'Update withdrawn', title_zh = '消息已撤回', body_en = NULL, body_zh = NULL
+      WHERE event_type = 'proactive.insight' AND json_extract(target_json, '$.inboxItemId') = ?`).run(id);
+		db.prepare(`UPDATE proactive_web_push_deliveries SET status = 'failed', lease_until = NULL, last_error = 'source_withdrawn'
+      WHERE inbox_item_id = ? AND status IN ('pending', 'sending')`).run(id);
+		db.prepare(`UPDATE notification_deliveries SET status = 'dead', updated_at = ? WHERE status IN ('pending', 'accepted') AND event_id IN
+      (SELECT event_id FROM notification_events WHERE event_type = 'proactive.insight' AND json_extract(target_json, '$.inboxItemId') = ?)`).run(now.getTime(), id);
+		db.prepare(`UPDATE proactive_channel_deliveries SET status = 'cancelled', lease_until = NULL, last_error = 'source_withdrawn' WHERE status IN ('pending', 'sending') AND notification_id IN
+      (SELECT event_id FROM notification_events WHERE event_type = 'proactive.insight' AND json_extract(target_json, '$.inboxItemId') = ?)`).run(id);
+		db.prepare("DELETE FROM proactive_digest_queue WHERE inbox_item_id = ?").run(id);
+	});
+}
+/** Conservative correlation: the same scope, evidence subjects and requested outcome. */
+function insightCorrelation(insightId) {
+	const row = getSqliteDatabase().prepare(`SELECT s.workspace_id, b.aggregation_key, x.evidence_ids_json, x.proposed_action_json, x.recommendation
+    FROM proactive_insights x JOIN proactive_runs r USING(run_id) JOIN proactive_signal_batches b USING(batch_id)
+    JOIN proactive_scenario_subscriptions s ON s.subscription_id = x.subscription_id WHERE x.insight_id = ?`).get(insightId);
+	if (!row) return insightId;
+	const normalize = (value) => value.normalize("NFKC").trim().toLowerCase().replace(/\s+/g, " ");
+	const evidence = JSON.parse(row.evidence_ids_json).filter((id) => /^(task|project|source-item|automation-run):/.test(id)).sort();
+	if (!evidence.length) return insightId;
+	const action = row.proposed_action_json ? JSON.parse(row.proposed_action_json) : null;
+	return createHash("sha256").update(JSON.stringify([
+		row.workspace_id,
+		row.aggregation_key,
+		evidence,
+		normalize(action ? JSON.stringify([action.id, action.input]) : row.recommendation)
+	])).digest("hex");
+}
+function reconcileCards(now = /* @__PURE__ */ new Date()) {
+	return runSqliteWriteTransaction((db) => {
+		const rows = db.prepare(`SELECT i.inbox_item_id, i.insight_id, i.correlation_key FROM proactive_inbox_items i
+      LEFT JOIN proactive_card_review_state r USING(inbox_item_id) WHERE i.withdrawn_at IS NULL
+      ORDER BY COALESCE(r.checked_at, ''), i.created_at LIMIT 200`).all();
+		let withdrawn = 0;
+		for (const row of rows) {
+			if (!insightSourcesAuthorized(row.insight_id)) {
+				withdrawCard(row.inbox_item_id, now);
+				withdrawn++;
+			} else {
+				const correlation = insightCorrelation(row.insight_id);
+				if (row.correlation_key !== correlation) db.prepare("UPDATE proactive_inbox_items SET correlation_key = ? WHERE inbox_item_id = ?").run(correlation, row.inbox_item_id);
+			}
+			db.prepare(`INSERT INTO proactive_card_review_state VALUES (?, ?) ON CONFLICT(inbox_item_id) DO UPDATE SET checked_at = excluded.checked_at`).run(row.inbox_item_id, now.toISOString());
+		}
+		return withdrawn;
+	});
+}
+//#endregion
+export { insightCorrelation, reconcileCards, withdrawCard };

package/dist/src/proactive/inbox/notification-policy.d.ts

@@ -0,0 +1 @@
+export declare function recheckProactiveNotification(itemId: string, now?: Date, notificationRevision?: unknown): 'send' | 'cancel' | Date;

package/dist/src/proactive/inbox/notification-policy.js

@@ -0,0 +1,20 @@
+import { effectiveProactivePolicy, quietHoursEnd } from "../policy/service.js";
+import { insightSourcesAuthorized } from "../execution/authorization.js";
+import { getInboxItem } from "./repository.js";
+//#region src/proactive/inbox/notification-policy.ts
+function recheckProactiveNotification(itemId, now = /* @__PURE__ */ new Date(), notificationRevision) {
+	const item = getInboxItem(itemId);
+	if (!item || item.withdrawnAt || !insightSourcesAuthorized(item.insightId) || item.status === "resolved" || item.expiresAt && Date.parse(item.expiresAt) <= now.getTime()) return "cancel";
+	if (typeof notificationRevision === "number" && notificationRevision !== item.notificationRevision) return "cancel";
+	const policy = effectiveProactivePolicy(item.subscriptionId, now);
+	if (!policy.enabled || policy.preferences.digestEnabled && item.insight.attentionKind !== "receipt") return "cancel";
+	if (item.status === "snoozed") return new Date(item.snoozedUntil);
+	if (policy.settings.managed || policy.preferences.revision > 0) {
+		if (policy.level === "quiet" || policy.settings.delivery !== "important") return "cancel";
+		const until = quietHoursEnd(policy.preferences, now);
+		if (until) return until;
+	}
+	return "send";
+}
+//#endregion
+export { recheckProactiveNotification };

package/dist/src/proactive/inbox/repository.d.ts

@@ -22,3 +22,4 @@ export interface OutboxClaim {
 export declare function claimDelivery(now?: Date): OutboxClaim | null;
 export declare function finishDelivery(id: string, error?: unknown, attempt?: number, now?: Date): void;
 export declare function recoverExpiredDeliveries(now?: Date): number;
+export declare function deferDelivery(id: string, attempt: number, retryAt: string): void;

package/dist/src/proactive/inbox/repository.js

@@ -1,5 +1,7 @@
 import { getSqliteDatabase, runSqliteWriteTransaction } from "../../storage/sqlite/transaction.js";
+import { effectiveProactivePolicy } from "../policy/service.js";
 import { decideProactiveDisposition, nextQuietHoursEnd, proactiveDispositionReason } from "../../tasks/project-monitoring-service.js";
+import { insightSourcesAuthorized } from "../execution/authorization.js";
 import { randomUUID } from "node:crypto";
 //#region src/proactive/inbox/repository.ts
 const s = (row, key) => String(row[key]);
@@ -8,6 +10,12 @@ function itemFromRow(row) {
 	return {
 		id: s(row, "inbox_item_id"),
 		insightId: s(row, "insight_id"),
+		subscriptionId: s(row, "subscription_id"),
+		withdrawnAt: row.withdrawn_at ? s(row, "withdrawn_at") : void 0,
+		correlationKey: row.correlation_key ? s(row, "correlation_key") : void 0,
+		revision: Number(row.revision),
+		notificationRevision: Number(row.notification_revision),
+		...row.expires_at ? { expiresAt: s(row, "expires_at") } : {},
 		status: s(row, "status"),
 		...row.snoozed_until ? { snoozedUntil: s(row, "snoozed_until") } : {},
 		...row.resolution ? { resolution: s(row, "resolution") } : {},
@@ -42,7 +50,7 @@ const SELECT_ITEM = `SELECT i.*, x.subscription_id, x.scenario_key, x.title, x.s
   JOIN proactive_insights x ON x.insight_id = i.insight_id`;
 function projectInsightsToInbox(now = /* @__PURE__ */ new Date()) {
 	return runSqliteWriteTransaction((db) => {
-		const missing = db.prepare(`SELECT x.insight_id, x.confidence, x.value_score, x.decision_json,
+		const missing = db.prepare(`SELECT x.insight_id, x.subscription_id, x.scenario_key, x.urgency, x.confidence, x.value_score, x.decision_json,
       x.proposed_action_json, b.aggregation_key, p.project_id, p.mode, p.quiet_hours_json,
       p.allowed_actions_json, p.confidence_threshold FROM proactive_insights x
       JOIN proactive_runs r ON r.run_id = x.run_id
@@ -52,6 +60,11 @@ function projectInsightsToInbox(now = /* @__PURE__ */ new Date()) {
       WHERE x.disposition IS NULL ORDER BY x.created_at`).all();
 		let projected = 0;
 		for (const row of missing) {
+			const attention = effectiveProactivePolicy(String(row.subscription_id), now);
+			if (!attention.enabled) {
+				db.prepare("UPDATE proactive_insights SET disposition = 'record_silently', disposition_reason = 'Proactive subscription paused' WHERE insight_id = ?").run(String(row.insight_id));
+				continue;
+			}
 			const aggregationKey = String(row.aggregation_key);
 			const projectId = aggregationKey.startsWith("project:") ? aggregationKey.slice(8) : void 0;
 			const policy = projectId ? row.project_id ? {
@@ -85,19 +98,53 @@ function projectInsightsToInbox(now = /* @__PURE__ */ new Date()) {
 				...action ? { actionId: action.id } : {},
 				requiresApproval: !action && Boolean(row.decision_json)
 			};
-			const disposition = action && !projectId ? "show_in_work" : decideProactiveDisposition(policy, dispositionInput);
+			const legacyDisposition = action && !projectId ? "show_in_work" : decideProactiveDisposition(policy, dispositionInput);
+			const disposition = attention.settings.managed && legacyDisposition === "record_silently" ? action && projectId ? "request_approval" : "show_in_work" : legacyDisposition;
 			const reason = action && !projectId ? "Proposed project action cannot run outside a project scope" : proactiveDispositionReason(policy, dispositionInput, disposition);
 			const actionStatus = action ? disposition === "auto_execute" ? "pending" : disposition === "request_approval" ? "approval_required" : disposition === "show_in_work" ? "not_authorized" : null : null;
 			const nowIso = now.toISOString();
 			db.prepare(`UPDATE proactive_insights SET disposition = ?, disposition_reason = ?, action_status = ?,
         disposition_at = ?, action_updated_at = ? WHERE insight_id = ? AND disposition IS NULL`).run(disposition, reason, actionStatus, nowIso, actionStatus ? nowIso : null, String(row.insight_id));
 			if (disposition === "record_silently") continue;
-			const id = randomUUID();
-			db.prepare(`INSERT INTO proactive_inbox_items (inbox_item_id, insight_id, status, created_at, updated_at)
-        VALUES (?, ?, 'unread', ?, ?)`).run(id, String(row.insight_id), nowIso, nowIso);
-			const nextAttemptAt = nextQuietHoursEnd(policy.quietHours, now)?.toISOString() ?? nowIso;
+			const previous = attention.settings.managed ? db.prepare(`SELECT i.inbox_item_id, x.urgency, x.decision_json,
+        o.delivered_at FROM proactive_inbox_items i JOIN proactive_insights x USING(insight_id)
+        JOIN proactive_runs r USING(run_id) JOIN proactive_signal_batches b USING(batch_id)
+        LEFT JOIN proactive_delivery_outbox o USING(inbox_item_id)
+        WHERE x.subscription_id = ? AND x.scenario_key = ? AND b.aggregation_key = ?
+        AND i.withdrawn_at IS NULL AND i.status IN ('unread', 'read', 'snoozed') AND (i.expires_at IS NULL OR i.expires_at > ?)
+        AND (x.action_status IS NULL OR x.action_status IN ('not_authorized', 'rejected', 'failed'))
+        ORDER BY i.updated_at DESC LIMIT 1`).get(String(row.subscription_id), String(row.scenario_key), aggregationKey, nowIso) : void 0;
+			const id = previous?.inbox_item_id ?? randomUUID();
+			const urgencyRank = {
+				low: 0,
+				medium: 1,
+				high: 2,
+				critical: 3
+			};
+			const materialChange = previous && ((urgencyRank[String(row.urgency)] ?? 0) > (urgencyRank[previous.urgency] ?? 0) || row.decision_json !== previous.decision_json);
+			if (previous) db.prepare(`UPDATE proactive_inbox_items SET insight_id = ?, updated_at = ?,
+          notification_revision = notification_revision + ? WHERE inbox_item_id = ?`).run(String(row.insight_id), nowIso, materialChange ? 1 : 0, id);
+			else db.prepare(`INSERT INTO proactive_inbox_items (inbox_item_id, insight_id, status, created_at, updated_at)
+          VALUES (?, ?, 'unread', ?, ?)`).run(id, String(row.insight_id), nowIso, nowIso);
+			if (attention.settings.managed) {
+				const meeting = db.prepare(`SELECT e.payload_json FROM proactive_events e
+          JOIN proactive_batch_events be ON be.event_id = e.event_id
+          JOIN proactive_runs r ON r.batch_id = be.batch_id JOIN proactive_insights x ON x.run_id = r.run_id
+          WHERE x.insight_id = ? AND e.type = 'connected_source.calendar_window.v1' ORDER BY e.occurred_at DESC LIMIT 1`).get(String(row.insight_id));
+				const meetingStart = meeting ? JSON.parse(meeting.payload_json).meetingStartsAt : void 0;
+				const expiresAt = typeof meetingStart === "string" && Number.isFinite(Date.parse(meetingStart)) ? meetingStart : new Date(now.getTime() + 7 * 864e5).toISOString();
+				db.prepare("UPDATE proactive_inbox_items SET expires_at = ? WHERE inbox_item_id = ?").run(expiresAt, id);
+			}
+			const quietEnd = nextQuietHoursEnd(policy.quietHours, now)?.getTime() ?? now.getTime();
+			const cooldownEnd = previous?.delivered_at ? Date.parse(previous.delivered_at) + 4 * 36e5 : now.getTime();
+			const nextAttemptAt = new Date(Math.max(quietEnd, cooldownEnd)).toISOString();
+			if (previous && !materialChange) {
+				projected += 1;
+				continue;
+			}
 			db.prepare(`INSERT INTO proactive_delivery_outbox (delivery_id, inbox_item_id, status, attempt, next_attempt_at, created_at, updated_at)
-        VALUES (?, ?, 'pending', 0, ?, ?, ?)`).run(randomUUID(), id, nextAttemptAt, nowIso, nowIso);
+        VALUES (?, ?, 'pending', 0, ?, ?, ?)
+        ON CONFLICT(inbox_item_id) DO UPDATE SET delivery_id = excluded.delivery_id, status = 'pending', attempt = 0, next_attempt_at = excluded.next_attempt_at, lease_expires_at = NULL, updated_at = excluded.updated_at`).run(randomUUID(), id, nextAttemptAt, nowIso, nowIso);
 			projected += 1;
 		}
 		return projected;
@@ -109,22 +156,29 @@ function wakeSnoozedItems(now = /* @__PURE__ */ new Date()) {
 }
 function listInbox(input = {}) {
 	const limit = Math.min(200, Math.max(1, input.limit ?? 50));
-	return (input.status ? getSqliteDatabase().prepare(`${SELECT_ITEM} WHERE i.status = ? ORDER BY i.updated_at DESC LIMIT ?`).all(input.status, limit) : getSqliteDatabase().prepare(`${SELECT_ITEM} ORDER BY i.updated_at DESC LIMIT ?`).all(limit)).map(itemFromRow);
+	return (input.status ? getSqliteDatabase().prepare(`${SELECT_ITEM} WHERE i.status = ? ORDER BY i.updated_at DESC LIMIT ?`).all(input.status, limit) : getSqliteDatabase().prepare(`${SELECT_ITEM} ORDER BY i.updated_at DESC LIMIT ?`).all(limit)).map(itemFromRow).filter((item) => !item.withdrawnAt && insightSourcesAuthorized(item.insightId));
 }
 function getInboxItem(id) {
 	const row = getSqliteDatabase().prepare(`${SELECT_ITEM} WHERE i.inbox_item_id = ?`).get(id);
 	return row ? itemFromRow(row) : null;
 }
 function transitionInboxItem(id, input, now = /* @__PURE__ */ new Date()) {
-	if (input.status === "snoozed" && (!input.snoozedUntil || Date.parse(input.snoozedUntil) <= now.getTime())) throw new Error("snoozedUntil must be in the future");
+	if (input.status === "snoozed" && (!input.snoozedUntil || !Number.isFinite(Date.parse(input.snoozedUntil)) || Date.parse(input.snoozedUntil) <= now.getTime())) throw new Error("snoozedUntil must be in the future");
 	if (input.status === "resolved" && !input.resolution?.trim()) throw new Error("resolution is required");
 	runSqliteWriteTransaction((db) => {
+		const current = getInboxItem(id);
+		if (!current || current.withdrawnAt || !insightSourcesAuthorized(current.insightId)) throw new Error("Inbox item not found");
+		if ((current.status === "resolved" || current.expiresAt && Date.parse(current.expiresAt) <= now.getTime()) && input.status !== "resolved") throw new Error("Card is no longer actionable");
 		if (db.prepare(`UPDATE proactive_inbox_items SET status = ?, snoozed_until = ?, resolution = ?, updated_at = ? WHERE inbox_item_id = ?`).run(input.status, input.status === "snoozed" ? input.snoozedUntil : null, input.status === "resolved" ? input.resolution.trim() : null, now.toISOString(), id).changes !== 1) throw new Error("Inbox item not found");
 	});
 	return getInboxItem(id);
 }
 function recordDecision(id, choice, note = "", now = /* @__PURE__ */ new Date()) {
 	if (!choice.trim()) throw new Error("choice is required");
+	const activeItem = getInboxItem(id);
+	if (!activeItem || activeItem.withdrawnAt || !insightSourcesAuthorized(activeItem.insightId)) throw new Error("Inbox item not found");
+	if (activeItem?.expiresAt && Date.parse(activeItem.expiresAt) <= now.getTime()) throw new Error("Card expired");
+	if (choice === "approve" && activeItem?.subscriptionId && !effectiveProactivePolicy(activeItem.subscriptionId, now).enabled) throw new Error("Subscription paused");
 	runSqliteWriteTransaction((db) => {
 		const row = db.prepare(`SELECT i.status, x.decision_json, x.action_status FROM proactive_inbox_items i
       JOIN proactive_insights x ON x.insight_id = i.insight_id WHERE i.inbox_item_id = ?`).get(id);
@@ -168,12 +222,15 @@ function finishDelivery(id, error, attempt = 1, now = /* @__PURE__ */ new Date()
 	runSqliteWriteTransaction((db) => {
 		const retry = Boolean(error) && attempt < 5;
 		db.prepare(`UPDATE proactive_delivery_outbox SET status = ?, next_attempt_at = ?, lease_expires_at = NULL,
-      error_message = ?, delivered_at = ?, updated_at = ? WHERE delivery_id = ?`).run(error ? retry ? "retryable" : "failed" : "delivered", retry ? new Date(now.getTime() + attempt * 3e4).toISOString() : now.toISOString(), error ? String(error instanceof Error ? error.message : error).slice(0, 1e3) : null, error ? null : now.toISOString(), now.toISOString(), id);
+      error_message = ?, delivered_at = ?, updated_at = ? WHERE delivery_id = ? AND status = 'delivering' AND attempt = ?`).run(error ? retry ? "retryable" : "failed" : "delivered", retry ? new Date(now.getTime() + attempt * 3e4).toISOString() : now.toISOString(), error ? String(error instanceof Error ? error.message : error).slice(0, 1e3) : null, error ? null : now.toISOString(), now.toISOString(), id, attempt);
 	});
 }
 function recoverExpiredDeliveries(now = /* @__PURE__ */ new Date()) {
 	return Number(runSqliteWriteTransaction((db) => db.prepare(`UPDATE proactive_delivery_outbox SET status = 'retryable', next_attempt_at = ?, lease_expires_at = NULL, updated_at = ?
     WHERE status = 'delivering' AND lease_expires_at <= ?`).run(now.toISOString(), now.toISOString(), now.toISOString()).changes));
 }
+function deferDelivery(id, attempt, retryAt) {
+	getSqliteDatabase().prepare("UPDATE proactive_delivery_outbox SET status = 'pending', attempt = attempt - 1, next_attempt_at = ?, lease_expires_at = NULL WHERE delivery_id = ? AND status = 'delivering' AND attempt = ?").run(retryAt, id, attempt);
+}
 //#endregion
-export { claimDelivery, finishDelivery, getInboxItem, getInboxSubscriptionId, listInbox, projectInsightsToInbox, recordDecision, recordFeedback, recoverExpiredDeliveries, transitionInboxItem, wakeSnoozedItems };
+export { claimDelivery, deferDelivery, finishDelivery, getInboxItem, getInboxSubscriptionId, listInbox, projectInsightsToInbox, recordDecision, recordFeedback, recoverExpiredDeliveries, transitionInboxItem, wakeSnoozedItems };

package/dist/src/proactive/inbox/types.d.ts

@@ -2,6 +2,12 @@ export type InboxStatus = 'unread' | 'read' | 'snoozed' | 'resolved';
 export interface InboxItem {
     id: string;
     insightId: string;
+    subscriptionId?: string;
+    revision?: number;
+    notificationRevision?: number;
+    expiresAt?: string;
+    withdrawnAt?: string;
+    correlationKey?: string;
     status: InboxStatus;
     snoozedUntil?: string;
     resolution?: string;
@@ -49,5 +55,7 @@ export interface InboxDelivery {
     deliveryId: string;
 }
 export interface InboxDeliveryAdapter {
-    deliver(delivery: InboxDelivery): Promise<void>;
+    deliver(delivery: InboxDelivery): Promise<void | {
+        retryAt: string;
+    }>;
 }

package/dist/src/proactive/inbox/worker.js

@@ -1,8 +1,9 @@
 import { createLogger } from "../../utils/logger/index.js";
 import { init_logger } from "../../utils/logger.js";
-import { pruneProactiveHistory } from "../maintenance.js";
+import { reconcileCards } from "./lifecycle.js";
 import { executePendingProactiveActions } from "../actions/service.js";
-import { claimDelivery, finishDelivery, projectInsightsToInbox, recoverExpiredDeliveries, wakeSnoozedItems } from "./repository.js";
+import { claimDelivery, deferDelivery, finishDelivery, projectInsightsToInbox, recoverExpiredDeliveries, wakeSnoozedItems } from "./repository.js";
+import { pruneProactiveHistory } from "../maintenance.js";
 //#region src/proactive/inbox/worker.ts
 init_logger();
 const log = createLogger("ProactiveInboxWorker");
@@ -36,16 +37,21 @@ var ProactiveInboxWorker = class {
 				this.lastMaintenanceAt = now;
 			}
 			projectInsightsToInbox();
+			reconcileCards();
 			executePendingProactiveActions();
 			wakeSnoozedItems();
 			recoverExpiredDeliveries();
 			const claim = claimDelivery();
 			if (!claim) return;
 			try {
-				await this.delivery.deliver({
+				const result = await this.delivery.deliver({
 					deliveryId: claim.id,
 					inboxItem: claim.item
 				});
+				if (result && result.retryAt) {
+					deferDelivery(claim.id, claim.attempt, result.retryAt);
+					return;
+				}
 				finishDelivery(claim.id, void 0, claim.attempt);
 			} catch (error) {
 				finishDelivery(claim.id, error, claim.attempt);

package/dist/src/proactive/index.js

@@ -1,4 +1,5 @@
 import { ProactiveScenarioService } from "./scenarios/service.js";
+import { ProactiveInboxService } from "./inbox/service.js";
 import { normalizeEventEnvelope } from "./events/envelope.js";
 import { mapProductEventToProactive } from "./events/product-event-bridge.js";
 import { matchScenario, matchesCondition } from "./routing/matcher.js";
@@ -9,6 +10,5 @@ import { ReadonlyProactiveAgentExecutor } from "./execution/agent-executor.js";
 import { listInsights } from "./execution/repository.js";
 import { ProactiveWorker } from "./execution/worker.js";
 import { ProactiveTemporalWorker } from "./temporal/worker.js";
-import { ProactiveInboxService } from "./inbox/service.js";
 import { ProactiveInboxWorker } from "./inbox/worker.js";
 export { AutomationStateContextProvider, ConnectedSourceContextProvider, ContextProviderRegistry, EventBatchContextProvider, InternalObjectContextProvider, MeetingWorkspaceContextProvider, ProactiveEventService, ProactiveInboxService, ProactiveInboxWorker, ProactiveScenarioService, ProactiveTemporalWorker, ProactiveWorker, ProjectStateContextProvider, ReadonlyProactiveAgentExecutor, UserModelContextProvider, listInsights, mapProductEventToProactive, matchScenario, matchesCondition, normalizeEventEnvelope, pruneProactiveHistory };

package/dist/src/proactive/maintenance.js

@@ -11,6 +11,13 @@ function pruneProactiveHistory(now = /* @__PURE__ */ new Date()) {
         SELECT 1 FROM proactive_batch_events batch_event
         WHERE batch_event.event_id = proactive_events.event_id
       )`).run(cutoff).changes;
+		db.prepare("DELETE FROM proactive_notification_budget WHERE created_at < ?").run(cutoff);
+		db.prepare("DELETE FROM proactive_presence WHERE expires_at <= ?").run(now.getTime());
+		db.prepare("DELETE FROM proactive_delivery_decisions WHERE created_at < ?").run(cutoff);
+		db.prepare("DELETE FROM proactive_preview_runs WHERE created_at < ?").run(cutoff);
+		db.prepare("DELETE FROM proactive_push_probes WHERE created_at < ?").run(Date.parse(cutoff));
+		db.prepare("DELETE FROM proactive_digest_queue WHERE consumed_at < ?").run(cutoff);
+		db.prepare("DELETE FROM proactive_digests WHERE created_at < ?").run(cutoff);
 		return {
 			batches: Number(batches),
 			events: Number(events)

package/dist/src/proactive/metrics.d.ts

@@ -0,0 +1,10 @@
+export declare function proactiveMetrics(workspace: string, now?: number): {
+    usage: Record<string, import("node:sqlite").SQLOutputValue>;
+    since: string;
+    cards: Record<string, import("node:sqlite").SQLOutputValue>;
+    feedback: Record<string, import("node:sqlite").SQLOutputValue>[];
+    interruptions: Record<string, import("node:sqlite").SQLOutputValue>[];
+    runs: Record<string, import("node:sqlite").SQLOutputValue>[];
+    browser: Record<string, import("node:sqlite").SQLOutputValue>[];
+    telegram: Record<string, import("node:sqlite").SQLOutputValue>[];
+};

package/dist/src/proactive/metrics.js

@@ -0,0 +1,27 @@
+import { getSqliteDatabase } from "../storage/sqlite/transaction.js";
+//#region src/proactive/metrics.ts
+function proactiveMetrics(workspace, now = Date.now()) {
+	const db = getSqliteDatabase();
+	const since = (/* @__PURE__ */ new Date(now - 30 * 864e5)).toISOString();
+	const cards = db.prepare(`SELECT COUNT(*) AS total, SUM(CASE WHEN i.status = 'resolved' THEN 1 ELSE 0 END) AS resolved,
+    SUM(CASE WHEN i.withdrawn_at IS NOT NULL THEN 1 ELSE 0 END) AS withdrawn FROM proactive_inbox_items i
+    JOIN proactive_insights x USING(insight_id) JOIN proactive_scenario_subscriptions s USING(subscription_id) WHERE s.workspace_id = ? AND i.created_at >= ?`).get(workspace, since);
+	const feedback = db.prepare(`SELECT f.rating, COUNT(*) AS count FROM proactive_feedback f JOIN proactive_inbox_items i USING(inbox_item_id)
+    JOIN proactive_insights x USING(insight_id) JOIN proactive_scenario_subscriptions s USING(subscription_id) WHERE s.workspace_id = ? AND f.created_at >= ? AND NOT EXISTS (SELECT 1 FROM proactive_feedback newer WHERE newer.inbox_item_id = f.inbox_item_id AND (newer.created_at > f.created_at OR (newer.created_at = f.created_at AND newer.rowid > f.rowid))) GROUP BY f.rating`).all(workspace, since);
+	const interruptions = db.prepare("SELECT local_day AS day, COUNT(*) AS count FROM proactive_notification_budget WHERE workspace_id = ? AND created_at >= ? GROUP BY local_day ORDER BY local_day DESC").all(workspace, since);
+	const runs = db.prepare(`SELECT r.status, r.outcome_reason AS reason, COUNT(*) AS count FROM proactive_runs r JOIN proactive_scenario_subscriptions s USING(subscription_id) WHERE s.workspace_id = ? AND r.started_at >= ? GROUP BY r.status, r.outcome_reason`).all(workspace, since);
+	const browser = db.prepare(`SELECT d.status, COUNT(*) AS count FROM proactive_web_push_deliveries d JOIN proactive_web_push_subscriptions s ON s.id = d.subscription_id WHERE s.workspace_id = ? GROUP BY d.status`).all(workspace);
+	const telegram = db.prepare("SELECT status, COUNT(*) AS count FROM proactive_channel_deliveries WHERE workspace_id = ? GROUP BY status").all(workspace);
+	return {
+		usage: db.prepare(`SELECT SUM(r.input_tokens) AS inputTokens, SUM(r.output_tokens) AS outputTokens, SUM(r.estimated_cost_usd) AS estimatedCostUsd, COUNT(r.estimated_cost_usd) AS pricedRuns, COUNT(*) AS totalRuns FROM proactive_runs r JOIN proactive_scenario_subscriptions s USING(subscription_id) WHERE s.workspace_id = ? AND r.started_at >= ?`).get(workspace, since),
+		since,
+		cards,
+		feedback,
+		interruptions,
+		runs,
+		browser,
+		telegram
+	};
+}
+//#endregion
+export { proactiveMetrics };

package/dist/src/proactive/policy/presence.d.ts

@@ -0,0 +1,2 @@
+export declare function recordProactivePresence(workspaceId: string, value: unknown, now?: number): void;
+export declare function viewingProactiveCards(workspaceId: string, now?: number): boolean;

package/dist/src/proactive/policy/presence.js

@@ -0,0 +1,27 @@
+import { getSqliteDatabase } from "../../storage/sqlite/transaction.js";
+import { z } from "zod";
+//#region src/proactive/policy/presence.ts
+const PresenceSchema = z.object({
+	clientId: z.string().min(8).max(128),
+	active: z.boolean(),
+	surface: z.enum([
+		"web",
+		"electron",
+		"mobile"
+	])
+}).strict();
+function recordProactivePresence(workspaceId, value, now = Date.now()) {
+	const input = PresenceSchema.parse(value);
+	const db = getSqliteDatabase();
+	db.prepare("DELETE FROM proactive_presence WHERE expires_at <= ?").run(now);
+	if (!input.active) {
+		db.prepare("DELETE FROM proactive_presence WHERE workspace_id = ? AND client_id = ?").run(workspaceId, input.clientId);
+		return;
+	}
+	db.prepare(`INSERT INTO proactive_presence VALUES (?, ?, ?, ?) ON CONFLICT(workspace_id, client_id) DO UPDATE SET surface = excluded.surface, expires_at = excluded.expires_at`).run(workspaceId, input.clientId, input.surface, now + 75e3);
+}
+function viewingProactiveCards(workspaceId, now = Date.now()) {
+	return Boolean(getSqliteDatabase().prepare("SELECT 1 FROM proactive_presence WHERE workspace_id = ? AND expires_at > ?").get(workspaceId, now));
+}
+//#endregion
+export { recordProactivePresence, viewingProactiveCards };

package/dist/src/proactive/policy/service.d.ts

@@ -0,0 +1,53 @@
+import { type ProactivePreferences } from '@xopcai/gateway-contract';
+export declare class ProactiveConflict extends Error {
+}
+export declare function subscriptionSettings(id: string): {
+    revision: number;
+    managed: boolean;
+    level: "off" | "active" | "quiet" | "balanced";
+    delivery: "digest" | "inbox" | "important";
+    preparationWorkflowId: string;
+    scanIntervalMinutes: number;
+    userInstructions: string;
+};
+export declare function proactivePreferences(workspaceId: string): ProactivePreferences;
+export declare function updateProactivePreferences(workspaceId: string, value: unknown): ProactivePreferences;
+export declare function effectiveProactivePolicy(subscriptionId: string, now?: Date): {
+    enabled: boolean;
+    level: "off" | "active" | "quiet" | "balanced";
+    settings: {
+        revision: number;
+        managed: boolean;
+        level: "off" | "active" | "quiet" | "balanced";
+        delivery: "digest" | "inbox" | "important";
+        preparationWorkflowId: string;
+        scanIntervalMinutes: number;
+        userInstructions: string;
+    };
+    preferences: {
+        level: "off" | "active" | "quiet" | "balanced";
+        timezone: string;
+        quietStartHour: number;
+        quietEndHour: number;
+        dailyNotificationLimit: number;
+        digestEnabled: boolean;
+        digestHour: number;
+        digestMinute: number;
+        preferredChannel: "mobile" | "all" | "auto" | "browser" | "telegram";
+        suppressWhileViewing: boolean;
+        telegram: {
+            chatId: string;
+            publicUrl: string;
+            accountId?: string;
+        };
+        pausedUntil: string;
+        revision: number;
+    };
+    workspaceId: string;
+    scanIntervalMinutes: number;
+};
+export declare function localProactiveDay(now: Date, timezone: string): string;
+export declare function quietHoursEnd(preferences: ProactivePreferences, now: Date): Date | null;
+/** Called in the same transaction as notification persistence. Reservations survive retries. */
+export declare function reserveProactiveNotification(subscriptionId: string, dedupeKey: string, now?: Date): 'allowed' | 'suppressed' | Date;
+export declare function nextDigestTime(preferences: ProactivePreferences, after: Date): Date;