@xopcai/xopc 0.0.225 → 0.0.227

package/dist/src/projects/project-skill-service.js

@@ -1,5 +1,6 @@
+import { init_paths, resolveBundledSkillsDir } from "../config/paths.js";
 import { resolveWorkspaceSkillsDir, resolveWorkspaceSkillsLockPath } from "../agent/skills/workspace-skills-dir.js";
-import { loadWorkspaceSkills } from "../agent/skills/index.js";
+import { loadSkills, loadWorkspaceSkillInventory } from "../agent/skills/index.js";
 import { removeSkillsLockEntry } from "../agent/skills/hub-lock.js";
 import { deleteManagedSkill, installSkillFromZip, isValidSkillId } from "../agent/skills/managed-store.js";
 import { pullSkillFromSource } from "../agent/skills/hub-pull.js";
@@ -7,6 +8,7 @@ import { downloadFromMarketplace } from "../agent/skills/skills-marketplace.js";
 import { basename, dirname, join, relative, resolve, sep } from "node:path";
 import { accessSync, constants, existsSync, statSync } from "node:fs";
 //#region src/projects/project-skill-service.ts
+init_paths();
 var ProjectSkillError = class extends Error {
 	constructor(code, status, message) {
 		super(message);
@@ -20,21 +22,44 @@ var ProjectSkillService = class {
 		this.options = options;
 	}
 	list(projectId) {
-		const location = this.resolveLocation(projectId, false);
-		const loaded = loadWorkspaceSkills(location.workspaceRoot);
+		const { location, loaded, inherited, trust } = this.loadCatalog(projectId);
 		return {
-			...location,
-			items: loaded.skills.filter((skill) => this.isDirectSkill(skill, location.skillsRoot)).map((skill) => this.toSummary(skill)),
-			diagnostics: loaded.diagnostics
+			workspaceRoot: location.workspaceRoot,
+			sources: loaded.sources,
+			trust,
+			items: loaded.entries.map((entry) => this.toSummary(entry)),
+			inheritedItems: inherited.skills.map((skill) => this.toSummary({
+				skill,
+				effective: true
+			})),
+			diagnostics: inherited.diagnostics
 		};
 	}
-	getContent(projectId, skillId) {
-		const { skill } = this.findSkill(projectId, skillId);
+	getContent(projectId, skillKey) {
+		const { loaded, inherited } = this.loadCatalog(projectId);
+		const entry = loaded.entries.find((candidate) => this.skillKey(candidate.skill) === skillKey);
+		if (entry) return {
+			...this.toSummary(entry),
+			bodyMarkdown: entry.skill.content
+		};
+		const inheritedSkill = inherited.skills.find((candidate) => this.skillKey(candidate) === skillKey);
+		if (!inheritedSkill) throw new ProjectSkillError("skill_not_found", 404, "Project skill not found");
 		return {
-			...this.toSummary(skill),
-			bodyMarkdown: skill.content
+			...this.toSummary({
+				skill: inheritedSkill,
+				effective: true
+			}),
+			bodyMarkdown: inheritedSkill.content
 		};
 	}
+	getWorkspaceTrust(projectId) {
+		const location = this.resolveLocation(projectId, false);
+		return this.options.getWorkspaceTrust(location.workspaceRoot);
+	}
+	setWorkspaceTrust(projectId, trusted) {
+		const location = this.resolveLocation(projectId, false);
+		return this.options.setWorkspaceTrust(location.workspaceRoot, trusted);
+	}
 	async installZip(projectId, buffer, input = {}) {
 		const location = this.resolveLocation(projectId, true);
 		const installed = installSkillFromZip(buffer, {
@@ -44,7 +69,7 @@ var ProjectSkillService = class {
 		});
 		removeSkillsLockEntry(installed.skillId, resolveWorkspaceSkillsLockPath(location.workspaceRoot));
 		await this.options.refreshSkills();
-		return this.getContent(projectId, installed.skillId);
+		return this.getContent(projectId, this.encodeSkillKey("xopc-workspace", installed.skillId));
 	}
 	async installMarketplace(projectId, input) {
 		const downloaded = await downloadFromMarketplace(this.options.getConfig(), input.name, input.version, input.provider);
@@ -64,7 +89,7 @@ var ProjectSkillService = class {
 			lockPath: resolveWorkspaceSkillsLockPath(location.workspaceRoot)
 		});
 		await this.options.refreshSkills();
-		return this.getContent(projectId, installed.skillId);
+		return this.getContent(projectId, this.encodeSkillKey("xopc-workspace", installed.skillId));
 	}
 	async remove(projectId, skillId) {
 		const location = this.resolveLocation(projectId, true);
@@ -74,18 +99,6 @@ var ProjectSkillService = class {
 		removeSkillsLockEntry(skillId, resolveWorkspaceSkillsLockPath(location.workspaceRoot));
 		await this.options.refreshSkills();
 	}
-	findSkill(projectId, skillId) {
-		if (!isValidSkillId(skillId)) throw new ProjectSkillError("invalid_skill_id", 400, "Invalid skill id");
-		const location = this.resolveLocation(projectId, false);
-		const skill = loadWorkspaceSkills(location.workspaceRoot).skills.find((item) => {
-			return !relative(location.skillsRoot, item.baseDir).includes(sep) && basename(item.baseDir) === skillId;
-		});
-		if (!skill) throw new ProjectSkillError("skill_not_found", 404, "Project skill not found");
-		return {
-			skill,
-			skillsRoot: location.skillsRoot
-		};
-	}
 	resolveLocation(projectId, requireWritable) {
 		const project = this.options.projects.get(projectId);
 		if (!project) throw new ProjectSkillError("project_not_found", 404, "Project not found");
@@ -110,16 +123,50 @@ var ProjectSkillService = class {
 			skillsRoot
 		};
 	}
-	isDirectSkill(skill, skillsRoot) {
-		const rel = relative(skillsRoot, skill.baseDir);
-		return Boolean(rel) && !rel.includes(sep) && isValidSkillId(basename(skill.baseDir));
+	loadCatalog(projectId) {
+		const location = this.resolveLocation(projectId, false);
+		const trust = this.options.getWorkspaceTrust(location.workspaceRoot);
+		const loaded = loadWorkspaceSkillInventory(location.workspaceRoot, { workspaceTrust: trust.trusted ? "trusted" : "untrusted" });
+		const all = loadSkills({
+			workspaceDir: location.workspaceRoot,
+			builtinDir: resolveBundledSkillsDir(),
+			workspaceTrust: trust.trusted ? "trusted" : "untrusted"
+		});
+		return {
+			location,
+			loaded,
+			inherited: {
+				skills: all.skills.filter((skill) => skill.origin.scope !== "workspace"),
+				diagnostics: all.diagnostics
+			},
+			trust
+		};
+	}
+	skillKey(skill) {
+		const rel = relative(skill.origin.rootDir, skill.baseDir).split(sep).join("/");
+		return this.encodeSkillKey(skill.origin.id, rel);
+	}
+	encodeSkillKey(origin, relativeDir) {
+		return Buffer.from(`${origin}\0${relativeDir}`, "utf8").toString("base64url");
 	}
-	toSummary(skill) {
+	toSummary(entry) {
+		const { skill } = entry;
+		const id = basename(skill.baseDir);
+		const relativeDir = relative(skill.origin.rootDir, skill.baseDir);
+		const removable = skill.origin.id === "xopc-workspace" && !relativeDir.includes(sep) && isValidSkillId(id);
 		return {
-			id: basename(skill.baseDir),
+			key: this.skillKey(skill),
+			directoryId: id,
 			name: skill.name,
 			description: skill.description,
 			category: skill.category,
+			origin: skill.origin.id,
+			path: skill.baseDir,
+			managed: skill.origin.managed,
+			writable: skill.origin.writable,
+			removable,
+			effective: entry.effective,
+			shadowedBy: entry.shadowedBy,
 			disableModelInvocation: skill.disableModelInvocation,
 			metadata: skill.metadata,
 			toolConditions: skill.toolConditions,

package/dist/src/storage/sqlite/index.d.ts

@@ -10,6 +10,7 @@ export { closeTemporalAssertions, createTemporalAssertion, linkContextObjects, l
 export { finishContextConsolidationRun, getContextConsolidationRun, listContextConsolidationDecisions, listContextConsolidationRuns, recordContextConsolidationDecision, startContextConsolidationRun, type ContextConsolidationDecision, type ContextConsolidationRun, } from './context-consolidation-repository.js';
 export { summarizeUnderstandingFeedback, summarizeUserUnderstandingQuality, type UnderstandingFeedbackSummary, type UserUnderstandingQualityMetrics, } from './user-context-quality-repository.js';
 export { createCollaborationRule, createContextEvidence, createUnderstanding, closeUnderstandingValidity, consumeContextConsent, deleteCollaborationRule, deleteUnderstanding, decideContextConsent, ensureContextConsent, getCollaborationRule, getTurnPersonalization, getUnderstanding, getUserProfile, hasContextConsent, isUnderstandingSuppressed, listCollaborationRules, listUnderstandingEvidence, listUnderstandings, linkUnderstandingEvidence, recordContextFeedback, recordContextRun, rejectUnderstanding, reviseCollaborationRule, reviseUnderstanding, searchActiveUnderstandings, setCollaborationRuleStatus, setUnderstandingStatus, updateUserProfile, type CreateUnderstandingInput, } from './user-context-repository.js';
+export { getUserPerson, getUserPeopleIndexState, listUserPeople, mergeUserPeople, replaceUserPeopleIndex, summarizeUserPeople, updateUserPerson, } from './user-people-repository.js';
 export { cancelQueuedSessionInput, claimNextSessionInput, findSessionInput, finishSessionInputRun, getSessionInputState, getSessionInputById, insertSessionInput, mutateQueuedSessionInput, recoverSessionInputState, setSessionInputStatus, type SessionInput, type SessionInputDelivery, type SessionInputState, type SessionInputStatus, } from './session-input-repository.js';
 export { replaceLatestSessionTurnAndQueueInput, validateLatestSessionTurnTarget, type ReplaceLatestSessionTurnInput, type ReplaceLatestSessionTurnResult, } from './session-turn-replace-repository.js';
 export { acknowledgeHomeAttention, isHomeAttentionAcknowledged, type HomeAttentionSubjectKind, } from './home-attention-repository.js';

package/dist/src/storage/sqlite/index.js

@@ -11,6 +11,7 @@ import { closeTemporalAssertions, createTemporalAssertion, linkContextObjects, l
 import { finishContextConsolidationRun, getContextConsolidationRun, listContextConsolidationDecisions, listContextConsolidationRuns, recordContextConsolidationDecision, startContextConsolidationRun } from "./context-consolidation-repository.js";
 import { summarizeUnderstandingFeedback, summarizeUserUnderstandingQuality } from "./user-context-quality-repository.js";
 import { closeUnderstandingValidity, consumeContextConsent, createCollaborationRule, createContextEvidence, createUnderstanding, decideContextConsent, deleteCollaborationRule, deleteUnderstanding, ensureContextConsent, getCollaborationRule, getTurnPersonalization, getUnderstanding, getUserProfile, hasContextConsent, isUnderstandingSuppressed, linkUnderstandingEvidence, listCollaborationRules, listUnderstandingEvidence, listUnderstandings, recordContextFeedback, recordContextRun, rejectUnderstanding, reviseCollaborationRule, reviseUnderstanding, searchActiveUnderstandings, setCollaborationRuleStatus, setUnderstandingStatus, updateUserProfile } from "./user-context-repository.js";
+import { getUserPeopleIndexState, getUserPerson, listUserPeople, mergeUserPeople, replaceUserPeopleIndex, summarizeUserPeople, updateUserPerson } from "./user-people-repository.js";
 import { cancelQueuedSessionInput, claimNextSessionInput, findSessionInput, finishSessionInputRun, getSessionInputById, getSessionInputState, insertSessionInput, mutateQueuedSessionInput, recoverSessionInputState, setSessionInputStatus } from "./session-input-repository.js";
 import { buildDefaultSessionMetadata } from "./session-metadata.js";
 import { buildGlobalSessionStats, classifyStoredRow, estimateTokensFromMessages, extractFtsContent, metadataToSessionInsert, sessionConfigRowToConfig, sessionRowToMetadata, transcriptEntryRowToStoredRow } from "./row-mappers.js";
@@ -35,4 +36,4 @@ import { appendConnectorExecutionAudit, claimConnectorWebhookDelivery, completeC
 import { getConnectorAccount, listConnectorAccounts, reconcileConnectorAccount, refreshConnectorAccountCurrent } from "./connector-account-repository.js";
 import { getConnectorSyncPolicy, getConnectorSyncPolicyForConnection, listConnectorSyncPolicies, upsertConnectorSyncPolicy } from "./connector-sync-policy-repository.js";
 import { getUserTrustPolicy, setUserTrustPolicy } from "./user-trust-repository.js";
-export { COMPOSER_INPUT_HISTORY_LIMIT, DatabaseSchemaMigrationGapError, DatabaseSchemaTooNewError, SCHEMA_META_SCHEMA_VERSION_KEY, XOPC_DB_BASELINE_SCHEMA_VERSION, XOPC_DB_FILENAME, XOPC_DB_SCHEMA_VERSION, acknowledgeHomeAttention, appendCompactionBoundaryIfUnchanged, appendComposerInputHistory, appendConnectorExecutionAudit, appendMemorySignal, appendMemoryTraceEvent, appendTranscriptEntry, applyPendingMigrations, attachMemoryEvidence, bindEndpointPrincipal, buildDefaultSessionMetadata, buildGlobalSessionStats, buildRelationshipPrompt, cancelQueuedSessionInput, claimConnectorWebhookDelivery, claimContextExtractionRun, claimKnowledgeSourceItems, claimNextConnectorLearningJob, claimNextSessionInput, classifyStoredRow, clearComposerInputHistory, closeTemporalAssertions, closeUnderstandingValidity, closeXopcDatabase, completeConnectorWebhookDelivery, completeKnowledgeSourceItemSynthesis, consumeConnectorApproval, consumeContextConsent, countKnowledgeSourceItems, countMemoryRecordsBySourceInstanceId, createCollaborationRule, createConnectorApproval, createContextEvidence, createEndpointPrincipal, createObjectLinkRecord, createTemporalAssertion, createUnderstanding, decideConnectorApproval, decideContextConsent, deleteCollaborationRule, deleteConnectorConnection, deleteConnectorInstallation, deleteKnowledgeSourceItems, deleteMemoryEvidenceForRecord, deleteMemoryRecord, deleteMemoryRecordsBySourceInstanceId, deleteNoteAgentContextRecord, deleteNoteRecord, deleteObjectLinkRecord, deleteSessionConfig, deleteSessionRecord, deleteUnderstanding, discoverSqlMigrations, enqueueConnectorLearningJob, ensureContextConsent, ensureSessionRecord, ensureXopcDatabaseSchema, estimateTokensFromMessages, extractFtsContent, findSessionInput, findSessionKeyBySessionId, finishContextConsolidationRun, finishContextExtractionRun, finishEndpointToolInvocationAudit, finishKnowledgeSyncRun, finishSessionInputRun, getActivityEventRecord, getCachedConnectorCatalogEntry, getCollaborationRule, getConnectorAccount, getConnectorApproval, getConnectorConnection, getConnectorInstallation, getConnectorSyncPolicy, getConnectorSyncPolicyForConnection, getContextConsolidationRun, getContextExtractionRun, getCurrentSessionId, getEndpointPrincipal, getGlobalSessionStats, getInteractionState, getKnowledgeConsumerWatermark, getKnowledgeSourceCursor, getKnowledgeSourceItem, getMemoryProviderState, getMemoryRecord, getMemoryTurnFeedback, getNoteAgentContextRecord, getNoteRecord, getRelationshipSettings, getSessionConfig, getSessionInputById, getSessionInputState, getSessionMetadata, getSessionPersistedLevels, getSessionTaskPlan, getSqliteDatabase, getTurnPersonalization, getUnderstanding, getUserProfile, getUserTrustPolicy, getXopcDatabase, hasContextConsent, hasIndependentExtractionOutput, hasSessionConfig, hasUnresolvedMemoryConflict, incrementSessionStatsOnAppend, insertSessionInput, inspectSchemaMigrationStatus, isHomeAttentionAcknowledged, isProactiveSupportAllowed, isUnderstandingSuppressed, isXopcDatabaseOpen, linkContextObjects, linkUnderstandingEvidence, listActivityRecords, listCachedConnectorCatalogEntries, listCollaborationRules, listCompactionBoundaries, listComposerInputHistory, listConnectorAccounts, listConnectorActionMetadata, listConnectorApprovals, listConnectorConnections, listConnectorExecutionAudit, listConnectorInstallations, listConnectorLearningJobs, listConnectorSyncPolicies, listContextConsolidationDecisions, listContextConsolidationRuns, listContextExtractionOutputs, listContextExtractionRuns, listContextObjectRelations, listEndpointPrincipals, listEndpointToolInvocationAudits, listKnowledgeSourceChanges, listKnowledgeSourceItems, listKnowledgeSyncRuns, listMemoryEvidence, listMemoryRecords, listMemorySignals, listMemoryTraceEvents, listNoteRecords, listObjectActivityRecords, listObjectLinkRecords, listProjectActivityRecords, listRegisteredMigrationTargets, listSessionMetadata, listSessionsByAgent, listTemporalAssertions, listUnderstandingEvidence, listUnderstandings, loadCompactionSourceSnapshot, loadLlmMessagesForSession, loadTranscriptHistoryRowsForSession, loadTranscriptRows, loadTranscriptRowsForSession, markMemoryRecordsConflicted, metadataToSessionInsert, mutateQueuedSessionInput, openXopcDatabase, paginateTranscriptMessages, patchSessionMetadata, pruneBoundedKnowledgeSourceItems, readSchemaVersion, readSchemaVersionForTest, reconcileConnectorAccount, recordActivityEvent, recordContextConsolidationDecision, recordContextFeedback, recordContextRun, recoverSessionInputState, recoverStaleConnectorLearningJobs, refreshConnectorAccountCurrent, rejectUnderstanding, releaseConnectorWebhookDelivery, replaceConnectorCatalogEntries, replaceLatestSessionTurnAndQueueInput, replaceTranscriptRows, requireXopcDatabase, resetSessionRecord, resetXopcDatabaseSingletonForTest, resolveMigrationsDir, resolveSessionAgentId, resolveXopcDatabasePath, restoreBeforeCompactionBoundary, reviseCollaborationRule, reviseUnderstanding, revokeEndpointPrincipal, runSqliteWriteTransaction, searchActiveUnderstandings, searchMemoryRecords, searchSessionTranscript, sessionConfigRowToConfig, sessionRowToMetadata, setCollaborationRuleStatus, setConnectorLearningPaused, setInteractionState, setKnowledgeConsumerWatermark, setKnowledgeSourceCursor, setKnowledgeSourceItemSynthesisStatus, setMemoryProviderState, setMemoryRecordStatus, setMemoryTurnFeedback, setSessionConfig, setSessionInputStatus, setSessionTaskPlan, setUnderstandingStatus, setUserTrustPolicy, startContextConsolidationRun, startEndpointToolInvocationAudit, startKnowledgeSyncRun, summarizeMemoryRecallFeedback, summarizeUnderstandingFeedback, summarizeUserUnderstandingQuality, touchEndpointPrincipal, transcriptEntryRowToStoredRow, updateConnectorLearningJob, updateInteractionStateFromMessage, updateRelationshipSettings, updateSessionConfig, updateSessionStats, updateUserProfile, upsertConnectorActionMetadata, upsertConnectorCatalogEntry, upsertConnectorConnection, upsertConnectorInstallation, upsertConnectorSyncPolicy, upsertKnowledgeSourceItems, upsertMemoryRecord, upsertNoteAgentContextRecord, upsertNoteRecord, validateLatestSessionTurnTarget };
+export { COMPOSER_INPUT_HISTORY_LIMIT, DatabaseSchemaMigrationGapError, DatabaseSchemaTooNewError, SCHEMA_META_SCHEMA_VERSION_KEY, XOPC_DB_BASELINE_SCHEMA_VERSION, XOPC_DB_FILENAME, XOPC_DB_SCHEMA_VERSION, acknowledgeHomeAttention, appendCompactionBoundaryIfUnchanged, appendComposerInputHistory, appendConnectorExecutionAudit, appendMemorySignal, appendMemoryTraceEvent, appendTranscriptEntry, applyPendingMigrations, attachMemoryEvidence, bindEndpointPrincipal, buildDefaultSessionMetadata, buildGlobalSessionStats, buildRelationshipPrompt, cancelQueuedSessionInput, claimConnectorWebhookDelivery, claimContextExtractionRun, claimKnowledgeSourceItems, claimNextConnectorLearningJob, claimNextSessionInput, classifyStoredRow, clearComposerInputHistory, closeTemporalAssertions, closeUnderstandingValidity, closeXopcDatabase, completeConnectorWebhookDelivery, completeKnowledgeSourceItemSynthesis, consumeConnectorApproval, consumeContextConsent, countKnowledgeSourceItems, countMemoryRecordsBySourceInstanceId, createCollaborationRule, createConnectorApproval, createContextEvidence, createEndpointPrincipal, createObjectLinkRecord, createTemporalAssertion, createUnderstanding, decideConnectorApproval, decideContextConsent, deleteCollaborationRule, deleteConnectorConnection, deleteConnectorInstallation, deleteKnowledgeSourceItems, deleteMemoryEvidenceForRecord, deleteMemoryRecord, deleteMemoryRecordsBySourceInstanceId, deleteNoteAgentContextRecord, deleteNoteRecord, deleteObjectLinkRecord, deleteSessionConfig, deleteSessionRecord, deleteUnderstanding, discoverSqlMigrations, enqueueConnectorLearningJob, ensureContextConsent, ensureSessionRecord, ensureXopcDatabaseSchema, estimateTokensFromMessages, extractFtsContent, findSessionInput, findSessionKeyBySessionId, finishContextConsolidationRun, finishContextExtractionRun, finishEndpointToolInvocationAudit, finishKnowledgeSyncRun, finishSessionInputRun, getActivityEventRecord, getCachedConnectorCatalogEntry, getCollaborationRule, getConnectorAccount, getConnectorApproval, getConnectorConnection, getConnectorInstallation, getConnectorSyncPolicy, getConnectorSyncPolicyForConnection, getContextConsolidationRun, getContextExtractionRun, getCurrentSessionId, getEndpointPrincipal, getGlobalSessionStats, getInteractionState, getKnowledgeConsumerWatermark, getKnowledgeSourceCursor, getKnowledgeSourceItem, getMemoryProviderState, getMemoryRecord, getMemoryTurnFeedback, getNoteAgentContextRecord, getNoteRecord, getRelationshipSettings, getSessionConfig, getSessionInputById, getSessionInputState, getSessionMetadata, getSessionPersistedLevels, getSessionTaskPlan, getSqliteDatabase, getTurnPersonalization, getUnderstanding, getUserPeopleIndexState, getUserPerson, getUserProfile, getUserTrustPolicy, getXopcDatabase, hasContextConsent, hasIndependentExtractionOutput, hasSessionConfig, hasUnresolvedMemoryConflict, incrementSessionStatsOnAppend, insertSessionInput, inspectSchemaMigrationStatus, isHomeAttentionAcknowledged, isProactiveSupportAllowed, isUnderstandingSuppressed, isXopcDatabaseOpen, linkContextObjects, linkUnderstandingEvidence, listActivityRecords, listCachedConnectorCatalogEntries, listCollaborationRules, listCompactionBoundaries, listComposerInputHistory, listConnectorAccounts, listConnectorActionMetadata, listConnectorApprovals, listConnectorConnections, listConnectorExecutionAudit, listConnectorInstallations, listConnectorLearningJobs, listConnectorSyncPolicies, listContextConsolidationDecisions, listContextConsolidationRuns, listContextExtractionOutputs, listContextExtractionRuns, listContextObjectRelations, listEndpointPrincipals, listEndpointToolInvocationAudits, listKnowledgeSourceChanges, listKnowledgeSourceItems, listKnowledgeSyncRuns, listMemoryEvidence, listMemoryRecords, listMemorySignals, listMemoryTraceEvents, listNoteRecords, listObjectActivityRecords, listObjectLinkRecords, listProjectActivityRecords, listRegisteredMigrationTargets, listSessionMetadata, listSessionsByAgent, listTemporalAssertions, listUnderstandingEvidence, listUnderstandings, listUserPeople, loadCompactionSourceSnapshot, loadLlmMessagesForSession, loadTranscriptHistoryRowsForSession, loadTranscriptRows, loadTranscriptRowsForSession, markMemoryRecordsConflicted, mergeUserPeople, metadataToSessionInsert, mutateQueuedSessionInput, openXopcDatabase, paginateTranscriptMessages, patchSessionMetadata, pruneBoundedKnowledgeSourceItems, readSchemaVersion, readSchemaVersionForTest, reconcileConnectorAccount, recordActivityEvent, recordContextConsolidationDecision, recordContextFeedback, recordContextRun, recoverSessionInputState, recoverStaleConnectorLearningJobs, refreshConnectorAccountCurrent, rejectUnderstanding, releaseConnectorWebhookDelivery, replaceConnectorCatalogEntries, replaceLatestSessionTurnAndQueueInput, replaceTranscriptRows, replaceUserPeopleIndex, requireXopcDatabase, resetSessionRecord, resetXopcDatabaseSingletonForTest, resolveMigrationsDir, resolveSessionAgentId, resolveXopcDatabasePath, restoreBeforeCompactionBoundary, reviseCollaborationRule, reviseUnderstanding, revokeEndpointPrincipal, runSqliteWriteTransaction, searchActiveUnderstandings, searchMemoryRecords, searchSessionTranscript, sessionConfigRowToConfig, sessionRowToMetadata, setCollaborationRuleStatus, setConnectorLearningPaused, setInteractionState, setKnowledgeConsumerWatermark, setKnowledgeSourceCursor, setKnowledgeSourceItemSynthesisStatus, setMemoryProviderState, setMemoryRecordStatus, setMemoryTurnFeedback, setSessionConfig, setSessionInputStatus, setSessionTaskPlan, setUnderstandingStatus, setUserTrustPolicy, startContextConsolidationRun, startEndpointToolInvocationAudit, startKnowledgeSyncRun, summarizeMemoryRecallFeedback, summarizeUnderstandingFeedback, summarizeUserPeople, summarizeUserUnderstandingQuality, touchEndpointPrincipal, transcriptEntryRowToStoredRow, updateConnectorLearningJob, updateInteractionStateFromMessage, updateRelationshipSettings, updateSessionConfig, updateSessionStats, updateUserPerson, updateUserProfile, upsertConnectorActionMetadata, upsertConnectorCatalogEntry, upsertConnectorConnection, upsertConnectorInstallation, upsertConnectorSyncPolicy, upsertKnowledgeSourceItems, upsertMemoryRecord, upsertNoteAgentContextRecord, upsertNoteRecord, validateLatestSessionTurnTarget };

package/dist/src/storage/sqlite/migrations/135_user_people.sql

@@ -0,0 +1,59 @@
+CREATE TABLE user_people (
+  person_id TEXT PRIMARY KEY,
+  principal_id TEXT NOT NULL,
+  display_name TEXT NOT NULL,
+  user_display_name TEXT,
+  inferred_kind TEXT NOT NULL CHECK (inferred_kind IN ('person', 'bot', 'service', 'group', 'unknown')),
+  user_kind TEXT CHECK (user_kind IS NULL OR user_kind IN ('person', 'bot', 'service', 'group', 'unknown')),
+  hidden INTEGER NOT NULL DEFAULT 0 CHECK (hidden IN (0, 1)),
+  merged_into_person_id TEXT REFERENCES user_people(person_id) ON DELETE SET NULL,
+  confidence REAL NOT NULL CHECK (confidence >= 0 AND confidence <= 1),
+  first_observed_at INTEGER NOT NULL,
+  last_observed_at INTEGER NOT NULL,
+  created_at INTEGER NOT NULL,
+  updated_at INTEGER NOT NULL
+);
+
+CREATE INDEX idx_user_people_principal_kind
+  ON user_people(principal_id, inferred_kind, last_observed_at DESC);
+CREATE INDEX idx_user_people_merge_target
+  ON user_people(merged_into_person_id);
+
+CREATE TABLE user_person_handles (
+  handle_id TEXT PRIMARY KEY,
+  person_id TEXT NOT NULL REFERENCES user_people(person_id) ON DELETE CASCADE,
+  handle_type TEXT NOT NULL CHECK (handle_type IN ('email', 'provider_user', 'username', 'display_name')),
+  normalized_value TEXT NOT NULL,
+  display_value TEXT NOT NULL,
+  source_instance_id TEXT NOT NULL,
+  verification TEXT NOT NULL CHECK (verification IN ('observed', 'inferred', 'user_confirmed')),
+  first_observed_at INTEGER NOT NULL,
+  last_observed_at INTEGER NOT NULL,
+  created_at INTEGER NOT NULL,
+  updated_at INTEGER NOT NULL,
+  UNIQUE(handle_type, normalized_value, source_instance_id)
+);
+
+CREATE INDEX idx_user_person_handles_person ON user_person_handles(person_id);
+CREATE INDEX idx_user_person_handles_lookup ON user_person_handles(handle_type, normalized_value);
+
+CREATE TABLE user_person_source_stats (
+  person_id TEXT NOT NULL REFERENCES user_people(person_id) ON DELETE CASCADE,
+  source_instance_id TEXT NOT NULL,
+  interaction_count INTEGER NOT NULL CHECK (interaction_count >= 0),
+  first_observed_at INTEGER NOT NULL,
+  last_observed_at INTEGER NOT NULL,
+  last_source_item_id TEXT,
+  updated_at INTEGER NOT NULL,
+  PRIMARY KEY(person_id, source_instance_id)
+);
+
+CREATE INDEX idx_user_person_source_stats_source
+  ON user_person_source_stats(source_instance_id, last_observed_at DESC);
+
+CREATE TABLE user_people_index_state (
+  principal_id TEXT PRIMARY KEY,
+  source_change_sequence INTEGER NOT NULL,
+  source_grants_updated_at INTEGER NOT NULL,
+  rebuilt_at INTEGER NOT NULL
+);

package/dist/src/storage/sqlite/migrations/runner.d.ts

@@ -3,7 +3,7 @@ import type { ApplyMigrationsOptions } from './types.js';
 /** Baseline schema version applied from schema.sql on first open. */
 export declare const XOPC_DB_BASELINE_SCHEMA_VERSION = 11;
 /** Latest schema version this release supports (increment when adding migrations). */
-export declare const XOPC_DB_SCHEMA_VERSION = 134;
+export declare const XOPC_DB_SCHEMA_VERSION = 135;
 export declare function resolveMigrationsDir(override?: string): string;
 /**
  * Apply sequential SQL migrations from (currentVersion + 1) through targetVersion.

package/dist/src/storage/sqlite/migrations/runner.js

@@ -12,7 +12,7 @@ const log = createLogger("Sqlite:Migrations");
 /** Baseline schema version applied from schema.sql on first open. */
 const XOPC_DB_BASELINE_SCHEMA_VERSION = 11;
 /** Latest schema version this release supports (increment when adding migrations). */
-const XOPC_DB_SCHEMA_VERSION = 134;
+const XOPC_DB_SCHEMA_VERSION = 135;
 const MODULE_DIR = dirname(fileURLToPath(import.meta.url));
 function backupBeforeTaskCutover(db, databasePath) {
 	db.exec("PRAGMA wal_checkpoint(FULL)");
@@ -57,7 +57,7 @@ function applySingleMigration(db, migration) {
 * Each step runs in its own transaction and updates schema_meta on success.
 */
 function applyPendingMigrations(db, options = {}) {
-	const targetVersion = options.targetVersion ?? 134;
+	const targetVersion = options.targetVersion ?? 135;
 	let currentVersion = readSchemaVersion(db);
 	if (currentVersion > targetVersion) throw new DatabaseSchemaTooNewError(currentVersion, targetVersion);
 	if (currentVersion >= targetVersion) return currentVersion;
@@ -94,7 +94,7 @@ function applyPendingMigrations(db, options = {}) {
 }
 /** Inspect schema version without mutating the database. */
 function inspectSchemaMigrationStatus(db, options = {}) {
-	const appVersion = options.targetVersion ?? 134;
+	const appVersion = options.targetVersion ?? 135;
 	const dbVersion = readSchemaVersion(db);
 	if (dbVersion > appVersion) return {
 		dbVersion,

package/dist/src/storage/sqlite/migrations/runner.ts

@@ -19,7 +19,7 @@ const log = createLogger('Sqlite:Migrations');
 export const XOPC_DB_BASELINE_SCHEMA_VERSION = 11;
 
 /** Latest schema version this release supports (increment when adding migrations). */
-export const XOPC_DB_SCHEMA_VERSION = 134;
+export const XOPC_DB_SCHEMA_VERSION = 135;
 
 const MODULE_DIR = dirname(fileURLToPath(import.meta.url));
 

package/dist/src/storage/sqlite/schema.js

@@ -32,7 +32,7 @@ function ensureXopcDatabaseSchema(db, options = {}) {
 		currentVersion = 11;
 	}
 	applyPendingMigrations(db, {
-		targetVersion: 134,
+		targetVersion: 135,
 		databasePath: options.databasePath
 	});
 }

package/dist/src/storage/sqlite/user-people-repository.d.ts

@@ -0,0 +1,32 @@
+import type { UserPerson, UserPersonIndexEntry, UserPersonKind, UserRelationshipSummary } from '../../user-context/relationships/types.js';
+export declare function replaceUserPeopleIndex(entries: UserPersonIndexEntry[], revision: {
+    sourceChangeSequence: number;
+    sourceGrantsUpdatedAt: number;
+}, principalId?: string, nowMs?: number): void;
+export declare function getUserPeopleIndexState(principalId?: string): {
+    sourceChangeSequence: number;
+    sourceGrantsUpdatedAt: number;
+    rebuiltAt: number;
+} | null;
+export declare function listUserPeople(options?: {
+    query?: string;
+    kind?: UserPersonKind;
+    sourceInstanceId?: string;
+    includeHidden?: boolean;
+    hiddenOnly?: boolean;
+    offset?: number;
+    limit?: number;
+    principalId?: string;
+}): {
+    items: UserPerson[];
+    total: number;
+    nextOffset?: number;
+};
+export declare function getUserPerson(personId: string, principalId?: string): UserPerson | null;
+export declare function updateUserPerson(personId: string, patch: {
+    displayName?: string | null;
+    kind?: UserPersonKind | null;
+    hidden?: boolean;
+}, principalId?: string): UserPerson | null;
+export declare function summarizeUserPeople(principalId?: string): UserRelationshipSummary;
+export declare function mergeUserPeople(sourcePersonId: string, targetPersonId: string, principalId?: string): UserPerson | null;

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