@xopcai/xopc 0.0.227 → 0.0.228

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

@@ -1,4 +1,4 @@
-import { acknowledgeMobileActivityEvent, listMobileActivityEvents, registerMobileDevice, removeMobileDevice, updateMobileDevicePreferences } from "../../../mobile/notification-store.js";
+import { registerNotificationDevice, removeNotificationDevice, updateNotificationDevicePreferences } from "../../../notifications/device-store.js";
 //#region src/gateway/hono/routes/mobile.ts
 function stringField(value, maxLength) {
 	return typeof value === "string" && value.trim().length > 0 && value.trim().length <= maxLength ? value.trim() : null;
@@ -9,10 +9,15 @@ function parsePreferences(value) {
 	const source = value;
 	const result = {};
 	for (const key of [
-		"needsInput",
-		"failed",
-		"completed",
-		"automationFailed"
+		"chatCompleted",
+		"chatFailed",
+		"taskNeedsInput",
+		"taskBlocked",
+		"taskFailed",
+		"taskCompleted",
+		"automationCompleted",
+		"automationFailed",
+		"proactiveInsight"
 	]) {
 		if (source[key] === void 0) continue;
 		if (typeof source[key] !== "boolean") return null;
@@ -26,15 +31,8 @@ function parsePlatform(value) {
 function parsePermission(value) {
 	return value === "granted" || value === "denied" || value === "unknown" ? value : null;
 }
-function parseCursor(value) {
-	if (!value) return void 0;
-	const parsed = Number.parseInt(value, 10);
-	return Number.isFinite(parsed) && parsed > 0 ? parsed : void 0;
-}
-function parseLimit(value) {
-	if (!value) return void 0;
-	const parsed = Number.parseInt(value, 10);
-	return Number.isFinite(parsed) ? Math.max(1, Math.min(100, parsed)) : void 0;
+function parseLocale(value) {
+	return value === "en" || value === "zh" ? value : null;
 }
 function registerMobileRoutes(authenticated, _deps) {
 	authenticated.post("/api/mobile/devices/register", async (c) => {
@@ -44,17 +42,19 @@ function registerMobileRoutes(authenticated, _deps) {
 		const platform = parsePlatform(body?.platform);
 		const permissions = parsePermission(body?.permissions);
 		const preferences = parsePreferences(body?.preferences);
+		const locale = parseLocale(body?.locale);
 		const appVersion = body?.appVersion === void 0 ? void 0 : stringField(body.appVersion, 128);
-		if (!id || !pushToken || !platform || !permissions || preferences === null || appVersion === null) return c.json({
+		if (!id || !pushToken || !platform || !permissions || !locale || preferences === null || appVersion === null) return c.json({
 			ok: false,
 			error: "Invalid mobile device registration"
 		}, 400);
-		const device = registerMobileDevice({
+		const device = registerNotificationDevice({
 			id,
 			pushToken,
 			platform,
 			permissions,
 			preferences,
+			locale,
 			appVersion
 		});
 		return c.json({
@@ -68,7 +68,7 @@ function registerMobileRoutes(authenticated, _deps) {
 			ok: false,
 			error: "Invalid notification preferences"
 		}, 400);
-		const device = updateMobileDevicePreferences(c.req.param("id"), preferences);
+		const device = updateNotificationDevicePreferences(c.req.param("id"), preferences);
 		if (!device) return c.json({
 			ok: false,
 			error: "Mobile device not found"
@@ -81,31 +81,9 @@ function registerMobileRoutes(authenticated, _deps) {
 	authenticated.delete("/api/mobile/devices/:id", (c) => {
 		return c.json({
 			ok: true,
-			removed: removeMobileDevice(c.req.param("id"))
-		});
-	});
-	authenticated.get("/api/mobile/activity", (c) => {
-		const result = listMobileActivityEvents({
-			cursor: parseCursor(c.req.query("cursor")),
-			limit: parseLimit(c.req.query("limit"))
-		});
-		return c.json({
-			ok: true,
-			...result
+			removed: removeNotificationDevice(c.req.param("id"))
 		});
 	});
-	authenticated.post("/api/mobile/activity/:id/ack", async (c) => {
-		const deviceId = stringField((await c.req.json().catch(() => null))?.deviceId, 160);
-		if (!deviceId) return c.json({
-			ok: false,
-			error: "deviceId is required"
-		}, 400);
-		if (!acknowledgeMobileActivityEvent(c.req.param("id"), deviceId)) return c.json({
-			ok: false,
-			error: "Activity event or mobile device not found"
-		}, 404);
-		return c.json({ ok: true });
-	});
 }
 //#endregion
 export { registerMobileRoutes };

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

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

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

@@ -0,0 +1,45 @@
+import { acknowledgeNotification, listNotificationEvents, notificationDeliveryMetrics } from "../../../notifications/store.js";
+//#region src/gateway/hono/routes/notifications.ts
+function integerQuery(value, min, max) {
+	if (!value) return void 0;
+	const parsed = Number.parseInt(value, 10);
+	return Number.isFinite(parsed) ? Math.max(min, Math.min(max, parsed)) : void 0;
+}
+function stringField(value, maxLength) {
+	return typeof value === "string" && value.trim().length > 0 && value.trim().length <= maxLength ? value.trim() : null;
+}
+function registerNotificationRoutes(authenticated, _deps) {
+	authenticated.get("/api/notifications", (c) => {
+		const result = listNotificationEvents({
+			afterId: c.req.query("after")?.trim() || void 0,
+			since: integerQuery(c.req.query("since"), 0, Number.MAX_SAFE_INTEGER),
+			limit: integerQuery(c.req.query("limit"), 1, 100)
+		});
+		return c.json({
+			ok: true,
+			...result
+		});
+	});
+	authenticated.post("/api/notifications/:id/ack", async (c) => {
+		const body = await c.req.json().catch(() => null);
+		const consumerId = stringField(body?.consumerId, 160);
+		const surface = body?.surface;
+		if (!consumerId || surface !== "web" && surface !== "electron" && surface !== "mobile") return c.json({
+			ok: false,
+			error: "Invalid notification acknowledgement"
+		}, 400);
+		if (!acknowledgeNotification(c.req.param("id"), consumerId, surface)) return c.json({
+			ok: false,
+			error: "Notification not found"
+		}, 404);
+		return c.json({ ok: true });
+	});
+	authenticated.get("/api/notifications/metrics", (c) => {
+		return c.json({
+			ok: true,
+			deliveries: notificationDeliveryMetrics()
+		});
+	});
+}
+//#endregion
+export { registerNotificationRoutes };

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

@@ -60,6 +60,14 @@ function buildDirectSessionMetadata(params) {
 }
 function registerSessionsRoutes(authenticated, deps) {
 	const { service } = deps;
+	authenticated.get("/api/session-runs", (c) => {
+		const blocked = ensureGatewayReadyForSessions(c, service, "sessions.list");
+		if (blocked) return blocked;
+		return c.json({
+			ok: true,
+			payload: { runs: service.sessions.listActiveRuns() }
+		});
+	});
 	authenticated.get("/api/sidebar/chat-list", async (c) => {
 		const blocked = ensureGatewayReadyForSessions(c, service, "sessions.list");
 		if (blocked) return blocked;
@@ -648,6 +656,29 @@ function registerSessionsRoutes(authenticated, deps) {
 			}, 400);
 		}
 	});
+	authenticated.post("/api/sessions/:key/fork-at-turn", async (c) => {
+		const key = c.req.param("key");
+		const body = await c.req.json().catch(() => ({}));
+		const lastTurnId = typeof body.lastTurnId === "string" ? body.lastTurnId.trim() : "";
+		if (!lastTurnId) return c.json({
+			ok: false,
+			error: "lastTurnId is required"
+		}, 400);
+		try {
+			const result = await service.sessions.forkAtTurn(key, lastTurnId);
+			return c.json({
+				ok: true,
+				...result
+			}, 201);
+		} catch (err) {
+			const errorMessage = err instanceof Error ? err.message : String(err);
+			const status = errorMessage.startsWith("Session not found:") ? 404 : 409;
+			return c.json({
+				ok: false,
+				error: errorMessage
+			}, status);
+		}
+	});
 	authenticated.post("/api/sessions/:key/fork-row", async (c) => {
 		const key = c.req.param("key");
 		const body = await c.req.json().catch(() => ({}));

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

@@ -1,6 +1,7 @@
 import { runSqliteWriteTransaction } from "../../../storage/sqlite/transaction.js";
 import { TaskRepository } from "../../../tasks/task-repository.js";
 import { TaskConversationRepository } from "../../../tasks/task-conversation-repository.js";
+import { enqueueTaskChangedEvent } from "../../../tasks/task-change-events.js";
 import { TaskRunRepository } from "../../../tasks/task-run-repository.js";
 import { TaskReadModelProjector } from "../../../tasks/task-read-model-projector.js";
 import { TaskPhaseSchema } from "../../../../packages/gateway-contract/src/task-lifecycle.js";
@@ -8,7 +9,6 @@ import { TaskBoardPositionRequestSchema, TaskCommandRequestSchema, TaskContextIn
 import { ProjectMonitoringUpdateSchema } from "../../../../packages/gateway-contract/src/project-monitoring.js";
 import { resolveProjectAgentId } from "../../../projects/project-agent.js";
 import { TaskContextRepository } from "../../../tasks/task-context-repository.js";
-import { enqueueTaskChangedEvent } from "../../../tasks/task-change-events.js";
 import { TaskDependencyError, TaskDependencyService } from "../../../tasks/task-dependency-service.js";
 import { TaskApplicationService } from "../../../tasks/task-application-service.js";
 import { ProjectMonitoringService } from "../../../tasks/project-monitoring-service.js";

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

@@ -1,5 +1,7 @@
 import { createLogger } from "../../utils/logger/index.js";
 import { init_logger } from "../../utils/logger.js";
+import { listActiveSessionInputRuns } from "../../storage/sqlite/session-input-repository.js";
+import "../../storage/sqlite/index.js";
 import { ClarifyBridge } from "../clarify-bridge.js";
 import { runGatewayAgent } from "./run-gateway-agent.js";
 import { fitSourceContextsToBudget } from "../../agent/source-context/budget.js";
@@ -75,10 +77,12 @@ var GatewayAgentRunner = class {
 		return this.activeWebchatRunBySession.has(sessionKey);
 	}
 	getActiveRunId(sessionKey) {
-		return this.activeWebchatRunBySession.get(sessionKey);
+		return this.activeWebchatRunBySession.get(sessionKey) ?? this.inputs.snapshot(sessionKey).activeRunId;
 	}
 	listActiveRuns() {
-		return [...this.activeWebchatRunBySession.entries()].map(([sessionKey, runId]) => ({
+		const runs = new Map(listActiveSessionInputRuns().map(({ sessionKey, runId }) => [sessionKey, runId]));
+		for (const [sessionKey, runId] of this.activeWebchatRunBySession) runs.set(sessionKey, runId);
+		return [...runs].map(([sessionKey, runId]) => ({
 			sessionKey,
 			runId
 		}));

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

@@ -13,6 +13,7 @@ import { ChatStreamMapper } from "../chat-stream/mapper.js";
 import { resolveWebchatSessionKey } from "../resolve-webchat-session-key.js";
 import { recordExplicitRelationshipFollowUp } from "../../user-context/relationship-continuity.js";
 import { coalesceThinkingDeltas } from "../chat-stream/thinking-delta-coalescer.js";
+import { TurnOutcomeCollector } from "../chat-stream/turn-outcome-collector.js";
 import crypto from "crypto";
 //#region src/gateway/service/run-gateway-agent.ts
 init_logger();
@@ -34,9 +35,11 @@ async function* runGatewayAgent(deps, message, channel, chatId, origin, attachme
 	let taskRunStatus = "failed";
 	let taskRunSummary = "Agent run ended unexpectedly";
 	let terminalStatus = "error";
+	let runTopicCompleted = false;
 	let webchatSessionKey;
 	let webchatSessionId;
 	let webchatMetadata;
+	let outcomeEnvironment = "workspace";
 	if (channel === "webchat") {
 		const resolved = resolveWebchatSessionKey({ sessionKey: chatId });
 		if (resolved.ok === false) throw new Error(resolved.error);
@@ -65,6 +68,8 @@ async function* runGatewayAgent(deps, message, channel, chatId, origin, attachme
 			channel,
 			metadata: webchatMetadata
 		});
+		if (/remote/i.test(executionContext.strategy ?? "")) outcomeEnvironment = "remote_runtime";
+		else if (/worktree/i.test(executionContext.strategy ?? "")) outcomeEnvironment = "worktree";
 		taskRun = TaskRunCoordinator.start({
 			runId,
 			context: executionContext,
@@ -76,8 +81,11 @@ async function* runGatewayAgent(deps, message, channel, chatId, origin, attachme
 		sessionKey: streamSessionKey,
 		channel
 	});
+	const outcomeCollector = new TurnOutcomeCollector(runId, outcomeEnvironment);
+	let outcomeFinalized = false;
 	let registeredActiveWebchatRun = false;
 	const captureTaskEvent = (event) => {
+		outcomeCollector.capture(event);
 		if (event.type === "task_plan_updated") {
 			taskRun?.capturePlan(event.payload.items);
 			return;
@@ -102,6 +110,30 @@ async function* runGatewayAgent(deps, message, channel, chatId, origin, attachme
 			yield event;
 		}
 	};
+	const finalizeOutcome = async (status, summary) => {
+		if (outcomeFinalized) return [];
+		outcomeFinalized = true;
+		const outcome = outcomeCollector.finalize(status, summary);
+		if (webchatSessionKey) try {
+			await sessionIndex.appendTranscriptCustomEntry(webchatSessionKey, {
+				customType: "turn_outcome",
+				data: outcome
+			});
+		} catch (err) {
+			log.warn({
+				err,
+				runId,
+				sessionKey: webchatSessionKey
+			}, `Turn outcome persistence failed: ${err instanceof Error ? err.message : String(err)}`);
+		}
+		return [{
+			type: "turn_outcome",
+			runId,
+			sessionKey: streamSessionKey,
+			timestamp: Date.now(),
+			payload: outcome
+		}];
+	};
 	try {
 		yield* emitAndYield(mapper.start());
 		if (channel === "webchat" && webchatSessionKey) {
@@ -141,8 +173,10 @@ async function* runGatewayAgent(deps, message, channel, chatId, origin, attachme
 				taskRunStatus = mergedSignal.aborted ? "cancelled" : "succeeded";
 				terminalStatus = endStatus;
 				taskRunSummary = endSummary;
+				yield* emitAndYield(await finalizeOutcome(endStatus, endSummary));
 				yield* emitAndYield(mapper.end(endStatus, endSummary));
 				completeRealtimeTopic(`run:${runId}`);
+				runTopicCompleted = true;
 				return {
 					status: mergedSignal.aborted ? "aborted" : "ok",
 					summary: mergedSignal.aborted ? "Interrupted" : "Message processed successfully"
@@ -163,8 +197,10 @@ async function* runGatewayAgent(deps, message, channel, chatId, origin, attachme
 				taskRunSummary = em;
 				const errorContent = formatAgentRunErrorForClient(streamError);
 				yield* emitAndYield(mapper.error(errorContent));
+				yield* emitAndYield(await finalizeOutcome("error", streamError));
 				yield* emitAndYield(mapper.end("error", streamError));
 				completeRealtimeTopic(`run:${runId}`);
+				runTopicCompleted = true;
 				return {
 					status: "error",
 					summary: streamError
@@ -247,6 +283,7 @@ async function* runGatewayAgent(deps, message, channel, chatId, origin, attachme
 				presentation: "answer"
 			}
 		}]);
+		yield* emitAndYield(await finalizeOutcome("success", "Message processed"));
 		yield* emitAndYield(mapper.end("success", "Message processed"));
 		taskRunStatus = "succeeded";
 		taskRunSummary = "Message processed";
@@ -257,6 +294,7 @@ async function* runGatewayAgent(deps, message, channel, chatId, origin, attachme
 	} catch (error) {
 		const em = error instanceof Error ? error.message : String(error);
 		taskRunStatus = "failed";
+		terminalStatus = "error";
 		taskRunSummary = em;
 		log.error({
 			err: error,
@@ -266,6 +304,17 @@ async function* runGatewayAgent(deps, message, channel, chatId, origin, attachme
 			channel,
 			chatId
 		}, `Agent run failed: ${em}`);
+		if (channel === "webchat" && !runTopicCompleted) {
+			yield* emitAndYield(mapper.error(formatAgentRunErrorForClient(em)));
+			yield* emitAndYield(await finalizeOutcome("error", em));
+			yield* emitAndYield(mapper.end("error", em));
+			completeRealtimeTopic(`run:${runId}`);
+			runTopicCompleted = true;
+			return {
+				status: "error",
+				summary: em
+			};
+		}
 		throw error;
 	} finally {
 		if (taskRun) try {
@@ -292,7 +341,10 @@ async function* runGatewayAgent(deps, message, channel, chatId, origin, attachme
 				sessionKey: webchatSessionKey,
 				status: terminalStatus,
 				completedAtMs: Date.now(),
-				route: `/chat/${encodeURIComponent(webchatSessionKey)}`,
+				target: {
+					kind: "chat",
+					sessionKey: webchatSessionKey
+				},
 				source: "webchat",
 				...metaAfter?.name?.trim() ? { sessionTitle: metaAfter.name.trim().slice(0, 100) } : {}
 			});

package/dist/src/gateway/service/sessions-api.d.ts

@@ -159,6 +159,12 @@ export declare class GatewaySessionsApi {
         sessionKey: string;
         rowCount: number;
     }>;
+    forkAtTurn(sourceKey: string, lastTurnId: string): Promise<{
+        sessionKey: string;
+        rowCount: number;
+        lastTurnId: string;
+        session: NonNullable<Awaited<ReturnType<GatewaySessionsApi['getSession']>>>;
+    }>;
     btwQuery(sessionKey: string, question: string): Promise<{
         text: string;
         error?: string;

package/dist/src/gateway/service/sessions-api.js

@@ -1,11 +1,28 @@
+import { init_agent_session_key, resolveAgentIdFromSessionKey } from "../../routing/agent-session-key.js";
+import { buildSessionKey, init_session_key } from "../../routing/session-key.js";
 import { retireSessionMcpRuntimeForSessionKey } from "../../agent/mcp/bundle-mcp-runtime.js";
 import "../../agent/mcp/bundle-mcp-tools.js";
 import { buildSessionTimeline } from "../../session/transcript-outline.js";
 import { transcriptRowsToClientHistory } from "../../session/client-history.js";
-import { collectMediaUrisFromMessages, deleteMediaUris } from "../../media/session-references.js";
+import { collectMediaUrisFromValues, deleteMediaUris } from "../../media/session-references.js";
 import { getDistinctSessionChatIds } from "./session-chat-ids.js";
 import { performSessionReset } from "../session-reset-service.js";
+import { randomUUID } from "node:crypto";
 //#region src/gateway/service/sessions-api.ts
+/**
+* GatewaySessionsApi — session CRUD, search, compaction, tag/pin/archive,
+* stats, and chat-id grouping for the gateway REST surface.
+*
+* Twenty-four methods, previously sitting on `GatewayService` as a mix of
+* one-line `sessionIndex.*` delegations and small composite operations (e.g.
+* `restoreCheckpoint` also evicts the in-memory agent, `runCompaction` also
+* appends a transcript context entry). Centralising them here lets routes
+* depend on the narrow `GatewaySessionsApi` surface instead of the full
+* `GatewayService`, and keeps the gateway composition root focused on
+* lifecycle + wiring.
+*/
+init_session_key();
+init_agent_session_key();
 function clampWindowSpan(value, fallback) {
 	const parsed = Math.trunc(value ?? fallback);
 	if (!Number.isFinite(parsed)) return fallback;
@@ -117,10 +134,10 @@ var GatewaySessionsApi = class {
 		return result;
 	}
 	async delete(key) {
-		const messages = await this.opts.sessionIndex.loadMessages(key).catch(() => []);
+		const transcriptRows = await this.opts.sessionIndex.getStore().loadTranscriptHistoryRows(key).catch(() => []);
 		const result = await this.opts.sessionIndex.deleteSession(key);
 		if (result) {
-			await deleteMediaUris(collectMediaUrisFromMessages(messages));
+			await deleteMediaUris(collectMediaUrisFromValues(transcriptRows));
 			this.opts.getAgentService().evictSessionAgent(key);
 			await retireSessionMcpRuntimeForSessionKey({
 				sessionKey: key,
@@ -185,6 +202,46 @@ var GatewaySessionsApi = class {
 	forkRows(key, targetKey, options = {}) {
 		return this.opts.sessionIndex.forkSessionRows(key, targetKey, options);
 	}
+	async forkAtTurn(sourceKey, lastTurnId) {
+		const source = await this.opts.sessionIndex.getSessionMetadata(sourceKey);
+		if (!source) throw new Error(`Session not found: ${sourceKey}`);
+		if (source.sessionType !== "chat") throw new Error("Only chat sessions can be forked");
+		const normalizedTurnId = lastTurnId.trim();
+		if (!normalizedTurnId) throw new Error("lastTurnId is required");
+		if (this.opts.getActiveWebchatRunId(sourceKey)?.trim() === normalizedTurnId) throw new Error("Cannot fork a turn that is still running");
+		const agentId = source.routing?.agentId?.trim() || resolveAgentIdFromSessionKey(sourceKey);
+		const chatId = `chat_${randomUUID()}`;
+		const targetKey = buildSessionKey({
+			agentId,
+			source: "webchat",
+			accountId: "default",
+			peerKind: "direct",
+			peerId: chatId
+		});
+		const result = await this.opts.sessionIndex.forkSessionAtTurn(sourceKey, {
+			targetKey,
+			lastTurnId: normalizedTurnId,
+			targetMetadata: {
+				sourceChannel: "webchat",
+				sourceChatId: `default:direct:${chatId}`,
+				sessionType: "chat",
+				routing: {
+					agentId,
+					source: "webchat",
+					accountId: "default",
+					peerKind: "direct",
+					peerId: chatId
+				}
+			}
+		});
+		const session = await this.getSession(result.sessionKey);
+		if (!session) throw new Error(`Forked session not found: ${result.sessionKey}`);
+		return {
+			...result,
+			lastTurnId: normalizedTurnId,
+			session
+		};
+	}
 	btwQuery(sessionKey, question) {
 		return this.opts.getAgentService().sessionInspector.btwQuery(sessionKey, question);
 	}

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

@@ -68,7 +68,7 @@ export declare class GatewayService {
     private taskRunDispatcher;
     private taskRunDispatchTimer;
     private managedComposioEventPoller?;
-    private mobileNotifications;
+    private notificationService;
     private connectorSupervisor;
     private connectorLearningCoordinator;
     private connectedSourceChangePublisher;
@@ -120,7 +120,7 @@ export declare class GatewayService {
     private ensureAgentService;
     private ensureHeartbeatService;
     private createTaskRunDispatcher;
-    private createMobileNotificationService;
+    private createNotificationService;
     dispatchTaskRuns(): void;
     ensureTaskConversation(taskId: string, options?: {
         runId?: string;

package/dist/src/gateway/service.js

@@ -92,7 +92,7 @@ import { auditGatewayConfig } from "./security/audit.js";
 import { getXopcCloudCatalogCoordinator } from "../providers/xopc-cloud-catalog-coordinator.js";
 import { ModelCatalogSyncService } from "../providers/model-catalog-sync-service.js";
 import { runBootstrapMigrationsSync } from "../migrations/runner.js";
-import { MobileNotificationService } from "../mobile/notification-service.js";
+import { NotificationService } from "../notifications/service.js";
 import { LocalAppService } from "../local-apps/service.js";
 import "../local-apps/index.js";
 import { createRuntimeBrowserRecipeService } from "../browser/recipes/runtime-service.js";
@@ -185,7 +185,7 @@ var GatewayService = class {
 	taskRunDispatcher = null;
 	taskRunDispatchTimer = null;
 	managedComposioEventPoller;
-	mobileNotifications = null;
+	notificationService = null;
 	connectorSupervisor = null;
 	connectorLearningCoordinator = null;
 	connectedSourceChangePublisher = null;
@@ -239,7 +239,6 @@ var GatewayService = class {
 		this.proactiveTemporalWorker = new ProactiveTemporalWorker(this.proactive);
 		this.proactiveInboxWorker = new ProactiveInboxWorker({ deliver: async ({ inboxItem }) => {
 			this.emit("proactive.inbox.created", inboxItem);
-			await this.createMobileNotificationService().deliverGatewayEvent("proactive.inbox.created", inboxItem);
 		} });
 		let bootstrapConfigChanged = initializeVoiceDefaults(this.config, inferProductLanguageFromEnvironment());
 		const starterResult = ensureStarterAgentsInitialized(this.config);
@@ -574,9 +573,9 @@ var GatewayService = class {
 		});
 		return this.taskRunDispatcher;
 	}
-	createMobileNotificationService() {
-		if (!this.mobileNotifications) this.mobileNotifications = new MobileNotificationService();
-		return this.mobileNotifications;
+	createNotificationService() {
+		if (!this.notificationService) this.notificationService = new NotificationService({ publish: (type, payload) => this.realtime.broker.publish("gateway", type, payload) });
+		return this.notificationService;
 	}
 	dispatchTaskRuns() {
 		new TaskSignalService().tick();
@@ -798,6 +797,7 @@ var GatewayService = class {
 		});
 		log.debug("Starting gateway service...");
 		openXopcDatabase();
+		this.createNotificationService().start();
 		this.startTime = Date.now();
 		this.running = true;
 		this.taskRunDispatchTimer = setInterval(() => this.dispatchTaskRuns(), 1e3);
@@ -1103,6 +1103,7 @@ var GatewayService = class {
 		await this.discussionLiveWorker.stop();
 		this.proactiveTemporalWorker.stop();
 		await this.proactiveInboxWorker.stop();
+		this.notificationService?.stop();
 		if (this.taskRunDispatchTimer) {
 			clearInterval(this.taskRunDispatchTimer);
 			this.taskRunDispatchTimer = null;
@@ -1543,7 +1544,7 @@ var GatewayService = class {
 	}
 	emit(type, payload) {
 		this.realtime.broker.publish("gateway", type, payload);
-		this.createMobileNotificationService().handleGatewayEvent(type, payload);
+		this.createNotificationService().handleGatewayEvent(type, payload);
 	}
 	handleAutomationRunCompleted(run) {
 		this.automationService.get(run.automationId).then((automation) => {

package/dist/src/history/ctx/exporter.d.ts

@@ -0,0 +1,14 @@
+import type { DatabaseSync } from 'node:sqlite';
+export interface CtxHistoryExportResult {
+    outputDir: string;
+    historyPath: string;
+    manifestPath: string;
+    sessionCount: number;
+    eventCount: number;
+    changed: boolean;
+}
+export declare function resolveDefaultCtxHistoryExportDir(env?: NodeJS.ProcessEnv): string;
+export declare function exportCtxHistory(db: DatabaseSync, options?: {
+    outputDir?: string;
+    env?: NodeJS.ProcessEnv;
+}): Promise<CtxHistoryExportResult>;