@xopcai/xopc 0.0.171 → 0.0.172

package/dist/src/gateway/hono/routes/models.js

@@ -16,6 +16,7 @@ import { getAgentImageGenerationConfig, getImageGenerationCatalog, prepareImageG
 import { discoverProviderModels, isProviderApiDiscoverable } from "../../../providers/model-discovery.js";
 import { respondStartupUnavailable } from "../lib/startup-unavailable.js";
 import { auditModelReferences } from "../../../providers/model-reference-auditor.js";
+import { XopcCloudAccountError, XopcCloudAccountService } from "../../../providers/xopc-cloud-account-service.js";
 //#region src/gateway/hono/routes/models.ts
 init_models_json();
 init_resolve_config_value();
@@ -66,6 +67,7 @@ function mapPluginModel(providerId, model, available) {
 function registerModelsRoutes(authenticated, deps) {
 	const { service, strictRateLimitMiddleware } = deps;
 	const catalogSync = service.getModelCatalogSync();
+	const xopcCloudAccount = new XopcCloudAccountService();
 	authenticated.get("/api/models/catalog/status", (c) => c.json({
 		ok: true,
 		payload: catalogSync.getStatus()
@@ -90,6 +92,28 @@ function registerModelsRoutes(authenticated, deps) {
 			payload: result
 		});
 	});
+	authenticated.get("/api/models/xopc-cloud/account-summary", async (c) => {
+		try {
+			const summary = await xopcCloudAccount.getSummary();
+			if (!summary) return c.json({
+				ok: false,
+				error: { message: "XOPC Cloud is not configured" }
+			}, 404);
+			return c.json({
+				ok: true,
+				payload: summary
+			});
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			return c.json({
+				ok: false,
+				error: {
+					message,
+					...error instanceof XopcCloudAccountError && error.code ? { code: error.code } : {}
+				}
+			}, 502);
+		}
+	});
 	authenticated.get("/api/models-json", async (c) => {
 		const path = resolveModelsJsonPath();
 		const { config, error } = loadModelsJson(path);

package/dist/src/gateway/hono/routes/public-gateway.js

@@ -68,9 +68,10 @@ function registerPublicGatewayRoutes(app, service) {
 				data: payload
 			};
 			const normalized = normalizeComposioTriggerPayload(archivedPayload, webhookId);
-			applyComposioConnectionLifecycleEvent(archivedPayload);
+			const inactiveConnectionId = applyComposioConnectionLifecycleEvent(archivedPayload);
+			if (inactiveConnectionId) service.setConnectorLearningPaused(inactiveConnectionId, true);
 			const event = await appendComposioTriggerEvent(service.currentConfig, archivedPayload);
-			service.requestConnectorMemorySync(normalized.toolkit);
+			if (normalized.toolkit) service.requestConnectorLearningForToolkit(normalized.toolkit);
 			const runs = await service.automationServiceInstance.triggerEvent({
 				type: `connector.${normalized.trigger ?? normalized.type}`,
 				source: normalized.toolkit ? `composio:${normalized.toolkit}` : "composio",

package/dist/src/gateway/hono/routes/you.js

@@ -1,4 +1,6 @@
 import { runSqliteWriteTransaction } from "../../../storage/sqlite/transaction.js";
+import { getUserClaim, linkUserClaimMemoryRecord, listUserClaimEvidence, listUserClaimStatsBySource, listUserClaims, removeUserClaimEvidenceForSource, setUserClaimDecision } from "../../../storage/sqlite/user-claims-repository.js";
+import { listConnectorLearningJobs } from "../../../storage/sqlite/connector-learning-repository.js";
 import { getRelationshipSettings, updateRelationshipSettings } from "../../../storage/sqlite/relationship-settings-repository.js";
 import { deleteMemoryRecord, getMemoryRecord, listMemoryRecords, upsertMemoryRecord } from "../../../storage/sqlite/memory-records-repository.js";
 import { listKnowledgeSourceItems, listKnowledgeSyncRuns } from "../../../storage/sqlite/knowledge-repository.js";
@@ -19,6 +21,7 @@ import { nextMemoryReviewAt, resolveMemoryStability } from "../../../agent/memor
 import { PERSONAL_PLAYBOOK_DISABLED_TAG, PERSONAL_PLAYBOOK_ORDER_PREFIX, PERSONAL_PLAYBOOK_RULE_TAG, patchPersonalPlaybookContextTags, personalPlaybookContext } from "../../../user-context/personal-playbook.js";
 import { listConnectorInstances } from "../../../connectors/instances.js";
 import { uninstallConnector } from "../../../connectors/install.js";
+import { renderUserClaim } from "../../../knowledge/connected-understanding-pipeline.js";
 import { readUserProfileFile, writeUserProfileFile } from "../../agents-admin.js";
 import { isUserContextMemoryKind, isUserContextRecord, projectPersonalContextSources, projectUserContextRecord, recordsDerivedFromPersonalContextSource } from "../../../user-context/projection.js";
 import { prepareUserContextImport } from "../../../user-context/import.js";
@@ -321,10 +324,12 @@ function registerYouRoutes(authenticated, deps) {
 		const trustPolicy = getUserTrustPolicy();
 		const sourceDefinitions = listConnectorCatalog();
 		const sourceInstances = listConnectorInstances(config);
-		const sources = projectPersonalContextSources(sourceDefinitions, sourceInstances, allUserContextRecords, {
+		const sources = projectPersonalContextSources(sourceDefinitions, sourceInstances, {
 			sourceItems: listKnowledgeSourceItems({ limit: 500 }),
 			syncRuns: listKnowledgeSyncRuns({ limit: 500 }),
-			connections: listConnectorConnections({ principalId: "local-owner" })
+			connections: listConnectorConnections({ principalId: "local-owner" }),
+			learningJobs: listConnectorLearningJobs({ limit: 500 }),
+			claimStatsBySource: listUserClaimStatsBySource()
 		});
 		const activeGoals = new GoalService().list({
 			agentId,
@@ -344,6 +349,13 @@ function registerYouRoutes(authenticated, deps) {
 			},
 			...profileBundle,
 			understanding: records.map(projectUserContextRecord),
+			connectedClaims: listUserClaims({
+				agentId,
+				limit: 100
+			}).map((claim) => ({
+				...claim,
+				evidence: listUserClaimEvidence(claim.id)
+			})),
 			consentRequests: consents.filter((consent) => consent.status === "pending").flatMap((consent) => {
 				const record = recordById.get(consent.recordId);
 				return record ? [projectReferenceConsent(consent, record)] : [];
@@ -404,6 +416,64 @@ function registerYouRoutes(authenticated, deps) {
 			relationship: updateRelationshipSettings(patch)
 		});
 	});
+	authenticated.patch("/api/you/claims/:id", deps.strictRateLimitMiddleware, async (c) => {
+		const body = await c.req.json().catch(() => ({}));
+		const action = body.action === "confirm" || body.action === "reject" ? body.action : void 0;
+		if (!action) return c.json({ error: "Action must be confirm or reject" }, 400);
+		const claim = runSqliteWriteTransaction(() => {
+			const updated = setUserClaimDecision(c.req.param("id"), action === "confirm" ? "confirmed" : "rejected");
+			if (!updated) return updated;
+			const existing = updated.memoryRecordId ? getMemoryRecord(updated.memoryRecordId) : void 0;
+			if (existing) preserveRecord(existing, {
+				status: action === "confirm" ? "active" : "rejected",
+				...action === "confirm" ? { reviewAfter: nextMemoryReviewAt(existing) } : {}
+			});
+			else if (action === "confirm") {
+				const candidate = renderUserClaim(updated);
+				const evidence = listUserClaimEvidence(updated.id);
+				const record = upsertMemoryRecord({
+					providerId: "connected-understanding",
+					kind: candidate.kind,
+					sourceAgentId: updated.agentId,
+					content: candidate.content,
+					canonicalKey: candidate.canonicalKey,
+					source: { provider: "connected-sources" },
+					confidence: 1,
+					status: "active",
+					sensitivity: candidate.sensitivity,
+					explicitness: "explicit",
+					durability: candidate.durability,
+					importance: candidate.importance,
+					disclosurePolicy: candidate.disclosurePolicy,
+					tags: [...new Set([
+						"user-understanding",
+						...candidate.tags ?? [],
+						"user-confirmed"
+					])],
+					evidence: evidence.map((item) => ({
+						sourceItemId: item.sourceItemId,
+						relation: item.relation === "contradicts" ? "contradicts" : "supports",
+						observedAt: item.observedAt,
+						confidence: updated.confidence
+					})),
+					reviewAfter: nextMemoryReviewAt({
+						durability: candidate.durability,
+						explicitness: "explicit"
+					})
+				});
+				linkUserClaimMemoryRecord(updated.id, record.id);
+			}
+			return getUserClaim(updated.id);
+		});
+		if (!claim) return c.json({ error: "Connected claim not found" }, 404);
+		return c.json({
+			ok: true,
+			claim: {
+				...claim,
+				evidence: listUserClaimEvidence(claim.id)
+			}
+		});
+	});
 	authenticated.get("/api/you/profile", async (c) => {
 		return c.json(await readProfileBundle(deps.service.currentConfig));
 	});
@@ -889,17 +959,28 @@ function registerYouRoutes(authenticated, deps) {
 			return c.json({ error: error instanceof Error ? error.message : String(error) }, 400);
 		}
 		let deletedUnderstandingCount = 0;
+		let deletedClaimCount = 0;
 		if (body.deleteDerivedUnderstanding) {
 			const sourceInstanceId = connection ? `composio:${connection.connectorId}:${connection.id}` : instanceId;
 			const targets = recordsDerivedFromPersonalContextSource(listAllUserContextRecords(ALL_MEMORY_STATUSES), sourceInstanceId);
 			runSqliteWriteTransaction(() => {
-				for (const record of targets) deleteMemoryRecord(record.id);
+				const claimRemoval = removeUserClaimEvidenceForSource(sourceInstanceId);
+				deletedClaimCount = claimRemoval.deletedClaimCount;
+				const retainedMemoryIds = new Set(claimRemoval.retainedClaims.map((claim) => claim.memoryRecordId));
+				const deleteIds = new Set([...claimRemoval.deletedMemoryRecordIds, ...targets.filter((record) => !retainedMemoryIds.has(record.id)).map((record) => record.id)]);
+				for (const recordId of deleteIds) deleteMemoryRecord(recordId);
+				for (const retained of claimRemoval.retainedClaims) {
+					if (retained.state === "active") continue;
+					const record = getMemoryRecord(retained.memoryRecordId);
+					if (record) preserveRecord(record, { status: retained.state === "rejected" ? "rejected" : "stale" });
+				}
+				deletedUnderstandingCount = deleteIds.size;
 			});
-			deletedUnderstandingCount = targets.length;
 		}
 		return c.json({
 			ok: true,
-			deletedUnderstandingCount
+			deletedUnderstandingCount,
+			deletedClaimCount
 		});
 	});
 	authenticated.patch("/api/you/understanding/:id", deps.strictRateLimitMiddleware, async (c) => {

package/dist/src/gateway/service.d.ts

@@ -18,6 +18,7 @@ import { GatewayMarketplaceService } from './service/marketplace-service.js';
 import { GatewayAgentRunner } from './service/agent-runner.js';
 import type { GatewayServiceConfig, ServiceEvent } from './service/types.js';
 import { type GatewayReadinessSnapshot } from './startup-readiness.js';
+import { type ConnectorLearningCoordinator } from '../connectors/learning-coordinator.js';
 import { type ProductLanguage } from '../voice/language-profile.js';
 export type { GatewayChannelStartupPhase1Metrics, GatewayChannelStartupPhase2Metrics, GatewayServiceConfig, ServiceEvent, } from './service/types.js';
 export declare class GatewayService {
@@ -63,7 +64,7 @@ export declare class GatewayService {
     private goalNotifications;
     private mobileNotifications;
     private connectorSupervisor;
-    private connectorMemorySyncCoordinator;
+    private connectorLearningCoordinator;
     private connectedKnowledgeCoordinator;
     private stopAutomationProductEventBridge;
     private stopSessionTranscriptAutomationEvents;
@@ -207,7 +208,9 @@ export declare class GatewayService {
     requestHeartbeatNow(opts?: {
         reason?: string;
     }): void;
-    requestConnectorMemorySync(toolkit?: string): void;
+    requestConnectorLearning(connectionId: string, request?: Parameters<ConnectorLearningCoordinator['enqueueConnection']>[1]): ReturnType<ConnectorLearningCoordinator['enqueueConnection']>;
+    requestConnectorLearningForToolkit(toolkit: string): ReturnType<ConnectorLearningCoordinator['enqueueToolkit']>;
+    setConnectorLearningPaused(connectionId: string, paused: boolean): number;
     /**
      * Register graceful shutdown used after spawning a replacement gateway process (foreground CLI server).
      */

package/dist/src/gateway/service.js

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

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

@@ -0,0 +1,19 @@
+import type { UnderstandingCandidate, UnderstandingReviewResult } from '../agent/memory/understanding/types.js';
+import type { MemoryManager } from '../agent/memory/manager.js';
+import { resolveUserEntity, type UserClaim, type UserClaimClass } from '../storage/sqlite/index.js';
+import type { KnowledgeSourceItem } from './types.js';
+export type ClaimObservation = {
+    class: UserClaimClass;
+    key: string;
+    value: Record<string, unknown>;
+    subject?: Parameters<typeof resolveUserEntity>[0];
+    items: KnowledgeSourceItem[];
+    windowDays: number;
+};
+export declare function deriveConnectedClaimObservations(items: KnowledgeSourceItem[]): ClaimObservation[];
+export declare function renderUserClaim(claim: UserClaim): UnderstandingCandidate;
+export declare class ConnectedUnderstandingPipeline {
+    private readonly memoryManager;
+    constructor(memoryManager: MemoryManager);
+    process(sourceInstanceId: string, connectorId: string, agentId: string): Promise<UnderstandingReviewResult>;
+}

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

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

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

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

package/dist/src/knowledge/index.js

@@ -1,6 +1,7 @@
 import { KnowledgeIngestionService, SqliteKnowledgeSourceStateStore } from "./ingestion-service.js";
 import { ConnectedKnowledgePipeline } from "./connected-knowledge-pipeline.js";
+import { ConnectedUnderstandingPipeline, deriveConnectedClaimObservations, renderUserClaim } from "./connected-understanding-pipeline.js";
 import { startConnectedKnowledgeCoordinator } from "./coordinator.js";
 import { LocalFolderKnowledgeSourceAdapter } from "./local-folder-adapter.js";
 import { buildConnectedPeopleGraph } from "./people-graph.js";
-export { ConnectedKnowledgePipeline, KnowledgeIngestionService, LocalFolderKnowledgeSourceAdapter, SqliteKnowledgeSourceStateStore, buildConnectedPeopleGraph, startConnectedKnowledgeCoordinator };
+export { ConnectedKnowledgePipeline, ConnectedUnderstandingPipeline, KnowledgeIngestionService, LocalFolderKnowledgeSourceAdapter, SqliteKnowledgeSourceStateStore, buildConnectedPeopleGraph, deriveConnectedClaimObservations, renderUserClaim, startConnectedKnowledgeCoordinator };

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

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