@xopcai/xopc 0.0.227 → 0.0.229

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

@@ -1,7 +1,7 @@
 import { UNDERSTANDING_KINDS } from "../../../user-context/domain.js";
 import { listContextExtractionRuns } from "../../../storage/sqlite/context-extraction-repository.js";
 import { listContextConsolidationRuns } from "../../../storage/sqlite/context-consolidation-repository.js";
-import { createCollaborationRule, createUnderstanding, decideContextConsent, deleteCollaborationRule, deleteUnderstanding, getCollaborationRule, getTurnPersonalization, getUnderstanding, getUserProfile, listCollaborationRules, listUnderstandingEvidence, listUnderstandings, recordContextFeedback, rejectUnderstanding, reviseCollaborationRule, reviseUnderstanding, setCollaborationRuleStatus, setUnderstandingStatus, updateUserProfile } from "../../../storage/sqlite/user-context-repository.js";
+import { createCollaborationRule, createUnderstanding, decideContextConsent, deleteCollaborationRule, deleteUnderstanding, getCollaborationRule, getTurnPersonalization, getUnderstanding, getUserProfile, listCollaborationRules, listUnderstandingEvidence, listUnderstandingStatusEvents, listUnderstandings, recordContextFeedback, rejectUnderstanding, reviseCollaborationRule, reviseUnderstanding, setCollaborationRuleStatus, setUnderstandingStatus, updateUserProfile } from "../../../storage/sqlite/user-context-repository.js";
 import "../../../storage/sqlite/index.js";
 import { listUserFocuses, updateUserFocus } from "../../../user-context/sources/repository.js";
 import { canonicalUnderstandingKey, findDuplicateUnderstanding } from "../../../user-context/understanding.js";
@@ -199,8 +199,13 @@ function registerYouRoutes(authenticated, deps) {
 		const objects = normalized.map(({ objectType, objectId, action }) => {
 			if (objectType === "understanding") return action === "accept" ? setUnderstandingStatus(objectId, "active", {
 				explicitness: "explicit",
-				confidence: 1
-			}) : action === "reject" ? rejectUnderstanding(objectId, "Rejected during context review") : setUnderstandingStatus(objectId, "needs_review");
+				confidence: 1,
+				actorType: "user",
+				source: "context-review"
+			}) : action === "reject" ? rejectUnderstanding(objectId, "Rejected during context review", "user") : setUnderstandingStatus(objectId, "needs_review", {
+				actorType: "user",
+				source: "context-review-later"
+			});
 			return updateUserFocus(objectId, { status: action === "accept" ? "active" : action === "reject" ? "rejected" : "paused" });
 		});
 		return c.json({ objects });
@@ -271,7 +276,10 @@ function registerYouRoutes(authenticated, deps) {
 	authenticated.get("/api/you/understandings/:id/evidence", (c) => {
 		const understanding = getUnderstanding(c.req.param("id"));
 		if (!understanding) return c.json({ error: "Understanding not found" }, 404);
-		return c.json({ evidence: listUnderstandingEvidence(understanding.id) });
+		return c.json({
+			evidence: listUnderstandingEvidence(understanding.id),
+			statusEvents: listUnderstandingStatusEvents(understanding.id)
+		});
 	});
 	authenticated.patch("/api/you/understandings/:id", write, async (c) => {
 		const id = c.req.param("id");
@@ -299,10 +307,14 @@ function registerYouRoutes(authenticated, deps) {
 		}
 		if (body.status !== void 0) {
 			if (!UNDERSTANDING_STATUSES.has(body.status)) return c.json({ error: "Invalid status" }, 400);
-			understanding = body.status === "rejected" ? rejectUnderstanding(id, nonEmptyString(body.reason, 500) ?? "Rejected by user") : setUnderstandingStatus(id, body.status, body.status === "active" ? {
-				explicitness: "explicit",
-				confidence: 1
-			} : void 0);
+			understanding = body.status === "rejected" ? rejectUnderstanding(id, nonEmptyString(body.reason, 500) ?? "Rejected by user", "user") : setUnderstandingStatus(id, body.status, {
+				...body.status === "active" ? {
+					explicitness: "explicit",
+					confidence: 1
+				} : {},
+				actorType: "user",
+				source: "understanding-edit"
+			});
 		}
 		return c.json({ understanding });
 	});
@@ -374,9 +386,15 @@ function registerYouRoutes(authenticated, deps) {
 			...typeof body.reason === "string" ? { reason: body.reason.slice(0, 500) } : {}
 		});
 		if (objectType === "understanding" && typeof objectId === "string") {
-			if (rating === "wrong") rejectUnderstanding(objectId, "Marked wrong from turn feedback");
-			if (rating === "stale") setUnderstandingStatus(objectId, "stale");
-			if (rating === "sensitive") setUnderstandingStatus(objectId, "needs_review");
+			if (rating === "wrong") rejectUnderstanding(objectId, "Marked wrong from turn feedback", "user");
+			if (rating === "stale") setUnderstandingStatus(objectId, "stale", {
+				actorType: "user",
+				source: "turn-feedback-stale"
+			});
+			if (rating === "sensitive") setUnderstandingStatus(objectId, "needs_review", {
+				actorType: "user",
+				source: "turn-feedback-sensitive"
+			});
 		}
 		if (objectType === "focus" && typeof objectId === "string") {
 			if (rating === "wrong") updateUserFocus(objectId, { status: "rejected" });

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 {
@@ -282,6 +331,9 @@ async function* runGatewayAgent(deps, message, channel, chatId, origin, attachme
 		}
 		if (webchatSessionKey) {
 			const metaAfter = await sessionIndex.getSessionMetadata(webchatSessionKey).catch(() => void 0);
+			const normalizedResponse = terminalStatus === "success" ? mapper.getLastAssistantText().replace(/\s+/g, " ").trim() : "";
+			const responseCharacters = Array.from(normalizedResponse);
+			const responsePreview = responseCharacters.length > 180 ? `${responseCharacters.slice(0, 179).join("")}…` : normalizedResponse;
 			if (metaAfter?.name) emit("session.updated", {
 				key: webchatSessionKey,
 				name: metaAfter.name
@@ -292,9 +344,13 @@ 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) } : {}
+				...metaAfter?.name?.trim() ? { sessionTitle: metaAfter.name.trim().slice(0, 100) } : {},
+				...responsePreview ? { responsePreview } : {}
 			});
 		}
 	}

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

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;