@xopcai/xopc 0.0.225 → 0.0.228

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/hono/routes/voice.js

@@ -14,8 +14,8 @@ import "../../../voice/stt/index.js";
 import { listSttProvidersForApi } from "../../../voice/stt/list-providers.js";
 import "../../../voice/tts/index.js";
 import { createGatewayRouteLogger } from "../lib/route-logger.js";
-import { listTtsProvidersForApi } from "../../../voice/tts/list-providers.js";
 import { listLocalVoiceModelStatuses, removeLocalVoiceModel, startLocalVoiceModelInstall } from "../../../voice/local/model-manager.js";
+import { listTtsProvidersForApi } from "../../../voice/tts/list-providers.js";
 //#region src/gateway/hono/routes/voice.ts
 init_providers();
 const log = createGatewayRouteLogger("Voice");

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

@@ -7,6 +7,8 @@ import { listUserFocuses, updateUserFocus } from "../../../user-context/sources/
 import { canonicalUnderstandingKey, findDuplicateUnderstanding } from "../../../user-context/understanding.js";
 import { listContextObjects } from "../../../user-context/context-objects.js";
 import { repairExtractedContext } from "../../../user-context/extraction/repair.js";
+import { getUserRelationship, listUserRelationships, mergeUserRelationships, patchUserRelationship } from "../../../user-context/relationships/service.js";
+import { USER_PERSON_KINDS } from "../../../user-context/relationships/types.js";
 import { userInfo } from "node:os";
 //#region src/gateway/hono/routes/you.ts
 const UNDERSTANDING_KIND_SET = new Set(UNDERSTANDING_KINDS);
@@ -42,6 +44,7 @@ const CONTEXT_OBJECT_VIEWS = new Set([
 	"review",
 	"history"
 ]);
+const USER_PERSON_KIND_SET = new Set(USER_PERSON_KINDS);
 function asRecord(value) {
 	return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
 }
@@ -99,6 +102,55 @@ function registerYouRoutes(authenticated, deps) {
 		rules: listCollaborationRules(),
 		consolidation: { lastRun: listContextConsolidationRuns(1)[0] ?? null }
 	}));
+	authenticated.get("/api/you/relationships", (c) => {
+		const kind = c.req.query("kind");
+		if (kind && !USER_PERSON_KIND_SET.has(kind)) return c.json({ error: "Invalid relationship kind" }, 400);
+		const requestedLimit = Number(c.req.query("limit") ?? "30");
+		if (!Number.isInteger(requestedLimit) || requestedLimit < 1 || requestedLimit > 100) return c.json({ error: "limit must be an integer from 1 to 100" }, 400);
+		const cursor = c.req.query("cursor");
+		if (cursor && !/^\d+$/.test(cursor)) return c.json({ error: "Invalid cursor" }, 400);
+		return c.json(listUserRelationships({
+			query: c.req.query("q") ?? "",
+			...kind ? { kind } : {},
+			...c.req.query("source") ? { sourceInstanceId: c.req.query("source") } : {},
+			includeHidden: c.req.query("includeHidden") === "true",
+			hiddenOnly: c.req.query("hidden") === "true",
+			...cursor ? { cursor } : {},
+			limit: requestedLimit
+		}));
+	});
+	authenticated.get("/api/you/relationships/:id", (c) => {
+		const person = getUserRelationship(c.req.param("id"));
+		return person ? c.json({ person }) : c.json({ error: "Relationship not found" }, 404);
+	});
+	authenticated.patch("/api/you/relationships/:id", write, async (c) => {
+		const body = await readBody(c);
+		if (!body) return c.json({ error: "Invalid JSON" }, 400);
+		const patch = {};
+		if (body.displayName !== void 0) {
+			if (body.displayName !== null && (typeof body.displayName !== "string" || body.displayName.trim().length > 160)) return c.json({ error: "displayName must be null or a string of at most 160 characters" }, 400);
+			patch.displayName = typeof body.displayName === "string" && body.displayName.trim() ? body.displayName.trim() : null;
+		}
+		if (body.kind !== void 0) {
+			if (body.kind !== null && !USER_PERSON_KIND_SET.has(body.kind)) return c.json({ error: "Invalid relationship kind" }, 400);
+			patch.kind = body.kind;
+		}
+		if (body.hidden !== void 0) {
+			if (typeof body.hidden !== "boolean") return c.json({ error: "hidden must be a boolean" }, 400);
+			patch.hidden = body.hidden;
+		}
+		if (!Object.keys(patch).length) return c.json({ error: "No relationship fields provided" }, 400);
+		const person = patchUserRelationship(c.req.param("id"), patch);
+		return person ? c.json({ person }) : c.json({ error: "Relationship not found" }, 404);
+	});
+	authenticated.post("/api/you/relationships/merge", write, async (c) => {
+		const body = await readBody(c);
+		const sourcePersonId = nonEmptyString(body?.sourcePersonId, 200);
+		const targetPersonId = nonEmptyString(body?.targetPersonId, 200);
+		if (!sourcePersonId || !targetPersonId || sourcePersonId === targetPersonId) return c.json({ error: "Distinct sourcePersonId and targetPersonId are required" }, 400);
+		const person = mergeUserRelationships(sourcePersonId, targetPersonId);
+		return person ? c.json({ person }) : c.json({ error: "Relationship not found" }, 404);
+	});
 	authenticated.get("/api/you/context-objects", (c) => {
 		const view = c.req.query("view") ?? "current";
 		if (!CONTEXT_OBJECT_VIEWS.has(view)) return c.json({ error: "Invalid context object view" }, 400);

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/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/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>;

package/dist/src/history/ctx/exporter.js

@@ -0,0 +1,99 @@
+import { init_paths_state, resolveStateDir } from "../../config/paths-state.js";
+import { init_write_file_atomic, writeTextAtomic } from "../../infra/write-file-atomic.js";
+import { buildCtxHistoryJsonl, buildCtxPluginManifest } from "./format.js";
+import { join, resolve } from "node:path";
+import { mkdir, readFile } from "node:fs/promises";
+//#region src/history/ctx/exporter.ts
+init_paths_state();
+init_write_file_atomic();
+function readSnapshot(db) {
+	db.exec("BEGIN");
+	try {
+		const transcripts = db.prepare(`SELECT
+         t.session_id,
+         t.status,
+         t.created_at,
+         t.archived_at,
+         t.cwd,
+         s.agent_id,
+         s.session_type
+       FROM transcripts t
+       JOIN sessions s ON s.session_key = t.session_key
+       WHERE t.status = 'active' OR t.archive_reason IN ('reset', 'stale')
+       ORDER BY t.created_at ASC, t.session_id ASC`).all();
+		const entries = db.prepare(`SELECT e.entry_id, e.session_id, e.seq, e.payload_json, e.created_at
+       FROM transcript_entries e
+       JOIN transcripts t ON t.session_id = e.session_id
+       JOIN sessions s ON s.session_key = t.session_key
+       WHERE t.status = 'active' OR t.archive_reason IN ('reset', 'stale')
+       ORDER BY t.created_at ASC, t.session_id ASC, e.seq ASC, e.entry_id ASC`).all();
+		db.exec("COMMIT");
+		const entriesBySession = /* @__PURE__ */ new Map();
+		for (const entry of entries) {
+			const bucket = entriesBySession.get(entry.session_id) ?? [];
+			bucket.push({
+				entryId: entry.entry_id,
+				seq: entry.seq,
+				createdAt: entry.created_at,
+				payloadJson: entry.payload_json
+			});
+			entriesBySession.set(entry.session_id, bucket);
+		}
+		return transcripts.map((transcript) => ({
+			sessionId: transcript.session_id,
+			status: transcript.status,
+			createdAt: transcript.created_at,
+			archivedAt: transcript.archived_at,
+			cwd: transcript.cwd,
+			agentId: transcript.agent_id,
+			sessionType: transcript.session_type,
+			entries: entriesBySession.get(transcript.session_id) ?? []
+		}));
+	} catch (error) {
+		try {
+			db.exec("ROLLBACK");
+		} catch {}
+		throw error;
+	}
+}
+async function writeIfChanged(path, contents) {
+	let existing = null;
+	try {
+		existing = await readFile(path, "utf8");
+	} catch (error) {
+		if (error.code !== "ENOENT") throw error;
+	}
+	if (existing === contents) return false;
+	await writeTextAtomic(path, contents, {
+		mode: 384,
+		ensureDirMode: 448
+	});
+	return true;
+}
+function resolveDefaultCtxHistoryExportDir(env = process.env) {
+	return join(resolveStateDir(env), "exports", "ctx");
+}
+async function exportCtxHistory(db, options = {}) {
+	const outputDir = resolve(options.outputDir ?? resolveDefaultCtxHistoryExportDir(options.env));
+	const historyPath = join(outputDir, "history.jsonl");
+	const manifestPath = join(outputDir, "ctx-history-plugin.json");
+	const sessions = readSnapshot(db);
+	const history = buildCtxHistoryJsonl(sessions);
+	const manifest = buildCtxPluginManifest();
+	await mkdir(outputDir, {
+		recursive: true,
+		mode: 448
+	});
+	const historyChanged = await writeIfChanged(historyPath, history.contents);
+	const manifestChanged = await writeIfChanged(manifestPath, manifest);
+	return {
+		outputDir,
+		historyPath,
+		manifestPath,
+		sessionCount: sessions.length,
+		eventCount: history.eventCount,
+		changed: historyChanged || manifestChanged
+	};
+}
+//#endregion
+export { exportCtxHistory, resolveDefaultCtxHistoryExportDir };

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

@@ -0,0 +1,25 @@
+export declare const CTX_HISTORY_SCHEMA_VERSION = "ctx-history-jsonl-v2";
+export declare const CTX_PROVIDER_KEY = "xopc";
+export declare const CTX_SOURCE_ID = "default";
+export declare const CTX_SOURCE_FORMAT = "xopc-session-history-v1";
+export interface XopcHistorySession {
+    sessionId: string;
+    status: string;
+    createdAt: number;
+    archivedAt: number | null;
+    cwd: string;
+    agentId: string;
+    sessionType: string | null;
+    entries: XopcHistoryEntry[];
+}
+export interface XopcHistoryEntry {
+    entryId: string;
+    seq: number;
+    createdAt: number;
+    payloadJson: string;
+}
+export declare function buildCtxHistoryJsonl(sessions: XopcHistorySession[]): {
+    contents: string;
+    eventCount: number;
+};
+export declare function buildCtxPluginManifest(): string;