@xopcai/xopc 0.0.170 → 0.0.172

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

@@ -5,6 +5,39 @@ export declare const UserMemoryModeSchema: z.ZodEnum<{
     readOnly: "readOnly";
     confirmWrite: "confirmWrite";
 }>;
+export declare const DEFAULT_CONTEXT_COMPACTION_POLICY: {
+    enabled: boolean;
+    triggerThreshold: number;
+    reserveTokens: number;
+    minMessagesBeforeCompact: number;
+    keepRecentTokens: number;
+    recentTurnsPreserve: number;
+    summaryMaxTokens: number;
+    summaryChunkTokens: number;
+    summaryTimeoutMs: number;
+    summaryRetries: number;
+    qualityGuard: boolean;
+    minToolResultKeepChars: number;
+    maxActiveTranscriptBytes: number;
+    postCompactionSections: string[];
+};
+export declare const ContextCompactionPolicySchema: z.ZodDefault<z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    triggerThreshold: z.ZodDefault<z.ZodNumber>;
+    reserveTokens: z.ZodDefault<z.ZodNumber>;
+    minMessagesBeforeCompact: z.ZodDefault<z.ZodNumber>;
+    keepRecentTokens: z.ZodDefault<z.ZodNumber>;
+    recentTurnsPreserve: z.ZodDefault<z.ZodNumber>;
+    summaryMaxTokens: z.ZodDefault<z.ZodNumber>;
+    summaryChunkTokens: z.ZodDefault<z.ZodNumber>;
+    summaryTimeoutMs: z.ZodDefault<z.ZodNumber>;
+    summaryRetries: z.ZodDefault<z.ZodNumber>;
+    qualityGuard: z.ZodDefault<z.ZodBoolean>;
+    model: z.ZodOptional<z.ZodString>;
+    minToolResultKeepChars: z.ZodDefault<z.ZodNumber>;
+    maxActiveTranscriptBytes: z.ZodDefault<z.ZodNumber>;
+    postCompactionSections: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>>;
 export declare const UserMemoryConfigSchema: z.ZodDefault<z.ZodObject<{
     mode: z.ZodDefault<z.ZodEnum<{
         off: "off";
@@ -43,7 +76,23 @@ export declare const UserMemoryConfigSchema: z.ZodDefault<z.ZodObject<{
         }>>;
     }, z.core.$strict>>;
     retention: z.ZodOptional<z.ZodObject<{
-        compaction: z.ZodDefault<z.ZodBoolean>;
+        compaction: z.ZodDefault<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            triggerThreshold: z.ZodDefault<z.ZodNumber>;
+            reserveTokens: z.ZodDefault<z.ZodNumber>;
+            minMessagesBeforeCompact: z.ZodDefault<z.ZodNumber>;
+            keepRecentTokens: z.ZodDefault<z.ZodNumber>;
+            recentTurnsPreserve: z.ZodDefault<z.ZodNumber>;
+            summaryMaxTokens: z.ZodDefault<z.ZodNumber>;
+            summaryChunkTokens: z.ZodDefault<z.ZodNumber>;
+            summaryTimeoutMs: z.ZodDefault<z.ZodNumber>;
+            summaryRetries: z.ZodDefault<z.ZodNumber>;
+            qualityGuard: z.ZodDefault<z.ZodBoolean>;
+            model: z.ZodOptional<z.ZodString>;
+            minToolResultKeepChars: z.ZodDefault<z.ZodNumber>;
+            maxActiveTranscriptBytes: z.ZodDefault<z.ZodNumber>;
+            postCompactionSections: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>>;
         maxAgeDays: z.ZodOptional<z.ZodNumber>;
         maxItems: z.ZodOptional<z.ZodNumber>;
         maxChars: z.ZodOptional<z.ZodNumber>;
@@ -153,7 +202,23 @@ export declare const UserContextConfigSchema: z.ZodDefault<z.ZodObject<{
             }>>;
         }, z.core.$strict>>;
         retention: z.ZodOptional<z.ZodObject<{
-            compaction: z.ZodDefault<z.ZodBoolean>;
+            compaction: z.ZodDefault<z.ZodObject<{
+                enabled: z.ZodDefault<z.ZodBoolean>;
+                triggerThreshold: z.ZodDefault<z.ZodNumber>;
+                reserveTokens: z.ZodDefault<z.ZodNumber>;
+                minMessagesBeforeCompact: z.ZodDefault<z.ZodNumber>;
+                keepRecentTokens: z.ZodDefault<z.ZodNumber>;
+                recentTurnsPreserve: z.ZodDefault<z.ZodNumber>;
+                summaryMaxTokens: z.ZodDefault<z.ZodNumber>;
+                summaryChunkTokens: z.ZodDefault<z.ZodNumber>;
+                summaryTimeoutMs: z.ZodDefault<z.ZodNumber>;
+                summaryRetries: z.ZodDefault<z.ZodNumber>;
+                qualityGuard: z.ZodDefault<z.ZodBoolean>;
+                model: z.ZodOptional<z.ZodString>;
+                minToolResultKeepChars: z.ZodDefault<z.ZodNumber>;
+                maxActiveTranscriptBytes: z.ZodDefault<z.ZodNumber>;
+                postCompactionSections: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            }, z.core.$strict>>;
             maxAgeDays: z.ZodOptional<z.ZodNumber>;
             maxItems: z.ZodOptional<z.ZodNumber>;
             maxChars: z.ZodOptional<z.ZodNumber>;

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

@@ -1,7 +1,7 @@
 import { __esmMin } from "../../_virtual/_rolldown/runtime.js";
 import { z } from "zod";
 //#region src/user-context/config.ts
-var UserMemoryModeSchema, UserMemoryConfigSchema, UserUnderstandingConfigSchema, UserContextPrivacySchema, UserContextProviderRoutingSchema, DreamingPhaseSchema, UserContextDreamingSchema, UserContextConfigSchema;
+var UserMemoryModeSchema, DEFAULT_CONTEXT_COMPACTION_POLICY, ContextCompactionPolicySchema, UserMemoryConfigSchema, UserUnderstandingConfigSchema, UserContextPrivacySchema, UserContextProviderRoutingSchema, DreamingPhaseSchema, UserContextDreamingSchema, UserContextConfigSchema;
 var init_config = __esmMin((() => {
 	UserMemoryModeSchema = z.enum([
 		"off",
@@ -9,6 +9,39 @@ var init_config = __esmMin((() => {
 		"confirmWrite",
 		"auto"
 	]);
+	DEFAULT_CONTEXT_COMPACTION_POLICY = {
+		enabled: true,
+		triggerThreshold: .8,
+		reserveTokens: 8192,
+		minMessagesBeforeCompact: 10,
+		keepRecentTokens: 2e4,
+		recentTurnsPreserve: 3,
+		summaryMaxTokens: 2e3,
+		summaryChunkTokens: 24e3,
+		summaryTimeoutMs: 18e4,
+		summaryRetries: 2,
+		qualityGuard: true,
+		minToolResultKeepChars: 1e3,
+		maxActiveTranscriptBytes: 2e6,
+		postCompactionSections: ["Session Startup", "Red Lines"]
+	};
+	ContextCompactionPolicySchema = z.object({
+		enabled: z.boolean().default(true),
+		triggerThreshold: z.number().min(.1).max(.98).default(.8),
+		reserveTokens: z.number().int().min(1024).default(8192),
+		minMessagesBeforeCompact: z.number().int().min(2).default(10),
+		keepRecentTokens: z.number().int().min(1e3).default(2e4),
+		recentTurnsPreserve: z.number().int().min(1).max(12).default(3),
+		summaryMaxTokens: z.number().int().min(256).default(2e3),
+		summaryChunkTokens: z.number().int().min(1e3).default(24e3),
+		summaryTimeoutMs: z.number().int().min(1e3).max(6e5).default(18e4),
+		summaryRetries: z.number().int().min(0).max(5).default(2),
+		qualityGuard: z.boolean().default(true),
+		model: z.string().min(1).optional(),
+		minToolResultKeepChars: z.number().int().min(200).default(1e3),
+		maxActiveTranscriptBytes: z.number().int().min(64e3).default(2e6),
+		postCompactionSections: z.array(z.string().min(1)).max(12).default(["Session Startup", "Red Lines"])
+	}).strict().default(DEFAULT_CONTEXT_COMPACTION_POLICY);
 	UserMemoryConfigSchema = z.object({
 		mode: UserMemoryModeSchema.default("off"),
 		sources: z.array(z.enum([
@@ -42,7 +75,7 @@ var init_config = __esmMin((() => {
 			]).optional()
 		}).strict().optional(),
 		retention: z.object({
-			compaction: z.boolean().default(true),
+			compaction: ContextCompactionPolicySchema,
 			maxAgeDays: z.number().int().positive().optional(),
 			maxItems: z.number().int().positive().optional(),
 			maxChars: z.number().int().positive().optional()
@@ -153,4 +186,4 @@ var init_config = __esmMin((() => {
 }));
 //#endregion
 init_config();
-export { UserContextConfigSchema, UserContextDreamingSchema, UserContextPrivacySchema, UserContextProviderRoutingSchema, UserMemoryConfigSchema, UserMemoryModeSchema, UserUnderstandingConfigSchema, init_config };
+export { ContextCompactionPolicySchema, DEFAULT_CONTEXT_COMPACTION_POLICY, UserContextConfigSchema, UserContextDreamingSchema, UserContextPrivacySchema, UserContextProviderRoutingSchema, UserMemoryConfigSchema, UserMemoryModeSchema, UserUnderstandingConfigSchema, init_config };

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.170",
+  "version": "0.0.172",
   "description": "Local-first AI system that remembers context, coordinates AI, and sustains long-term progress.",
   "type": "module",
   "main": "dist/src/index.js",