@xopcai/xopc 0.0.309 → 0.0.312

package/dist/src/notifications/dispatch.js

@@ -0,0 +1,109 @@
+//#region src/notifications/dispatch.ts
+/** Owns durable delivery only. The host supplies policy and transports; neither may widen the saved scope. */
+var NotificationDispatcher = class {
+	active = null;
+	stopped = false;
+	constructor(db, dependencies) {
+		this.db = db;
+		this.dependencies = dependencies;
+		const timeout = dependencies.timeoutMs ?? 15e3;
+		if (!Number.isInteger(timeout) || timeout < 1 || timeout > 6e4) throw new Error("Invalid dispatch timeout");
+	}
+	/** Called by the host notification pump; overlapping passes never make a second claim. */
+	drainOne() {
+		if (this.stopped || this.active) return Promise.resolve(false);
+		const controller = new AbortController();
+		const work = Promise.resolve().then(() => this.deliver(controller)).finally(() => {
+			this.active = null;
+		});
+		this.active = {
+			controller,
+			work
+		};
+		return work;
+	}
+	async stop() {
+		this.stopped = true;
+		const active = this.active;
+		active?.controller.abort();
+		await active?.work;
+	}
+	now() {
+		return (this.dependencies.clock ?? Date.now)();
+	}
+	async deliver(controller) {
+		if (controller.signal.aborted) return false;
+		const now = this.now();
+		this.db.prepare(`UPDATE notification_dispatches SET status = 'unknown', lease_until = NULL, last_error = 'lease_expired'
+      WHERE status = 'sending' AND (lease_until IS NULL OR lease_until <= ?)`).run(now);
+		const row = this.db.prepare(`UPDATE notification_dispatches SET status = 'sending', attempt = attempt + 1, lease_until = ?
+      WHERE id = (SELECT id FROM notification_dispatches WHERE status = 'pending' AND next_attempt_at <= ?
+        ORDER BY next_attempt_at, id LIMIT 1) AND status = 'pending' RETURNING *`).get(now + (this.dependencies.timeoutMs ?? 15e3) + 1e3, now);
+		if (!row) return false;
+		const id = String(row.id);
+		const attempt = Number(row.attempt);
+		const failures = Number(row.failure_count);
+		const finish = (status, reason, retryAt = this.now(), receipt = null, failed = false) => this.db.prepare(`UPDATE notification_dispatches SET status = ?, last_error = ?, next_attempt_at = ?,
+        provider_message_id = ?, failure_count = failure_count + ?, lease_until = NULL
+        WHERE id = ? AND attempt = ? AND status = 'sending' AND lease_until > ?`).run(status, reason, retryAt, receipt, failed ? 1 : 0, id, attempt, this.now());
+		let sending = false;
+		let onAbort = () => {};
+		const cancelled = new Promise((_resolve, reject) => {
+			onAbort = () => reject(/* @__PURE__ */ new Error("Dispatch cancelled"));
+		});
+		controller.signal.addEventListener("abort", onAbort, { once: true });
+		const timer = setTimeout(() => controller.abort(), this.dependencies.timeoutMs ?? 15e3);
+		try {
+			const dispatch = {
+				id,
+				notificationId: String(row.notification_id),
+				ownerId: String(row.owner_id),
+				workspaceId: String(row.workspace_id),
+				channel: row.channel,
+				destinationId: String(row.destination_id),
+				destination: row.destination_json === null ? null : JSON.parse(String(row.destination_json)),
+				subjectId: row.subject_id === null ? null : String(row.subject_id),
+				subjectRevision: Number(row.subject_revision),
+				attempt
+			};
+			const policy = await Promise.race([this.dependencies.authorize(dispatch, controller.signal), cancelled]);
+			if (controller.signal.aborted) throw new Error("Dispatch cancelled");
+			if (policy.action === "cancel") {
+				finish("cancelled", "policy_cancelled");
+				return true;
+			}
+			if (policy.action === "defer") {
+				if (!Number.isSafeInteger(policy.until) || policy.until <= this.now()) throw new Error("Invalid notification deferral");
+				finish("pending", "policy_deferred", policy.until);
+				return true;
+			}
+			if (policy.action !== "send") throw new Error("Invalid dispatch policy");
+			if (!this.db.prepare("SELECT 1 FROM notification_dispatches WHERE id = ? AND attempt = ? AND status = 'sending' AND lease_until > ?").get(id, attempt, this.now())) return true;
+			sending = true;
+			const receipt = await Promise.race([this.dependencies.send(dispatch, controller.signal), cancelled]);
+			if (controller.signal.aborted) throw new Error("Dispatch cancelled");
+			if (receipt.status === "accepted") {
+				if (dispatch.channel === "telegram" && !receipt.providerMessageId?.trim()) {
+					finish("unknown", "missing_provider_receipt");
+					return true;
+				}
+				finish("accepted", null, this.now(), receipt.providerMessageId);
+			} else if (receipt.status === "rejected") {
+				const retryAt = receipt.retryAt;
+				if (retryAt !== void 0 && (!Number.isSafeInteger(retryAt) || retryAt <= this.now())) {
+					finish("failed", "invalid_retry_time");
+					return true;
+				}
+				finish(retryAt !== void 0 && failures + 1 < 5 ? "pending" : "failed", "provider_rejected", retryAt ?? this.now(), null, true);
+			} else finish("unknown", "invalid_provider_receipt");
+		} catch {
+			finish(sending ? "unknown" : failures + 1 < 5 ? "pending" : "failed", sending ? "transport_unconfirmed" : "policy_unavailable", this.now() + 3e4, null, true);
+		} finally {
+			clearTimeout(timer);
+			controller.signal.removeEventListener("abort", onAbort);
+		}
+		return true;
+	}
+};
+//#endregion
+export { NotificationDispatcher };

package/dist/src/notifications/domain-delivery.d.ts

@@ -0,0 +1,21 @@
+import type { ProductNotification, ProductNotificationType } from '@xopcai/gateway-contract';
+import type { NotificationPlan } from './planner.js';
+import type { NotificationDevice, NotificationPreferences } from './types.js';
+/** Domain decisions are injected by the host; transports never load domain runtimes. */
+export interface NotificationDomainDelivery {
+    owns(type: ProductNotificationType): boolean;
+    allowsDevice(preferences: NotificationPreferences): boolean;
+    planEvent(type: string, payload: unknown): NotificationPlan | null;
+    prepare(plan: NotificationPlan, devices: NotificationDevice[]): {
+        plan: NotificationPlan;
+        deviceIds: string[];
+        enqueue(notification: ProductNotification): void;
+    };
+    flush(persist: (plan: NotificationPlan) => ProductNotification | null): ProductNotification[];
+    drain(): Promise<void>;
+    recheckMobile(notification: ProductNotification): 'send' | 'cancel' | Date;
+    mobilePreview(notification: ProductNotification, locale: string): {
+        title: string;
+        body: string;
+    };
+}

package/dist/src/notifications/planner.js

@@ -122,41 +122,6 @@ function automationPlan(payload) {
 		}
 	};
 }
-function proactivePlan(payload) {
-	if (!payload || typeof payload !== "object") return null;
-	const item = payload;
-	if (typeof item.id !== "string" || typeof item.insightId !== "string" || typeof item.insight?.title !== "string") return null;
-	const requiresDecision = item.insight.attentionKind === "decision";
-	const highUrgency = item.insight.urgency === "high" || item.insight.urgency === "critical";
-	if (item.insight.attentionKind === "receipt") return null;
-	if (!requiresDecision && !highUrgency) return null;
-	const title = item.insight.title.trim().slice(0, 120);
-	const summary = typeof item.insight.summary === "string" ? item.insight.summary.trim().slice(0, 180) : "";
-	return {
-		dedupeKey: `proactive.insight:${item.id}${item.notificationRevision && item.notificationRevision > 1 ? `:${item.notificationRevision}` : ""}`,
-		notification: {
-			type: "proactive.insight",
-			target: {
-				kind: "insight",
-				inboxItemId: item.id
-			},
-			priority: requiresDecision || highUrgency ? "high" : "normal",
-			title: {
-				en: title,
-				zh: title
-			},
-			...summary ? { body: {
-				en: summary,
-				zh: summary
-			} } : {},
-			payload: {
-				inboxItemId: item.id,
-				insightId: item.insightId,
-				notificationRevision: item.notificationRevision ?? 1
-			}
-		}
-	};
-}
 function workDiscoveryPlan(eventType, payload) {
 	if (!payload || typeof payload !== "object") return null;
 	const event = payload;
@@ -195,7 +160,6 @@ function notificationPlanFromGatewayEvent(type, payload) {
 	if (type === "agent.run.ended") return chatPlan(payload);
 	if (type === "task.attention_required.v2" || type === "task.phase_changed.v2") return taskPlan(payload);
 	if (type === "automation.run.completed") return automationPlan(payload);
-	if (type === "proactive.inbox.created") return proactivePlan(payload);
 	if (type === "work-discovery.completed" || type === "work-discovery.failed") return workDiscoveryPlan(type, payload);
 	return null;
 }

package/dist/src/notifications/quietHours.d.ts

@@ -0,0 +1,6 @@
+/** Resolves a local-hour quiet window on the UTC timeline, including DST gaps and repeated hours. */
+export declare function notificationQuietUntil(input: {
+    timezone: string;
+    quietStartHour: number;
+    quietEndHour: number;
+}, now: number): number | null;

package/dist/src/notifications/quietHours.js

@@ -0,0 +1,23 @@
+//#region src/notifications/quietHours.ts
+/** Resolves a local-hour quiet window on the UTC timeline, including DST gaps and repeated hours. */
+function notificationQuietUntil(input, now) {
+	if (!Number.isSafeInteger(now) || now < 0 || ![input.quietStartHour, input.quietEndHour].every((hour) => Number.isInteger(hour) && hour >= 0 && hour < 24)) throw new Error("Invalid quiet hours");
+	if (input.quietStartHour === input.quietEndHour) return null;
+	const formatter = new Intl.DateTimeFormat("en", {
+		timeZone: input.timezone,
+		hour: "2-digit",
+		hourCycle: "h23"
+	});
+	const quiet = (at) => {
+		const hour = Number(formatter.format(at));
+		return input.quietStartHour < input.quietEndHour ? hour >= input.quietStartHour && hour < input.quietEndHour : hour >= input.quietStartHour || hour < input.quietEndHour;
+	};
+	if (!quiet(now)) return null;
+	for (let minute = 1; minute <= 2880; minute++) {
+		const candidate = Math.floor(now / 6e4) * 6e4 + minute * 6e4;
+		if (!quiet(candidate)) return candidate;
+	}
+	throw new Error("Quiet hours did not resolve within two days");
+}
+//#endregion
+export { notificationQuietUntil };

package/dist/src/notifications/resultOutbox.d.ts

@@ -0,0 +1,23 @@
+import type { DatabaseSync } from 'node:sqlite';
+export interface NotificationResult {
+    id: string;
+    ownerId: string;
+    workspaceId: string;
+    subjectId: string;
+}
+export type PublicationDecision = ({
+    action: 'settle';
+} | {
+    action: 'defer';
+    until: number;
+}) & {
+    reason?: string;
+};
+/** Publishes only database work. Transport calls belong to NotificationDispatcher, outside this transaction. */
+export declare class NotificationResultOutbox {
+    private readonly db;
+    private readonly publish;
+    private readonly clock;
+    constructor(db: DatabaseSync, publish: (result: NotificationResult) => PublicationDecision, clock?: () => number);
+    drainOne(): boolean;
+}

package/dist/src/notifications/resultOutbox.js

@@ -0,0 +1,49 @@
+//#region src/notifications/resultOutbox.ts
+/** Publishes only database work. Transport calls belong to NotificationDispatcher, outside this transaction. */
+var NotificationResultOutbox = class {
+	constructor(db, publish, clock = Date.now) {
+		this.db = db;
+		this.publish = publish;
+		this.clock = clock;
+	}
+	drainOne() {
+		const now = this.clock();
+		this.db.exec("SAVEPOINT notification_result_publication");
+		let id;
+		let attempt = 0;
+		try {
+			const row = this.db.prepare(`SELECT * FROM notification_result_outbox
+        WHERE (status = 'pending' AND next_attempt_at <= ?)
+          OR (status = 'processing' AND (lease_until IS NULL OR lease_until <= ?))
+        ORDER BY next_attempt_at, id LIMIT 1`).get(now, now);
+			if (!row) {
+				this.db.exec("RELEASE notification_result_publication");
+				return false;
+			}
+			id = String(row.id);
+			attempt = Number(row.attempt);
+			this.db.prepare(`UPDATE notification_result_outbox SET status = 'processing', lease_until = ?, updated_at = ? WHERE id = ?`).run(now + 3e4, now, id);
+			const decision = this.publish({
+				id,
+				ownerId: String(row.owner_id),
+				workspaceId: String(row.workspace_id),
+				subjectId: String(row.subject_id)
+			});
+			if (!decision || !["settle", "defer"].includes(decision.action) || decision.reason !== void 0 && !/^[a-z][a-z0-9_]{0,79}$/.test(decision.reason) || decision.action === "defer" && (!Number.isSafeInteger(decision.until) || decision.until <= now)) throw new Error("Notification publication must return a synchronous decision");
+			this.db.prepare(`UPDATE notification_result_outbox SET status = ?, next_attempt_at = ?, lease_until = NULL,
+        last_error = NULL, decision_reason = ?, settled_at = ?, updated_at = ? WHERE id = ?`).run(decision.action === "settle" ? "settled" : "pending", decision.action === "defer" ? decision.until : now, decision.reason ?? null, decision.action === "settle" ? now : null, now, id);
+			this.db.exec("RELEASE notification_result_publication");
+			return true;
+		} catch (error) {
+			this.db.exec("ROLLBACK TO notification_result_publication");
+			this.db.exec("RELEASE notification_result_publication");
+			if (!id) throw error;
+			this.db.prepare(`UPDATE notification_result_outbox SET status = ?, attempt = attempt + 1, next_attempt_at = ?,
+        lease_until = NULL, last_error = 'publication_failed', updated_at = ?
+        WHERE id = ? AND attempt = ? AND (status = 'pending' OR (status = 'processing' AND (lease_until IS NULL OR lease_until <= ?)))`).run(attempt + 1 >= 5 ? "failed" : "pending", now + 3e4, now, id, attempt, now);
+			return true;
+		}
+	}
+};
+//#endregion
+export { NotificationResultOutbox };

package/dist/src/notifications/service.d.ts

@@ -1,5 +1,5 @@
-import { type ProactiveChannelSender } from './proactive-channel.js';
 import { type NotificationPlan } from './planner.js';
+import type { NotificationDomainDelivery } from './domain-delivery.js';
 import { sendHarmonyPush } from './harmony-push.js';
 export declare class NotificationService {
     private readonly options;
@@ -9,7 +9,7 @@ export declare class NotificationService {
     constructor(options: {
         publish: (type: string, payload: unknown) => void;
         fetch?: typeof fetch;
-        sendChannel?: ProactiveChannelSender;
+        domainDelivery?: NotificationDomainDelivery;
         sendHarmony?: typeof sendHarmonyPush;
     });
     start(): void;
@@ -19,7 +19,7 @@ export declare class NotificationService {
     persistGatewayEvent(type: string, payload: unknown): {
         schemaVersion: 1;
         id: string;
-        type: "work_discovery.completed" | "work_discovery.failed" | "chat.completed" | "chat.failed" | "task.needs_input" | "task.blocked" | "task.failed" | "task.completed" | "automation.completed" | "automation.failed" | "proactive.insight";
+        type: "work_discovery.completed" | "work_discovery.failed" | "scene.result" | "scene.digest" | "chat.completed" | "chat.failed" | "task.needs_input" | "task.blocked" | "task.failed" | "task.completed" | "automation.completed" | "automation.failed" | "proactive.insight";
         priority: "normal" | "high";
         title: {
             en: string;
@@ -28,6 +28,13 @@ export declare class NotificationService {
         payload: Record<string, unknown>;
         createdAt: number;
         target?: {
+            kind: "scene_result";
+            activationId: string;
+            presentationId: string;
+        } | {
+            kind: "scene_digest";
+            digestId: string;
+        } | {
             kind: "chat";
             conversationId: string;
         } | {
@@ -56,7 +63,7 @@ export declare class NotificationService {
     persistPlan(plan: NotificationPlan): {
         schemaVersion: 1;
         id: string;
-        type: "work_discovery.completed" | "work_discovery.failed" | "chat.completed" | "chat.failed" | "task.needs_input" | "task.blocked" | "task.failed" | "task.completed" | "automation.completed" | "automation.failed" | "proactive.insight";
+        type: "work_discovery.completed" | "work_discovery.failed" | "scene.result" | "scene.digest" | "chat.completed" | "chat.failed" | "task.needs_input" | "task.blocked" | "task.failed" | "task.completed" | "automation.completed" | "automation.failed" | "proactive.insight";
         priority: "normal" | "high";
         title: {
             en: string;
@@ -65,6 +72,13 @@ export declare class NotificationService {
         payload: Record<string, unknown>;
         createdAt: number;
         target?: {
+            kind: "scene_result";
+            activationId: string;
+            presentationId: string;
+        } | {
+            kind: "scene_digest";
+            digestId: string;
+        } | {
             kind: "chat";
             conversationId: string;
         } | {

package/dist/src/notifications/service.js

@@ -1,17 +1,12 @@
 import { createLogger } from "../utils/logger/index.js";
 import { init_logger } from "../utils/logger.js";
-import { getSqliteDatabase, init_transaction, runSqliteWriteTransaction } from "../storage/sqlite/transaction.js";
+import { init_transaction, runSqliteWriteTransaction } from "../storage/sqlite/transaction.js";
 import { localizeNotification } from "../../packages/gateway-contract/src/notifications.js";
 import { init_src } from "../../packages/gateway-contract/src/index.js";
 import { getOrCreateGatewayIdentity } from "../storage/sqlite/gateway-identity-repository.js";
-import { proactivePreferences } from "../proactive/policy/service.js";
-import { flushDueDigests } from "../proactive/inbox/digest.js";
+import { disableNotificationDeviceForPushToken, listDeliverableNotificationDevices } from "./device-store.js";
 import { notificationPlanFromGatewayEvent } from "./planner.js";
-import { proactiveNotificationWorkspace, recheckNotificationDelivery } from "./proactive-policy.js";
 import { createNotificationEvent, deferNotificationDelivery, expireUndeliverableNotificationDeliveries, listDueNotificationDeliveries, markNotificationDeliveryAccepted, markNotificationDeliveryDead, markNotificationDeliveryDelivered, pruneNotificationEvents, rescheduleNotificationDelivery } from "./store.js";
-import { drainChannelNotifications, enqueueChannelNotification } from "./proactive-channel.js";
-import { drainBrowserPush, enqueueBrowserPush } from "./web-push.js";
-import { disableNotificationDeviceForPushToken, listDeliverableNotificationDevices } from "./device-store.js";
 import { sendHarmonyPush } from "./harmony-push.js";
 //#region src/notifications/service.ts
 init_transaction();
@@ -29,20 +24,21 @@ const RETRY_DELAYS_MS = [
 	216e5
 ];
 const RECEIPT_DELAY_MS = 15 * 6e4;
+const STANDARD_PREFERENCES = {
+	"chat.completed": "chatCompleted",
+	"chat.failed": "chatFailed",
+	"task.needs_input": "taskNeedsInput",
+	"task.blocked": "taskBlocked",
+	"task.failed": "taskFailed",
+	"task.completed": "taskCompleted",
+	"automation.completed": "automationCompleted",
+	"automation.failed": "automationFailed",
+	"work_discovery.completed": true,
+	"work_discovery.failed": true
+};
 function preferenceAllows(type, preferences) {
-	switch (type) {
-		case "chat.completed": return preferences.chatCompleted;
-		case "chat.failed": return preferences.chatFailed;
-		case "task.needs_input": return preferences.taskNeedsInput;
-		case "task.blocked": return preferences.taskBlocked;
-		case "task.failed": return preferences.taskFailed;
-		case "task.completed": return preferences.taskCompleted;
-		case "automation.completed": return preferences.automationCompleted;
-		case "automation.failed": return preferences.automationFailed;
-		case "proactive.insight": return preferences.proactiveInsight;
-		case "work_discovery.completed":
-		case "work_discovery.failed": return true;
-	}
+	const key = STANDARD_PREFERENCES[type];
+	return key === true || key !== void 0 && preferences[key];
 }
 function retryAt(attempts, now) {
 	return now + RETRY_DELAYS_MS[Math.min(attempts, RETRY_DELAYS_MS.length - 1)];
@@ -82,44 +78,21 @@ var NotificationService = class {
 	}
 	/** Throws on persistence failure so durable producers can retry the handoff. */
 	persistGatewayEvent(type, payload) {
-		const plan = notificationPlanFromGatewayEvent(type, payload);
+		const plan = notificationPlanFromGatewayEvent(type, payload) ?? this.options.domainDelivery?.planEvent(type, payload);
 		if (!plan) return null;
 		return this.persistPlan(plan);
 	}
 	persistPlan(plan) {
-		let devices = listDeliverableNotificationDevices().filter((device) => preferenceAllows(plan.notification.type, device.preferences));
-		const workspace = proactiveNotificationWorkspace(plan.notification);
-		let browserIds;
-		let selectedChannel = "all";
-		if (workspace) {
-			const preferences = proactivePreferences(workspace);
-			const browsers = getSqliteDatabase().prepare("SELECT id FROM proactive_web_push_subscriptions WHERE workspace_id = ? ORDER BY created_at DESC, id").all(workspace);
-			selectedChannel = preferences.preferredChannel === "auto" ? browsers.length ? "browser" : devices.length ? "mobile" : "browser" : preferences.preferredChannel;
-			if (!["all", "mobile"].includes(selectedChannel)) devices = [];
-			else if (preferences.preferredChannel === "auto") devices = devices.slice(0, 1);
-			browserIds = ["all", "browser"].includes(selectedChannel) ? browsers.map((row) => row.id) : [];
-			if (preferences.preferredChannel === "auto") browserIds = browserIds.slice(0, 1);
-			plan = {
-				...plan,
-				notification: {
-					...plan.notification,
-					payload: {
-						...plan.notification.payload,
-						deliveryChannel: selectedChannel,
-						deliveryMode: preferences.preferredChannel
-					}
-				}
-			};
-		}
+		const domain = this.options.domainDelivery?.owns(plan.notification.type) ? this.options.domainDelivery : void 0;
+		if (!domain && !Object.hasOwn(STANDARD_PREFERENCES, plan.notification.type)) throw new Error("Notification domain delivery is not installed");
+		const devices = listDeliverableNotificationDevices().filter((device) => domain ? domain.allowsDevice(device.preferences) : preferenceAllows(plan.notification.type, device.preferences));
 		const result = runSqliteWriteTransaction(() => {
+			const selection = domain?.prepare(plan, devices);
 			const created = createNotificationEvent({
-				...plan,
-				deviceIds: devices.map((device) => device.id)
+				...selection?.plan ?? plan,
+				deviceIds: selection?.deviceIds ?? devices.map((device) => device.id)
 			});
-			if (created.created) {
-				enqueueBrowserPush(created.notification, browserIds);
-				if (workspace && selectedChannel === "telegram") enqueueChannelNotification(created.notification, workspace);
-			}
+			if (created.created) selection?.enqueue(created.notification);
 			return created;
 		});
 		return result.created ? result.notification : null;
@@ -134,11 +107,10 @@ var NotificationService = class {
 				pruneNotificationEvents(now - 720 * 60 * 60 * 1e3);
 				this.lastMaintenanceAt = now;
 			}
-			for (const notification of flushDueDigests((plan) => this.persistPlan(plan))) this.options.publish("notification.created", notification);
+			for (const notification of this.options.domainDelivery?.flush((plan) => this.persistPlan(plan)) ?? []) this.options.publish("notification.created", notification);
 			await this.deliverPending();
 			await this.checkReceipts();
-			await drainBrowserPush();
-			if (this.options.sendChannel) await drainChannelNotifications(this.options.sendChannel);
+			await this.options.domainDelivery?.drain();
 		} catch (err) {
 			log.warn({ err }, "Notification delivery pass failed");
 		} finally {
@@ -150,10 +122,15 @@ var NotificationService = class {
 		await Promise.all(deliveries.map((delivery) => this.send(delivery)));
 	}
 	async send(delivery) {
-		if (delivery.event.type === "proactive.insight") {
-			const policy = recheckNotificationDelivery(delivery.event, "mobile");
+		const domain = this.options.domainDelivery?.owns(delivery.event.type) ? this.options.domainDelivery : void 0;
+		if (!domain && !Object.hasOwn(STANDARD_PREFERENCES, delivery.event.type)) {
+			markNotificationDeliveryDead(delivery.event.id, delivery.deviceId, "Notification domain delivery is not installed");
+			return;
+		}
+		if (domain) {
+			const policy = domain.recheckMobile(delivery.event);
 			if (policy === "cancel") {
-				markNotificationDeliveryDead(delivery.event.id, delivery.deviceId, "Proactive policy changed");
+				markNotificationDeliveryDead(delivery.event.id, delivery.deviceId, "Notification policy changed");
 				return;
 			}
 			if (policy instanceof Date) {
@@ -163,6 +140,10 @@ var NotificationService = class {
 		}
 		const fetchImpl = this.options.fetch ?? fetch;
 		const localized = localizeNotification(delivery.event, delivery.locale);
+		const preview = domain?.mobilePreview(delivery.event, delivery.locale) ?? {
+			title: localized.localizedTitle,
+			body: localized.localizedBody
+		};
 		try {
 			if (delivery.platform === "harmonyos") {
 				const ticket = await (this.options.sendHarmony ?? sendHarmonyPush)({
@@ -170,8 +151,8 @@ var NotificationService = class {
 					eventId: delivery.event.id,
 					gatewayId: getOrCreateGatewayIdentity().id,
 					target: delivery.event.target,
-					title: delivery.event.type === "proactive.insight" ? delivery.locale === "zh" ? "有一项工作需要查看" : "A work update is ready" : localized.localizedTitle,
-					body: delivery.event.type === "proactive.insight" ? delivery.locale === "zh" ? "打开 xopc 查看详情。" : "Open xopc to review it." : localized.localizedBody
+					title: preview.title,
+					body: preview.body
 				}, fetchImpl);
 				markNotificationDeliveryAccepted(delivery.event.id, delivery.deviceId, ticket, Number.MAX_SAFE_INTEGER);
 				return;
@@ -185,8 +166,8 @@ var NotificationService = class {
 				signal: AbortSignal.timeout(1e4),
 				body: JSON.stringify({
 					to: delivery.pushToken,
-					title: delivery.event.type === "proactive.insight" ? delivery.locale.startsWith("zh") ? "有一项工作需要查看" : "A work update is ready" : localized.localizedTitle,
-					body: delivery.event.type === "proactive.insight" ? delivery.locale.startsWith("zh") ? "打开 xopc 查看详情。" : "Open xopc to review it." : localized.localizedBody,
+					title: preview.title,
+					body: preview.body,
 					sound: delivery.event.priority === "high" ? "default" : void 0,
 					priority: delivery.event.priority,
 					data: {

package/dist/src/notifications/store.d.ts

@@ -1,3 +1,4 @@
+import type { DatabaseSync } from 'node:sqlite';
 import { type ProductNotification } from '@xopcai/gateway-contract';
 import type { NotificationDevicePlatform } from './types.js';
 export type NotificationDelivery = {
@@ -14,7 +15,7 @@ export declare function createNotificationEvent(input: {
     notification: Omit<ProductNotification, 'id' | 'createdAt' | 'schemaVersion'>;
     deviceIds: string[];
     createdAt?: number;
-}): {
+}, db?: DatabaseSync): {
     notification: ProductNotification;
     created: boolean;
 };

package/dist/src/notifications/store.js

@@ -1,4 +1,4 @@
-import { getSqliteDatabase, init_transaction, runSqliteWriteTransaction } from "../storage/sqlite/transaction.js";
+import { getSqliteDatabase, init_transaction, runSqliteSavepoint, runSqliteWriteTransaction } from "../storage/sqlite/transaction.js";
 import { ProductNotificationSchema } from "../../packages/gateway-contract/src/notifications.js";
 import { init_src } from "../../packages/gateway-contract/src/index.js";
 import { randomUUID } from "node:crypto";
@@ -42,10 +42,10 @@ function deliveryFromRow(row) {
 		...row.provider_ticket_id ? { providerTicketId: row.provider_ticket_id } : {}
 	};
 }
-function createNotificationEvent(input) {
+function createNotificationEvent(input, db = getSqliteDatabase()) {
 	const id = randomUUID();
 	const createdAt = input.createdAt ?? Date.now();
-	const created = runSqliteWriteTransaction((db) => {
+	return runSqliteSavepoint(db, () => {
 		const inserted = db.prepare(`INSERT OR IGNORE INTO notification_events (
         event_id, dedupe_key, event_type, target_json, priority,
         title_en, title_zh, body_en, body_zh, payload_json, created_at
@@ -56,12 +56,11 @@ function createNotificationEvent(input) {
         ) VALUES (?, ?, 'pending', ?, ?)`);
 			for (const deviceId of input.deviceIds) enqueue.run(id, deviceId, createdAt, createdAt);
 		}
-		return inserted;
+		return {
+			notification: eventFromRow(db.prepare("SELECT * FROM notification_events WHERE dedupe_key = ?").get(input.dedupeKey)),
+			created: inserted
+		};
 	});
-	return {
-		notification: eventFromRow(getSqliteDatabase().prepare("SELECT * FROM notification_events WHERE dedupe_key = ?").get(input.dedupeKey)),
-		created
-	};
 }
 function listNotificationEvents(options = {}) {
 	const limit = Math.max(1, Math.min(100, options.limit ?? 50));

package/dist/src/projects/project-service.d.ts

@@ -1,4 +1,3 @@
-import type { ProactiveSignalPublisher } from '../proactive/events/publisher.js';
 import { ProjectStore } from './project-store.js';
 import type { CreateProjectInput, Project, ProjectHealth, ProjectListQuery, ProjectListResult, ProjectMilestone, ProjectUpdate, ProjectWithDetails, SidebarProjectListQuery, UpdateProjectInput } from './types.js';
 import { type WorkspaceProjectMatch } from './workspace-project.js';
@@ -10,9 +9,7 @@ export type ProjectSuggestion = {
 };
 export declare class ProjectService {
     private readonly store;
-    private readonly signals?;
-    private readonly workspaceId;
-    constructor(store?: ProjectStore, signals?: ProactiveSignalPublisher, workspaceId?: string);
+    constructor(store?: ProjectStore);
     private listAllProjects;
     create(input: CreateProjectInput): Project;
     get(id: string): Project | null;

package/dist/src/projects/project-service.js

@@ -1,19 +1,16 @@
 import { init_transaction, runSqliteWriteTransaction } from "../storage/sqlite/transaction.js";
-import { getSessionMetadata } from "../storage/sqlite/session-repository.js";
+import { getSessionMetadata } from "../storage/sqlite/session-read-repository.js";
 import "../storage/sqlite/index.js";
 import { changedFieldsFromPatch, emitActivity, systemActivityActor, systemActivitySource } from "../activity/emitter.js";
 import { ProjectStore } from "./project-store.js";
 import { ProjectWorkspaceConflictError, ProjectWorkspaceMissingError, canonicalWorkspacePath, ensureWorkspaceDirectory, inferProjectNameFromWorkspaceRoot, isPathSameOrInsideWorkspace, isSafeAutoCreateWorkspaceRoot, resolveWorkspaceProjectRoot, workspaceDirectoryExists } from "./workspace-project.js";
 import { inferProjectExecutionMode } from "./project-kind.js";
 import { bindSessionToProject, listProjectConversationIds, unbindSessionFromProject } from "./session-bind.js";
-import { createHash } from "node:crypto";
 //#region src/projects/project-service.ts
 init_transaction();
 var ProjectService = class {
-	constructor(store = new ProjectStore(), signals, workspaceId = "default") {
+	constructor(store = new ProjectStore()) {
 		this.store = store;
-		this.signals = signals;
-		this.workspaceId = workspaceId;
 	}
 	listAllProjects() {
 		const items = [];
@@ -188,31 +185,6 @@ var ProjectService = class {
 				}],
 				nowMs: project.updatedAt
 			});
-			this.signals?.publish({
-				type: "project.updated.v1",
-				schemaVersion: 1,
-				source: {
-					kind: "projects",
-					id: "local"
-				},
-				subject: {
-					kind: "project",
-					id: project.id
-				},
-				actor: { kind: "system" },
-				scope: {
-					workspaceId: this.workspaceId,
-					projectId: project.id
-				},
-				occurredAt: new Date(project.updatedAt).toISOString(),
-				dedupeKey: `project:${project.id}:${project.updatedAt}:${createHash("sha256").update(JSON.stringify(patch)).digest("hex")}`,
-				sensitivity: "personal",
-				payload: {
-					before,
-					after: project,
-					changes
-				}
-			});
 			return project;
 		});
 	}

package/dist/src/projects/workspace.js

@@ -1,5 +1,5 @@
 import { isXopcDatabaseOpen } from "../storage/sqlite/connection.js";
-import { getSessionMetadata } from "../storage/sqlite/session-repository.js";
+import { getSessionMetadata } from "../storage/sqlite/session-read-repository.js";
 import "../storage/sqlite/index.js";
 import { resolveEffectiveAgentProfileForSession } from "../config/agent-profile.js";
 import { projectWorkspacePath } from "../session/session-workspace.js";