@xopcai/xopc 0.0.189 → 0.0.190

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

@@ -43,7 +43,7 @@ export interface GatewayConfigCoordinatorOptions {
     getExtensionLoader: () => ExtensionLoader | null;
     /** Re-evaluate browser-extension server attachment after agent defaults change. */
     reconcileBrowserExtensionServer: () => Promise<void>;
-    /** Sync built-in dreaming automations after memory.dreaming changes. */
+    /** Sync the built-in consolidation automation after userContext.dreaming changes. */
     reconcileDreamingAutomations: () => Promise<void>;
     /** Latest channel status snapshot for the `channels.status` event. */
     getChannelsStatus: () => unknown;

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

@@ -6,11 +6,11 @@ import "../../storage/sqlite/index.js";
 import { init_session_key, parseSessionKey } from "../../routing/session-key.js";
 import { resolveExecutionContext } from "../../tasks/execution-context.js";
 import { TaskRunCoordinator } from "../../tasks/task-run-coordinator.js";
-import { recordExplicitRelationshipFollowUp } from "../../user-context/relationship-continuity.js";
 import { formatAgentRunErrorForClient } from "../../agent/client-error-format.js";
 import { prependEnvelopeTimestamp } from "../../channels/envelope-timestamp.js";
 import "../chat-limits.js";
 import { resolveWebchatSessionKey } from "../resolve-webchat-session-key.js";
+import { recordExplicitRelationshipFollowUp } from "../../user-context/relationship-continuity.js";
 import { ChatStreamMapper } from "../chat-stream/mapper.js";
 import { coalesceThinkingDeltas } from "../chat-stream/thinking-delta-coalescer.js";
 import crypto from "crypto";
@@ -49,15 +49,13 @@ async function* runGatewayAgent(deps, message, channel, chatId, origin, attachme
 	const streamSessionKey = webchatSessionKey ?? chatId;
 	if (webchatSessionKey) {
 		if (!webchatMetadata) throw new Error("Session metadata is unavailable");
-		const parsedSession = parseSessionKey(webchatSessionKey);
-		if (!parsedSession) throw new Error("Resolved webchat session key is invalid");
+		if (!parseSessionKey(webchatSessionKey)) throw new Error("Resolved webchat session key is invalid");
 		updateInteractionStateFromMessage({
 			sessionKey: webchatSessionKey,
 			message
 		});
 		recordExplicitRelationshipFollowUp({
 			sessionKey: webchatSessionKey,
-			sourceAgentId: parsedSession.agentId,
 			message
 		});
 		const executionContext = resolveExecutionContext({

package/dist/src/knowledge/connected-knowledge-pipeline.js

@@ -1,7 +1,7 @@
 import { createLogger } from "../utils/logger/index.js";
 import { init_logger } from "../utils/logger.js";
-import { getMemoryRecord, upsertMemoryRecord } from "../storage/sqlite/memory-records-repository.js";
 import { attachMemoryEvidence, claimKnowledgeSourceItems, completeKnowledgeSourceItemSynthesis, deleteMemoryEvidenceForRecord, listKnowledgeSourceItems } from "../storage/sqlite/knowledge-repository.js";
+import { getMemoryRecord, upsertMemoryRecord } from "../storage/sqlite/memory-records-repository.js";
 import "../storage/sqlite/index.js";
 import { createHash, randomUUID } from "node:crypto";
 //#region src/knowledge/connected-knowledge-pipeline.ts

package/dist/src/knowledge/connected-understanding-pipeline.d.ts

@@ -1,17 +1,15 @@
 import type { UnderstandingCandidate, UnderstandingReviewResult } from '../agent/memory/understanding/types.js';
 import type { MemoryManager } from '../agent/memory/manager.js';
-import { resolveUserEntity, type UserClaim, type UserClaimClass } from '../storage/sqlite/index.js';
 import type { KnowledgeSourceItem } from './types.js';
 export type ClaimObservation = {
-    class: UserClaimClass;
+    class: 'relationship' | 'project' | 'routine';
     key: string;
     value: Record<string, unknown>;
-    subject?: Parameters<typeof resolveUserEntity>[0];
     items: KnowledgeSourceItem[];
     windowDays: number;
 };
 export declare function deriveConnectedClaimObservations(items: KnowledgeSourceItem[]): ClaimObservation[];
-export declare function renderUserClaim(claim: UserClaim): UnderstandingCandidate;
+export declare function renderConnectedObservation(observation: ClaimObservation): UnderstandingCandidate;
 export declare class ConnectedUnderstandingPipeline {
     private readonly memoryManager;
     constructor(memoryManager: MemoryManager);

package/dist/src/knowledge/connected-understanding-pipeline.js

@@ -1,4 +1,3 @@
-import { linkUserClaimMemoryRecord, reinforceUserClaim, resolveUserEntity } from "../storage/sqlite/user-claims-repository.js";
 import { listKnowledgeSourceItems } from "../storage/sqlite/knowledge-repository.js";
 import "../storage/sqlite/index.js";
 //#region src/knowledge/connected-understanding-pipeline.ts
@@ -43,30 +42,9 @@ function relationshipObservations(items) {
 			const strongIdentity = (signal.email ?? signal.username)?.toLowerCase();
 			if (strongIdentity && owners.has(strongIdentity)) continue;
 			const label = signal.name ?? signal.email ?? signal.username;
-			const handles = [
-				...signal.email ? [{
-					type: "email",
-					value: signal.email,
-					sourceScope: "global",
-					verified: true
-				}] : [],
-				...signal.username ? [{
-					type: "provider_user",
-					value: signal.username,
-					sourceScope: String(item.metadata.toolkit ?? item.sourceInstanceId),
-					verified: true
-				}] : [],
-				...signal.name ? [{
-					type: "display_name",
-					value: signal.name,
-					sourceScope: item.sourceInstanceId,
-					verified: false
-				}] : []
-			];
 			const identityKey = signal.email?.toLowerCase() ?? `${String(item.metadata.toolkit ?? item.sourceInstanceId)}:${signal.username?.toLowerCase() ?? signal.name?.toLowerCase()}`;
 			const entry = grouped.get(identityKey) ?? {
 				label,
-				handles,
 				events: /* @__PURE__ */ new Map()
 			};
 			const eventKey = logicalEventKey(item);
@@ -76,13 +54,8 @@ function relationshipObservations(items) {
 	}
 	return [...grouped.values()].sort((left, right) => right.events.size - left.events.size).slice(0, 8).map((entry) => ({
 		class: "relationship",
-		key: "person",
+		key: `person:${entry.label.toLocaleLowerCase()}`,
 		value: { label: entry.label },
-		subject: {
-			type: "person",
-			canonicalLabel: entry.label,
-			handles: entry.handles
-		},
 		items: [...entry.events.values()],
 		windowDays: 90
 	}));
@@ -131,18 +104,8 @@ function projectObservations(items) {
 		const { label: subject, events } = entry;
 		return {
 			class: "project",
-			key: "project",
+			key: `project:${subject.toLocaleLowerCase()}`,
 			value: { label: subject },
-			subject: {
-				type: "project",
-				canonicalLabel: subject,
-				handles: [{
-					type: "provider_user",
-					value: subject,
-					sourceScope: "project",
-					verified: true
-				}]
-			},
 			items: [...events.values()],
 			windowDays: 60
 		};
@@ -156,34 +119,41 @@ function deriveConnectedClaimObservations(items) {
 		...projectObservations(active)
 	];
 }
-function renderUserClaim(claim) {
-	const label = typeof claim.value.label === "string" ? claim.value.label : "";
-	if (claim.class === "relationship") return {
+function confidenceFor(observation) {
+	const days = new Set(observation.items.map((item) => item.occurredAt?.slice(0, 10)).filter(Boolean)).size;
+	return Math.min(.92, .48 + Math.min(observation.items.length, 8) * .035 + Math.min(days, 5) * .045);
+}
+function isDurableObservation(observation) {
+	const days = new Set(observation.items.map((item) => item.occurredAt?.slice(0, 10)).filter(Boolean)).size;
+	return observation.items.length >= 3 && days >= (observation.class === "routine" ? 3 : 2);
+}
+function renderConnectedObservation(observation) {
+	const label = typeof observation.value.label === "string" ? observation.value.label : "";
+	const confidence = confidenceFor(observation);
+	if (observation.class === "relationship") return {
 		kind: "relationship",
 		content: `Frequently collaborates with ${label}.`,
-		canonicalKey: `claim:${claim.id}`,
-		confidence: claim.confidence,
+		canonicalKey: `connected:${observation.key}`,
+		confidence,
 		importance: .65,
 		explicitness: "inferred",
 		durability: "recurring",
 		sensitivity: "personal",
-		disclosurePolicy: "ask_before_reference",
-		tags: ["connected-source", "structured-claim"]
+		disclosurePolicy: "ask_before_reference"
 	};
-	if (claim.class === "project") return {
+	if (observation.class === "project") return {
 		kind: "project_context",
 		content: `Recently contributed repeatedly to ${label}.`,
-		canonicalKey: `claim:${claim.id}`,
-		confidence: claim.confidence,
+		canonicalKey: `connected:${observation.key}`,
+		confidence,
 		importance: .72,
 		explicitness: "inferred",
 		durability: "recurring",
 		sensitivity: "personal",
-		disclosurePolicy: "referenceable",
-		tags: ["connected-source", "structured-claim"]
+		disclosurePolicy: "referenceable"
 	};
-	const weekday = Number(claim.value.weekday);
-	const hour = Number(claim.value.hour);
+	const weekday = Number(observation.value.weekday);
+	const hour = Number(observation.value.hour);
 	return {
 		kind: "routine",
 		content: `Often has calendar activity on ${[
@@ -195,14 +165,13 @@ function renderUserClaim(claim) {
 			"Friday",
 			"Saturday"
 		][weekday] ?? "Unknown"} around ${String(hour).padStart(2, "0")}:00 UTC.`,
-		canonicalKey: `claim:${claim.id}`,
-		confidence: claim.confidence,
+		canonicalKey: `connected:${observation.key}`,
+		confidence,
 		importance: .58,
 		explicitness: "inferred",
 		durability: "recurring",
 		sensitivity: "personal",
-		disclosurePolicy: "referenceable",
-		tags: ["connected-source", "structured-claim"]
+		disclosurePolicy: "referenceable"
 	};
 }
 var ConnectedUnderstandingPipeline = class {
@@ -223,29 +192,12 @@ var ConnectedUnderstandingPipeline = class {
 			createdRecords: []
 		};
 		for (const observation of observations) {
-			const subject = observation.subject ? resolveUserEntity(observation.subject) : void 0;
-			const claim = reinforceUserClaim({
-				agentId,
-				class: observation.class,
-				key: subject ? `${observation.key}:${subject.id}` : observation.key,
-				subjectEntityId: subject?.id,
-				value: observation.value,
-				evidence: observation.items.map((item) => ({
-					logicalEventKey: logicalEventKey(item),
-					sourceItemId: item.id,
-					sourceInstanceId: item.sourceInstanceId,
-					relation: "supports",
-					observedAt: item.occurredAt
-				}))
-			});
-			if (claim.state !== "active") continue;
-			const result = await this.memoryManager.applyUnderstandingCandidates([renderUserClaim(claim)], {
-				agentId,
+			if (!isDurableObservation(observation)) continue;
+			const result = await this.memoryManager.applyUnderstandingCandidates([renderConnectedObservation(observation)], {
 				sourceItemIds: observation.items.map((item) => item.id).slice(0, 20),
 				sourceText: JSON.stringify({
-					claimId: claim.id,
-					independentEvidenceCount: claim.independentEvidenceCount,
-					activeDays: claim.activeDayCount,
+					independentEvidenceCount: observation.items.length,
+					activeDays: new Set(observation.items.map((item) => item.occurredAt?.slice(0, 10))).size,
 					windowDays: observation.windowDays
 				}),
 				source: {
@@ -254,8 +206,6 @@ var ConnectedUnderstandingPipeline = class {
 				},
 				reviewSource: "background"
 			});
-			const memoryRecordId = result.createdRecords[0]?.id;
-			if (memoryRecordId) linkUserClaimMemoryRecord(claim.id, memoryRecordId);
 			totals.created += result.created;
 			totals.deduplicated += result.deduplicated;
 			totals.rejected += result.rejected;
@@ -265,4 +215,4 @@ var ConnectedUnderstandingPipeline = class {
 	}
 };
 //#endregion
-export { ConnectedUnderstandingPipeline, deriveConnectedClaimObservations, renderUserClaim };
+export { ConnectedUnderstandingPipeline, deriveConnectedClaimObservations, renderConnectedObservation };

package/dist/src/knowledge/index.js

@@ -1,7 +1,7 @@
 import { KnowledgeIngestionService, SqliteKnowledgeSourceStateStore } from "./ingestion-service.js";
 import { ConnectedKnowledgePipeline } from "./connected-knowledge-pipeline.js";
-import { ConnectedUnderstandingPipeline, deriveConnectedClaimObservations, renderUserClaim } from "./connected-understanding-pipeline.js";
+import { ConnectedUnderstandingPipeline, deriveConnectedClaimObservations, renderConnectedObservation } from "./connected-understanding-pipeline.js";
 import { startConnectedKnowledgeCoordinator } from "./coordinator.js";
 import { LocalFolderKnowledgeSourceAdapter } from "./local-folder-adapter.js";
 import { buildConnectedPeopleGraph } from "./people-graph.js";
-export { ConnectedKnowledgePipeline, ConnectedUnderstandingPipeline, KnowledgeIngestionService, LocalFolderKnowledgeSourceAdapter, SqliteKnowledgeSourceStateStore, buildConnectedPeopleGraph, deriveConnectedClaimObservations, renderUserClaim, startConnectedKnowledgeCoordinator };
+export { ConnectedKnowledgePipeline, ConnectedUnderstandingPipeline, KnowledgeIngestionService, LocalFolderKnowledgeSourceAdapter, SqliteKnowledgeSourceStateStore, buildConnectedPeopleGraph, deriveConnectedClaimObservations, renderConnectedObservation, startConnectedKnowledgeCoordinator };

package/dist/src/knowledge/people-graph.d.ts

@@ -1,28 +1,25 @@
-export type ConnectedPersonNode = {
-    id: string;
-    label: string;
-    names: string[];
-    emails: string[];
-    usernames: string[];
-    roles: string[];
-    mentionCount: number;
-    lastObservedAt: string;
-};
-export type ConnectedPersonSourceEdge = {
-    personId: string;
-    sourceInstanceId: string;
-    connectorId?: string;
-    toolkit?: string;
-    mentionCount: number;
-    lastObservedAt: string;
-};
-export type ConnectedPeopleGraph = {
-    people: ConnectedPersonNode[];
-    sourceEdges: ConnectedPersonSourceEdge[];
-    scannedItems: number;
-    truncated: boolean;
-};
 export declare function buildConnectedPeopleGraph(options?: {
     query?: string;
     limit?: number;
-}): ConnectedPeopleGraph;
+}): {
+    people: {
+        id: string;
+        label: string;
+        names: string[];
+        emails: string[];
+        usernames: string[];
+        roles: any[];
+        mentionCount: number;
+        lastObservedAt: string;
+    }[];
+    sourceEdges: {
+        mentionCount: number;
+        lastObservedAt: string;
+        connectorId?: string;
+        toolkit?: string;
+        personId: string;
+        sourceInstanceId: string;
+    }[];
+    scannedItems: number;
+    truncated: boolean;
+};

package/dist/src/knowledge/people-graph.js

@@ -1,58 +1,91 @@
-import { listUserPeopleGraphRows } from "../storage/sqlite/user-claims-repository.js";
+import { listKnowledgeSourceItems } from "../storage/sqlite/knowledge-repository.js";
 import "../storage/sqlite/index.js";
+import { createHash } from "node:crypto";
 //#region src/knowledge/people-graph.ts
+function readString(record, key) {
+	const value = record[key];
+	return typeof value === "string" && value.trim() ? value.trim().slice(0, 160) : void 0;
+}
+function personKey(name, email, username) {
+	return email?.toLocaleLowerCase() ?? username?.toLocaleLowerCase() ?? name?.toLocaleLowerCase();
+}
 function sourceMetadata(sourceInstanceId) {
-	const parts = sourceInstanceId.split(":");
-	if (parts[0] !== "composio" || !parts[1]) return {};
-	return {
-		connectorId: parts[1],
-		toolkit: parts[1].replace(/^composio-/, "")
-	};
+	const connectorId = sourceInstanceId.startsWith("composio:") ? sourceInstanceId.split(":")[1] : void 0;
+	return connectorId ? {
+		connectorId,
+		toolkit: connectorId.replace(/^composio-/, "")
+	} : {};
 }
 function buildConnectedPeopleGraph(options = {}) {
-	const graph = listUserPeopleGraphRows();
-	const edgesByPerson = /* @__PURE__ */ new Map();
-	for (const edge of graph.edges) {
-		const values = edgesByPerson.get(edge.entityId) ?? [];
-		values.push(edge);
-		edgesByPerson.set(edge.entityId, values);
+	const items = listKnowledgeSourceItems({
+		includeDeleted: false,
+		limit: 500
+	});
+	const people = /* @__PURE__ */ new Map();
+	for (const item of items) {
+		const entities = Array.isArray(item.metadata.personEntities) ? item.metadata.personEntities : [];
+		for (const raw of entities) {
+			if (!raw || typeof raw !== "object" || Array.isArray(raw)) continue;
+			const record = raw;
+			const name = readString(record, "name");
+			const email = readString(record, "email");
+			const username = readString(record, "username");
+			const key = personKey(name, email, username);
+			if (!key) continue;
+			const observedAt = item.occurredAt ?? new Date(item.updatedAt).toISOString();
+			const current = people.get(key) ?? {
+				id: createHash("sha256").update(key).digest("hex").slice(0, 20),
+				label: name ?? email ?? username,
+				names: /* @__PURE__ */ new Set(),
+				emails: /* @__PURE__ */ new Set(),
+				usernames: /* @__PURE__ */ new Set(),
+				sources: /* @__PURE__ */ new Map(),
+				mentionCount: 0,
+				lastObservedAt: observedAt
+			};
+			if (name) current.names.add(name);
+			if (email) current.emails.add(email);
+			if (username) current.usernames.add(username);
+			current.mentionCount += 1;
+			if (observedAt > current.lastObservedAt) current.lastObservedAt = observedAt;
+			const source = current.sources.get(item.sourceInstanceId) ?? {
+				count: 0,
+				lastObservedAt: observedAt
+			};
+			source.count += 1;
+			if (observedAt > source.lastObservedAt) source.lastObservedAt = observedAt;
+			current.sources.set(item.sourceInstanceId, source);
+			people.set(key, current);
+		}
 	}
-	const query = options.query?.trim().toLowerCase() ?? "";
-	const limit = Math.max(1, Math.min(options.limit ?? 100, 500));
-	const matching = graph.people.map((entity) => {
-		const edges = edgesByPerson.get(entity.id) ?? [];
-		const names = [...entity.canonicalLabel.includes("@") ? [] : [entity.canonicalLabel], ...entity.handles.filter((handle) => handle.type === "display_name").map((handle) => handle.value)].filter((value, index, values) => values.findIndex((candidate) => candidate.toLowerCase() === value.toLowerCase()) === index).toSorted();
-		const emails = entity.handles.filter((handle) => handle.type === "email").map((handle) => handle.value).toSorted();
-		const usernames = entity.handles.filter((handle) => handle.type === "provider_user").map((handle) => handle.value).toSorted();
-		return {
-			id: entity.id,
-			label: entity.canonicalLabel,
-			names,
-			emails,
-			usernames,
-			roles: [],
-			mentionCount: edges.reduce((sum, edge) => sum + edge.mentionCount, 0),
-			lastObservedAt: edges.reduce((latest, edge) => !latest || edge.lastObservedAt > latest ? edge.lastObservedAt : latest, "") || entity.updatedAt
-		};
-	}).filter((person) => !query || [
+	const query = options.query?.trim().toLocaleLowerCase() ?? "";
+	const all = [...people.values()].filter((person) => !query || [
 		person.label,
 		...person.names,
 		...person.emails,
 		...person.usernames
-	].some((value) => value.toLowerCase().includes(query))).toSorted((left, right) => right.mentionCount - left.mentionCount || right.lastObservedAt.localeCompare(left.lastObservedAt));
-	const people = matching.slice(0, limit);
-	const included = new Set(people.map((person) => person.id));
+	].some((value) => value.toLocaleLowerCase().includes(query))).sort((left, right) => right.mentionCount - left.mentionCount);
+	const selected = all.slice(0, Math.max(1, Math.min(options.limit ?? 100, 500)));
 	return {
-		people,
-		sourceEdges: graph.edges.filter((edge) => included.has(edge.entityId)).map((edge) => ({
-			personId: edge.entityId,
-			sourceInstanceId: edge.sourceInstanceId,
-			...sourceMetadata(edge.sourceInstanceId),
-			mentionCount: edge.mentionCount,
-			lastObservedAt: edge.lastObservedAt
+		people: selected.map((person) => ({
+			id: person.id,
+			label: person.label,
+			names: [...person.names],
+			emails: [...person.emails],
+			usernames: [...person.usernames],
+			roles: [],
+			mentionCount: person.mentionCount,
+			lastObservedAt: person.lastObservedAt
 		})),
-		scannedItems: graph.evidenceCount,
-		truncated: matching.length > limit
+		sourceEdges: selected.flatMap((person) => [...person.sources].map(([sourceInstanceId, source]) => ({
+			personId: person.id,
+			sourceInstanceId,
+			...sourceMetadata(sourceInstanceId),
+			mentionCount: source.count,
+			lastObservedAt: source.lastObservedAt
+		}))),
+		scannedItems: items.length,
+		truncated: all.length > selected.length
 	};
 }
 //#endregion

package/dist/src/proactive/execution/context.js

@@ -1,5 +1,5 @@
 import { getSqliteDatabase } from "../../storage/sqlite/transaction.js";
-import { listMemoryRecords } from "../../storage/sqlite/memory-records-repository.js";
+import { listUnderstandings } from "../../storage/sqlite/user-context-repository.js";
 import { getKnowledgeSourceItem } from "../../storage/sqlite/knowledge-repository.js";
 import { getConnectorSyncPolicyForConnection } from "../../storage/sqlite/connector-sync-policy-repository.js";
 import { wrapExternalContent } from "../../gateway/security/external-content.js";
@@ -162,25 +162,20 @@ var UserUnderstandingContextProvider = class {
 	async collect(input) {
 		const scope = eventRows(input.eventIds).at(-1);
 		if (!scope) return emptyContext();
-		const records = listMemoryRecords({
-			workspaceId: scope.workspace_id,
-			...scope.project_id ? { visibleToProjectId: scope.project_id } : { unscopedProjectOnly: true },
-			status: "active",
-			limit: 20
-		}).filter((record) => {
+		const records = listUnderstandings(["active"]).filter((record) => {
 			const now = Date.now();
-			return record.disclosurePolicy === "referenceable" && record.sensitivity !== "secret" && record.sensitivity !== "regulated" && !record.tags?.includes("playbook:disabled") && (!record.validFrom || Date.parse(record.validFrom) <= now) && (!record.validTo || Date.parse(record.validTo) >= now) && (!record.expiresAt || Date.parse(record.expiresAt) >= now) && (!record.reviewAfter || Date.parse(record.reviewAfter) >= now) && !record.conflictGroupId && (record.explicitness === "explicit" || record.importance >= .7);
-		});
+			const scopeMatches = record.scope.type === "global" || record.scope.type === "workspace" && record.scope.id === scope.workspace_id || record.scope.type === "project" && record.scope.id === scope.project_id;
+			return record.disclosurePolicy === "referenceable" && record.sensitivity !== "secret" && record.sensitivity !== "regulated" && scopeMatches && (!record.validFrom || record.validFrom <= now) && (!record.validTo || record.validTo >= now) && (!record.expiresAt || record.expiresAt >= now) && !record.conflictGroupId && (record.explicitness === "explicit" || record.confidence >= .7);
+		}).slice(0, 20);
 		return {
 			content: { records: records.map((record) => ({
-				evidenceId: `memory:${record.id}`,
+				evidenceId: `understanding:${record.id}`,
 				kind: record.kind,
-				content: boundedText(record.content, 1e3),
+				content: boundedText(record.statement, 1e3),
 				confidence: record.confidence,
-				importance: record.importance,
 				updatedAt: record.updatedAt
 			})) },
-			evidenceIds: records.map((record) => `memory:${record.id}`)
+			evidenceIds: records.map((record) => `understanding:${record.id}`)
 		};
 	}
 };

package/dist/src/realtime/broker.d.ts

@@ -12,6 +12,7 @@ export interface RealtimeTopicPolicy {
 export type RealtimeTopicPolicyResolver = (topic: string) => RealtimeTopicPolicy;
 export interface RealtimeSubscriptionHandle {
     initial: RealtimeDelivery[];
+    cursor: number;
     unsubscribe: () => void;
 }
 export declare function defaultRealtimeTopicPolicy(topic: string): RealtimeTopicPolicy;

package/dist/src/realtime/broker.js

@@ -47,8 +47,12 @@ var RealtimeBroker = class {
 		realtimeTopicSchema.parse(topic);
 		const state = this.ensureTopic(topic);
 		state.listeners.add(listener);
+		const initial = afterSeq === void 0 ? [] : this.replayFrom(topic, state, afterSeq);
+		const gap = initial[0]?.kind === "realtime.gap" ? initial[0] : void 0;
+		const currentSeq = state.nextSeq - 1;
 		return {
-			initial: afterSeq === void 0 ? [] : this.replayFrom(topic, state, afterSeq),
+			initial,
+			cursor: gap ? gap.payload.earliestSeq - 1 : afterSeq === void 0 ? currentSeq : Math.min(afterSeq, currentSeq),
 			unsubscribe: () => {
 				state.listeners.delete(listener);
 			}
@@ -65,6 +69,18 @@ var RealtimeBroker = class {
 	}
 	replayFrom(topic, state, afterSeq) {
 		const currentSeq = state.nextSeq - 1;
+		if (afterSeq > currentSeq) return [{
+			protocolVersion: 1,
+			messageId: crypto.randomUUID(),
+			kind: "realtime.gap",
+			sentAt: Date.now(),
+			payload: {
+				topic,
+				requestedSeq: afterSeq,
+				earliestSeq: state.events[0]?.payload.seq ?? 1,
+				recoverable: false
+			}
+		}];
 		if (currentSeq <= afterSeq) return [];
 		const earliestSeq = state.events[0]?.payload.seq;
 		if (earliestSeq === void 0 || afterSeq + 1 < earliestSeq) return [{
@@ -75,7 +91,8 @@ var RealtimeBroker = class {
 			payload: {
 				topic,
 				requestedSeq: afterSeq,
-				earliestSeq: earliestSeq ?? currentSeq + 1
+				earliestSeq: earliestSeq ?? currentSeq + 1,
+				recoverable: earliestSeq !== void 0
 			}
 		}, ...state.events];
 		return state.events.filter((event) => event.payload.seq > afterSeq);

package/dist/src/realtime/runtime.js

@@ -128,7 +128,8 @@ var RealtimeRuntime = class {
 					writer.enqueue(serverMessage("realtime.gap", {
 						topic: item.topic,
 						requestedSeq: item.afterSeq,
-						earliestSeq: 1
+						earliestSeq: 1,
+						recoverable: false
 					}));
 					continue;
 				}
@@ -137,6 +138,10 @@ var RealtimeRuntime = class {
 					writer.enqueue(event);
 				});
 				subscriptions.set(item.topic, handle);
+				writer.enqueue(serverMessage("realtime.subscribed", {
+					topic: item.topic,
+					cursor: handle.cursor
+				}), "critical");
 				for (const message of handle.initial) writer.enqueue(message);
 			}
 			return true;

package/dist/src/storage/sqlite/connector-account-repository.js

@@ -36,7 +36,6 @@ function mergeAccountSourceData(db, connectorId, sourceAccountId, targetAccountI
 	db.prepare("UPDATE knowledge_source_items SET source_instance_id = ? WHERE source_instance_id = ?").run(targetId, sourceId);
 	db.prepare("UPDATE knowledge_sync_runs SET source_instance_id = ? WHERE source_instance_id = ?").run(targetId, sourceId);
 	db.prepare("UPDATE knowledge_source_changes SET source_instance_id = ? WHERE source_instance_id = ?").run(targetId, sourceId);
-	db.prepare("UPDATE user_claim_evidence SET source_instance_id = ? WHERE source_instance_id = ?").run(targetId, sourceId);
 	db.prepare(`
     DELETE FROM knowledge_collection_state AS source
     WHERE source.source_instance_id = ?

package/dist/src/storage/sqlite/context-consolidation-repository.d.ts

@@ -0,0 +1,37 @@
+export type ContextConsolidationRun = {
+    runId: string;
+    triggerKind: 'schedule' | 'manual';
+    status: 'running' | 'completed' | 'failed';
+    reason?: string;
+    metrics: Record<string, unknown>;
+    startedAt: number;
+    completedAt?: number;
+};
+export type ContextConsolidationDecision = {
+    id: string;
+    runId: string;
+    understandingId?: string;
+    action: 'needs_review' | 'stale';
+    reasonCode: string;
+    evidenceCount: number;
+    createdAt: number;
+};
+export declare function startContextConsolidationRun(triggerKind: ContextConsolidationRun['triggerKind'], now?: number): ContextConsolidationRun;
+export declare function finishContextConsolidationRun(input: {
+    runId: string;
+    ok: boolean;
+    reason: string;
+    metrics: Record<string, unknown>;
+    now?: number;
+}): ContextConsolidationRun | undefined;
+export declare function recordContextConsolidationDecision(input: {
+    runId: string;
+    understandingId: string;
+    action: ContextConsolidationDecision['action'];
+    reasonCode: string;
+    evidenceCount: number;
+    now?: number;
+}): ContextConsolidationDecision;
+export declare function getContextConsolidationRun(runId: string): ContextConsolidationRun | undefined;
+export declare function listContextConsolidationRuns(limit?: number): ContextConsolidationRun[];
+export declare function listContextConsolidationDecisions(runId: string): ContextConsolidationDecision[];