@xopcai/xopc 0.0.171 → 0.0.173

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 = 61;
+export declare const XOPC_DB_SCHEMA_VERSION = 65;
 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 = 61;
+const XOPC_DB_SCHEMA_VERSION = 65;
 const MODULE_DIR = dirname(fileURLToPath(import.meta.url));
 function resolveMigrationsDir(override) {
 	if (override) return override;
@@ -46,7 +46,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 ?? 61;
+	const targetVersion = options.targetVersion ?? 65;
 	let currentVersion = readSchemaVersion(db);
 	if (currentVersion > targetVersion) throw new DatabaseSchemaTooNewError(currentVersion, targetVersion);
 	if (currentVersion >= targetVersion) return currentVersion;
@@ -62,7 +62,7 @@ function applyPendingMigrations(db, options = {}) {
 }
 /** Inspect schema version without mutating the database. */
 function inspectSchemaMigrationStatus(db, options = {}) {
-	const appVersion = options.targetVersion ?? 61;
+	const appVersion = options.targetVersion ?? 65;
 	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 = 61;
+export const XOPC_DB_SCHEMA_VERSION = 65;
 
 const MODULE_DIR = dirname(fileURLToPath(import.meta.url));
 

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

@@ -31,7 +31,7 @@ function ensureXopcDatabaseSchema(db) {
 		bootstrapFreshDatabase(db);
 		currentVersion = 11;
 	}
-	applyPendingMigrations(db, { targetVersion: 61 });
+	applyPendingMigrations(db, { targetVersion: 65 });
 }
 //#endregion
 export { SCHEMA_META_SCHEMA_VERSION_KEY, XOPC_DB_BASELINE_SCHEMA_VERSION, XOPC_DB_SCHEMA_VERSION, ensureSchemaMetaTable, ensureXopcDatabaseSchema, readSchemaVersion, readSchemaVersionForTest, setSchemaVersion };

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

@@ -0,0 +1,101 @@
+export type UserEntityType = 'person' | 'project' | 'organization';
+export type UserEntityHandleType = 'email' | 'provider_user' | 'display_name';
+export type UserClaimClass = 'relationship' | 'project' | 'routine';
+export type UserClaimState = 'provisional' | 'active' | 'rejected' | 'stale';
+export type UserClaimUserState = 'auto' | 'confirmed' | 'rejected';
+export type UserEntity = {
+    id: string;
+    type: UserEntityType;
+    canonicalLabel: string;
+    createdAt: string;
+    updatedAt: string;
+};
+export type UserClaim = {
+    id: string;
+    agentId: string;
+    class: UserClaimClass;
+    key: string;
+    subjectEntityId?: string;
+    value: Record<string, unknown>;
+    state: UserClaimState;
+    userState: UserClaimUserState;
+    confidence: number;
+    independentEvidenceCount: number;
+    activeDayCount: number;
+    firstObservedAt: string;
+    lastReinforcedAt: string;
+    memoryRecordId?: string;
+    createdAt: string;
+    updatedAt: string;
+};
+export declare function resolveUserEntity(input: {
+    type: UserEntityType;
+    canonicalLabel: string;
+    handles: Array<{
+        type: UserEntityHandleType;
+        value: string;
+        sourceScope: string;
+        verified: boolean;
+    }>;
+    nowMs?: number;
+}): UserEntity;
+export declare function reinforceUserClaim(input: {
+    agentId: string;
+    class: UserClaimClass;
+    key: string;
+    subjectEntityId?: string;
+    value: Record<string, unknown>;
+    evidence: Array<{
+        logicalEventKey: string;
+        sourceItemId: string;
+        sourceInstanceId: string;
+        relation: 'supports' | 'contradicts';
+        observedAt: string;
+    }>;
+    nowMs?: number;
+}): UserClaim;
+export declare function removeUserClaimEvidenceForSource(sourceInstanceId: string): {
+    deletedClaimCount: number;
+    deletedMemoryRecordIds: string[];
+    retainedClaims: Array<{
+        memoryRecordId: string;
+        state: UserClaimState;
+    }>;
+};
+export declare function setUserClaimDecision(claimId: string, userState: Exclude<UserClaimUserState, 'auto'>): UserClaim | undefined;
+export declare function linkUserClaimMemoryRecord(claimId: string, memoryRecordId: string): void;
+export declare function getUserClaim(claimId: string): UserClaim | undefined;
+export declare function listUserClaims(options?: {
+    agentId?: string;
+    state?: UserClaimState;
+    limit?: number;
+}): UserClaim[];
+export declare function listUserClaimEvidence(claimId: string): Array<{
+    logicalEventKey: string;
+    sourceItemId: string;
+    sourceInstanceId: string;
+    relation: string;
+    observedAt: string;
+}>;
+export declare function listUserPeopleGraphRows(): {
+    people: Array<UserEntity & {
+        handles: Array<{
+            type: UserEntityHandleType;
+            value: string;
+        }>;
+    }>;
+    edges: Array<{
+        entityId: string;
+        sourceInstanceId: string;
+        mentionCount: number;
+        lastObservedAt: string;
+    }>;
+    evidenceCount: number;
+};
+export declare function listUserClaimStatsBySource(): Record<string, {
+    evidenceCount: number;
+    provisionalClaims: number;
+    activeClaims: number;
+    resolvedEntities: number;
+    lastEvidenceAt?: string;
+}>;

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

@@ -0,0 +1,241 @@
+import { getSqliteDatabase, runSqliteWriteTransaction } from "./transaction.js";
+import { randomUUID } from "node:crypto";
+//#region src/storage/sqlite/user-claims-repository.ts
+function entityFromRow(row) {
+	return {
+		id: row.entity_id,
+		type: row.entity_type,
+		canonicalLabel: row.canonical_label,
+		createdAt: new Date(row.created_at).toISOString(),
+		updatedAt: new Date(row.updated_at).toISOString()
+	};
+}
+function claimFromRow(row) {
+	return {
+		id: row.claim_id,
+		agentId: row.agent_id,
+		class: row.claim_class,
+		key: row.claim_key,
+		...row.subject_entity_id ? { subjectEntityId: row.subject_entity_id } : {},
+		value: JSON.parse(row.value_json),
+		state: row.state,
+		userState: row.user_state,
+		confidence: row.confidence,
+		independentEvidenceCount: row.independent_evidence_count,
+		activeDayCount: row.active_day_count,
+		firstObservedAt: new Date(row.first_observed_at).toISOString(),
+		lastReinforcedAt: new Date(row.last_reinforced_at).toISOString(),
+		...row.memory_record_id ? { memoryRecordId: row.memory_record_id } : {},
+		createdAt: new Date(row.created_at).toISOString(),
+		updatedAt: new Date(row.updated_at).toISOString()
+	};
+}
+function resolveUserEntity(input) {
+	const now = input.nowMs ?? Date.now();
+	return runSqliteWriteTransaction((db) => {
+		const handles = input.handles.map((handle) => ({
+			...handle,
+			value: handle.value.trim().toLowerCase()
+		})).filter((handle) => handle.value);
+		const strong = handles.filter((handle) => handle.verified);
+		let row;
+		for (const handle of strong) {
+			row = db.prepare(`SELECT e.* FROM user_entities e JOIN user_entity_handles h ON h.entity_id = e.entity_id
+        WHERE h.handle_type = ? AND h.normalized_value = ? AND h.source_scope = ?`).get(handle.type, handle.value, handle.sourceScope);
+			if (row) break;
+		}
+		if (!row) {
+			const fallback = handles[0];
+			if (fallback) row = db.prepare(`SELECT e.* FROM user_entities e JOIN user_entity_handles h ON h.entity_id = e.entity_id
+          WHERE h.handle_type = ? AND h.normalized_value = ? AND h.source_scope = ?`).get(fallback.type, fallback.value, fallback.sourceScope);
+		}
+		const entityId = row?.entity_id ?? randomUUID();
+		if (!row) db.prepare(`INSERT INTO user_entities (entity_id, entity_type, canonical_label, created_at, updated_at)
+        VALUES (?, ?, ?, ?, ?)`).run(entityId, input.type, input.canonicalLabel, now, now);
+		else {
+			const incomingHumanName = input.canonicalLabel.includes(" ") && !input.canonicalLabel.includes("@");
+			const existingHumanName = row.canonical_label.includes(" ") && !row.canonical_label.includes("@");
+			if (incomingHumanName && (!existingHumanName || input.canonicalLabel.length > row.canonical_label.length)) db.prepare("UPDATE user_entities SET canonical_label = ?, updated_at = ? WHERE entity_id = ?").run(input.canonicalLabel, now, entityId);
+		}
+		for (const handle of handles) db.prepare(`INSERT OR IGNORE INTO user_entity_handles
+        (entity_id, handle_type, normalized_value, source_scope, verified, created_at)
+        VALUES (?, ?, ?, ?, ?, ?)`).run(entityId, handle.type, handle.value, handle.sourceScope, handle.verified ? 1 : 0, now);
+		return entityFromRow(db.prepare("SELECT * FROM user_entities WHERE entity_id = ?").get(entityId));
+	});
+}
+function thresholds(claimClass) {
+	return claimClass === "routine" ? {
+		evidence: 3,
+		days: 3
+	} : {
+		evidence: 3,
+		days: 2
+	};
+}
+function refreshUserClaim(db, row, now) {
+	const stats = db.prepare(`SELECT
+    SUM(CASE WHEN relation = 'supports' THEN 1 ELSE 0 END) AS evidence_count,
+    SUM(CASE WHEN relation = 'contradicts' THEN 1 ELSE 0 END) AS contradiction_count,
+    COUNT(DISTINCT CASE WHEN relation = 'supports' THEN date(observed_at / 1000, 'unixepoch') END) AS active_days,
+    MAX(observed_at) AS last_observed
+    FROM user_claim_evidence WHERE claim_id = ?`).get(row.claim_id);
+	const evidenceCount = stats.evidence_count ?? 0;
+	const contradictionCount = stats.contradiction_count ?? 0;
+	const limit = thresholds(row.claim_class);
+	const state = row.user_state === "rejected" ? "rejected" : row.user_state === "confirmed" ? "active" : contradictionCount >= evidenceCount && contradictionCount > 0 ? "stale" : evidenceCount >= limit.evidence && stats.active_days >= limit.days ? "active" : "provisional";
+	const confidence = Math.max(.1, Math.min(.92, .48 + Math.min(evidenceCount, 8) * .035 + Math.min(stats.active_days, 5) * .045 - Math.min(contradictionCount, 5) * .08));
+	db.prepare(`UPDATE user_claims SET state = ?, confidence = ?, independent_evidence_count = ?,
+    active_day_count = ?, last_reinforced_at = ?, updated_at = ? WHERE claim_id = ?`).run(state, confidence, evidenceCount, stats.active_days, stats.last_observed ?? row.last_reinforced_at, now, row.claim_id);
+	return claimFromRow(db.prepare("SELECT * FROM user_claims WHERE claim_id = ?").get(row.claim_id));
+}
+function reinforceUserClaim(input) {
+	const now = input.nowMs ?? Date.now();
+	return runSqliteWriteTransaction((db) => {
+		let row = db.prepare("SELECT * FROM user_claims WHERE agent_id = ? AND claim_class = ? AND claim_key = ?").get(input.agentId, input.class, input.key);
+		const claimId = row?.claim_id ?? randomUUID();
+		if (!row) {
+			const firstObserved = Math.min(...input.evidence.map((item) => Date.parse(item.observedAt)), now);
+			db.prepare(`INSERT INTO user_claims (
+        claim_id, agent_id, claim_class, claim_key, subject_entity_id, value_json, state, user_state,
+        confidence, independent_evidence_count, active_day_count, first_observed_at, last_reinforced_at,
+        created_at, updated_at
+      ) VALUES (?, ?, ?, ?, ?, ?, 'provisional', 'auto', 0, 0, 0, ?, ?, ?, ?)`).run(claimId, input.agentId, input.class, input.key, input.subjectEntityId ?? null, JSON.stringify(input.value), firstObserved, now, now, now);
+		}
+		for (const evidence of input.evidence) db.prepare(`INSERT INTO user_claim_evidence (
+        claim_id, logical_event_key, source_item_id, source_instance_id, relation, observed_at, created_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(claim_id, logical_event_key) DO UPDATE SET
+        source_item_id = excluded.source_item_id,
+        source_instance_id = excluded.source_instance_id,
+        relation = excluded.relation,
+        observed_at = excluded.observed_at`).run(claimId, evidence.logicalEventKey, evidence.sourceItemId, evidence.sourceInstanceId, evidence.relation, Date.parse(evidence.observedAt), now);
+		db.prepare("UPDATE user_claims SET subject_entity_id = ?, value_json = ? WHERE claim_id = ?").run(input.subjectEntityId ?? null, JSON.stringify(input.value), claimId);
+		row = db.prepare("SELECT * FROM user_claims WHERE claim_id = ?").get(claimId);
+		return refreshUserClaim(db, row, now);
+	});
+}
+function removeUserClaimEvidenceForSource(sourceInstanceId) {
+	return runSqliteWriteTransaction((db) => {
+		const affected = db.prepare(`SELECT DISTINCT c.* FROM user_claims c
+      JOIN user_claim_evidence e ON e.claim_id = c.claim_id
+      WHERE e.source_instance_id = ?`).all(sourceInstanceId);
+		db.prepare("DELETE FROM user_claim_evidence WHERE source_instance_id = ?").run(sourceInstanceId);
+		const deletedMemoryRecordIds = [];
+		const retainedClaims = [];
+		let deletedClaimCount = 0;
+		const now = Date.now();
+		for (const row of affected) {
+			if (db.prepare("SELECT COUNT(*) AS count FROM user_claim_evidence WHERE claim_id = ?").get(row.claim_id).count === 0) {
+				if (row.memory_record_id) deletedMemoryRecordIds.push(row.memory_record_id);
+				db.prepare("DELETE FROM user_claims WHERE claim_id = ?").run(row.claim_id);
+				deletedClaimCount += 1;
+				continue;
+			}
+			const claim = refreshUserClaim(db, row, now);
+			if (claim.memoryRecordId) retainedClaims.push({
+				memoryRecordId: claim.memoryRecordId,
+				state: claim.state
+			});
+		}
+		return {
+			deletedClaimCount,
+			deletedMemoryRecordIds,
+			retainedClaims
+		};
+	});
+}
+function setUserClaimDecision(claimId, userState) {
+	runSqliteWriteTransaction((db) => {
+		db.prepare(`UPDATE user_claims SET user_state = ?, state = ?, updated_at = ? WHERE claim_id = ?`).run(userState, userState === "confirmed" ? "active" : "rejected", Date.now(), claimId);
+	});
+	return getUserClaim(claimId);
+}
+function linkUserClaimMemoryRecord(claimId, memoryRecordId) {
+	runSqliteWriteTransaction((db) => {
+		db.prepare("UPDATE user_claims SET memory_record_id = ?, updated_at = ? WHERE claim_id = ?").run(memoryRecordId, Date.now(), claimId);
+	});
+}
+function getUserClaim(claimId) {
+	const row = getSqliteDatabase().prepare("SELECT * FROM user_claims WHERE claim_id = ?").get(claimId);
+	return row ? claimFromRow(row) : void 0;
+}
+function listUserClaims(options = {}) {
+	const where = [];
+	const params = [];
+	if (options.agentId) {
+		where.push("agent_id = ?");
+		params.push(options.agentId);
+	}
+	if (options.state) {
+		where.push("state = ?");
+		params.push(options.state);
+	}
+	const limit = Math.max(1, Math.min(options.limit ?? 100, 500));
+	return getSqliteDatabase().prepare(`SELECT * FROM user_claims
+    ${where.length ? `WHERE ${where.join(" AND ")}` : ""}
+    ORDER BY confidence DESC, last_reinforced_at DESC LIMIT ?`).all(...params, limit).map(claimFromRow);
+}
+function listUserClaimEvidence(claimId) {
+	return getSqliteDatabase().prepare(`SELECT logical_event_key, source_item_id, source_instance_id, relation, observed_at
+    FROM user_claim_evidence WHERE claim_id = ? ORDER BY observed_at DESC`).all(claimId).map((row) => ({
+		logicalEventKey: row.logical_event_key,
+		sourceItemId: row.source_item_id,
+		sourceInstanceId: row.source_instance_id,
+		relation: row.relation,
+		observedAt: new Date(row.observed_at).toISOString()
+	}));
+}
+function listUserPeopleGraphRows() {
+	const db = getSqliteDatabase();
+	const entities = db.prepare(`SELECT * FROM user_entities e WHERE entity_type = 'person'
+    AND EXISTS (SELECT 1 FROM user_claims c JOIN user_claim_evidence ce ON ce.claim_id = c.claim_id
+      WHERE c.subject_entity_id = e.entity_id)`).all();
+	const handles = db.prepare(`SELECT entity_id, handle_type, normalized_value FROM user_entity_handles
+    WHERE entity_id IN (SELECT entity_id FROM user_entities WHERE entity_type = 'person')`).all();
+	const byEntity = /* @__PURE__ */ new Map();
+	for (const handle of handles) {
+		const values = byEntity.get(handle.entity_id) ?? [];
+		values.push({
+			type: handle.handle_type,
+			value: handle.normalized_value
+		});
+		byEntity.set(handle.entity_id, values);
+	}
+	const edgeRows = db.prepare(`SELECT c.subject_entity_id AS entity_id, e.source_instance_id,
+      COUNT(*) AS mention_count, MAX(e.observed_at) AS last_observed_at
+    FROM user_claims c JOIN user_claim_evidence e ON e.claim_id = c.claim_id
+    WHERE c.claim_class = 'relationship' AND c.subject_entity_id IS NOT NULL AND e.relation = 'supports'
+    GROUP BY c.subject_entity_id, e.source_instance_id`).all();
+	return {
+		people: entities.map((row) => ({
+			...entityFromRow(row),
+			handles: byEntity.get(row.entity_id) ?? []
+		})),
+		edges: edgeRows.map((row) => ({
+			entityId: row.entity_id,
+			sourceInstanceId: row.source_instance_id,
+			mentionCount: row.mention_count,
+			lastObservedAt: new Date(row.last_observed_at).toISOString()
+		})),
+		evidenceCount: edgeRows.reduce((sum, row) => sum + row.mention_count, 0)
+	};
+}
+function listUserClaimStatsBySource() {
+	const rows = getSqliteDatabase().prepare(`SELECT e.source_instance_id,
+      COUNT(*) AS evidence_count,
+      COUNT(DISTINCT CASE WHEN c.state = 'provisional' THEN c.claim_id END) AS provisional_claims,
+      COUNT(DISTINCT CASE WHEN c.state = 'active' THEN c.claim_id END) AS active_claims,
+      COUNT(DISTINCT c.subject_entity_id) AS resolved_entities,
+      MAX(e.observed_at) AS last_evidence_at
+    FROM user_claim_evidence e JOIN user_claims c ON c.claim_id = e.claim_id
+    GROUP BY e.source_instance_id`).all();
+	return Object.fromEntries(rows.map((row) => [row.source_instance_id, {
+		evidenceCount: row.evidence_count,
+		provisionalClaims: row.provisional_claims,
+		activeClaims: row.active_claims,
+		resolvedEntities: row.resolved_entities,
+		...row.last_evidence_at == null ? {} : { lastEvidenceAt: new Date(row.last_evidence_at).toISOString() }
+	}]));
+}
+//#endregion
+export { getUserClaim, linkUserClaimMemoryRecord, listUserClaimEvidence, listUserClaimStatsBySource, listUserClaims, listUserPeopleGraphRows, reinforceUserClaim, removeUserClaimEvidenceForSource, resolveUserEntity, setUserClaimDecision };

package/dist/src/user-context/projection.d.ts

@@ -1,6 +1,7 @@
 import type { MemoryKind, MemoryRecord } from '../agent/memory/types.js';
 import type { ConnectorConnection, ConnectorDefinition, ConnectorInstance } from '../connectors/types.js';
 import type { KnowledgeSourceItem, KnowledgeSyncRun } from '../knowledge/types.js';
+import type { ConnectorLearningJob } from '../storage/sqlite/index.js';
 export type UserContextFacet = 'basics' | 'collaboration' | 'boundaries' | 'priorities' | 'people' | 'current';
 export type UserContextOrigin = 'told_by_you' | 'observed' | 'inferred' | 'connected_source';
 export declare function isUserContextRecord(record: MemoryRecord): boolean;
@@ -26,6 +27,11 @@ export declare function projectUserContextRecord(record: MemoryRecord): {
     reviewAt: string;
     reviewDue: boolean;
     evidenceCount: number;
+    evidenceBasis: {
+        eventCount: number;
+        activeDays: number;
+        windowDays: number;
+    };
     sourcePath: string;
     latestEvidenceAt: string;
     validFrom: string;
@@ -34,10 +40,18 @@ export declare function projectUserContextRecord(record: MemoryRecord): {
 };
 export declare function isPersonalContextConnector(definition: ConnectorDefinition): boolean;
 export declare function recordsDerivedFromPersonalContextSource(records: MemoryRecord[], sourceInstanceId: string): MemoryRecord[];
-export declare function projectPersonalContextSources(definitions: ConnectorDefinition[], instances: ConnectorInstance[], records?: MemoryRecord[], knowledge?: {
+export declare function projectPersonalContextSources(definitions: ConnectorDefinition[], instances: ConnectorInstance[], knowledge?: {
     sourceItems?: KnowledgeSourceItem[];
     syncRuns?: KnowledgeSyncRun[];
     connections?: ConnectorConnection[];
+    learningJobs?: ConnectorLearningJob[];
+    claimStatsBySource?: Record<string, {
+        evidenceCount: number;
+        provisionalClaims: number;
+        activeClaims: number;
+        resolvedEntities: number;
+        lastEvidenceAt?: string;
+    }>;
 }): {
     category: import("../connectors/types.js").ConnectorCategory;
     capabilities: ("context" | "tools" | "events" | "memory_source")[];
@@ -57,10 +71,31 @@ export declare function projectPersonalContextSources(definitions: ConnectorDefi
     lastHealthStatus: any;
     lastActivityAt: string;
     derivedUnderstandingCount: number;
+    learningFunnel: {
+        indexedItems: number;
+        attributedItems: number;
+        resolvedEntities: number;
+        provisionalClaims: number;
+        activeClaims: number;
+        evidenceCount: number;
+        lastEvidenceAt: string;
+    };
     knowledgeItemCount: number;
     lastSyncAt: string;
     lastSyncStatus: import("../knowledge/types.js").KnowledgeSyncRunStatus;
     lastSyncError: string;
+    learning: {
+        status: import("../storage/sqlite/connector-learning-repository.js").ConnectorLearningStatus;
+        phase: import("../storage/sqlite/connector-learning-repository.js").ConnectorLearningPhase;
+        itemsDiscovered: number;
+        itemsIndexed: number;
+        candidatesCreated: number;
+        mode: import("../storage/sqlite/connector-learning-repository.js").ConnectorLearningMode;
+        attemptCount: number;
+        nextRunAt: string;
+        error: string;
+        updatedAt: string;
+    };
     branding?: import("../connectors/types.js").ConnectorBranding;
     id: string;
     accountLabel: any;

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

@@ -39,9 +39,31 @@ function originForMemoryRecord(record) {
 	const origin = classifyMemoryContextOrigin(record);
 	return origin === "told_by_user" ? "told_by_you" : origin;
 }
+function connectedEvidenceBasis(sourceText) {
+	if (!sourceText) return void 0;
+	try {
+		const value = JSON.parse(sourceText);
+		const eventCount = Number(value.eventCount);
+		const activeDays = Number(value.activeDays);
+		const windowDays = Number(value.windowDays);
+		if (![
+			eventCount,
+			activeDays,
+			windowDays
+		].every((item) => Number.isInteger(item) && item > 0)) return void 0;
+		return {
+			eventCount,
+			activeDays,
+			windowDays
+		};
+	} catch {
+		return;
+	}
+}
 function projectUserContextRecord(record) {
 	const lifecycle = resolveMemoryStability(record);
 	const latestEvidenceAt = record.evidence?.map((evidence) => evidence.observedAt).filter((value) => Boolean(value)).sort().at(-1);
+	const evidenceBasis = record.evidence?.map((evidence) => connectedEvidenceBasis(evidence.sourceText)).filter((value) => Boolean(value)).at(-1);
 	return {
 		id: record.id,
 		statement: record.content,
@@ -61,6 +83,7 @@ function projectUserContextRecord(record) {
 		reviewAt: lifecycle.reviewAt,
 		reviewDue: lifecycle.reviewDue,
 		evidenceCount: record.evidence?.length ?? 0,
+		evidenceBasis,
 		sourcePath: record.source.path,
 		latestEvidenceAt,
 		validFrom: record.validFrom,
@@ -74,7 +97,29 @@ function isPersonalContextConnector(definition) {
 function recordsDerivedFromPersonalContextSource(records, sourceInstanceId) {
 	return records.filter((record) => record.source.sourceInstanceId === sourceInstanceId && isUserContextRecord(record));
 }
-function projectPersonalContextSources(definitions, instances, records = [], knowledge = {}) {
+function connectionIdentityKey(connection) {
+	const email = typeof connection.identity.email === "string" ? connection.identity.email.trim().toLocaleLowerCase() : "";
+	if (email) return `email:${email}`;
+	const username = typeof connection.identity.username === "string" ? connection.identity.username.trim().toLocaleLowerCase() : "";
+	if (username) return `username:${username}`;
+	return `connection:${connection.id}`;
+}
+function selectAccountConnections(connections) {
+	const byIdentity = /* @__PURE__ */ new Map();
+	for (const connection of connections) {
+		const key = connectionIdentityKey(connection);
+		const current = byIdentity.get(key);
+		if (!current) {
+			byIdentity.set(key, connection);
+			continue;
+		}
+		const currentRank = current.status === "active" ? 1 : 0;
+		const candidateRank = connection.status === "active" ? 1 : 0;
+		if (candidateRank > currentRank || candidateRank === currentRank && connection.updatedAt.localeCompare(current.updatedAt) > 0) byIdentity.set(key, connection);
+	}
+	return [...byIdentity.values()];
+}
+function projectPersonalContextSources(definitions, instances, knowledge = {}) {
 	const instanceByConnector = /* @__PURE__ */ new Map();
 	for (const instance of instances) {
 		const current = instanceByConnector.get(instance.connectorId) ?? [];
@@ -83,7 +128,13 @@ function projectPersonalContextSources(definitions, instances, records = [], kno
 	}
 	return definitions.filter(isPersonalContextConnector).flatMap((definition) => {
 		const connected = instanceByConnector.get(definition.id) ?? [];
-		const accounts = (knowledge.connections ?? []).filter((connection) => connection.provider === "composio" && connection.connectorId === definition.id && connection.status !== "revoked").sort((left, right) => {
+		const candidateAccounts = (knowledge.connections ?? []).filter((connection) => connection.provider === "composio" && connection.connectorId === definition.id && connection.status !== "revoked");
+		const hasActiveAccount = candidateAccounts.some((connection) => connection.status === "active");
+		const accounts = selectAccountConnections(candidateAccounts.filter((connection) => !hasActiveAccount || ![
+			"pending",
+			"unknown",
+			"disabled"
+		].includes(connection.status))).sort((left, right) => {
 			return (left.connectedAt ?? left.createdAt).localeCompare(right.connectedAt ?? right.createdAt) || left.id.localeCompare(right.id);
 		});
 		return (accounts.length > 0 ? accounts.map((connection, index) => ({
@@ -117,9 +168,13 @@ function projectPersonalContextSources(definitions, instances, records = [], kno
 			lastConnectedAt: void 0,
 			instances: []
 		}]).map((row) => {
-			const relatedRecords = row.sourceInstanceId ? records.filter((record) => record.source.sourceInstanceId === row.sourceInstanceId) : [];
 			const sourceItems = row.sourceInstanceId ? (knowledge.sourceItems ?? []).filter((item) => item.sourceInstanceId === row.sourceInstanceId) : [];
+			const claimStats = row.sourceInstanceId ? knowledge.claimStatsBySource?.[row.sourceInstanceId] : void 0;
 			const latestSync = (knowledge.syncRuns ?? []).filter((run) => run.sourceInstanceId === row.sourceInstanceId).sort((left, right) => Date.parse(right.startedAt) - Date.parse(left.startedAt))[0];
+			const learningJobs = (knowledge.learningJobs ?? []).filter((job) => job.sourceInstanceId === row.sourceInstanceId).sort((left, right) => Date.parse(right.createdAt) - Date.parse(left.createdAt));
+			const now = Date.now();
+			const nextScheduledLearning = learningJobs.filter((job) => job.status === "queued" && job.nextRunAt && Date.parse(job.nextRunAt) > now).sort((left, right) => Date.parse(left.nextRunAt) - Date.parse(right.nextRunAt))[0];
+			const latestLearning = learningJobs.find((job) => job.status !== "queued" || !job.nextRunAt || Date.parse(job.nextRunAt) <= now) ?? learningJobs[0];
 			const latestHealth = row.instances.filter((instance) => instance.usage.lastHealthCheckAt && instance.usage.lastHealthStatus).sort((left, right) => Date.parse(right.usage.lastHealthCheckAt) - Date.parse(left.usage.lastHealthCheckAt))[0]?.usage;
 			const permissionDetails = definition.permissions?.data ?? [];
 			const canWrite = permissionDetails.some((permission) => /(?:^|[.:/_-])(write|create|update|delete|manage|send|admin)(?:$|[.:/_-])/i.test(permission));
@@ -154,13 +209,36 @@ function projectPersonalContextSources(definitions, instances, records = [], kno
 						...instance.audit.map((entry) => entry.at)
 					]),
 					latestSync?.finishedAt,
-					latestSync?.startedAt
+					latestSync?.startedAt,
+					latestLearning?.finishedAt,
+					latestLearning?.startedAt
 				].filter((value) => Boolean(value)).sort().at(-1),
-				derivedUnderstandingCount: relatedRecords.length,
+				derivedUnderstandingCount: claimStats?.activeClaims ?? 0,
+				learningFunnel: {
+					indexedItems: sourceItems.filter((item) => !item.deletedAt).length,
+					attributedItems: sourceItems.filter((item) => !item.deletedAt && item.metadata.actorAttributed === true).length,
+					resolvedEntities: claimStats?.resolvedEntities ?? 0,
+					provisionalClaims: claimStats?.provisionalClaims ?? 0,
+					activeClaims: claimStats?.activeClaims ?? 0,
+					evidenceCount: claimStats?.evidenceCount ?? 0,
+					lastEvidenceAt: claimStats?.lastEvidenceAt
+				},
 				knowledgeItemCount: sourceItems.filter((item) => !item.deletedAt).length,
 				lastSyncAt: latestSync?.finishedAt ?? latestSync?.startedAt,
 				lastSyncStatus: latestSync?.status,
-				lastSyncError: latestSync?.error
+				lastSyncError: latestSync?.error,
+				learning: latestLearning ? {
+					status: latestLearning.status,
+					phase: latestLearning.phase,
+					itemsDiscovered: latestLearning.itemsDiscovered,
+					itemsIndexed: latestLearning.itemsIndexed,
+					candidatesCreated: latestLearning.candidatesCreated,
+					mode: latestLearning.mode,
+					attemptCount: latestLearning.attemptCount,
+					nextRunAt: nextScheduledLearning?.nextRunAt ?? latestLearning.nextRunAt,
+					error: latestLearning.error,
+					updatedAt: latestLearning.updatedAt
+				} : void 0
 			};
 		});
 	}).sort((left, right) => {

package/dist/src/work-discovery/service.js

@@ -267,6 +267,7 @@ var WorkDiscoveryService = class {
 			});
 			return {
 				sourceInstanceId: "desktop:calendar",
+				collectionScope: "events",
 				externalId: item.id,
 				itemType: "calendar_event",
 				authorRole: "unknown",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xopcai/xopc",
-  "version": "0.0.171",
+  "version": "0.0.173",
   "description": "Local-first AI system that remembers context, coordinates AI, and sustains long-term progress.",
   "type": "module",
   "main": "dist/src/index.js",