@xopcai/xopc 0.0.224 → 0.0.227

package/dist/src/storage/sqlite/user-people-repository.js

@@ -0,0 +1,246 @@
+import { getSqliteDatabase, runSqliteWriteTransaction } from "./transaction.js";
+import { USER_CONTEXT_PRINCIPAL_ID } from "../../user-context/domain.js";
+//#region src/storage/sqlite/user-people-repository.ts
+function sourceMetadata(sourceInstanceId) {
+	if (!sourceInstanceId.startsWith("composio:")) return {};
+	const connectorId = sourceInstanceId.split(":")[1];
+	if (!connectorId) return {};
+	return {
+		connectorId,
+		toolkit: connectorId.replace(/^composio-/, "")
+	};
+}
+function handlesFor(personId) {
+	return getSqliteDatabase().prepare(`SELECT handle_id, handle_type, display_value,
+    source_instance_id, verification, first_observed_at, last_observed_at
+    FROM user_person_handles WHERE person_id = ?
+    ORDER BY CASE handle_type WHEN 'email' THEN 0 WHEN 'provider_user' THEN 1 WHEN 'username' THEN 2 ELSE 3 END,
+      last_observed_at DESC`).all(personId).map((row) => ({
+		id: row.handle_id,
+		type: row.handle_type,
+		value: row.display_value,
+		sourceInstanceId: row.source_instance_id,
+		verification: row.verification,
+		firstObservedAt: row.first_observed_at,
+		lastObservedAt: row.last_observed_at
+	}));
+}
+function sourcesFor(personId) {
+	return getSqliteDatabase().prepare(`SELECT source_instance_id, interaction_count,
+    first_observed_at, last_observed_at FROM user_person_source_stats
+    WHERE person_id = ? ORDER BY last_observed_at DESC`).all(personId).map((row) => ({
+		sourceInstanceId: row.source_instance_id,
+		...sourceMetadata(row.source_instance_id),
+		interactionCount: row.interaction_count,
+		firstObservedAt: row.first_observed_at,
+		lastObservedAt: row.last_observed_at
+	}));
+}
+function fromRow(row, includeDetails = false) {
+	const handles = handlesFor(row.person_id);
+	const sources = sourcesFor(row.person_id);
+	const primaryHandle = handles.find((handle) => handle.type === "email")?.value ?? handles.find((handle) => handle.type === "provider_user" || handle.type === "username")?.value;
+	return {
+		id: row.person_id,
+		displayName: row.user_display_name ?? row.display_name,
+		kind: row.user_kind ?? row.inferred_kind,
+		hidden: row.hidden === 1,
+		confidence: row.confidence,
+		...primaryHandle ? { primaryHandle } : {},
+		interactionCount: sources.reduce((total, source) => total + source.interactionCount, 0),
+		firstObservedAt: row.first_observed_at,
+		lastObservedAt: row.last_observed_at,
+		handles: includeDetails ? handles : [],
+		sources
+	};
+}
+function replaceUserPeopleIndex(entries, revision, principalId = USER_CONTEXT_PRINCIPAL_ID, nowMs = Date.now()) {
+	runSqliteWriteTransaction((db) => {
+		const mergedRows = db.prepare(`SELECT person_id, merged_into_person_id FROM user_people
+      WHERE principal_id = ? AND merged_into_person_id IS NOT NULL`).all(principalId);
+		const mergedTargets = new Map(mergedRows.map((row) => [row.person_id, row.merged_into_person_id]));
+		const targetFor = (personId) => {
+			const seen = /* @__PURE__ */ new Set();
+			let current = personId;
+			while (mergedTargets.has(current) && !seen.has(current)) {
+				seen.add(current);
+				current = mergedTargets.get(current);
+			}
+			return current;
+		};
+		db.prepare(`DELETE FROM user_person_source_stats
+      WHERE person_id IN (SELECT person_id FROM user_people WHERE principal_id = ?)`).run(principalId);
+		db.prepare(`DELETE FROM user_person_handles
+      WHERE person_id IN (SELECT person_id FROM user_people WHERE principal_id = ?)
+        AND verification != 'user_confirmed'`).run(principalId);
+		for (const entry of entries) {
+			const personId = targetFor(entry.id);
+			if (personId === entry.id) db.prepare(`INSERT INTO user_people (
+        person_id, principal_id, display_name, inferred_kind, confidence,
+        first_observed_at, last_observed_at, created_at, updated_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(person_id) DO UPDATE SET
+        display_name = excluded.display_name,
+        inferred_kind = excluded.inferred_kind,
+        confidence = excluded.confidence,
+        first_observed_at = MIN(user_people.first_observed_at, excluded.first_observed_at),
+        last_observed_at = excluded.last_observed_at,
+        updated_at = excluded.updated_at`).run(entry.id, principalId, entry.displayName, entry.inferredKind, entry.confidence, entry.firstObservedAt, entry.lastObservedAt, nowMs, nowMs);
+			for (const handle of entry.handles) db.prepare(`INSERT INTO user_person_handles (
+          handle_id, person_id, handle_type, normalized_value, display_value,
+          source_instance_id, verification, first_observed_at, last_observed_at, created_at, updated_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        ON CONFLICT(handle_type, normalized_value, source_instance_id) DO UPDATE SET
+          person_id = excluded.person_id,
+          display_value = excluded.display_value,
+          verification = CASE WHEN user_person_handles.verification = 'user_confirmed'
+            THEN 'user_confirmed' ELSE excluded.verification END,
+          first_observed_at = MIN(user_person_handles.first_observed_at, excluded.first_observed_at),
+          last_observed_at = excluded.last_observed_at,
+          updated_at = excluded.updated_at`).run(handle.id, personId, handle.type, handle.value.toLocaleLowerCase(), handle.value, handle.sourceInstanceId, handle.verification, handle.firstObservedAt, handle.lastObservedAt, nowMs, nowMs);
+			for (const source of entry.sources) db.prepare(`INSERT INTO user_person_source_stats (
+          person_id, source_instance_id, interaction_count, first_observed_at,
+          last_observed_at, updated_at
+        ) VALUES (?, ?, ?, ?, ?, ?)
+        ON CONFLICT(person_id, source_instance_id) DO UPDATE SET
+          interaction_count = user_person_source_stats.interaction_count + excluded.interaction_count,
+          first_observed_at = MIN(user_person_source_stats.first_observed_at, excluded.first_observed_at),
+          last_observed_at = MAX(user_person_source_stats.last_observed_at, excluded.last_observed_at),
+          updated_at = excluded.updated_at`).run(personId, source.sourceInstanceId, source.interactionCount, source.firstObservedAt, source.lastObservedAt, nowMs);
+		}
+		db.prepare(`DELETE FROM user_people
+      WHERE principal_id = ? AND merged_into_person_id IS NULL AND hidden = 0
+        AND user_display_name IS NULL AND user_kind IS NULL
+        AND NOT EXISTS (SELECT 1 FROM user_person_source_stats s WHERE s.person_id = user_people.person_id)
+        AND NOT EXISTS (SELECT 1 FROM user_person_handles h WHERE h.person_id = user_people.person_id)`).run(principalId);
+		db.prepare(`INSERT INTO user_people_index_state (
+      principal_id, source_change_sequence, source_grants_updated_at, rebuilt_at
+    ) VALUES (?, ?, ?, ?)
+    ON CONFLICT(principal_id) DO UPDATE SET
+      source_change_sequence = excluded.source_change_sequence,
+      source_grants_updated_at = excluded.source_grants_updated_at,
+      rebuilt_at = excluded.rebuilt_at`).run(principalId, revision.sourceChangeSequence, revision.sourceGrantsUpdatedAt, nowMs);
+	});
+}
+function getUserPeopleIndexState(principalId = USER_CONTEXT_PRINCIPAL_ID) {
+	const row = getSqliteDatabase().prepare(`SELECT source_change_sequence, source_grants_updated_at, rebuilt_at
+    FROM user_people_index_state WHERE principal_id = ?`).get(principalId);
+	return row ? {
+		sourceChangeSequence: row.source_change_sequence,
+		sourceGrantsUpdatedAt: row.source_grants_updated_at,
+		rebuiltAt: row.rebuilt_at
+	} : null;
+}
+function listUserPeople(options = {}) {
+	const principalId = options.principalId ?? "local-owner";
+	const clauses = [
+		"p.principal_id = ?",
+		"p.merged_into_person_id IS NULL",
+		"EXISTS (SELECT 1 FROM user_person_source_stats active_source WHERE active_source.person_id = p.person_id)"
+	];
+	const params = [principalId];
+	if (options.hiddenOnly) clauses.push("p.hidden = 1");
+	else if (!options.includeHidden) clauses.push("p.hidden = 0");
+	if (options.kind) {
+		clauses.push("COALESCE(p.user_kind, p.inferred_kind) = ?");
+		params.push(options.kind);
+	}
+	if (options.sourceInstanceId) {
+		clauses.push("EXISTS (SELECT 1 FROM user_person_source_stats filtered_source WHERE filtered_source.person_id = p.person_id AND filtered_source.source_instance_id = ?)");
+		params.push(options.sourceInstanceId);
+	}
+	const query = options.query?.trim().toLocaleLowerCase();
+	if (query) {
+		clauses.push(`(LOWER(COALESCE(p.user_display_name, p.display_name)) LIKE ? OR EXISTS (
+      SELECT 1 FROM user_person_handles search_handle
+      WHERE search_handle.person_id = p.person_id AND search_handle.normalized_value LIKE ?
+    ))`);
+		params.push(`%${query}%`, `%${query}%`);
+	}
+	const where = clauses.join(" AND ");
+	const total = Number(getSqliteDatabase().prepare(`SELECT COUNT(*) AS count FROM user_people p WHERE ${where}`).get(...params).count);
+	const limit = Math.max(1, Math.min(100, Math.floor(options.limit ?? 30)));
+	const offset = Math.max(0, Math.floor(options.offset ?? 0));
+	const rows = getSqliteDatabase().prepare(`SELECT p.* FROM user_people p WHERE ${where}
+    ORDER BY p.last_observed_at DESC, COALESCE(p.user_display_name, p.display_name) ASC
+    LIMIT ? OFFSET ?`).all(...params, limit, offset);
+	return {
+		items: rows.map((row) => fromRow(row)),
+		total,
+		...offset + rows.length < total ? { nextOffset: offset + rows.length } : {}
+	};
+}
+function getUserPerson(personId, principalId = USER_CONTEXT_PRINCIPAL_ID) {
+	const row = getSqliteDatabase().prepare(`SELECT * FROM user_people
+    WHERE person_id = ? AND principal_id = ? AND merged_into_person_id IS NULL`).get(personId, principalId);
+	return row ? fromRow(row, true) : null;
+}
+function updateUserPerson(personId, patch, principalId = USER_CONTEXT_PRINCIPAL_ID) {
+	const current = getUserPerson(personId, principalId);
+	if (!current) return null;
+	runSqliteWriteTransaction((db) => db.prepare(`UPDATE user_people SET
+    user_display_name = ?, user_kind = ?, hidden = ?, updated_at = ?
+    WHERE person_id = ? AND principal_id = ?`).run(patch.displayName === void 0 ? getUserDisplayName(personId) : patch.displayName, patch.kind === void 0 ? getUserKind(personId) : patch.kind, patch.hidden === void 0 ? Number(current.hidden) : Number(patch.hidden), Date.now(), personId, principalId));
+	return getUserPerson(personId, principalId);
+}
+function getUserDisplayName(personId) {
+	return getSqliteDatabase().prepare("SELECT user_display_name AS value FROM user_people WHERE person_id = ?").get(personId)?.value ?? null;
+}
+function getUserKind(personId) {
+	return getSqliteDatabase().prepare("SELECT user_kind AS value FROM user_people WHERE person_id = ?").get(personId)?.value ?? null;
+}
+function summarizeUserPeople(principalId = USER_CONTEXT_PRINCIPAL_ID) {
+	const row = getSqliteDatabase().prepare(`SELECT
+    SUM(CASE WHEN hidden = 0 AND COALESCE(user_kind, inferred_kind) = 'person' THEN 1 ELSE 0 END) AS people,
+    SUM(CASE WHEN hidden = 0 AND COALESCE(user_kind, inferred_kind) IN ('bot', 'service', 'group') THEN 1 ELSE 0 END) AS automated,
+    SUM(CASE WHEN hidden = 0 AND COALESCE(user_kind, inferred_kind) = 'unknown' THEN 1 ELSE 0 END) AS needs_review,
+    SUM(CASE WHEN hidden = 1 THEN 1 ELSE 0 END) AS hidden,
+    MAX(last_observed_at) AS last_updated_at
+    FROM user_people p WHERE principal_id = ? AND merged_into_person_id IS NULL
+      AND EXISTS (SELECT 1 FROM user_person_source_stats s WHERE s.person_id = p.person_id)`).get(principalId);
+	const sources = Number(getSqliteDatabase().prepare(`SELECT COUNT(DISTINCT source_instance_id) AS count
+    FROM user_person_source_stats s JOIN user_people p ON p.person_id = s.person_id
+    WHERE p.principal_id = ? AND p.merged_into_person_id IS NULL`).get(principalId).count);
+	return {
+		people: Number(row.people ?? 0),
+		automatedAccounts: Number(row.automated ?? 0),
+		needsReview: Number(row.needs_review ?? 0),
+		hidden: Number(row.hidden ?? 0),
+		sources,
+		...row.last_updated_at == null ? {} : { lastUpdatedAt: row.last_updated_at }
+	};
+}
+function mergeUserPeople(sourcePersonId, targetPersonId, principalId = USER_CONTEXT_PRINCIPAL_ID) {
+	if (sourcePersonId === targetPersonId) return getUserPerson(targetPersonId, principalId);
+	const source = getUserPerson(sourcePersonId, principalId);
+	const target = getUserPerson(targetPersonId, principalId);
+	if (!source || !target) return null;
+	runSqliteWriteTransaction((db) => {
+		const duplicateHandles = db.prepare(`SELECT source.handle_id FROM user_person_handles source
+      JOIN user_person_handles target
+        ON target.person_id = ? AND target.handle_type = source.handle_type
+        AND target.normalized_value = source.normalized_value
+        AND target.source_instance_id = source.source_instance_id
+      WHERE source.person_id = ?`).all(targetPersonId, sourcePersonId);
+		for (const duplicate of duplicateHandles) db.prepare("DELETE FROM user_person_handles WHERE handle_id = ?").run(duplicate.handle_id);
+		db.prepare("UPDATE user_person_handles SET person_id = ?, updated_at = ? WHERE person_id = ?").run(targetPersonId, Date.now(), sourcePersonId);
+		const sourceStats = db.prepare("SELECT * FROM user_person_source_stats WHERE person_id = ?").all(sourcePersonId);
+		for (const stat of sourceStats) db.prepare(`INSERT INTO user_person_source_stats (
+        person_id, source_instance_id, interaction_count, first_observed_at,
+        last_observed_at, last_source_item_id, updated_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(person_id, source_instance_id) DO UPDATE SET
+        interaction_count = user_person_source_stats.interaction_count + excluded.interaction_count,
+        first_observed_at = MIN(user_person_source_stats.first_observed_at, excluded.first_observed_at),
+        last_observed_at = MAX(user_person_source_stats.last_observed_at, excluded.last_observed_at),
+        last_source_item_id = CASE WHEN excluded.last_observed_at >= user_person_source_stats.last_observed_at
+          THEN excluded.last_source_item_id ELSE user_person_source_stats.last_source_item_id END,
+        updated_at = excluded.updated_at`).run(targetPersonId, stat.source_instance_id, stat.interaction_count, stat.first_observed_at, stat.last_observed_at, stat.last_source_item_id, Date.now());
+		db.prepare("DELETE FROM user_person_source_stats WHERE person_id = ?").run(sourcePersonId);
+		db.prepare(`UPDATE user_people SET merged_into_person_id = ?, updated_at = ?
+      WHERE person_id = ? AND principal_id = ?`).run(targetPersonId, Date.now(), sourcePersonId, principalId);
+	});
+	return getUserPerson(targetPersonId, principalId);
+}
+//#endregion
+export { getUserPeopleIndexState, getUserPerson, listUserPeople, mergeUserPeople, replaceUserPeopleIndex, summarizeUserPeople, updateUserPerson };

package/dist/src/tui/backends/embedded-backend.js

@@ -23,9 +23,9 @@ import { parseModelRef } from "../../agent/models/selection.js";
 import { buildReviewContext, resolveGitRoot } from "../../review/review-git.js";
 import { MessageBus, MessageBusShutdownError } from "../../infra/bus/queue.js";
 import "../../infra/bus/index.js";
+import { prependEnvelopeTimestamp } from "../../channels/envelope-timestamp.js";
 import { getWorkspacePath } from "../../config/workspace-path-helpers.js";
 import "../../config/index.js";
-import { prependEnvelopeTimestamp } from "../../channels/envelope-timestamp.js";
 import { buildWorkflowChildTools } from "../../agent/workflow/workflow-child-tools.js";
 import { WorkflowRunService } from "../../workflows/service/workflow-run-service.js";
 import { WorkflowSessionBridge } from "../../workflows/service/workflow-session-bridge.js";

package/dist/src/user-context/planner.js

@@ -160,6 +160,8 @@ var UserContextPlanner = class {
 			rejected: [],
 			consentRequests: [],
 			estimatedTokens: 0,
+			contextChars: 0,
+			contextItemCount: 0,
 			allocation: params.allocation
 		};
 		const started = Date.now();
@@ -174,7 +176,8 @@ var UserContextPlanner = class {
 		const queryProfile = buildRetrievalQueryProfile(query, scopeInput);
 		const selfReview = queryProfile.selfReview;
 		const maxResults = requestedMaxResults ?? (selfReview ? SELF_REVIEW_MAX_RESULTS : DEFAULT_MAX_RESULTS);
-		const maxChars = requestedMaxChars ?? (selfReview ? SELF_REVIEW_MAX_CONTEXT_CHARS : DEFAULT_MAX_CONTEXT_CHARS);
+		const budgetChars = requestedMaxChars ?? (selfReview ? SELF_REVIEW_MAX_CONTEXT_CHARS : DEFAULT_MAX_CONTEXT_CHARS);
+		const maxChars = Math.max(0, budgetChars - 2);
 		const projects = new ProjectStore();
 		const excluded = new Set(params.excludedRecordIds ?? []);
 		const rejected = [];
@@ -464,7 +467,7 @@ var UserContextPlanner = class {
 			turnId: params.turnId,
 			sessionKey: params.sessionKey,
 			query,
-			budget: maxChars,
+			budget: budgetChars,
 			durationMs: Date.now() - started,
 			items: traceItems
 		});
@@ -474,7 +477,9 @@ var UserContextPlanner = class {
 			items,
 			rejected,
 			consentRequests,
-			estimatedTokens: Math.ceil(block.length / 4),
+			estimatedTokens: Math.ceil((block.length + (block ? 2 : 0)) / 4),
+			contextChars: block.length + (block ? 2 : 0),
+			contextItemCount: traceItems.filter((item) => item.decision === "selected").length,
 			allocation: params.allocation
 		};
 	}

package/dist/src/user-context/relationships/indexer.d.ts

@@ -0,0 +1,13 @@
+import type { KnowledgeSourceItem } from '../../knowledge/types.js';
+import type { UserPersonIndexEntry } from './types.js';
+type PersonSignal = {
+    name?: string;
+    email?: string;
+    username?: string;
+};
+export declare function personIdentityKey(signal: PersonSignal, sourceInstanceId: string): string | undefined;
+export declare function personIdForIdentity(signal: PersonSignal, sourceInstanceId: string): string | undefined;
+export declare function buildUserPeopleIndex(items: KnowledgeSourceItem[]): UserPersonIndexEntry[];
+export declare function rebuildUserPeopleIndex(): UserPersonIndexEntry[];
+export declare function ensureUserPeopleIndex(): void;
+export {};

package/dist/src/user-context/relationships/indexer.js

@@ -0,0 +1,185 @@
+import { getSqliteDatabase } from "../../storage/sqlite/transaction.js";
+import { getUserPeopleIndexState, replaceUserPeopleIndex } from "../../storage/sqlite/user-people-repository.js";
+import { listKnowledgeSourceItems } from "../../storage/sqlite/knowledge-repository.js";
+import "../../storage/sqlite/index.js";
+import { listUnderstandingSourceGrants } from "../sources/repository.js";
+import { createHash } from "node:crypto";
+//#region src/user-context/relationships/indexer.ts
+function hash(value) {
+	return createHash("sha256").update(value).digest("hex").slice(0, 20);
+}
+function normalized(value) {
+	return value?.trim().toLocaleLowerCase() || void 0;
+}
+function readSignal(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+	const row = value;
+	const read = (key) => typeof row[key] === "string" && row[key].trim() ? row[key].trim().slice(0, 160) : void 0;
+	const signal = {
+		name: read("name"),
+		email: read("email"),
+		username: read("username")
+	};
+	return signal.name || signal.email || signal.username ? signal : void 0;
+}
+function providerScope(sourceInstanceId) {
+	if (!sourceInstanceId.startsWith("composio:")) return sourceInstanceId.toLocaleLowerCase();
+	return sourceInstanceId.split(":")[1]?.toLocaleLowerCase() ?? sourceInstanceId.toLocaleLowerCase();
+}
+function personIdentityKey(signal, sourceInstanceId) {
+	const email = normalized(signal.email);
+	if (email) return `email:${email}`;
+	const username = normalized(signal.username);
+	if (username) return `provider:${providerScope(sourceInstanceId)}:${username}`;
+	const name = normalized(signal.name);
+	return name ? `name:${sourceInstanceId.toLocaleLowerCase()}:${name}` : void 0;
+}
+function personIdForIdentity(signal, sourceInstanceId) {
+	const key = personIdentityKey(signal, sourceInstanceId);
+	return key ? `person_${hash(key)}` : void 0;
+}
+function inferredKind(signal) {
+	const name = normalized(signal.name) ?? "";
+	const username = normalized(signal.username) ?? "";
+	const emailLocal = (normalized(signal.email) ?? "").split("@")[0] ?? "";
+	if (/\[bot\]|(?:^|[-_.])bot(?:$|[-_.])|bot$/.test(`${name} ${username}`)) return "bot";
+	if (/^(?:no[-_.]?reply|do[-_.]?not[-_.]?reply|notifications?|alerts?|mailer[-_.]?daemon)(?:$|[-+_.])/.test(emailLocal)) return "service";
+	if (/^(?:team|group|all|everyone|support|help|sales|contact)(?:$|[-+_.])/.test(emailLocal)) return "group";
+	if (!signal.name && !signal.email && signal.username) return "unknown";
+	return "person";
+}
+function confidence(signal) {
+	if (signal.email) return signal.name ? .95 : .88;
+	if (signal.username) return signal.name ? .86 : .72;
+	return .55;
+}
+function observedAt(item) {
+	const value = Date.parse(item.occurredAt ?? item.sourceUpdatedAt ?? item.updatedAt);
+	return Number.isFinite(value) ? value : Date.now();
+}
+function handle(personId, type, value, sourceInstanceId, time) {
+	return {
+		id: `handle_${hash(`${type}:${normalized(value)}:${sourceInstanceId}`)}`,
+		type,
+		value,
+		sourceInstanceId,
+		verification: type === "display_name" ? "inferred" : "observed",
+		firstObservedAt: time,
+		lastObservedAt: time
+	};
+}
+function activeConnectorSources() {
+	return new Set(listUnderstandingSourceGrants().flatMap((grant) => {
+		const sourceInstanceId = typeof grant.config.sourceInstanceId === "string" ? grant.config.sourceInstanceId.trim() : "";
+		if (sourceInstanceId) return [sourceInstanceId];
+		const connectorId = typeof grant.config.connectorId === "string" ? grant.config.connectorId.trim() : "";
+		const accountId = typeof grant.config.accountId === "string" ? grant.config.accountId.trim() : "";
+		return connectorId && accountId ? [`composio:${connectorId}:${accountId}`] : [];
+	}));
+}
+function loadActiveSourceItems() {
+	const activeSources = activeConnectorSources();
+	const items = [];
+	let offset = 0;
+	while (true) {
+		const page = listKnowledgeSourceItems({
+			includeDeleted: false,
+			limit: 500,
+			offset
+		});
+		items.push(...page.filter((item) => item.synthesisPipeline === "connected_knowledge" && item.sensitivity !== "secret" && item.sensitivity !== "regulated" && item.metadata.observationKind !== "inventory" && (!item.sourceInstanceId.startsWith("composio:") || activeSources.has(item.sourceInstanceId))));
+		if (page.length < 500) break;
+		offset += page.length;
+	}
+	return items;
+}
+function currentIndexRevision() {
+	const db = getSqliteDatabase();
+	return {
+		sourceChangeSequence: Number(db.prepare("SELECT COALESCE(MAX(sequence), 0) AS value FROM knowledge_source_changes").get().value),
+		sourceGrantsUpdatedAt: Number(db.prepare("SELECT COALESCE(MAX(updated_at), 0) AS value FROM understanding_source_grants").get().value)
+	};
+}
+function buildUserPeopleIndex(items) {
+	const owners = new Set(items.flatMap((item) => Array.isArray(item.metadata.ownerIdentities) ? item.metadata.ownerIdentities.filter((value) => typeof value === "string").map((value) => value.trim().toLocaleLowerCase()).filter(Boolean) : []));
+	const people = /* @__PURE__ */ new Map();
+	for (const item of items) {
+		const values = Array.isArray(item.metadata.personEntities) ? item.metadata.personEntities : [];
+		const seenInItem = /* @__PURE__ */ new Set();
+		for (const value of values) {
+			const signal = readSignal(value);
+			if (!signal) continue;
+			const strongIdentity = normalized(signal.email) ?? normalized(signal.username);
+			if (strongIdentity && owners.has(strongIdentity)) continue;
+			const identityKey = personIdentityKey(signal, item.sourceInstanceId);
+			const id = personIdForIdentity(signal, item.sourceInstanceId);
+			if (!identityKey || !id || seenInItem.has(identityKey)) continue;
+			seenInItem.add(identityKey);
+			const time = observedAt(item);
+			const name = signal.name ?? signal.email ?? signal.username;
+			const current = people.get(identityKey) ?? {
+				id,
+				displayName: name,
+				inferredKind: inferredKind(signal),
+				confidence: confidence(signal),
+				firstObservedAt: time,
+				lastObservedAt: time,
+				handles: /* @__PURE__ */ new Map(),
+				sources: /* @__PURE__ */ new Map()
+			};
+			if (signal.name && (!current.displayName || current.displayName.includes("@"))) current.displayName = signal.name;
+			current.inferredKind = current.inferredKind === "unknown" ? inferredKind(signal) : current.inferredKind;
+			current.confidence = Math.max(current.confidence, confidence(signal));
+			current.firstObservedAt = Math.min(current.firstObservedAt, time);
+			current.lastObservedAt = Math.max(current.lastObservedAt, time);
+			for (const [type, displayValue] of [
+				["email", signal.email],
+				["username", signal.username],
+				["display_name", signal.name]
+			]) {
+				if (!displayValue) continue;
+				const next = handle(id, type, displayValue, item.sourceInstanceId, time);
+				const key = `${type}:${normalized(displayValue)}:${item.sourceInstanceId}`;
+				const previous = current.handles.get(key);
+				if (previous) {
+					previous.firstObservedAt = Math.min(previous.firstObservedAt, time);
+					previous.lastObservedAt = Math.max(previous.lastObservedAt, time);
+				} else current.handles.set(key, next);
+			}
+			const source = current.sources.get(item.sourceInstanceId) ?? {
+				sourceInstanceId: item.sourceInstanceId,
+				interactionCount: 0,
+				firstObservedAt: time,
+				lastObservedAt: time
+			};
+			source.interactionCount += 1;
+			source.firstObservedAt = Math.min(source.firstObservedAt, time);
+			source.lastObservedAt = Math.max(source.lastObservedAt, time);
+			current.sources.set(item.sourceInstanceId, source);
+			people.set(identityKey, current);
+		}
+	}
+	return [...people.values()].map((person) => ({
+		id: person.id,
+		displayName: person.displayName,
+		inferredKind: person.inferredKind,
+		confidence: person.confidence,
+		firstObservedAt: person.firstObservedAt,
+		lastObservedAt: person.lastObservedAt,
+		handles: [...person.handles.values()],
+		sources: [...person.sources.values()]
+	}));
+}
+function rebuildUserPeopleIndex() {
+	const revision = currentIndexRevision();
+	const entries = buildUserPeopleIndex(loadActiveSourceItems());
+	replaceUserPeopleIndex(entries, revision);
+	return entries;
+}
+function ensureUserPeopleIndex() {
+	const revision = currentIndexRevision();
+	const state = getUserPeopleIndexState();
+	if (!state || state.sourceChangeSequence !== revision.sourceChangeSequence || state.sourceGrantsUpdatedAt !== revision.sourceGrantsUpdatedAt) rebuildUserPeopleIndex();
+}
+//#endregion
+export { buildUserPeopleIndex, ensureUserPeopleIndex, personIdForIdentity, personIdentityKey, rebuildUserPeopleIndex };

package/dist/src/user-context/relationships/service.d.ts

@@ -0,0 +1,22 @@
+import type { UserPerson, UserPersonKind } from './types.js';
+export declare function listUserRelationships(options?: {
+    query?: string;
+    kind?: UserPersonKind;
+    sourceInstanceId?: string;
+    includeHidden?: boolean;
+    hiddenOnly?: boolean;
+    cursor?: string;
+    limit?: number;
+}): {
+    nextCursor?: string;
+    items: UserPerson[];
+    summary: import("./types.js").UserRelationshipSummary;
+    total: number;
+};
+export declare function getUserRelationship(personId: string): UserPerson | null;
+export declare function patchUserRelationship(personId: string, patch: {
+    displayName?: string | null;
+    kind?: UserPersonKind | null;
+    hidden?: boolean;
+}): UserPerson | null;
+export declare function mergeUserRelationships(sourcePersonId: string, targetPersonId: string): UserPerson | null;

package/dist/src/user-context/relationships/service.js

@@ -0,0 +1,50 @@
+import { listUnderstandings } from "../../storage/sqlite/user-context-repository.js";
+import { getUserPerson, listUserPeople, mergeUserPeople, summarizeUserPeople, updateUserPerson } from "../../storage/sqlite/user-people-repository.js";
+import "../../storage/sqlite/index.js";
+import { ensureUserPeopleIndex } from "./indexer.js";
+//#region src/user-context/relationships/service.ts
+function withUnderstanding(person) {
+	const understanding = listUnderstandings().find((item) => item.kind === "relationship" && item.payload.personId === person.id && !["archived", "rejected"].includes(item.status));
+	return understanding ? {
+		...person,
+		relationshipUnderstanding: {
+			id: understanding.id,
+			statement: understanding.statement,
+			status: understanding.status
+		}
+	} : person;
+}
+function listUserRelationships(options = {}) {
+	ensureUserPeopleIndex();
+	const offset = options.cursor && /^\d+$/.test(options.cursor) ? Number(options.cursor) : 0;
+	const result = listUserPeople({
+		query: options.query,
+		kind: options.kind,
+		sourceInstanceId: options.sourceInstanceId,
+		includeHidden: options.includeHidden,
+		hiddenOnly: options.hiddenOnly,
+		offset,
+		limit: options.limit
+	});
+	return {
+		items: result.items.map(withUnderstanding),
+		summary: summarizeUserPeople(),
+		total: result.total,
+		...result.nextOffset === void 0 ? {} : { nextCursor: String(result.nextOffset) }
+	};
+}
+function getUserRelationship(personId) {
+	ensureUserPeopleIndex();
+	const person = getUserPerson(personId);
+	return person ? withUnderstanding(person) : null;
+}
+function patchUserRelationship(personId, patch) {
+	const person = updateUserPerson(personId, patch);
+	return person ? withUnderstanding(person) : null;
+}
+function mergeUserRelationships(sourcePersonId, targetPersonId) {
+	const person = mergeUserPeople(sourcePersonId, targetPersonId);
+	return person ? withUnderstanding(person) : null;
+}
+//#endregion
+export { getUserRelationship, listUserRelationships, mergeUserRelationships, patchUserRelationship };

package/dist/src/user-context/relationships/types.d.ts

@@ -0,0 +1,55 @@
+export declare const USER_PERSON_KINDS: readonly ["person", "bot", "service", "group", "unknown"];
+export type UserPersonKind = typeof USER_PERSON_KINDS[number];
+export type UserPersonHandle = {
+    id: string;
+    type: 'email' | 'provider_user' | 'username' | 'display_name';
+    value: string;
+    sourceInstanceId: string;
+    verification: 'observed' | 'inferred' | 'user_confirmed';
+    firstObservedAt: number;
+    lastObservedAt: number;
+};
+export type UserPersonSource = {
+    sourceInstanceId: string;
+    connectorId?: string;
+    toolkit?: string;
+    interactionCount: number;
+    firstObservedAt: number;
+    lastObservedAt: number;
+};
+export type UserPerson = {
+    id: string;
+    displayName: string;
+    kind: UserPersonKind;
+    hidden: boolean;
+    confidence: number;
+    primaryHandle?: string;
+    interactionCount: number;
+    firstObservedAt: number;
+    lastObservedAt: number;
+    handles: UserPersonHandle[];
+    sources: UserPersonSource[];
+    relationshipUnderstanding?: {
+        id: string;
+        statement: string;
+        status: 'candidate' | 'active' | 'needs_review' | 'stale' | 'archived' | 'rejected';
+    };
+};
+export type UserRelationshipSummary = {
+    people: number;
+    automatedAccounts: number;
+    needsReview: number;
+    hidden: number;
+    sources: number;
+    lastUpdatedAt?: number;
+};
+export type UserPersonIndexEntry = {
+    id: string;
+    displayName: string;
+    inferredKind: UserPersonKind;
+    confidence: number;
+    firstObservedAt: number;
+    lastObservedAt: number;
+    handles: UserPersonHandle[];
+    sources: UserPersonSource[];
+};

package/dist/src/user-context/relationships/types.js

@@ -0,0 +1,10 @@
+//#region src/user-context/relationships/types.ts
+const USER_PERSON_KINDS = [
+	"person",
+	"bot",
+	"service",
+	"group",
+	"unknown"
+];
+//#endregion
+export { USER_PERSON_KINDS };

package/dist/src/user-context/sources/repository.d.ts

@@ -55,6 +55,6 @@ export declare function updateUnderstandingSourceRun(id: string, patch: {
 }): UnderstandingSourceRun | null;
 export declare function upsertUserFocus(input: UserFocusInput): UserFocus;
 export declare function listUserFocuses(statuses?: UserFocus['status'][]): UserFocus[];
-export declare function updateUserFocus(id: string, patch: Partial<Pick<UserFocus, 'title' | 'summary' | 'status'>>, nowMs?: number): UserFocus | null;
+export declare function updateUserFocus(id: string, patch: Partial<Pick<UserFocus, 'title' | 'summary' | 'status' | 'validFrom' | 'validTo' | 'reviewAt'>>, nowMs?: number): UserFocus | null;
 export declare function deleteUserFocus(id: string): boolean;
 export {};