@xopcai/xopc 0.0.308 → 0.0.311

package/dist/src/gateway/scenes/host.js

@@ -0,0 +1,129 @@
+import { createLogger } from "../../utils/logger/index.js";
+import { init_logger } from "../../utils/logger.js";
+import { assertSceneStorageReady, init_scenes_schema } from "../../storage/sqlite/scenes-schema.js";
+import { getDefaultModelSync, init_providers, isProviderConfiguredSync, resolveModel } from "../../providers/index.js";
+import { BrowserSubscriptionService } from "../../notifications/browserSubscriptions.js";
+import { SceneRepository } from "../../scenes/repository.js";
+import { ScenePreferenceService } from "../../scenes/preferences.js";
+import { SceneExecutionService } from "../../scenes/execution.js";
+import { SceneAgentExecutor } from "../../scenes/agentExecutor.js";
+import { SceneInboxService } from "../../scenes/inbox.js";
+import { SceneMailObservationService } from "../../scenes/mailObservations.js";
+import { maintainSceneStorage } from "../../scenes/maintenance.js";
+import { SceneMetrics } from "../../scenes/metrics.js";
+import { SceneResultNotifications } from "../../scenes/resultNotifications.js";
+import { SceneRuntime } from "../../scenes/runtime.js";
+import { SceneApplicationService } from "../../scenes/service.js";
+import { familyPlanTemplate, mailFollowUpTemplate } from "../../scenes/templates.js";
+import { SceneUserNotesProvider } from "../../scenes/userNotes.js";
+import { createSceneBrowserDispatcher } from "./browserNotifications.js";
+import { GatewaySceneMailContext } from "./mailContext.js";
+//#region src/gateway/scenes/host.ts
+init_providers();
+init_scenes_schema();
+init_logger();
+const log = createLogger("Gateway:Scenes");
+/** Composition root for the initialized database. Never creates tables or starts an old worker. */
+var GatewaySceneHost = class {
+	http;
+	runtime;
+	notifications;
+	browserDispatcher;
+	timer;
+	active;
+	stopped = false;
+	nextMaintenanceAt = 0;
+	clock;
+	constructor(db, input) {
+		this.db = db;
+		assertSceneStorageReady(db);
+		if (!input.principal.ownerId.trim() || !input.principal.workspaceId.trim()) throw new Error("Scene host principal is required");
+		const clock = input.clock ?? Date.now;
+		this.clock = clock;
+		const repository = new SceneRepository(db);
+		repository.installTemplate(mailFollowUpTemplate);
+		repository.installTemplate(familyPlanTemplate);
+		const mail = input.mail ?? new GatewaySceneMailContext(db, clock);
+		const providers = [mail, new SceneUserNotesProvider(db, clock)];
+		const authorize = (activation) => {
+			if (activation.ownerId !== input.principal.ownerId || activation.workspaceId !== input.principal.workspaceId) return {
+				accountIds: [],
+				contextProviders: [],
+				effectHandlers: []
+			};
+			const accountIds = mail.authorizedAccounts(activation);
+			return {
+				accountIds,
+				contextProviders: [...activation.scope.kind === "personal" ? ["user_notes"] : [], ...accountIds.length ? ["mail"] : []],
+				effectHandlers: []
+			};
+		};
+		const grant = async (activation) => authorize(activation);
+		const executor = input.executor ?? new SceneAgentExecutor(() => resolveModel(getDefaultModelSync(input.config())));
+		this.http = {
+			repository,
+			mail,
+			mailDiscovery: mail instanceof GatewaySceneMailContext ? mail : void 0,
+			application: new SceneApplicationService(repository, providers, grant, clock, () => {
+				if (input.executor) return [];
+				try {
+					return isProviderConfiguredSync(resolveModel(getDefaultModelSync(input.config())).provider) ? [] : ["model_credentials"];
+				} catch {
+					return ["model_configuration"];
+				}
+			}),
+			inbox: new SceneInboxService(db, clock),
+			browser: new BrowserSubscriptionService(db, clock),
+			preferences: new ScenePreferenceService(db),
+			metrics: new SceneMetrics(db, clock)
+		};
+		this.runtime = new SceneRuntime(repository, new SceneExecutionService(repository, providers, executor, grant, clock), new SceneMailObservationService(repository, mail, grant, clock, 6e4), clock, input.intervalMs ?? 5e3);
+		this.notifications = new SceneResultNotifications(db, authorize, (event) => input.publish("notification.created", event), clock);
+		this.browserDispatcher = createSceneBrowserDispatcher(db, authorize, clock);
+		this.intervalMs = input.intervalMs ?? 5e3;
+	}
+	intervalMs;
+	start() {
+		if (this.stopped) throw new Error("Create a new scene host after shutdown");
+		if (this.timer) return;
+		assertSceneStorageReady(this.db);
+		this.runtime.start();
+		const poll = () => {
+			try {
+				if (this.clock() >= this.nextMaintenanceAt) {
+					maintainSceneStorage(this.db, this.clock());
+					this.nextMaintenanceAt = this.clock() + 36e5;
+				}
+				this.notifications.drain();
+				this.browserDispatcher.drainOne().catch((err) => log.error({ err }, "Scene browser reminder failed"));
+			} catch (err) {
+				log.error({ err }, "Scene result publication failed");
+			}
+		};
+		this.timer = setInterval(poll, this.intervalMs);
+		this.timer.unref();
+		poll();
+	}
+	tick() {
+		if (this.stopped) return Promise.reject(/* @__PURE__ */ new Error("Scene host stopped"));
+		if (this.active) return this.active;
+		const work = this.runtime.tick().then(() => {
+			if (!this.stopped) this.notifications.drain();
+		});
+		this.active = work.finally(() => {
+			this.active = void 0;
+		});
+		return this.active;
+	}
+	/** Must finish before the Gateway closes SQLite or its realtime broker. */
+	async stop() {
+		this.stopped = true;
+		if (this.timer) clearInterval(this.timer);
+		this.timer = void 0;
+		await this.runtime.stop();
+		await this.browserDispatcher.stop();
+		await this.active?.catch(() => void 0);
+	}
+};
+//#endregion
+export { GatewaySceneHost };

package/dist/src/gateway/scenes/mailContext.d.ts

@@ -0,0 +1,32 @@
+import type { DatabaseSync } from 'node:sqlite';
+import { ComposioSessionsAdapter } from '../../connectors/composio-sessions.js';
+import { type SceneActivation, type ScenePrincipal } from '../../scenes/contracts.js';
+import type { SceneContextProvider, SceneEvidence } from '../../scenes/execution.js';
+import { SceneMailContextProvider } from '../../scenes/mailContext.js';
+/** Reads only the delegated thread; never starts mailbox learning or persists raw mail. */
+export declare class GatewaySceneMailContext extends SceneMailContextProvider {
+    private readonly connectionDb;
+    private readonly now;
+    private readonly adapter;
+    constructor(connectionDb: DatabaseSync, now?: () => number, adapter?: Pick<ComposioSessionsAdapter, 'executeWithPolicy'>);
+    private recordRequest;
+    listAccounts(principal: ScenePrincipal): Array<{
+        id: string;
+        label: string;
+    }>;
+    authorizedAccounts(activation: SceneActivation): string[];
+    listSources(principal: ScenePrincipal, limit?: number, afterId?: string): {
+        id: string;
+        accountId: string;
+        subject: string;
+        sender: string;
+    }[];
+    searchSources(principal: ScenePrincipal, value: unknown, signal: AbortSignal): Promise<{
+        id: string;
+        accountId: string;
+        subject: string;
+        sender: string;
+    }[]>;
+    private source;
+    read(input: Parameters<SceneContextProvider['read']>[0]): Promise<SceneEvidence[]>;
+}

package/dist/src/gateway/scenes/mailContext.js

@@ -0,0 +1,235 @@
+import { getConnectorConnection, getConnectorInstallation, init_connector_repository } from "../../storage/sqlite/connector-repository.js";
+import { ComposioSessionsAdapter } from "../../connectors/composio-sessions.js";
+import { getConnectorDefinition } from "../../connectors/catalog.js";
+import { normalizeConnectedSourceResult } from "../../connectors/connected-source-normalizers.js";
+import { sanitizeConnectedSourceValue } from "../../connectors/connected-source-sanitization.js";
+import { sceneContentHash } from "../../scenes/contracts.js";
+import { SceneSourceNotReady, sceneSourceFailureReason } from "../../scenes/readiness.js";
+import { SceneMailContextProvider } from "../../scenes/mailContext.js";
+import { createHash } from "node:crypto";
+import { z } from "zod";
+//#region src/gateway/scenes/mailContext.ts
+init_connector_repository();
+const ACTION = "GMAIL_FETCH_MESSAGE_BY_THREAD_ID";
+function record(value) {
+	return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+/** Reads only the delegated thread; never starts mailbox learning or persists raw mail. */
+var GatewaySceneMailContext = class extends SceneMailContextProvider {
+	constructor(connectionDb, now = Date.now, adapter = new ComposioSessionsAdapter()) {
+		super(connectionDb, now);
+		this.connectionDb = connectionDb;
+		this.now = now;
+		this.adapter = adapter;
+	}
+	recordRequest(principal, accountId) {
+		this.connectionDb.prepare(`INSERT INTO scene_connector_usage VALUES (?, ?, ?, ?, 1)
+      ON CONFLICT(owner_id, workspace_id, account_id, utc_day) DO UPDATE SET request_count = request_count + 1`).run(principal.ownerId, principal.workspaceId, accountId, Math.floor(this.now() / 864e5));
+	}
+	listAccounts(principal) {
+		return this.connectionDb.prepare(`SELECT a.id, a.label, a.identity_json, c.connector_id FROM connector_accounts a
+      JOIN connector_connections c ON c.id = a.current_connection_id AND c.account_id = a.id
+        AND c.principal_id = a.principal_id AND c.connector_id = a.connector_id
+      JOIN connector_installations i ON i.id = c.installation_id AND i.principal_id = a.principal_id AND i.connector_id = a.connector_id
+      WHERE a.principal_id = ? AND a.enabled = 1 AND c.status = 'active' AND c.provider = 'composio'
+        AND i.enabled = 1 AND i.confirmation_policy <> 'always'
+        AND json_array_length(i.allowed_agent_ids_json) = 0 AND a.allowed_agent_ids_json IS NULL
+        AND (i.selected_account_ids_json = 'null' OR EXISTS (SELECT 1 FROM json_each(i.selected_account_ids_json) WHERE value = a.id))
+        AND (c.expires_at IS NULL OR julianday(c.expires_at) > julianday(?, 'unixepoch')) ORDER BY a.id LIMIT 100`).all(principal.ownerId, this.now() / 1e3).filter((row) => {
+			const definition = getConnectorDefinition(String(row.connector_id));
+			return definition?.runtime.type === "composio" && definition.runtime.toolkit === "gmail";
+		}).map((row) => {
+			const identity = record(JSON.parse(String(row.identity_json)));
+			return {
+				id: String(row.id),
+				label: String(row.label || identity.email || identity.name || row.id).slice(0, 300)
+			};
+		});
+	}
+	authorizedAccounts(activation) {
+		if (activation.scope.kind !== "objects" || activation.scope.ids.length !== 1) return [];
+		const source = this.connectionDb.prepare("SELECT account_id FROM scene_mail_sources WHERE id = ? AND owner_id = ? AND workspace_id = ?").get(activation.scope.ids[0], activation.ownerId, activation.workspaceId);
+		return source && activation.permissions.accountIds.includes(String(source.account_id)) && this.listAccounts(activation).some((account) => account.id === source.account_id) ? [String(source.account_id)] : [];
+	}
+	listSources(principal, limit = 50, afterId = "") {
+		const accounts = new Set(this.listAccounts(principal).map((account) => account.id));
+		return this.connectionDb.prepare("SELECT id, account_id, subject, sender FROM scene_mail_sources WHERE owner_id = ? AND workspace_id = ? AND id > ? ORDER BY id LIMIT ?").all(principal.ownerId, principal.workspaceId, afterId, limit).filter((row) => accounts.has(String(row.account_id))).map((row) => ({
+			id: String(row.id),
+			accountId: String(row.account_id),
+			subject: String(row.subject),
+			sender: String(row.sender)
+		}));
+	}
+	async searchSources(principal, value, signal) {
+		const { accountId, query } = z.strictObject({
+			accountId: z.string().min(1).max(200),
+			query: z.string().trim().min(1).max(500)
+		}).parse(value);
+		if (!this.listAccounts(principal).some((account) => account.id === accountId)) throw new Error("Mail account is not available for scene reads");
+		const account = this.connectionDb.prepare("SELECT current_connection_id FROM connector_accounts WHERE id = ?").get(accountId);
+		const connection = getConnectorConnection(String(account.current_connection_id));
+		const installation = getConnectorInstallation(connection.installationId);
+		signal.throwIfAborted();
+		this.recordRequest(principal, accountId);
+		const response = await this.adapter.executeWithPolicy({
+			context: {
+				principalId: principal.ownerId,
+				toolkits: ["gmail"]
+			},
+			connection,
+			installation,
+			signal,
+			action: {
+				connectorId: connection.connectorId,
+				toolkit: "gmail",
+				actionId: "GMAIL_FETCH_EMAILS",
+				scope: "read",
+				curated: true,
+				cachedAt: new Date(this.now()).toISOString()
+			},
+			args: {
+				query: `(${query}) -in:spam -in:trash -in:drafts`,
+				max_results: 30,
+				include_payload: true,
+				verbose: false
+			}
+		});
+		signal.throwIfAborted();
+		if (response.decision !== "allowed") throw new Error("Mail search permission is required");
+		const envelope = record(response.result);
+		if (envelope.successful === false || envelope.error || !Array.isArray(record(envelope.data).messages)) throw new SceneSourceNotReady();
+		if (!this.listAccounts(principal).some((account) => account.id === accountId) || this.connectionDb.prepare("SELECT current_connection_id FROM connector_accounts WHERE id = ?").get(accountId)?.current_connection_id !== connection.id) throw new Error("Mail authorization changed");
+		const normalized = normalizeConnectedSourceResult({
+			toolkit: "gmail",
+			actionId: "GMAIL_FETCH_EMAILS",
+			result: envelope.data
+		});
+		const sources = /* @__PURE__ */ new Map();
+		for (const mail of normalized.slice(0, 30)) {
+			const threadId = mail.value.threadId;
+			if (typeof threadId !== "string" || !threadId.trim() || threadId.length > 200) continue;
+			if (Array.isArray(mail.value.labels) && mail.value.labels.some((label) => [
+				"DRAFT",
+				"TRASH",
+				"SPAM"
+			].includes(String(label)))) continue;
+			const id = createHash("sha256").update(JSON.stringify([
+				principal.ownerId,
+				principal.workspaceId,
+				accountId,
+				threadId
+			])).digest("hex");
+			const subject = String(mail.value.subject ?? "").slice(0, 300);
+			const sender = String(mail.value.sender ?? "").slice(0, 300);
+			this.connectionDb.prepare(`INSERT INTO scene_mail_sources VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+        ON CONFLICT(id) DO UPDATE SET subject = excluded.subject, sender = excluded.sender, selected_at = excluded.selected_at`).run(id, principal.ownerId, principal.workspaceId, accountId, threadId, subject, sender, this.now());
+			sources.set(id, {
+				id,
+				accountId,
+				subject,
+				sender
+			});
+		}
+		return [...sources.values()];
+	}
+	source(subjectId) {
+		const row = this.connectionDb.prepare(`SELECT a.current_connection_id, s.thread_id FROM scene_mail_sources s
+      JOIN connector_accounts a ON a.id = s.account_id WHERE s.id = ?`).get(subjectId);
+		if (!row) throw new Error("Mail source unavailable");
+		return {
+			connectionId: String(row.current_connection_id),
+			threadId: String(row.thread_id)
+		};
+	}
+	async read(input) {
+		input.signal.throwIfAborted();
+		const accounts = this.authorizedAccounts(input.activation);
+		if (!input.permissions.contextProviders.includes("mail") || accounts.length !== 1 || !input.permissions.accountIds.includes(accounts[0]) || input.activation.scope.kind !== "objects" || input.activation.scope.ids[0] !== input.subjectId) throw new Error("Mail permission is required");
+		const origin = this.source(input.subjectId);
+		const startedAt = this.now();
+		if (input.notBefore !== void 0 && startedAt < input.notBefore) throw new SceneSourceNotReady();
+		const connection = getConnectorConnection(origin.connectionId);
+		const installation = getConnectorInstallation(connection.installationId);
+		const messages = [];
+		const tokens = /* @__PURE__ */ new Set();
+		let pageToken;
+		do {
+			input.signal.throwIfAborted();
+			if (!this.authorizedAccounts(input.activation).includes(accounts[0]) || sceneContentHash(this.source(input.subjectId)) !== sceneContentHash(origin)) throw new Error("Mail permission changed");
+			let response;
+			try {
+				this.recordRequest(input.activation, accounts[0]);
+				response = await this.adapter.executeWithPolicy({
+					context: {
+						principalId: input.activation.ownerId,
+						toolkits: ["gmail"]
+					},
+					connection,
+					installation,
+					signal: input.signal,
+					action: {
+						connectorId: connection.connectorId,
+						toolkit: "gmail",
+						actionId: ACTION,
+						scope: "read",
+						curated: true,
+						cachedAt: new Date(startedAt).toISOString()
+					},
+					args: {
+						user_id: "me",
+						thread_id: origin.threadId,
+						...pageToken ? { page_token: pageToken } : {}
+					}
+				});
+			} catch (error) {
+				input.signal.throwIfAborted();
+				throw new SceneSourceNotReady(sceneSourceFailureReason(error));
+			}
+			input.signal.throwIfAborted();
+			if (response.decision !== "allowed") throw new Error("Mail connector permission is required");
+			const envelope = record(response.result);
+			const data = record(envelope.data);
+			if (envelope.successful === false || envelope.error || !Array.isArray(data.messages) || data.messages.some((message) => !message || typeof message !== "object")) throw new SceneSourceNotReady(sceneSourceFailureReason(envelope.error));
+			messages.push(...data.messages.map(record));
+			if (messages.length > 30 || JSON.stringify(messages).length > 5e5) throw new Error("Mail thread exceeds its context budget");
+			if (data.nextPageToken != null && typeof data.nextPageToken !== "string") throw new SceneSourceNotReady();
+			pageToken = typeof data.nextPageToken === "string" && data.nextPageToken ? data.nextPageToken : void 0;
+			if (pageToken) {
+				if (!data.messages.length || tokens.has(pageToken) || tokens.size >= 29) throw new SceneSourceNotReady();
+				tokens.add(pageToken);
+			}
+		} while (pageToken);
+		if (!this.authorizedAccounts(input.activation).includes(accounts[0]) || sceneContentHash(this.source(input.subjectId)) !== sceneContentHash(origin)) throw new Error("Mail permission changed");
+		if (messages.some((message) => message.threadId !== origin.threadId || !Array.isArray(message.labelIds))) throw new SceneSourceNotReady();
+		const normalized = normalizeConnectedSourceResult({
+			toolkit: "gmail",
+			actionId: ACTION,
+			result: { messages }
+		});
+		if (normalized.length !== messages.length || new Set(normalized.map((message) => message.externalId)).size !== messages.length) throw new SceneSourceNotReady();
+		const active = normalized.filter((message) => !message.value.labels.some((label) => [
+			"DRAFT",
+			"TRASH",
+			"SPAM"
+		].includes(String(label))));
+		if (!active.length || active.some((message) => typeof message.value.content !== "string" || !message.value.content.trim())) throw new SceneSourceNotReady();
+		const evidence = active.map((message) => {
+			const content = JSON.stringify(sanitizeConnectedSourceValue(message.value));
+			return {
+				id: `mail:${accounts[0]}:${message.externalId}`,
+				subjectId: input.subjectId,
+				ownerId: input.activation.ownerId,
+				workspaceId: input.activation.workspaceId,
+				accountId: accounts[0],
+				content,
+				revision: sceneContentHash(content),
+				freshUntil: startedAt + 30 * 6e4,
+				...message.occurredAt ? { occurredAt: Date.parse(message.occurredAt) } : {}
+			};
+		});
+		if (evidence.reduce((size, message) => size + message.content.length, 0) > 12e4) throw new Error("Mail thread exceeds its context budget");
+		return evidence;
+	}
+};
+//#endregion
+export { GatewaySceneMailContext };

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

@@ -23,10 +23,6 @@ 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 (/^\/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/security/index.js

@@ -3,10 +3,10 @@ import { hasGatewayScope, parseGatewayScopes, requiredGatewayScope } from "./gat
 import { safeEqualSecret } from "./secret-equal.js";
 import { KNOWN_WEAK_GATEWAY_TOKEN_PLACEHOLDERS, assertGatewayAuthNotKnownWeak } from "./known-weak-secrets.js";
 import { auditGatewayConfig, collectGatewayConfigFindings, collectGatewaySecurityFindings, collectGatewayStartupGuardFindings } from "./audit.js";
-import { detectSuspiciousPatterns, wrapExternalContent, wrapWebContent } from "./external-content.js";
 import { createPreauthConnectionBudget, getMaxPreauthConnectionsPerIp } from "./preauth-connection-budget.js";
 import { buildGatewayConsoleCspHeader, computeInlineScriptHashes } from "./csp.js";
 import { checkBrowserOrigin } from "./origin-check.js";
 import { getGatewayPrincipal, setGatewayPrincipal } from "./gateway-principal.js";
 import { DEFAULT_GATEWAY_HTTP_TOOL_DENY, filterDangerousHttpTools, isDangerousHttpTool } from "./dangerous-tools.js";
+import { detectSuspiciousPatterns, wrapExternalContent, wrapWebContent } from "./external-content.js";
 export { DEFAULT_GATEWAY_HTTP_TOOL_DENY, DEFAULT_MOBILE_SCOPES, GATEWAY_SCOPES, KNOWN_WEAK_GATEWAY_TOKEN_PLACEHOLDERS, assertGatewayAuthNotKnownWeak, auditGatewayConfig, buildGatewayConsoleCspHeader, checkBrowserOrigin, collectGatewayConfigFindings, collectGatewaySecurityFindings, collectGatewayStartupGuardFindings, computeInlineScriptHashes, createPreauthConnectionBudget, detectSuspiciousPatterns, filterDangerousHttpTools, getGatewayPrincipal, getMaxPreauthConnectionsPerIp, hasGatewayScope, isDangerousHttpTool, isGatewayScope, parseGatewayScopes, requiredGatewayScope, safeEqualSecret, setGatewayPrincipal, wrapExternalContent, wrapWebContent };

package/dist/src/gateway/service/config-coordinator.d.ts

@@ -10,7 +10,7 @@
  *     (QR-login follow-ups that bypass the watcher)
  *   - `ConfigHotReloader` (fs.watch → debounced per-section dispatch)
  *   - Section reload handlers (models / agents / channels /
- *     heartbeat / tools / mcp / extensions)
+ *     tools / mcp / extensions)
  *   - `scheduleChannelPluginsAfterPersist` (coalesces rapid saves so
  *     Telegram/Weixin do not stop/start repeatedly)
  *
@@ -26,7 +26,6 @@
 import type { Config } from '../../config/schema.js';
 import type { AgentService } from '../../agent/service.js';
 import type { ChannelManager } from '../../channels/manager.js';
-import type { HeartbeatService } from '../heartbeat/index.js';
 import type { ExtensionLoader } from '../../extensions/loader.js';
 import type { MessageBus } from '../../infra/bus/index.js';
 export interface GatewayConfigCoordinatorOptions {
@@ -39,7 +38,6 @@ export interface GatewayConfigCoordinatorOptions {
     setConfig: (next: Config) => void;
     getAgentService: () => AgentService;
     getChannelManager: () => ChannelManager;
-    getHeartbeatService: () => HeartbeatService | null;
     getExtensionLoader: () => ExtensionLoader | null;
     /** Sync deterministic user-model maintenance automations after config changes. */
     reconcileMemoryMaintenanceAutomations: () => Promise<void>;
@@ -88,12 +86,6 @@ export declare class GatewayConfigCoordinator {
      * saves, and Weixin QR follow-up.
      */
     handleChannelsReload(newConfig: Config): Promise<void>;
-    /**
-     * Apply `gateway.heartbeat` from current config after PATCH /api/config (and
-     * when hot reload is off). File watcher uses `handleHeartbeatReload` with
-     * the same effect when paths match.
-     */
-    reloadHeartbeatFromCurrentConfig(): void;
     private handleModelsReload;
     private handleAgentDefaultsReload;
     /**
@@ -103,7 +95,6 @@ export declare class GatewayConfigCoordinator {
      */
     private scheduleChannelPluginsAfterPersist;
     private handleAutomationReload;
-    private handleHeartbeatReload;
     private handleToolsReload;
     private handleMcpReload;
     /** Dispatch config hot reload to extensions that registered `registerReload`. */

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

@@ -31,7 +31,6 @@ var GatewayConfigCoordinator = class {
 			onAgentDefaultsReload: (newConfig) => this.handleAgentDefaultsReload(newConfig),
 			onChannelsReload: (newConfig) => this.handleChannelsReload(newConfig),
 			onCronReload: (newConfig) => this.handleAutomationReload(newConfig),
-			onHeartbeatReload: (newConfig) => this.handleHeartbeatReload(newConfig),
 			onToolsReload: (newConfig) => this.handleToolsReload(newConfig),
 			onMcpReload: (newConfig) => this.handleMcpReload(newConfig),
 			onExtensionsReload: async (newConfig, changedPaths) => {
@@ -206,14 +205,6 @@ var GatewayConfigCoordinator = class {
 		this.opts.emit("channels.status", { channels: this.opts.getChannelsStatus() });
 		log.debug("Channels config reloaded");
 	}
-	/**
-	* Apply `gateway.heartbeat` from current config after PATCH /api/config (and
-	* when hot reload is off). File watcher uses `handleHeartbeatReload` with
-	* the same effect when paths match.
-	*/
-	reloadHeartbeatFromCurrentConfig() {
-		this.handleHeartbeatReload(this.opts.getConfig());
-	}
 	handleModelsReload(newConfig) {
 		log.debug("Reloading models config...");
 		this.opts.setConfig(newConfig);
@@ -268,13 +259,6 @@ var GatewayConfigCoordinator = class {
 		this.opts.emit("config.reload", { section: "automations" });
 		log.debug("Automation-related config reloaded");
 	}
-	handleHeartbeatReload(newConfig) {
-		log.debug("Reloading heartbeat config...");
-		this.opts.setConfig(newConfig);
-		this.opts.getHeartbeatService()?.updateConfig(newConfig);
-		this.opts.emit("config.reload", { section: "heartbeat" });
-		log.debug("Heartbeat config reloaded");
-	}
 	handleToolsReload(newConfig) {
 		log.debug("Reloading tools config...");
 		this.opts.setConfig(newConfig);

package/dist/src/gateway/service/run-gateway-agent.js

@@ -12,8 +12,8 @@ import { TaskRunCoordinator } from "../../tasks/task-run-coordinator.js";
 import { formatAgentRunErrorForClient } from "../../agent/client-error-format.js";
 import "../chat-limits.js";
 import { prependEnvelopeTimestamp } from "../../channels/envelope-timestamp.js";
-import { markdownNotificationPreview } from "../../notifications/plain-text.js";
 import { ChatStreamMapper } from "../chat-stream/mapper.js";
+import { markdownNotificationPreview } from "../../notifications/plain-text.js";
 import { resolveWebchatConversationId } from "../resolve-webchat-session-key.js";
 import { recordExplicitRelationshipFollowUp } from "../../user-context/relationship-continuity.js";
 import { coalesceThinkingDeltas } from "../chat-stream/thinking-delta-coalescer.js";

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

@@ -16,7 +16,6 @@ import { ProjectService } from '../projects/index.js';
 import { LocalAppService } from '../local-apps/index.js';
 import { TaskConversationRepository } from '../tasks/task-conversation-repository.js';
 import { type BrowserAutomationService } from '../browser/automations/index.js';
-import { listInsights, ProactiveEventService, ProactiveInboxService, ProactiveInboxWorker, ProactiveScenarioService, ProactiveTemporalWorker, ProactiveWorker } from '../proactive/index.js';
 import { GatewaySessionsApi } from './service/sessions-api.js';
 import { GatewayMarketplaceService } from './service/marketplace-service.js';
 import { GatewayAgentRunner } from './service/agent-runner.js';
@@ -25,6 +24,7 @@ import { VoiceRealtimeRuntime } from '../voice/realtime/runtime.js';
 import type { GatewayServiceConfig } from './service/types.js';
 import { type GatewayReadinessSnapshot } from './startup-readiness.js';
 import { type ConnectorLearningCoordinator } from '../connectors/learning-coordinator.js';
+import type { SceneAccess } from '../scenes/httpServices.js';
 import { type ProductLanguage } from '../voice/language-profile.js';
 import { EndpointToolRuntime } from '../endpoint-tools/index.js';
 export type { GatewayChannelStartupPhase1Metrics, GatewayChannelStartupPhase2Metrics, GatewayServiceConfig, } from './service/types.js';
@@ -40,7 +40,7 @@ export declare class GatewayService {
     private notesService;
     private extensionLoader;
     private extensionMetadataSnapshot;
-    private heartbeatService;
+    private sceneHost;
     private sessionIndex;
     private running;
     private startTime;
@@ -72,7 +72,6 @@ export declare class GatewayService {
     private notificationService;
     private connectorSupervisor;
     private connectorLearningCoordinator;
-    private connectedSourceChangePublisher;
     private connectedKnowledgeCoordinator;
     private stopAutomationProductEventBridge;
     private stopSessionTranscriptAutomationEvents;
@@ -107,21 +106,13 @@ export declare class GatewayService {
     readonly discussionSealer: DiscussionSealer;
     /** Local user-created apps, their coder projects, previews, and installs. */
     readonly localApps: LocalAppService;
-    /** Unified durable event spine for proactive scenarios. */
-    readonly proactiveScenarios: ProactiveScenarioService;
-    readonly proactive: ProactiveEventService;
-    readonly proactiveInbox: ProactiveInboxService;
-    readonly proactiveInsights: typeof listInsights;
-    readonly proactiveWorker: ProactiveWorker;
-    readonly proactiveTemporalWorker: ProactiveTemporalWorker;
-    readonly proactiveInboxWorker: ProactiveInboxWorker;
+    get sceneAccess(): SceneAccess | undefined;
     constructor(serviceConfig?: GatewayServiceConfig);
     /** Lazy AgentService — constructed on first use or during `start()`. */
     get agentService(): AgentService;
     refreshActionTrustPolicy(): void;
     refreshUserProfileContext(): void;
     private ensureAgentService;
-    private ensureHeartbeatService;
     private createTaskRunDispatcher;
     private createNotificationService;
     private readonly taskRunDispatch;
@@ -184,6 +175,7 @@ export declare class GatewayService {
     private schedulePostReadySidecars;
     private runPostReadySidecars;
     start(): Promise<void>;
+    private startRuntime;
     /** Called when the HTTP listener is bound (before deferred channel work). */
     markHttpListening(): void;
     isGatewayReady(): boolean;
@@ -202,7 +194,6 @@ export declare class GatewayService {
      * Start processing outbound messages and send through channels
      */
     private startOutboundProcessor;
-    reloadHeartbeatFromCurrentConfig(): void;
     reloadConfig(): Promise<{
         reloaded: boolean;
         error?: string;
@@ -256,18 +247,6 @@ export declare class GatewayService {
         manageable: boolean;
         order: number;
     }>;
-    heartbeatStatus(): {
-        enabled: boolean;
-        checksAllowed: boolean;
-        nextCheckAt: string;
-        recent: import("./heartbeat/check-store.js").HeartbeatCheck[];
-    };
-    /**
-     * Request an immediate heartbeat run (coalesced like interval/cron wakes).
-     */
-    requestHeartbeatNow(opts?: {
-        reason?: string;
-    }): void;
     requestConnectorLearning(connectionId: string, request?: Parameters<ConnectorLearningCoordinator['enqueueConnection']>[1]): ReturnType<ConnectorLearningCoordinator['enqueueConnection']>;
     requestConnectorLearningForToolkit(toolkit: string): ReturnType<ConnectorLearningCoordinator['enqueueToolkit']>;
     setConnectorLearningPaused(connectionId: string, paused: boolean): number;