@xopcai/xopc 0.0.170 → 0.0.172

package/dist/src/gateway/service.js

@@ -44,7 +44,7 @@ import { getWorkspacePath } from "../config/workspace-path-helpers.js";
 import "../config/index.js";
 import { startConnectedKnowledgeCoordinator } from "../knowledge/coordinator.js";
 import "../knowledge/index.js";
-import { startConnectorMemorySyncCoordinator } from "../connectors/memory-sync-coordinator.js";
+import { startConnectorLearningCoordinator } from "../connectors/learning-coordinator.js";
 import { startConnectorSupervisor } from "../connectors/supervisor.js";
 import { assertGatewayAuthConfigured, extractToken, resolveGatewayAuth, validateToken } from "./auth.js";
 import { reconcileDreamingAutomations } from "./dreaming-automation-reconciler.js";
@@ -159,7 +159,7 @@ var GatewayService = class {
 	goalNotifications = null;
 	mobileNotifications = null;
 	connectorSupervisor = null;
-	connectorMemorySyncCoordinator = null;
+	connectorLearningCoordinator = null;
 	connectedKnowledgeCoordinator = null;
 	stopAutomationProductEventBridge = null;
 	stopSessionTranscriptAutomationEvents = null;
@@ -713,9 +713,11 @@ var GatewayService = class {
 			getConfig: () => this.config,
 			saveConfig: (cfg) => this.saveConfig(cfg)
 		});
-		this.connectorMemorySyncCoordinator = startConnectorMemorySyncCoordinator({
+		this.connectorLearningCoordinator = startConnectorLearningCoordinator({
 			getConfig: () => this.config,
-			resolveAgentId: () => resolveDefaultAgentId(this.config)
+			resolveAgentId: () => resolveDefaultAgentId(this.config),
+			getMemoryManager: () => this.agentService.getMemoryManager(),
+			emit: (type, payload) => this.emit(type, payload)
 		});
 		this.connectedKnowledgeCoordinator = startConnectedKnowledgeCoordinator({ resolvePipelineOptions: () => ({
 			agentId: resolveDefaultAgentId(this.config),
@@ -841,8 +843,8 @@ var GatewayService = class {
 		this.heartbeatService?.stop();
 		this.connectorSupervisor?.stop();
 		this.connectorSupervisor = null;
-		this.connectorMemorySyncCoordinator?.stop();
-		this.connectorMemorySyncCoordinator = null;
+		this.connectorLearningCoordinator?.stop();
+		this.connectorLearningCoordinator = null;
 		this.connectedKnowledgeCoordinator?.stop();
 		this.connectedKnowledgeCoordinator = null;
 		await this.browserRecipeService?.shutdown();
@@ -1085,11 +1087,14 @@ var GatewayService = class {
 	requestHeartbeatNow(opts) {
 		this.heartbeatService?.requestNow({ reason: opts?.reason ?? "manual" });
 	}
-	requestConnectorMemorySync(toolkit) {
-		this.connectorMemorySyncCoordinator?.runNow({
-			toolkit,
-			force: true
-		});
+	requestConnectorLearning(connectionId, request) {
+		return this.connectorLearningCoordinator?.enqueueConnection(connectionId, request) ?? null;
+	}
+	requestConnectorLearningForToolkit(toolkit) {
+		return this.connectorLearningCoordinator?.enqueueToolkit(toolkit) ?? [];
+	}
+	setConnectorLearningPaused(connectionId, paused) {
+		return this.connectorLearningCoordinator?.setPaused(connectionId, paused) ?? 0;
 	}
 	/**
 	* Register graceful shutdown used after spawning a replacement gateway process (foreground CLI server).

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

@@ -0,0 +1,19 @@
+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;
+    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 class ConnectedUnderstandingPipeline {
+    private readonly memoryManager;
+    constructor(memoryManager: MemoryManager);
+    process(sourceInstanceId: string, connectorId: string, agentId: string): Promise<UnderstandingReviewResult>;
+}

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

@@ -0,0 +1,268 @@
+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
+function logicalEventKey(item) {
+	const value = item.metadata.logicalEventKey;
+	return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function eventTime(item) {
+	if (!item.occurredAt) return void 0;
+	const value = Date.parse(item.occurredAt);
+	return Number.isFinite(value) ? value : void 0;
+}
+function recent(items, days) {
+	const now = Date.now();
+	const cutoff = now - days * 864e5;
+	return items.filter((item) => {
+		const time = eventTime(item);
+		return time !== void 0 && time >= cutoff && time <= now + 3e5 && logicalEventKey(item);
+	});
+}
+function person(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+	const row = value;
+	const read = (field) => typeof row[field] === "string" && row[field].trim() ? row[field].trim().slice(0, 160) : void 0;
+	const result = {
+		name: read("name"),
+		email: read("email"),
+		username: read("username")
+	};
+	return result.name || result.email || result.username ? result : void 0;
+}
+function relationshipObservations(items) {
+	const grouped = /* @__PURE__ */ new Map();
+	for (const item of recent(items, 90)) {
+		if (item.metadata.actorAttributed !== true) continue;
+		const owners = new Set(Array.isArray(item.metadata.ownerIdentities) ? item.metadata.ownerIdentities.filter((value) => typeof value === "string").map((value) => value.toLowerCase()) : []);
+		const values = item.metadata.personEntities;
+		if (!Array.isArray(values)) continue;
+		for (const value of values) {
+			const signal = person(value);
+			if (!signal) continue;
+			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);
+			if (!entry.events.has(eventKey)) entry.events.set(eventKey, item);
+			grouped.set(identityKey, entry);
+		}
+	}
+	return [...grouped.values()].sort((left, right) => right.events.size - left.events.size).slice(0, 8).map((entry) => ({
+		class: "relationship",
+		key: "person",
+		value: { label: entry.label },
+		subject: {
+			type: "person",
+			canonicalLabel: entry.label,
+			handles: entry.handles
+		},
+		items: [...entry.events.values()],
+		windowDays: 90
+	}));
+}
+function routineObservations(items) {
+	const slots = /* @__PURE__ */ new Map();
+	for (const item of recent(items, 120).filter((candidate) => candidate.itemType === "calendar_event")) {
+		const date = new Date(item.occurredAt);
+		const slot = `${date.getUTCDay()}:${date.getUTCHours()}`;
+		const events = slots.get(slot) ?? /* @__PURE__ */ new Map();
+		const eventKey = logicalEventKey(item);
+		if (!events.has(eventKey)) events.set(eventKey, item);
+		slots.set(slot, events);
+	}
+	return [...slots.entries()].sort((left, right) => right[1].size - left[1].size).slice(0, 4).map(([slot, events]) => {
+		const [weekday, hour] = slot.split(":").map(Number);
+		return {
+			class: "routine",
+			key: `calendar-slot:${slot}`,
+			value: {
+				weekday,
+				hour,
+				timezone: "UTC"
+			},
+			items: [...events.values()],
+			windowDays: 120
+		};
+	});
+}
+function projectObservations(items) {
+	const grouped = /* @__PURE__ */ new Map();
+	for (const item of recent(items, 60)) {
+		if (item.metadata.observationKind !== "activity" || item.metadata.actorAttributed !== true) continue;
+		const subject = typeof item.metadata.subjectKey === "string" ? item.metadata.subjectKey.trim() : "";
+		if (!subject) continue;
+		const entry = grouped.get(subject.toLowerCase()) ?? {
+			label: subject,
+			events: /* @__PURE__ */ new Map()
+		};
+		const events = entry.events;
+		const eventKey = logicalEventKey(item);
+		if (!events.has(eventKey)) events.set(eventKey, item);
+		grouped.set(subject.toLowerCase(), entry);
+	}
+	return [...grouped.entries()].sort((left, right) => right[1].events.size - left[1].events.size).slice(0, 8).map(([, entry]) => {
+		const { label: subject, events } = entry;
+		return {
+			class: "project",
+			key: "project",
+			value: { label: subject },
+			subject: {
+				type: "project",
+				canonicalLabel: subject,
+				handles: [{
+					type: "provider_user",
+					value: subject,
+					sourceScope: "project",
+					verified: true
+				}]
+			},
+			items: [...events.values()],
+			windowDays: 60
+		};
+	});
+}
+function deriveConnectedClaimObservations(items) {
+	const active = items.filter((item) => !item.deletedAt && item.synthesisPipeline === "connected_knowledge" && item.sensitivity !== "secret" && item.sensitivity !== "regulated" && item.metadata.observationKind !== "inventory");
+	return [
+		...relationshipObservations(active),
+		...routineObservations(active),
+		...projectObservations(active)
+	];
+}
+function renderUserClaim(claim) {
+	const label = typeof claim.value.label === "string" ? claim.value.label : "";
+	if (claim.class === "relationship") return {
+		kind: "relationship",
+		content: `Frequently collaborates with ${label}.`,
+		canonicalKey: `claim:${claim.id}`,
+		confidence: claim.confidence,
+		importance: .65,
+		explicitness: "inferred",
+		durability: "recurring",
+		sensitivity: "personal",
+		disclosurePolicy: "ask_before_reference",
+		tags: ["connected-source", "structured-claim"]
+	};
+	if (claim.class === "project") return {
+		kind: "project_context",
+		content: `Recently contributed repeatedly to ${label}.`,
+		canonicalKey: `claim:${claim.id}`,
+		confidence: claim.confidence,
+		importance: .72,
+		explicitness: "inferred",
+		durability: "recurring",
+		sensitivity: "personal",
+		disclosurePolicy: "referenceable",
+		tags: ["connected-source", "structured-claim"]
+	};
+	const weekday = Number(claim.value.weekday);
+	const hour = Number(claim.value.hour);
+	return {
+		kind: "routine",
+		content: `Often has calendar activity on ${[
+			"Sunday",
+			"Monday",
+			"Tuesday",
+			"Wednesday",
+			"Thursday",
+			"Friday",
+			"Saturday"
+		][weekday] ?? "Unknown"} around ${String(hour).padStart(2, "0")}:00 UTC.`,
+		canonicalKey: `claim:${claim.id}`,
+		confidence: claim.confidence,
+		importance: .58,
+		explicitness: "inferred",
+		durability: "recurring",
+		sensitivity: "personal",
+		disclosurePolicy: "referenceable",
+		tags: ["connected-source", "structured-claim"]
+	};
+}
+var ConnectedUnderstandingPipeline = class {
+	constructor(memoryManager) {
+		this.memoryManager = memoryManager;
+	}
+	async process(sourceInstanceId, connectorId, agentId) {
+		const observations = deriveConnectedClaimObservations(listKnowledgeSourceItems({
+			sourceInstanceId,
+			includeDeleted: false,
+			limit: 500
+		}));
+		const totals = {
+			proposed: observations.length,
+			created: 0,
+			deduplicated: 0,
+			rejected: 0,
+			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,
+				sourceItemIds: observation.items.map((item) => item.id).slice(0, 20),
+				sourceText: JSON.stringify({
+					claimId: claim.id,
+					independentEvidenceCount: claim.independentEvidenceCount,
+					activeDays: claim.activeDayCount,
+					windowDays: observation.windowDays
+				}),
+				source: {
+					provider: connectorId,
+					sourceInstanceId
+				},
+				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;
+			totals.createdRecords.push(...result.createdRecords);
+		}
+		return totals;
+	}
+};
+//#endregion
+export { ConnectedUnderstandingPipeline, deriveConnectedClaimObservations, renderUserClaim };

package/dist/src/knowledge/index.d.ts

@@ -1,6 +1,7 @@
 export * from './types.js';
 export * from './ingestion-service.js';
 export * from './connected-knowledge-pipeline.js';
+export * from './connected-understanding-pipeline.js';
 export * from './coordinator.js';
 export * from './local-folder-adapter.js';
 export * from './people-graph.js';

package/dist/src/knowledge/index.js

@@ -1,6 +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 { startConnectedKnowledgeCoordinator } from "./coordinator.js";
 import { LocalFolderKnowledgeSourceAdapter } from "./local-folder-adapter.js";
 import { buildConnectedPeopleGraph } from "./people-graph.js";
-export { ConnectedKnowledgePipeline, KnowledgeIngestionService, LocalFolderKnowledgeSourceAdapter, SqliteKnowledgeSourceStateStore, buildConnectedPeopleGraph, startConnectedKnowledgeCoordinator };
+export { ConnectedKnowledgePipeline, ConnectedUnderstandingPipeline, KnowledgeIngestionService, LocalFolderKnowledgeSourceAdapter, SqliteKnowledgeSourceStateStore, buildConnectedPeopleGraph, deriveConnectedClaimObservations, renderUserClaim, startConnectedKnowledgeCoordinator };

package/dist/src/knowledge/ingestion-service.d.ts

@@ -1,11 +1,11 @@
 import type { KnowledgeSourceAdapter, KnowledgeSourceItemInput, KnowledgeSyncRun } from './types.js';
 export interface KnowledgeSourceStateStore {
-    getCursor(instanceId: string): string | undefined;
-    setCursor(instanceId: string, cursor: string | undefined): void;
+    getCursor(instanceId: string, collectionScope: string): string | undefined;
+    setCursor(instanceId: string, collectionScope: string, cursor: string | undefined): void;
 }
 export declare class SqliteKnowledgeSourceStateStore implements KnowledgeSourceStateStore {
-    getCursor(instanceId: string): string | undefined;
-    setCursor(instanceId: string, cursor: string | undefined): void;
+    getCursor(instanceId: string, collectionScope: string): string | undefined;
+    setCursor(instanceId: string, collectionScope: string, cursor: string | undefined): void;
 }
 export declare class KnowledgeIngestionService {
     private readonly adapters;
@@ -13,6 +13,7 @@ export declare class KnowledgeIngestionService {
     constructor(adapters: ReadonlyMap<string, KnowledgeSourceAdapter>, state?: KnowledgeSourceStateStore);
     ingest(params: {
         instanceId: string;
+        collectionScope: string;
         items: KnowledgeSourceItemInput[];
         cursorAfter?: string;
         warnings?: string[];
@@ -20,6 +21,7 @@ export declare class KnowledgeIngestionService {
     sync(params: {
         adapterKind: string;
         instanceId: string;
+        collectionScope: string;
         windowStart?: string;
         signal?: AbortSignal;
     }): Promise<KnowledgeSyncRun>;

package/dist/src/knowledge/ingestion-service.js

@@ -4,7 +4,7 @@ import { finishKnowledgeSyncRun, getKnowledgeSourceCursor, listKnowledgeSourceIt
 //#region src/knowledge/ingestion-service.ts
 init_logger();
 const log = createLogger("KnowledgeIngestion");
-function deletionInputs(instanceId, snapshotExternalIds) {
+function deletionInputs(instanceId, collectionScope, snapshotExternalIds) {
 	if (!snapshotExternalIds) return [];
 	const seen = new Set(snapshotExternalIds);
 	const deletedAt = (/* @__PURE__ */ new Date()).toISOString();
@@ -12,6 +12,7 @@ function deletionInputs(instanceId, snapshotExternalIds) {
 	for (let offset = 0;; offset += 500) {
 		const page = listKnowledgeSourceItems({
 			sourceInstanceId: instanceId,
+			collectionScope,
 			limit: 500,
 			offset
 		});
@@ -20,6 +21,7 @@ function deletionInputs(instanceId, snapshotExternalIds) {
 			missing.push({
 				id: item.id,
 				sourceInstanceId: item.sourceInstanceId,
+				collectionScope: item.collectionScope,
 				externalId: item.externalId,
 				itemType: item.itemType,
 				authorRole: item.authorRole,
@@ -40,11 +42,11 @@ function deletionInputs(instanceId, snapshotExternalIds) {
 	return missing;
 }
 var SqliteKnowledgeSourceStateStore = class {
-	getCursor(instanceId) {
-		return getKnowledgeSourceCursor(instanceId);
+	getCursor(instanceId, collectionScope) {
+		return getKnowledgeSourceCursor(instanceId, collectionScope);
 	}
-	setCursor(instanceId, cursor) {
-		setKnowledgeSourceCursor(instanceId, cursor);
+	setCursor(instanceId, collectionScope, cursor) {
+		setKnowledgeSourceCursor(instanceId, collectionScope, cursor);
 	}
 };
 var KnowledgeIngestionService = class {
@@ -53,14 +55,14 @@ var KnowledgeIngestionService = class {
 		this.state = state;
 	}
 	ingest(params) {
-		const cursorBefore = this.state.getCursor(params.instanceId);
+		const cursorBefore = this.state.getCursor(params.instanceId, params.collectionScope);
 		const run = startKnowledgeSyncRun({
 			sourceInstanceId: params.instanceId,
 			cursorBefore
 		});
 		try {
 			const stored = upsertKnowledgeSourceItems(params.items);
-			this.state.setCursor(params.instanceId, params.cursorAfter);
+			this.state.setCursor(params.instanceId, params.collectionScope, params.cursorAfter);
 			return finishKnowledgeSyncRun({
 				runId: run.id,
 				status: params.warnings?.length ? "partial" : "succeeded",
@@ -83,7 +85,7 @@ var KnowledgeIngestionService = class {
 	async sync(params) {
 		const adapter = this.adapters.get(params.adapterKind);
 		if (!adapter) throw new Error(`Knowledge source adapter not found: ${params.adapterKind}`);
-		const cursorBefore = this.state.getCursor(params.instanceId);
+		const cursorBefore = this.state.getCursor(params.instanceId, params.collectionScope);
 		const run = startKnowledgeSyncRun({
 			sourceInstanceId: params.instanceId,
 			cursorBefore
@@ -93,13 +95,14 @@ var KnowledgeIngestionService = class {
 		try {
 			const pulled = await adapter.pull({
 				instanceId: params.instanceId,
+				collectionScope: params.collectionScope,
 				cursor: cursorBefore,
 				windowStart: params.windowStart,
 				signal
 			});
-			const tombstones = deletionInputs(params.instanceId, pulled.snapshotExternalIds);
+			const tombstones = deletionInputs(params.instanceId, params.collectionScope, pulled.snapshotExternalIds);
 			const stored = upsertKnowledgeSourceItems([...pulled.items, ...tombstones]);
-			this.state.setCursor(params.instanceId, pulled.nextCursor);
+			this.state.setCursor(params.instanceId, params.collectionScope, pulled.nextCursor);
 			const completed = finishKnowledgeSyncRun({
 				runId: run.id,
 				status: pulled.warnings.length > 0 ? "partial" : "succeeded",

package/dist/src/knowledge/local-folder-adapter.js

@@ -59,6 +59,7 @@ var LocalFolderKnowledgeSourceAdapter = class {
 			const externalId = relative(root, canonicalPath).split(sep).join("/");
 			items.push({
 				sourceInstanceId: input.instanceId,
+				collectionScope: "files",
 				externalId,
 				itemType: "local_file",
 				authorRole: "user",

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

@@ -1,125 +1,58 @@
-import { listKnowledgeSourceItems } from "../storage/sqlite/knowledge-repository.js";
-import { createHash } from "node:crypto";
+import { listUserPeopleGraphRows } from "../storage/sqlite/user-claims-repository.js";
+import "../storage/sqlite/index.js";
 //#region src/knowledge/people-graph.ts
-function nonEmpty(value) {
-	return typeof value === "string" && value.trim() ? value.trim() : void 0;
-}
-function signalsFor(item) {
-	const structured = item.metadata.personEntities;
-	if (Array.isArray(structured)) {
-		const signals = structured.flatMap((value) => {
-			if (!value || typeof value !== "object" || Array.isArray(value)) return [];
-			const record = value;
-			const signal = {
-				role: nonEmpty(record.role),
-				name: nonEmpty(record.name),
-				email: nonEmpty(record.email),
-				username: nonEmpty(record.username)
-			};
-			return signal.name || signal.email || signal.username ? [signal] : [];
-		});
-		if (signals.length > 0) return signals;
-	}
-	return Array.isArray(item.metadata.people) ? item.metadata.people.flatMap((value) => {
-		const text = nonEmpty(value);
-		if (!text) return [];
-		return text.includes("@") ? [{ email: text }] : [{ name: text }];
-	}) : [];
-}
-function identityFor(signal) {
-	if (signal.email) return `email:${signal.email.toLowerCase()}`;
-	if (signal.username) return `username:${signal.username.toLowerCase().replace(/^@/, "")}`;
-	if (signal.name) return `name:${signal.name.toLocaleLowerCase()}`;
-}
-function personId(identity) {
-	return `person_${createHash("sha256").update(identity).digest("hex").slice(0, 24)}`;
-}
-function latest(left, right) {
-	return Date.parse(left) >= Date.parse(right) ? left : right;
+function sourceMetadata(sourceInstanceId) {
+	const parts = sourceInstanceId.split(":");
+	if (parts[0] !== "composio" || !parts[1]) return {};
+	return {
+		connectorId: parts[1],
+		toolkit: parts[1].replace(/^composio-/, "")
+	};
 }
 function buildConnectedPeopleGraph(options = {}) {
-	const maxItems = 5e3;
-	const items = [];
-	for (let offset = 0; offset < maxItems; offset += 500) {
-		const page = listKnowledgeSourceItems({
-			limit: 500,
-			offset
-		});
-		items.push(...page);
-		if (page.length < 500) break;
-	}
-	const nodeByIdentity = /* @__PURE__ */ new Map();
-	const edgeByKey = /* @__PURE__ */ new Map();
-	for (const item of items) {
-		const observedAt = item.occurredAt ?? item.sourceUpdatedAt ?? item.updatedAt;
-		const observedIdentities = /* @__PURE__ */ new Set();
-		for (const signal of signalsFor(item)) {
-			const identity = identityFor(signal);
-			if (!identity) continue;
-			let aggregate = nodeByIdentity.get(identity);
-			if (!aggregate) {
-				aggregate = {
-					node: {
-						id: personId(identity),
-						label: signal.name ?? signal.email ?? signal.username ?? identity,
-						names: [],
-						emails: [],
-						usernames: [],
-						roles: [],
-						mentionCount: 0,
-						lastObservedAt: observedAt
-					},
-					names: /* @__PURE__ */ new Set(),
-					emails: /* @__PURE__ */ new Set(),
-					usernames: /* @__PURE__ */ new Set(),
-					roles: /* @__PURE__ */ new Set()
-				};
-				nodeByIdentity.set(identity, aggregate);
-			}
-			if (signal.name) aggregate.names.add(signal.name);
-			if (signal.email) aggregate.emails.add(signal.email.toLowerCase());
-			if (signal.username) aggregate.usernames.add(signal.username.replace(/^@/, ""));
-			if (signal.role) aggregate.roles.add(signal.role);
-			if (observedIdentities.has(identity)) continue;
-			observedIdentities.add(identity);
-			aggregate.node.mentionCount += 1;
-			aggregate.node.lastObservedAt = latest(aggregate.node.lastObservedAt, observedAt);
-			const edgeKey = `${aggregate.node.id}\u0000${item.sourceInstanceId}`;
-			const existingEdge = edgeByKey.get(edgeKey);
-			if (existingEdge) {
-				existingEdge.mentionCount += 1;
-				existingEdge.lastObservedAt = latest(existingEdge.lastObservedAt, observedAt);
-			} else edgeByKey.set(edgeKey, {
-				personId: aggregate.node.id,
-				sourceInstanceId: item.sourceInstanceId,
-				connectorId: nonEmpty(item.metadata.connectorId),
-				toolkit: nonEmpty(item.metadata.toolkit),
-				mentionCount: 1,
-				lastObservedAt: observedAt
-			});
-		}
+	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 query = options.query?.trim().toLocaleLowerCase() ?? "";
+	const query = options.query?.trim().toLowerCase() ?? "";
 	const limit = Math.max(1, Math.min(options.limit ?? 100, 500));
-	const matchingPeople = [...nodeByIdentity.values()].map((aggregate) => ({
-		...aggregate.node,
-		names: [...aggregate.names].toSorted(),
-		emails: [...aggregate.emails].toSorted(),
-		usernames: [...aggregate.usernames].toSorted(),
-		roles: [...aggregate.roles].toSorted()
-	})).filter((person) => !query || [
+	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 || [
 		person.label,
 		...person.names,
 		...person.emails,
 		...person.usernames
-	].some((value) => value.toLocaleLowerCase().includes(query))).toSorted((left, right) => right.mentionCount - left.mentionCount || right.lastObservedAt.localeCompare(left.lastObservedAt));
-	const people = matchingPeople.slice(0, limit);
+	].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));
 	return {
 		people,
-		sourceEdges: [...edgeByKey.values()].filter((edge) => included.has(edge.personId)),
-		scannedItems: items.length,
-		truncated: items.length >= maxItems || matchingPeople.length > limit
+		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
+		})),
+		scannedItems: graph.evidenceCount,
+		truncated: matching.length > limit
 	};
 }
 //#endregion