@xopcai/xopc 0.0.267 → 0.0.269

package/dist/src/gateway/hono/routes/models.js

@@ -1,5 +1,5 @@
-import { init_resolve_config_value, testApiKeyResolution } from "../../../config/resolve-config-value.js";
 import { resolveModelsJsonPath } from "../../../config/paths.js";
+import { init_resolve_config_value, testApiKeyResolution } from "../../../config/resolve-config-value.js";
 import { init_models_json, loadModelsJson, saveModelsJson, validateModelsConfig } from "../../../config/models-json.js";
 import { getModelCatalogStore, init_model_catalog_store } from "../../../providers/model-catalog-store.js";
 import { getModelRegistry } from "../../../providers/model-registry.js";

package/dist/src/gateway/hono/routes/proactive-control.d.ts

@@ -0,0 +1,3 @@
+import type { Hono } from 'hono';
+import type { AuthenticatedRouteDeps } from './deps.js';
+export declare function registerProactiveControlRoutes(app: Hono, deps: AuthenticatedRouteDeps): void;

package/dist/src/gateway/hono/routes/proactive-control.js

@@ -0,0 +1,161 @@
+import { getSqliteDatabase } from "../../../storage/sqlite/transaction.js";
+import { getDefaultAgentId, init_resolve_route } from "../../../routing/resolve-route.js";
+import { resolveProjectAgentId } from "../../../projects/project-agent.js";
+import "../../../projects/index.js";
+import { ProactiveConflict, proactivePreferences, updateProactivePreferences } from "../../../proactive/policy/service.js";
+import { recordProactivePresence } from "../../../proactive/policy/presence.js";
+import { controlledSubscriptions, createControlledSubscription, requireSubscription, templateCatalog, updateControlledSubscription } from "../../../proactive/scenarios/control.js";
+import { cardChanges, getCard, listCards, performCardAction } from "../../../proactive/inbox/cards.js";
+import { digestCards } from "../../../proactive/inbox/digest.js";
+import { acknowledgeBrowserProbe, listBrowserProbes, prepareBrowserPush, registerBrowserPush, testBrowserPush, unregisterBrowserPush } from "../../../notifications/web-push.js";
+import { ReadonlyProactiveAgentExecutor } from "../../../proactive/execution/agent-executor.js";
+import { proactiveMetrics } from "../../../proactive/metrics.js";
+import { prepareCardWorkflow, workflowForCard } from "../../../proactive/actions/workflow.js";
+import { previewSubscription } from "../../../proactive/scenarios/preview.js";
+import { ZodError } from "zod";
+//#region src/gateway/hono/routes/proactive-control.ts
+init_resolve_route();
+function registerProactiveControlRoutes(app, deps) {
+	app.onError((error, c) => c.json({
+		ok: false,
+		error: error instanceof ZodError ? "Invalid request" : error.message
+	}, error instanceof ProactiveConflict ? 409 : 400));
+	const workspace = () => deps.service.currentWorkspacePath;
+	for (const path of ["/api/proactive/*", "/api/inbox/judgments/*"]) app.use(path, async (c, next) => {
+		try {
+			const id = c.req.path.match(/^\/api\/inbox\/judgments\/([^/]+)/)?.[1];
+			if (id && id !== "changes") getCard(decodeURIComponent(id), workspace());
+			await next();
+		} catch (error) {
+			return c.json({
+				ok: false,
+				error: error instanceof ZodError ? "Invalid request" : error instanceof Error ? error.message : "Request failed"
+			}, error instanceof ProactiveConflict ? 409 : 400);
+		}
+	});
+	app.get("/api/proactive/web-push/probes", (c) => c.json({
+		ok: true,
+		probes: listBrowserProbes(workspace())
+	}));
+	app.post("/api/proactive/web-push/subscriptions/:id/test", deps.strictRateLimitMiddleware, async (c) => c.json({
+		ok: true,
+		...await testBrowserPush(workspace(), c.req.param("id"))
+	}));
+	app.post("/api/proactive/web-push/probes/:id/opened", deps.strictRateLimitMiddleware, (c) => {
+		acknowledgeBrowserProbe(workspace(), c.req.param("id"));
+		return c.json({ ok: true });
+	});
+	app.post("/api/proactive/web-push/prepare", deps.strictRateLimitMiddleware, (c) => c.json({
+		ok: true,
+		...prepareBrowserPush()
+	}));
+	app.post("/api/proactive/web-push/subscriptions", deps.strictRateLimitMiddleware, async (c) => c.json({
+		ok: true,
+		...registerBrowserPush(workspace(), await c.req.json())
+	}, 201));
+	app.delete("/api/proactive/web-push/subscriptions/:id", deps.strictRateLimitMiddleware, (c) => {
+		unregisterBrowserPush(workspace(), c.req.param("id"));
+		return c.json({ ok: true });
+	});
+	app.get("/api/inbox/judgments/:itemId/workflow", async (c) => c.json({
+		ok: true,
+		workflow: await workflowForCard(c.req.param("itemId"), workspace(), deps.service.createWorkflowRunService())
+	}));
+	app.post("/api/inbox/judgments/:itemId/prepare", deps.strictRateLimitMiddleware, async (c) => {
+		const card = getCard(c.req.param("itemId"), workspace());
+		const sub = requireSubscription(card.subscriptionId, workspace());
+		const config = deps.service.currentConfig;
+		const agentId = sub.scopeKind === "project" ? resolveProjectAgentId({
+			config,
+			projects: deps.service.projects,
+			projectId: sub.scopeId
+		}) : getDefaultAgentId(config);
+		return c.json({
+			ok: true,
+			workflow: await prepareCardWorkflow(workspace(), card.id, await c.req.json(), agentId, deps.service.createWorkflowRunService())
+		}, 202);
+	});
+	app.post("/api/proactive/presence", deps.strictRateLimitMiddleware, async (c) => {
+		recordProactivePresence(workspace(), await c.req.json());
+		return c.json({ ok: true });
+	});
+	app.get("/api/proactive/metrics", (c) => c.json({
+		ok: true,
+		metrics: proactiveMetrics(workspace())
+	}));
+	app.get("/api/proactive/digests/:id", (c) => c.json({
+		ok: true,
+		cards: digestCards(c.req.param("id"), workspace())
+	}));
+	app.post("/api/proactive/subscriptions/:id/preview", deps.strictRateLimitMiddleware, async (c) => c.json({
+		ok: true,
+		...await previewSubscription(workspace(), c.req.param("id"), new ReadonlyProactiveAgentExecutor(() => deps.service.getConfig()), c.req.raw.signal)
+	}));
+	app.get("/api/proactive/templates", (c) => c.json({
+		ok: true,
+		templates: templateCatalog(workspace())
+	}));
+	app.get("/api/proactive/preferences", (c) => c.json({
+		ok: true,
+		preferences: proactivePreferences(workspace())
+	}));
+	app.patch("/api/proactive/preferences", deps.strictRateLimitMiddleware, async (c) => c.json({
+		ok: true,
+		preferences: updateProactivePreferences(workspace(), await c.req.json())
+	}));
+	app.get("/api/proactive/subscriptions", (c) => c.json({
+		ok: true,
+		subscriptions: controlledSubscriptions(workspace())
+	}));
+	app.post("/api/proactive/subscriptions", deps.strictRateLimitMiddleware, async (c) => c.json({
+		ok: true,
+		subscription: createControlledSubscription(workspace(), await c.req.json())
+	}, 201));
+	app.patch("/api/proactive/subscriptions/:id", deps.strictRateLimitMiddleware, async (c) => c.json({
+		ok: true,
+		subscription: updateControlledSubscription(workspace(), c.req.param("id"), await c.req.json())
+	}));
+	app.get("/api/proactive/subscriptions/:id/runs", (c) => {
+		requireSubscription(c.req.param("id"), workspace());
+		return c.json({
+			ok: true,
+			runs: getSqliteDatabase().prepare(`SELECT run_id AS id, status, outcome_reason AS reason,
+      started_at AS startedAt, completed_at AS completedAt, error_message AS error FROM proactive_runs WHERE subscription_id = ? ORDER BY started_at DESC LIMIT 30`).all(c.req.param("id"))
+		});
+	});
+	app.get("/api/proactive/cards", (c) => c.json({
+		ok: true,
+		...listCards(workspace(), {
+			status: c.req.query("status"),
+			before: c.req.query("before")
+		})
+	}));
+	app.get("/api/inbox/judgments/changes", (c) => {
+		const cursor = Number(c.req.query("cursor") ?? 0);
+		if (!Number.isSafeInteger(cursor) || cursor < 0) return c.json({
+			ok: false,
+			error: "Invalid cursor"
+		}, 400);
+		return c.json({
+			ok: true,
+			...cardChanges(workspace(), cursor)
+		});
+	});
+	app.get("/api/inbox/judgments/:itemId", (c) => c.json({
+		ok: true,
+		card: getCard(c.req.param("itemId"), workspace())
+	}));
+	app.post("/api/inbox/judgments/:itemId/actions", deps.strictRateLimitMiddleware, async (c) => {
+		const card = performCardAction(c.req.param("itemId"), workspace(), await c.req.json());
+		deps.service.emit("proactive.card.changed", {
+			cardId: card.id,
+			revision: card.revision
+		});
+		return c.json({
+			ok: true,
+			card
+		});
+	});
+}
+//#endregion
+export { registerProactiveControlRoutes };

package/dist/src/gateway/hono/routes/proactive.d.ts

@@ -1,4 +1,4 @@
 import type { Hono } from 'hono';
 import type { AuthenticatedRouteDeps } from './deps.js';
-/** User-facing judgment inbox plus internal diagnostics. There is intentionally no proactive control-panel API. */
+/** Proactive controls, cards and internal diagnostics. */
 export declare function registerProactiveRoutes(authenticated: Hono, deps: AuthenticatedRouteDeps): void;

package/dist/src/gateway/hono/routes/proactive.js

@@ -1,10 +1,14 @@
+import { getInboxItem } from "../../../proactive/inbox/repository.js";
+import { listCards } from "../../../proactive/inbox/cards.js";
+import { registerProactiveControlRoutes } from "./proactive-control.js";
 //#region src/gateway/hono/routes/proactive.ts
 function positiveInt(value, fallback) {
 	const parsed = Number(value);
 	return Number.isInteger(parsed) && parsed > 0 ? parsed : fallback;
 }
-/** User-facing judgment inbox plus internal diagnostics. There is intentionally no proactive control-panel API. */
+/** Proactive controls, cards and internal diagnostics. */
 function registerProactiveRoutes(authenticated, deps) {
+	registerProactiveControlRoutes(authenticated, deps);
 	authenticated.get("/api/inbox/judgments", (c) => {
 		const status = c.req.query("status");
 		if (status && ![
@@ -16,12 +20,15 @@ function registerProactiveRoutes(authenticated, deps) {
 			ok: false,
 			error: "Invalid inbox status"
 		}, 400);
+		const page = listCards(deps.service.currentWorkspacePath, {
+			status,
+			limit: positiveInt(c.req.query("limit"), 50),
+			before: c.req.query("before")
+		});
 		return c.json({
 			ok: true,
-			items: deps.service.proactiveInbox.list({
-				...status ? { status } : {},
-				limit: positiveInt(c.req.query("limit"), 50)
-			})
+			...page,
+			items: page.cards.map((card) => getInboxItem(card.id))
 		});
 	});
 	authenticated.post("/api/inbox/judgments/:itemId/transition", deps.strictRateLimitMiddleware, async (c) => {

package/dist/src/gateway/hono/routes/voice.js

@@ -256,7 +256,7 @@ function registerVoiceRoutes(authenticated, deps) {
 			}
 		}, 400);
 		const principal = getGatewayPrincipal(c);
-		service.voiceRealtime.cancelSession(parsed.data.sessionId, parsed.data.ticket, principal.principalId);
+		await service.voiceRealtime.cancelSession(parsed.data.sessionId, parsed.data.ticket, principal.principalId);
 		return c.json({ ok: true });
 	});
 	authenticated.post("/api/voice/language", strictRateLimitMiddleware, async (c) => {

package/dist/src/gateway/security/gateway-scopes.js

@@ -63,6 +63,11 @@ function requiredGatewayScope(method, path) {
 	if (path.startsWith("/api/agents") || path.startsWith("/api/models")) return methodScope(method, "agents.read", "gateway.admin");
 	if (path.startsWith("/api/sessions") || path.startsWith("/api/side-chats")) return methodScope(method, "sessions.read", "sessions.write");
 	if (path.startsWith("/api/tasks")) return methodScope(method, "tasks.read", "tasks.write");
+	if (method === "POST" && /^\/api\/proactive\/subscriptions\/[^/]+\/preview$/.test(path)) return "agents.run";
+	if (/^\/api\/inbox\/judgments\/[^/]+\/workflow$/.test(path)) return methodScope(method, "automations.read", "automations.write");
+	if (method === "POST" && /^\/api\/inbox\/judgments\/[^/]+\/prepare$/.test(path)) return "automations.write";
+	if (path.startsWith("/api/proactive/web-push")) return "notifications.self";
+	if (path === "/api/proactive" || path.startsWith("/api/proactive/")) return methodScope(method, "tasks.read", "tasks.write");
 	if (path.startsWith("/api/home") || path.startsWith("/api/inbox")) return methodScope(method, "tasks.read", "tasks.write");
 	if (path.startsWith("/api/automations") || path.startsWith("/api/automation-runs")) return methodScope(method, "automations.read", "automations.write");
 	if (path.startsWith("/api/workflows")) return methodScope(method, "automations.read", "automations.write");

package/dist/src/gateway/service/config-coordinator.js

@@ -1,7 +1,7 @@
 import { createLogger } from "../../utils/logger/index.js";
 import { init_logger } from "../../utils/logger.js";
-import { getModelRegistry } from "../../providers/model-registry.js";
 import { loadConfig, saveConfig } from "../../config/loader.js";
+import { getModelRegistry } from "../../providers/model-registry.js";
 import { init_providers } from "../../providers/index.js";
 import { disposeAllSessionMcpRuntimes } from "../../agent/mcp/bundle-mcp-runtime.js";
 import { reloadImageGenerationProviders } from "../../agent/image/generation/provider-registry.js";

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

@@ -179,7 +179,6 @@ export declare class GatewayService {
     private schedulePostReadySidecars;
     private runPostReadySidecars;
     start(): Promise<void>;
-    private ensureDefaultProactiveScenarioSubscriptions;
     /** Called when the HTTP listener is bound (before deferred channel work). */
     markHttpListening(): void;
     isGatewayReady(): boolean;

package/dist/src/gateway/service.js

@@ -12,16 +12,16 @@ import { getSessionConfig } from "../storage/sqlite/config-repository.js";
 import "../storage/sqlite/index.js";
 import { getAgentDefaultModelRef, init_schema } from "../config/schema.js";
 import { init_agent_scope, listAgentEntries, normalizeAgentId, resolveAgentWorkspaceDir, resolveDefaultAgentId } from "../agent/agent-scope.js";
+import { buildSessionKey, init_session_key, sanitizeSegment } from "../routing/session-key.js";
+import { getDefaultAgentId, init_resolve_route } from "../routing/resolve-route.js";
+import { resolveEffectiveAgentProfileForSession } from "../config/agent-profile.js";
 import { init_paths, resolveConfigPath, resolveExtensionsDir } from "../config/paths.js";
-import { prewarmModelRegistry } from "../providers/model-registry.js";
 import { areExtensionsGloballyDisabled } from "../extensions/discover-extensions.js";
 import { buildExtensionMetadataSnapshot } from "../extensions/extension-metadata-snapshot.js";
 import { buildChannelCatalogForConfig, buildChannelCatalogFromSnapshot, init_channel_catalog_service } from "../channels/catalog/channel-catalog-service.js";
 import { loadConfig, saveConfig } from "../config/loader.js";
-import { buildSessionKey, init_session_key, sanitizeSegment } from "../routing/session-key.js";
-import { getDefaultAgentId, init_resolve_route } from "../routing/resolve-route.js";
+import { prewarmModelRegistry } from "../providers/model-registry.js";
 import { init_providers, providers_exports } from "../providers/index.js";
-import { resolveEffectiveAgentProfileForSession } from "../config/agent-profile.js";
 import { TaskRepository } from "../tasks/task-repository.js";
 import { TaskConversationRepository } from "../tasks/task-conversation-repository.js";
 import { getEmbeddedExecutionSession } from "../agent/embedded/execution-context.js";
@@ -54,6 +54,12 @@ import { registerClarificationChannelRuntime } from "./clarify-runtime.js";
 import { ChannelManager } from "../channels/manager.js";
 import { getWorkspacePath } from "../config/workspace-path-helpers.js";
 import "../config/index.js";
+import { DiscussionService } from "../discussions/service.js";
+import { DiscussionOrganizer } from "../discussions/organizer.js";
+import { DiscussionLiveWorker } from "../discussions/live-worker.js";
+import { DiscussionOrganizerWorker } from "../discussions/organizer-worker.js";
+import { DiscussionSealer } from "../discussions/sealer.js";
+import "../discussions/index.js";
 import { ManagedComposioEventPoller } from "../connectors/composio-managed-events.js";
 import { startConnectedKnowledgeCoordinator } from "../knowledge/coordinator.js";
 import "../knowledge/index.js";
@@ -61,17 +67,13 @@ import { ConnectionRecoveryService } from "../connectors/connection-recovery-ser
 import { startConnectorLearningCoordinator } from "../connectors/learning-coordinator.js";
 import { ConnectedSourceChangePublisher } from "../connectors/source-change-publisher.js";
 import { startConnectorSupervisor } from "../connectors/supervisor.js";
-import { DiscussionService } from "../discussions/service.js";
-import { DiscussionOrganizer } from "../discussions/organizer.js";
-import { DiscussionLiveWorker } from "../discussions/live-worker.js";
-import { DiscussionOrganizerWorker } from "../discussions/organizer-worker.js";
-import { DiscussionSealer } from "../discussions/sealer.js";
-import "../discussions/index.js";
 import { EndpointToolRuntime } from "../endpoint-tools/runtime.js";
 import "../endpoint-tools/index.js";
 import { assertGatewayAuthConfigured, extractToken, resolveGatewayAuth, validateToken } from "./auth.js";
 import { prepareAutomationAgentSession } from "./automation-agent-session.js";
 import { stopTailscaleExposure } from "./tailscale-lifecycle.js";
+import { ProactiveInboxService } from "../proactive/inbox/service.js";
+import { deliverProactiveCard } from "../proactive/inbox/delivery.js";
 import { buildVoiceMemoryContext } from "../voice/realtime/memory-context.js";
 import { buildVoicePersonaContext } from "../voice/realtime/persona-context.js";
 import { voiceMemoryBudget, voicePersonaBudget } from "../voice/realtime/conversation-context.js";
@@ -111,7 +113,6 @@ import { ReadonlyProactiveAgentExecutor } from "../proactive/execution/agent-exe
 import { listInsights } from "../proactive/execution/repository.js";
 import { ProactiveWorker } from "../proactive/execution/worker.js";
 import { ProactiveTemporalWorker } from "../proactive/temporal/worker.js";
-import { ProactiveInboxService } from "../proactive/inbox/service.js";
 import { ProactiveInboxWorker } from "../proactive/inbox/worker.js";
 import "../proactive/index.js";
 import { scheduleGatewayUpdateCheck } from "../infra/update-startup.js";
@@ -317,7 +318,7 @@ var GatewayService = class {
 		this.proactiveWorker = new ProactiveWorker(new ReadonlyProactiveAgentExecutor(() => this.config));
 		this.proactiveTemporalWorker = new ProactiveTemporalWorker(this.proactive);
 		this.proactiveInboxWorker = new ProactiveInboxWorker({ deliver: async ({ inboxItem }) => {
-			this.emit("proactive.inbox.created", inboxItem);
+			return deliverProactiveCard(inboxItem, this.createNotificationService(), (type, payload) => this.realtime.broker.publish("gateway", type, payload));
 		} });
 		let bootstrapConfigChanged = initializeVoiceDefaults(this.config, inferProductLanguageFromEnvironment());
 		const starterResult = ensureStarterAgentsInitialized(this.config);
@@ -680,7 +681,21 @@ var GatewayService = class {
 		return this.taskRunDispatcher;
 	}
 	createNotificationService() {
-		if (!this.notificationService) this.notificationService = new NotificationService({ publish: (type, payload) => this.realtime.broker.publish("gateway", type, payload) });
+		if (!this.notificationService) this.notificationService = new NotificationService({
+			publish: (type, payload) => this.realtime.broker.publish("gateway", type, payload),
+			sendChannel: async (target, text) => {
+				const outbound = this.channelManager.getPlugin("telegram")?.outbound;
+				if (!outbound?.sendText || !this.channelManager.getRunningChannels().includes("telegram")) throw new Error("Telegram is not connected");
+				const result = await outbound.sendText({
+					cfg: this.config,
+					to: target.chatId,
+					accountId: target.accountId,
+					text
+				});
+				if (!result.success) throw new Error("Telegram delivery failed");
+				return { messageId: result.messageId };
+			}
+		});
 		return this.notificationService;
 	}
 	dispatchTaskRuns() {
@@ -921,7 +936,6 @@ var GatewayService = class {
 		this.running = true;
 		this.taskRunDispatchTimer = setInterval(() => this.dispatchTaskRuns(), 1e3);
 		this.taskRunDispatchTimer.unref?.();
-		this.ensureDefaultProactiveScenarioSubscriptions();
 		this.proactiveWorker.start();
 		this.proactiveTemporalWorker.start();
 		this.proactiveInboxWorker.start();
@@ -1115,22 +1129,6 @@ var GatewayService = class {
 		else trace.mark("service.started-awaiting-http");
 		log.debug("Gateway service started");
 	}
-	ensureDefaultProactiveScenarioSubscriptions() {
-		for (const scenarioKey of [
-			"automation_failure_impact",
-			"meeting_preparation",
-			"discussion_follow_up"
-		]) {
-			if (this.proactiveScenarios.subscriptions(scenarioKey).some((subscription) => subscription.workspaceId === this.currentWorkspacePath)) continue;
-			this.proactiveScenarios.subscribe({
-				scenarioKey,
-				workspaceId: this.currentWorkspacePath,
-				scopeKind: "workspace",
-				scopeId: this.currentWorkspacePath,
-				enabled: true
-			});
-		}
-	}
 	/** Called when the HTTP listener is bound (before deferred channel work). */
 	markHttpListening() {
 		this.readiness.markHttpListening();

package/dist/src/heartbeat/index.js

@@ -1,6 +1,6 @@
 import { DEFAULT_ACK_MAX_CHARS, HEARTBEAT_OK, NO_REPLY, shouldSilence, stripHeartbeatToken } from "./tokens.js";
-import { appendCronEventLines } from "./event-prompt.js";
 import { isWithinActiveHours } from "./active-hours.js";
 import { isHeartbeatContentEmpty } from "./content-check.js";
+import { appendCronEventLines } from "./event-prompt.js";
 import { createHeartbeatWake } from "./wake.js";
 export { DEFAULT_ACK_MAX_CHARS, HEARTBEAT_OK, NO_REPLY, appendCronEventLines, createHeartbeatWake, isHeartbeatContentEmpty, isWithinActiveHours, shouldSilence, stripHeartbeatToken };

package/dist/src/notifications/planner.js

@@ -122,7 +122,7 @@ 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;
+	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;
@@ -130,7 +130,7 @@ function proactivePlan(payload) {
 	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}`,
+		dedupeKey: `proactive.insight:${item.id}${item.notificationRevision && item.notificationRevision > 1 ? `:${item.notificationRevision}` : ""}`,
 		notification: {
 			type: "proactive.insight",
 			target: {
@@ -148,7 +148,8 @@ function proactivePlan(payload) {
 			} } : {},
 			payload: {
 				inboxItemId: item.id,
-				insightId: item.insightId
+				insightId: item.insightId,
+				notificationRevision: item.notificationRevision ?? 1
 			}
 		}
 	};

package/dist/src/notifications/proactive-channel.d.ts

@@ -0,0 +1,8 @@
+import type { ProductNotification, ProactivePreferences } from '@xopcai/gateway-contract';
+type Target = NonNullable<ProactivePreferences['telegram']>;
+export type ProactiveChannelSender = (target: Target, text: string) => Promise<{
+    messageId: string;
+}>;
+export declare function enqueueChannelNotification(notification: ProductNotification, workspace: string): void;
+export declare function drainChannelNotifications(send: ProactiveChannelSender): Promise<void>;
+export {};

package/dist/src/notifications/proactive-channel.js

@@ -0,0 +1,57 @@
+import { getSqliteDatabase, runSqliteWriteTransaction } from "../storage/sqlite/transaction.js";
+import { notificationTargetRoute } from "../../packages/gateway-contract/src/notifications.js";
+import { proactivePreferences } from "../proactive/policy/service.js";
+import { recheckNotificationDelivery } from "./proactive-policy.js";
+import { getNotificationEvent } from "./store.js";
+//#region src/notifications/proactive-channel.ts
+function enqueueChannelNotification(notification, workspace) {
+	const target = proactivePreferences(workspace).telegram;
+	if (!target) throw new Error("Configure a Telegram destination before selecting it");
+	getSqliteDatabase().prepare("INSERT OR IGNORE INTO proactive_channel_deliveries(notification_id, workspace_id, target_json, next_attempt_at) VALUES (?, ?, ?, ?)").run(notification.id, workspace, JSON.stringify(target), Date.now());
+}
+async function drainChannelNotifications(send) {
+	const db = getSqliteDatabase();
+	const claim = runSqliteWriteTransaction((tx) => {
+		tx.prepare("UPDATE proactive_channel_deliveries SET status = 'failed', last_error = 'Lease exhausted' WHERE status = 'sending' AND lease_until <= ? AND attempt >= 5").run(Date.now());
+		const row = tx.prepare(`SELECT * FROM proactive_channel_deliveries WHERE (status = 'pending' AND next_attempt_at <= ?) OR (status = 'sending' AND lease_until <= ?) ORDER BY next_attempt_at LIMIT 1`).get(Date.now(), Date.now());
+		if (!row) return null;
+		tx.prepare("UPDATE proactive_channel_deliveries SET status = 'sending', attempt = attempt + 1, lease_until = ? WHERE notification_id = ?").run(Date.now() + 12e4, row.notification_id);
+		return {
+			...row,
+			attempt: row.attempt + 1
+		};
+	});
+	if (!claim) return;
+	const finish = (status, nextAt, messageId = null, error = null) => {
+		db.prepare(`UPDATE proactive_channel_deliveries SET status = ?, next_attempt_at = ?, provider_message_id = ?, last_error = ?, lease_until = NULL
+      WHERE notification_id = ? AND status = 'sending' AND attempt = ?`).run(status, nextAt, messageId, error, claim.notification_id, claim.attempt);
+	};
+	try {
+		const notification = getNotificationEvent(claim.notification_id);
+		const current = proactivePreferences(claim.workspace_id);
+		if (!notification || current.preferredChannel !== "telegram" || JSON.stringify(current.telegram) !== claim.target_json) {
+			finish("cancelled", Date.now());
+			return;
+		}
+		const policy = recheckNotificationDelivery(notification, "telegram");
+		if (policy === "cancel") {
+			finish("cancelled", Date.now());
+			return;
+		}
+		if (policy instanceof Date) {
+			finish("pending", policy.getTime());
+			db.prepare("UPDATE proactive_channel_deliveries SET attempt = attempt - 1 WHERE notification_id = ? AND attempt = ?").run(claim.notification_id, claim.attempt);
+			return;
+		}
+		const target = JSON.parse(claim.target_json);
+		const url = new URL(target.publicUrl);
+		url.hash = notificationTargetRoute(notification.target, "web");
+		const result = await send(target, `${notification.target.kind === "proactive_digest" ? "你的工作摘要已就绪 / Your work digest is ready." : "有一项工作需要查看 / A work update is ready."}\n${url.toString()}`);
+		if (!result.messageId) throw new Error("No delivery receipt");
+		finish("sent", Date.now(), result.messageId);
+	} catch {
+		finish(claim.attempt >= 5 ? "failed" : "pending", Date.now() + Math.min(36e5, 3e4 * 2 ** claim.attempt), null, "Telegram delivery failed");
+	}
+}
+//#endregion
+export { drainChannelNotifications, enqueueChannelNotification };

package/dist/src/notifications/proactive-policy.d.ts

@@ -0,0 +1,3 @@
+import type { ProductNotification } from '@xopcai/gateway-contract';
+export declare function proactiveNotificationWorkspace(notification: Pick<ProductNotification, 'target'>): string | null;
+export declare function recheckNotificationDelivery(notification: ProductNotification, channel: 'browser' | 'mobile' | 'telegram', now?: Date): 'send' | 'cancel' | Date;

package/dist/src/notifications/proactive-policy.js

@@ -0,0 +1,32 @@
+import { getSqliteDatabase } from "../storage/sqlite/transaction.js";
+import { proactivePreferences, quietHoursEnd } from "../proactive/policy/service.js";
+import { viewingProactiveCards } from "../proactive/policy/presence.js";
+import { digestCards } from "../proactive/inbox/digest.js";
+import { recheckProactiveNotification } from "../proactive/inbox/notification-policy.js";
+//#region src/notifications/proactive-policy.ts
+function proactiveNotificationWorkspace(notification) {
+	const target = notification.target;
+	const db = getSqliteDatabase();
+	return (target.kind === "insight" ? db.prepare(`SELECT s.workspace_id 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 = ?`).get(target.inboxItemId) : target.kind === "proactive_digest" ? db.prepare("SELECT workspace_id FROM proactive_digests WHERE digest_id = ?").get(target.digestId) : null)?.workspace_id ?? null;
+}
+function recheckNotificationDelivery(notification, channel, now = /* @__PURE__ */ new Date()) {
+	if (notification.type !== "proactive.insight") return "send";
+	const workspace = proactiveNotificationWorkspace(notification);
+	if (!workspace) return "cancel";
+	const preferences = proactivePreferences(workspace);
+	if (![
+		"all",
+		"auto",
+		channel
+	].includes(preferences.preferredChannel)) return "cancel";
+	if (preferences.level === "off" || preferences.pausedUntil && Date.parse(preferences.pausedUntil) > now.getTime()) return "cancel";
+	if (preferences.suppressWhileViewing && viewingProactiveCards(workspace, now.getTime())) return "cancel";
+	if (notification.target.kind === "insight") return recheckProactiveNotification(notification.target.inboxItemId, now, notification.payload.notificationRevision);
+	if (notification.target.kind === "proactive_digest") {
+		if (!digestCards(notification.target.digestId, workspace).length) return "cancel";
+		return quietHoursEnd(preferences, now) ?? "send";
+	}
+	return "cancel";
+}
+//#endregion
+export { proactiveNotificationWorkspace, recheckNotificationDelivery };

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

@@ -1,3 +1,5 @@
+import { type ProactiveChannelSender } from './proactive-channel.js';
+import { type NotificationPlan } from './planner.js';
 export declare class NotificationService {
     private readonly options;
     private timer;
@@ -6,10 +8,86 @@ export declare class NotificationService {
     constructor(options: {
         publish: (type: string, payload: unknown) => void;
         fetch?: typeof fetch;
+        sendChannel?: ProactiveChannelSender;
     });
     start(): void;
     stop(): void;
     handleGatewayEvent(type: string, payload: unknown): void;
+    /** Throws on persistence failure so durable producers can retry the handoff. */
+    persistGatewayEvent(type: string, payload: unknown): {
+        schemaVersion: 1;
+        id: string;
+        type: "work_discovery.failed" | "chat.completed" | "chat.failed" | "task.needs_input" | "task.blocked" | "task.failed" | "task.completed" | "automation.completed" | "automation.failed" | "proactive.insight" | "work_discovery.review_ready";
+        priority: "normal" | "high";
+        title: {
+            en: string;
+            zh: string;
+        };
+        payload: Record<string, unknown>;
+        createdAt: number;
+        target?: {
+            kind: "chat";
+            sessionKey: string;
+        } | {
+            kind: "task";
+            taskId: string;
+        } | {
+            kind: "automation_run";
+            automationId: string;
+            runId: string;
+        } | {
+            kind: "proactive_digest";
+            digestId: string;
+        } | {
+            kind: "insight";
+            inboxItemId: string;
+        } | {
+            kind: "work_discovery";
+            runId: string;
+            sessionKey: string;
+        };
+        body?: {
+            en: string;
+            zh: string;
+        };
+    };
+    persistPlan(plan: NotificationPlan): {
+        schemaVersion: 1;
+        id: string;
+        type: "work_discovery.failed" | "chat.completed" | "chat.failed" | "task.needs_input" | "task.blocked" | "task.failed" | "task.completed" | "automation.completed" | "automation.failed" | "proactive.insight" | "work_discovery.review_ready";
+        priority: "normal" | "high";
+        title: {
+            en: string;
+            zh: string;
+        };
+        payload: Record<string, unknown>;
+        createdAt: number;
+        target?: {
+            kind: "chat";
+            sessionKey: string;
+        } | {
+            kind: "task";
+            taskId: string;
+        } | {
+            kind: "automation_run";
+            automationId: string;
+            runId: string;
+        } | {
+            kind: "proactive_digest";
+            digestId: string;
+        } | {
+            kind: "insight";
+            inboxItemId: string;
+        } | {
+            kind: "work_discovery";
+            runId: string;
+            sessionKey: string;
+        };
+        body?: {
+            en: string;
+            zh: string;
+        };
+    };
     drain(): Promise<void>;
     private deliverPending;
     private send;