@xopcai/xopc 0.0.268 → 0.0.269

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

@@ -0,0 +1,237 @@
+import { getSqliteDatabase, runSqliteWriteTransaction } from "../../storage/sqlite/transaction.js";
+import { ProactiveCardActionSchema } from "../../../packages/gateway-contract/src/proactive.js";
+import { getKnowledgeSourceItem } from "../../storage/sqlite/knowledge-repository.js";
+import { ProactiveConflict, effectiveProactivePolicy, subscriptionSettings } from "../policy/service.js";
+import { insightSourcesAuthorized } from "../execution/authorization.js";
+import { withdrawCard } from "./lifecycle.js";
+import { executePendingProactiveActions } from "../actions/service.js";
+import { updateControlledSubscription } from "../scenarios/control.js";
+import { getInboxItem } from "./repository.js";
+import { ProactiveInboxService } from "./service.js";
+//#region src/proactive/inbox/cards.ts
+function requireCardScope(id, workspaceId) {
+	if (!getSqliteDatabase().prepare(`SELECT 1 FROM proactive_inbox_items i JOIN proactive_insights x USING(insight_id)
+    JOIN proactive_scenario_subscriptions s USING(subscription_id) WHERE i.inbox_item_id = ? AND s.workspace_id = ?`).get(id, workspaceId)) throw new Error("Card not found");
+}
+function getCard(id, workspaceId) {
+	requireCardScope(id, workspaceId);
+	const item = getInboxItem(id);
+	if (!insightSourcesAuthorized(item.insightId)) {
+		withdrawCard(id);
+		item.withdrawnAt = (/* @__PURE__ */ new Date()).toISOString();
+	}
+	if (item.withdrawnAt) return {
+		schemaVersion: 1,
+		id,
+		revision: getInboxItem(id).revision,
+		notificationRevision: item.notificationRevision,
+		subscriptionId: item.subscriptionId,
+		scenarioKey: item.insight.scenarioKey,
+		kind: "briefing",
+		status: "withdrawn",
+		title: "Source unavailable / 来源已撤回",
+		summary: "",
+		whyNow: "",
+		recommendation: "",
+		workDone: "",
+		evidence: [],
+		createdAt: item.createdAt,
+		updatedAt: item.withdrawnAt,
+		fallbackText: "Source unavailable / 来源已撤回"
+	};
+	const insight = item.insight;
+	const expired = item.expiresAt && Date.parse(item.expiresAt) <= Date.now();
+	return {
+		schemaVersion: 1,
+		id,
+		revision: item.revision,
+		notificationRevision: item.notificationRevision,
+		subscriptionId: item.subscriptionId,
+		preparationAvailable: Boolean(subscriptionSettings(item.subscriptionId).preparationWorkflowId),
+		relatedCardIds: item.correlationKey ? getSqliteDatabase().prepare("SELECT inbox_item_id AS id FROM proactive_inbox_items WHERE correlation_key = ? AND inbox_item_id <> ? AND withdrawn_at IS NULL").all(item.correlationKey, id).map((row) => row.id) : [],
+		scenarioKey: insight.scenarioKey,
+		kind: insight.attentionKind === "receipt" ? "receipt" : insight.decision ? "decision" : insight.scenarioKey === "meeting_preparation" ? "briefing" : insight.scenarioKey.includes("risk") || insight.scenarioKey.includes("failure") ? "risk" : insight.scenarioKey === "blocked_work" ? "reminder" : "recommendation",
+		status: expired ? "expired" : item.status,
+		title: insight.title,
+		summary: insight.summary,
+		whyNow: insight.whyNow,
+		recommendation: insight.recommendation,
+		workDone: insight.workDone,
+		evidence: insight.evidenceIds.map((evidenceId) => cardEvidence(evidenceId, workspaceId)),
+		...insight.decision ? { decision: insight.decision } : {},
+		actionStatus: insight.actionStatus,
+		actionResult: insight.actionResult,
+		actionError: insight.actionError,
+		createdAt: item.createdAt,
+		updatedAt: item.updatedAt,
+		expiresAt: item.expiresAt,
+		fallbackText: `${insight.title}\n${insight.summary}\n${insight.whyNow}`
+	};
+}
+function listCards(workspaceId, input = {}) {
+	const limit = Math.min(100, Math.max(1, input.limit ?? 30));
+	const rows = getSqliteDatabase().prepare(`SELECT i.inbox_item_id, i.created_at FROM proactive_inbox_items i
+    JOIN proactive_insights x USING(insight_id) JOIN proactive_scenario_subscriptions s USING(subscription_id)
+    WHERE i.withdrawn_at IS NULL AND s.workspace_id = ? AND (? IS NULL OR i.status = ?) AND (? IS NULL OR i.created_at || ':' || i.inbox_item_id < ?)
+    ORDER BY i.created_at DESC, i.inbox_item_id DESC LIMIT ?`).all(workspaceId, input.status || null, input.status || null, input.before || null, input.before || null, limit + 1);
+	const page = rows.slice(0, limit);
+	const last = page.at(-1);
+	return {
+		cards: page.flatMap((row) => {
+			try {
+				const card = getCard(row.inbox_item_id, workspaceId);
+				return card.status === "withdrawn" ? [] : [card];
+			} catch {
+				return [];
+			}
+		}),
+		nextCursor: rows.length > limit && last ? `${last.created_at}:${last.inbox_item_id}` : null
+	};
+}
+function cardChanges(workspaceId, cursor = 0) {
+	const rows = getSqliteDatabase().prepare("SELECT sequence, inbox_item_id, deleted FROM proactive_card_changes WHERE sequence > ? AND workspace_id = ? ORDER BY sequence LIMIT 200").all(cursor, workspaceId);
+	const items = [];
+	for (const row of rows) {
+		if (row.deleted) {
+			items.push({
+				id: row.inbox_item_id,
+				deleted: true
+			});
+			continue;
+		}
+		try {
+			const card = getCard(row.inbox_item_id, workspaceId);
+			items.push(card.status === "withdrawn" ? {
+				id: row.inbox_item_id,
+				deleted: true
+			} : {
+				id: row.inbox_item_id,
+				deleted: false,
+				card
+			});
+		} catch {
+			items.push({
+				id: row.inbox_item_id,
+				deleted: true
+			});
+		}
+	}
+	return {
+		items,
+		nextCursor: rows.at(-1)?.sequence ?? cursor,
+		hasMore: rows.length === 200
+	};
+}
+function performCardAction(id, workspaceId, value) {
+	const input = ProactiveCardActionSchema.parse(value);
+	return runSqliteWriteTransaction((db) => {
+		requireCardScope(id, workspaceId);
+		const request = JSON.stringify({
+			id,
+			...input
+		});
+		const prior = db.prepare("SELECT request_json, response_json FROM proactive_card_actions WHERE idempotency_key = ?").get(input.idempotencyKey);
+		if (prior) {
+			if (prior.request_json !== request) throw new ProactiveConflict("Idempotency key was already used for a different action");
+			return getCard(id, workspaceId);
+		}
+		const card = getCard(id, workspaceId);
+		if (card.revision !== input.expectedRevision) throw new ProactiveConflict("Card changed; refresh before acting");
+		if (card.status === "withdrawn" || card.status === "expired" || card.status === "resolved" && ![
+			"useful",
+			"not_useful",
+			"retry"
+		].includes(input.actionId)) throw new ProactiveConflict("Card is no longer actionable");
+		applyCardAction(card, workspaceId, input);
+		const result = getCard(id, workspaceId);
+		db.prepare("INSERT INTO proactive_card_actions(idempotency_key, inbox_item_id, request_json, response_json) VALUES (?, ?, ?, ?)").run(input.idempotencyKey, id, request, JSON.stringify(result));
+		return result;
+	});
+}
+function applyCardAction(card, workspaceId, input) {
+	const service = new ProactiveInboxService();
+	switch (input.actionId) {
+		case "retry":
+			if (!effectiveProactivePolicy(card.subscriptionId).enabled) throw new Error("Subscription paused");
+			if (!getSqliteDatabase().prepare("UPDATE proactive_insights SET action_status = 'pending', action_error = NULL, action_updated_at = ? WHERE insight_id = (SELECT insight_id FROM proactive_inbox_items WHERE inbox_item_id = ?) AND action_status = 'failed'").run((/* @__PURE__ */ new Date()).toISOString(), card.id).changes) throw new Error("Only failed actions can be retried");
+			executePendingProactiveActions();
+			break;
+		case "useful":
+		case "not_useful":
+			service.feedback(card.id, input.actionId);
+			break;
+		case "read":
+			service.transition(card.id, { status: "read" });
+			break;
+		case "resolve":
+			service.transition(card.id, {
+				status: "resolved",
+				resolution: "dismissed"
+			});
+			break;
+		case "snooze":
+			service.transition(card.id, {
+				status: "snoozed",
+				snoozedUntil: input.snoozedUntil ?? new Date(Date.now() + 36e5).toISOString()
+			});
+			break;
+		case "decide":
+			if (!input.choice) throw new Error("Decision choice required");
+			if (!effectiveProactivePolicy(card.subscriptionId).enabled) throw new Error("Subscription paused");
+			service.decide(card.id, input.choice);
+			break;
+		case "less":
+		case "pause": {
+			const settings = subscriptionSettings(card.subscriptionId);
+			updateControlledSubscription(workspaceId, card.subscriptionId, {
+				expectedRevision: settings.revision,
+				...input.actionId === "less" ? { delivery: "inbox" } : { enabled: false }
+			});
+			service.transition(card.id, {
+				status: "resolved",
+				resolution: input.actionId
+			});
+			break;
+		}
+	}
+}
+function cardEvidence(id, workspaceId) {
+	const db = getSqliteDatabase();
+	const split = id.indexOf(":");
+	const kind = id.slice(0, split);
+	const objectId = id.slice(split + 1);
+	if (kind === "task") {
+		const task = db.prepare("SELECT title FROM tasks WHERE task_id = ?").get(objectId);
+		if (task) return {
+			id,
+			label: task.title,
+			route: `/tasks/${encodeURIComponent(objectId)}`
+		};
+	}
+	if (kind === "project") {
+		const project = db.prepare("SELECT name FROM projects WHERE project_id = ?").get(objectId);
+		if (project) return {
+			id,
+			label: project.name,
+			route: `/projects/${encodeURIComponent(objectId)}`
+		};
+	}
+	if (kind === "source-item") {
+		const source = getKnowledgeSourceItem(objectId);
+		if (source && !source.deletedAt && source.metadata.workspaceId === workspaceId) {
+			const excerpt = source.normalizedText?.slice(0, 600) ?? "";
+			return {
+				id,
+				label: typeof source.metadata.title === "string" ? source.metadata.title.slice(0, 120) : excerpt.split("\n")[0]?.slice(0, 120) || source.itemType,
+				excerpt
+			};
+		}
+	}
+	const event = db.prepare("SELECT type, occurred_at FROM proactive_events WHERE event_id = ? AND workspace_id = ?").get(id, workspaceId);
+	return {
+		id,
+		label: event ? `${event.type} · ${event.occurred_at}` : kind || "Evidence"
+	};
+}
+//#endregion
+export { cardChanges, getCard, listCards, performCardAction, requireCardScope };

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

@@ -0,0 +1,6 @@
+import type { NotificationService } from '../../notifications/service.js';
+import type { InboxItem } from './types.js';
+/** The outbox is acknowledged only after a notification or suppression is persisted. */
+export declare function deliverProactiveCard(item: InboxItem, notifications: NotificationService, publish: (type: string, payload: unknown) => void): void | {
+    retryAt: string;
+};

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

@@ -0,0 +1,52 @@
+import { getSqliteDatabase, runSqliteWriteTransaction } from "../../storage/sqlite/transaction.js";
+import { effectiveProactivePolicy, localProactiveDay, nextDigestTime, quietHoursEnd, reserveProactiveNotification } from "../policy/service.js";
+import { viewingProactiveCards } from "../policy/presence.js";
+import { insightSourcesAuthorized } from "../execution/authorization.js";
+import { insightCorrelation } from "./lifecycle.js";
+import { getInboxItem } from "./repository.js";
+import { queueDigest } from "./digest.js";
+import { notificationPlanFromGatewayEvent } from "../../notifications/planner.js";
+import { createHash } from "node:crypto";
+//#region src/proactive/inbox/delivery.ts
+/** The outbox is acknowledged only after a notification or suppression is persisted. */
+function deliverProactiveCard(item, notifications, publish) {
+	const result = runSqliteWriteTransaction(() => {
+		const current = getInboxItem(item.id);
+		if (!current || current.withdrawnAt || !insightSourcesAuthorized(current.insightId) || current.status === "resolved" || current.expiresAt && Date.parse(current.expiresAt) <= Date.now()) return null;
+		if (current.status === "snoozed") return { retryAt: current.snoozedUntil };
+		const policy = effectiveProactivePolicy(current.subscriptionId);
+		if (!policy.enabled || policy.settings.delivery === "inbox") return null;
+		if ((policy.preferences.digestEnabled || policy.settings.delivery === "digest") && current.insight.attentionKind !== "receipt") {
+			queueDigest(current, "daily", nextDigestTime(policy.preferences, /* @__PURE__ */ new Date()));
+			return null;
+		}
+		if (!notificationPlanFromGatewayEvent("proactive.inbox.created", current)) return null;
+		if (policy.level === "quiet") return null;
+		const quietUntil = quietHoursEnd(policy.preferences, /* @__PURE__ */ new Date());
+		if (quietUntil) {
+			queueDigest(current, "quiet", quietUntil);
+			return null;
+		}
+		const db = getSqliteDatabase();
+		const key = `proactive:${insightCorrelation(current.insightId)}:${createHash("sha256").update(JSON.stringify([current.insight.urgency, current.insight.decision ?? null])).digest("hex")}:${localProactiveDay(/* @__PURE__ */ new Date(), policy.preferences.timezone)}`;
+		if (db.prepare("SELECT 1 FROM proactive_delivery_decisions WHERE notification_key = ?").get(key)) return null;
+		if (policy.preferences.suppressWhileViewing && viewingProactiveCards(policy.workspaceId)) {
+			db.prepare("INSERT INTO proactive_delivery_decisions VALUES (?, ?, ?, ?)").run(key, policy.workspaceId, "visible_in_app", (/* @__PURE__ */ new Date()).toISOString());
+			return null;
+		}
+		const decision = reserveProactiveNotification(current.subscriptionId, key);
+		if (decision instanceof Date) return { retryAt: decision.toISOString() };
+		if (decision === "suppressed") return null;
+		const result = notifications.persistGatewayEvent("proactive.inbox.created", current);
+		db.prepare("INSERT INTO proactive_delivery_decisions VALUES (?, ?, ?, ?)").run(key, policy.workspaceId, "immediate", (/* @__PURE__ */ new Date()).toISOString());
+		return result;
+	});
+	publish("proactive.card.changed", {
+		cardId: item.id,
+		revision: item.revision
+	});
+	if (result && "retryAt" in result) return result;
+	if (result) publish("notification.created", result);
+}
+//#endregion
+export { deliverProactiveCard };

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

@@ -0,0 +1,8 @@
+import type { ProductNotification } from '@xopcai/gateway-contract';
+import type { NotificationPlan } from '../../notifications/planner.js';
+import type { InboxItem } from './types.js';
+export { nextDigestTime } from '../policy/service.js';
+export declare function queueDigest(item: InboxItem, mode: 'daily' | 'quiet', dueAt: Date): void;
+export declare function digestCards(id: string, workspaceId: string): import("@xopcai/gateway-contract").ProactiveCard[];
+export declare function reserveWorkspaceAttention(workspaceId: string, key: string, now?: Date): boolean;
+export declare function flushDueDigests(persist: (plan: NotificationPlan) => ProductNotification | null, now?: Date): ProductNotification[];

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;