@xopcai/xopc 0.0.268 → 0.0.270

package/dist/src/cli/extension-cli-register.js

@@ -4,9 +4,9 @@ import { ExtensionLoader } from "../extensions/loader.js";
 import "../extensions/index.js";
 import { MessageBus } from "../infra/bus/queue.js";
 import "../infra/bus/index.js";
-import { createDefaultContext } from "./registry.js";
 import { getWorkspacePath } from "../config/workspace-path-helpers.js";
 import "../config/index.js";
+import { createDefaultContext } from "./registry.js";
 import { registerExtensionCliProgram } from "../extensions/sdk/channel-helpers.js";
 import { join } from "path";
 //#region src/cli/extension-cli-register.ts

package/dist/src/config/index.js

@@ -13,10 +13,10 @@ import { clearConfigValueCache, getAllowedCommands, getCacheStats, init_resolve_
 import { CustomModelSchema, ImageGenerationCapabilitiesSchema, ImageGenerationModelSchema, ImageGenerationProviderSchema, ModelOverrideSchema, ModelsJsonSchema, OpenAICompatSchema, OpenAICompletionsCompatSchema, OpenAIResponsesCompatSchema, OpenRouterRoutingSchema, ProviderConfigSchema, VercelGatewayRoutingSchema, getDefaultModelValues, init_models_json, loadModelsJson, modelsJsonExists, saveModelsJson, validateModelsConfig } from "./models-json.js";
 import { canonicalizeConfiguredMcpServer, isKnownCliMcpTypeAlias, normalizeConfiguredMcpServers, resolveXopcMcpTransportAlias } from "./mcp-config-normalize.js";
 import { formatThinkingLevels, listThinkingLevels, normalizeElevatedMode, normalizeReasoningLevel, normalizeThinkLevel, normalizeVerboseLevel, thinkLevelToNumber } from "../agent/transcript/thinking-types.js";
+import { diffConfigPaths } from "./diff.js";
 import { getWorkspacePath } from "./workspace-path-helpers.js";
 import { listAgentProfileMarkdownDirs, listAgentWorkspaceDirs } from "./workspace-dirs.js";
 import { ProfileManager, createProfile, deleteProfile, getCurrentProfile, getProfileManager, getProfileNameFromDir, getSwitchCommand, listProfiles, resolveProfileStateDir } from "./profile.js";
-import { diffConfigPaths } from "./diff.js";
 import { BASE_RELOAD_RULES, buildReloadPlan, matchReloadRule } from "./rules.js";
 import { ConfigHotReloader } from "./reload.js";
 //#region src/config/index.ts

package/dist/src/connectors/connected-source-normalizers.js

@@ -122,6 +122,9 @@ function normalizeCalendar(result) {
 			value: compact({
 				id: externalId,
 				title: text(event, "summary", "title", "name"),
+				description: text(event, "description"),
+				location: text(event, "location"),
+				allDay: Boolean(event.start && typeof event.start === "object" && "date" in event.start),
 				start: occurredAt,
 				end: time(event.end ?? event.endTime ?? event.end_time),
 				organizer: event.organizer,

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

@@ -20,7 +20,6 @@ import { registerLocalAppsRoutes } from "./local-apps.js";
 import { registerWorkDiscoveryRoutes } from "./work-discovery.js";
 import { registerContextSourceRoutes } from "./context-sources.js";
 import { registerTaskRoutes } from "./tasks.js";
-import { registerProactiveRoutes } from "./proactive.js";
 import { registerMobilePrivacyRoutes } from "./mobile-privacy.js";
 import { mountAppLazyRoutePrefixes, registerAuthenticatedLazyRouteFallback } from "./lazy-fallback.js";
 //#region src/gateway/hono/routes/index.ts
@@ -40,7 +39,6 @@ function registerCoreAuthenticatedRoutes(authenticated, deps) {
 	registerWorkDiscoveryRoutes(authenticated, deps);
 	registerContextSourceRoutes(authenticated, deps);
 	registerTaskRoutes(authenticated, deps);
-	registerProactiveRoutes(authenticated, deps);
 	registerSearchRoutes(authenticated, deps);
 	registerDevicePushRoutes(authenticated);
 	registerNotificationRoutes(authenticated, deps);

package/dist/src/gateway/hono/routes/lazy-bundles.js

@@ -3,6 +3,18 @@ function startsWithAny(path, prefixes) {
 	return prefixes.some((prefix) => path === prefix || path.startsWith(`${prefix}/`));
 }
 const AUTHENTICATED_LAZY_ROUTE_BUNDLES = [
+	{
+		id: "proactive",
+		match: (path) => startsWithAny(path, [
+			"/api/proactive",
+			"/api/inbox/judgments",
+			"/api/internal/proactive"
+		]),
+		load: async () => {
+			const { registerProactiveRoutes } = await import("./proactive.js");
+			return { register: registerProactiveRoutes };
+		}
+	},
 	{
 		id: "runtime-tools",
 		match: (path) => startsWithAny(path, ["/api/runtime-tools"]),

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,168 @@
+import { getSqliteDatabase } from "../../../storage/sqlite/transaction.js";
+import { ProactiveConflict, proactivePreferences, updateProactivePreferences } from "../../../proactive/policy/service.js";
+import { controlledSubscriptions, createControlledSubscription, requireSubscription, templateCatalog, updateControlledSubscription } from "../../../proactive/scenarios/control.js";
+import { listMailFollowUps, mailFollowUpSources, startMailFollowUp, updateMailFollowUp } from "../../../proactive/follow-ups.js";
+import { cardChanges, getCard, listCards, performCardAction } from "../../../proactive/inbox/cards.js";
+import { checkDelegation, delegationOverview, startDelegation } from "../../../proactive/experience.js";
+import { recordProactivePresence } from "../../../proactive/policy/presence.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 { previewSubscription } from "../../../proactive/scenarios/preview.js";
+import { ZodError } from "zod";
+//#region src/gateway/hono/routes/proactive-control.ts
+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;
+	app.get("/api/proactive/follow-ups/sources", (c) => c.json({
+		ok: true,
+		sources: mailFollowUpSources(workspace())
+	}));
+	app.get("/api/proactive/follow-ups", (c) => c.json({
+		ok: true,
+		followUps: listMailFollowUps(workspace())
+	}));
+	app.post("/api/proactive/follow-ups", deps.strictRateLimitMiddleware, async (c) => c.json({
+		ok: true,
+		followUp: startMailFollowUp(workspace(), await c.req.json())
+	}, 201));
+	app.patch("/api/proactive/follow-ups/:id", deps.strictRateLimitMiddleware, async (c) => c.json({
+		ok: true,
+		followUp: updateMailFollowUp(workspace(), c.req.param("id"), await c.req.json())
+	}));
+	app.get("/api/proactive/overview", (c) => c.json({
+		ok: true,
+		...delegationOverview(workspace())
+	}));
+	app.post("/api/proactive/delegations", deps.strictRateLimitMiddleware, async (c) => c.json({
+		ok: true,
+		subscription: startDelegation(workspace(), await c.req.json())
+	}, 201));
+	app.post("/api/proactive/subscriptions/:id/check", deps.strictRateLimitMiddleware, (c) => c.json({
+		ok: true,
+		...checkDelegation(workspace(), c.req.param("id"))
+	}, 202));
+	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.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/run-loop.js

@@ -1,6 +1,6 @@
 import { loadConfig } from "../config/loader.js";
-import "../config/index.js";
 import { isRestartEnabled } from "../config/commands.flags.js";
+import "../config/index.js";
 import { runBootstrapMigrationsSync } from "../migrations/runner.js";
 import { restartGatewayProcessWithFreshPid } from "./respawn.js";
 import { acquireGatewayLock } from "./lock.js";

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/server.js

@@ -1,6 +1,6 @@
 import { resolveGatewayBindHost, resolveGatewayListenHosts } from "../config/gateway-bind.js";
-import { ensureXopcCliOnPath } from "../infra/path-env.js";
 import { resolveGatewayListenPlan } from "./listen.js";
+import { ensureXopcCliOnPath } from "../infra/path-env.js";
 import { GatewayService } from "./service.js";
 import { handleSiteShareUpgrade } from "../share/site-share-router.js";
 import { createHonoApp } from "./hono/app.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

@@ -31,11 +31,13 @@ import { resolveProjectAgentId } from "../projects/project-agent.js";
 import "../projects/index.js";
 import { resolveEffectiveGatewayPort } from "./host.js";
 import { onSessionTranscriptUpdate } from "../session/transcript-events.js";
+import { ProactiveScenarioService } from "../proactive/scenarios/service.js";
+import { ProactiveEventService } from "../proactive/service.js";
+import { TaskApplicationService } from "../tasks/task-application-service.js";
+import { ProactiveInboxService } from "../proactive/inbox/service.js";
 import { AutomationService } from "../automations/service/automation-service.js";
 import { onAutomationProductEvent, publishAutomationProductEvent } from "../automations/product-events.js";
 import "../automations/index.js";
-import { TaskApplicationService } from "../tasks/task-application-service.js";
-import { ProactiveScenarioService } from "../proactive/scenarios/service.js";
 import { TaskOutboxDispatcher } from "../tasks/task-outbox-dispatcher.js";
 import { TaskRunDispatcher } from "../tasks/task-run-dispatcher.js";
 import { TaskSignalService } from "../tasks/task-signal-service.js";
@@ -72,6 +74,7 @@ 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 { 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";
@@ -106,12 +109,10 @@ import "../local-apps/index.js";
 import { createRuntimeBrowserAutomationService } from "../browser/automations/runtime-service.js";
 import "../browser/automations/index.js";
 import { mapProductEventToProactive } from "../proactive/events/product-event-bridge.js";
-import { ProactiveEventService } from "../proactive/service.js";
 import { ReadonlyProactiveAgentExecutor } from "../proactive/execution/agent-executor.js";
 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/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 };