@xopcai/xopc 0.0.171 → 0.0.173

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

@@ -1,3 +1,4 @@
+import { listConnectorLearningJobs } from "../../../storage/sqlite/connector-learning-repository.js";
 import { decideConnectorApproval, getConnectorApproval, listConnectorApprovals, listConnectorConnections } from "../../../storage/sqlite/connector-repository.js";
 import "../../../storage/sqlite/index.js";
 import { init_agent_scope, resolveDefaultAgentId } from "../../../agent/agent-scope.js";
@@ -15,11 +16,10 @@ import { composioLogoResponse } from "../../../connectors/composio-logo.js";
 import { appendComposioTriggerEvent, listComposioTriggerEvents } from "../../../connectors/composio-triggers.js";
 import { buildConnectedPeopleGraph } from "../../../knowledge/people-graph.js";
 import "../../../knowledge/index.js";
-import { syncComposioResultToMemory, syncLocalFolderToMemory } from "../../../connectors/connector-memory-sync.js";
+import { ingestLocalFolderSource } from "../../../connectors/connected-source-ingestion.js";
 import { previewConnectorDefinition, testConnectorInstance } from "../../../connectors/health.js";
 import { setConnectorEnabled } from "../../../connectors/lifecycle.js";
-import { getComposioMemorySyncProfile, updateComposioMemorySyncProfile } from "../../../connectors/memory-sync-profile.js";
-import { projectComposioRuntimeStatus } from "../../../connectors/runtime-status.js";
+import { projectComposioConnectionStatus } from "../../../connectors/runtime-status.js";
 //#region src/gateway/hono/routes/connectors.ts
 init_agent_scope();
 function errorMessage(error) {
@@ -39,45 +39,13 @@ function registerConnectorRoutes(authenticated, deps) {
 			}
 		});
 	});
-	authenticated.get("/api/connectors/installed", async (c) => {
+	authenticated.get("/api/connectors/installed", (c) => {
 		const config = service.currentConfig;
 		const instances = listConnectorInstances(config);
-		const composioInstances = instances.filter((instance) => instance.materialized.type === "composio" && instance.materialized.role === "toolkit");
-		if (composioInstances.length === 0) return c.json({
-			ok: true,
-			payload: { instances }
-		});
-		const checkedAt = (/* @__PURE__ */ new Date()).toISOString();
-		let connectionError;
-		try {
-			await listComposioConnections();
-		} catch (error) {
-			connectionError = errorMessage(error);
-		}
-		const probes = await Promise.all([...new Map(composioInstances.map((instance) => [instance.connectorId, instance])).values()].map(async (instance) => {
-			try {
-				const tools = await listComposioTools(instance.materialized.type === "composio" ? instance.materialized.toolkit : "", config);
-				return {
-					connectorId: instance.connectorId,
-					checkedAt,
-					toolCount: tools.length,
-					...connectionError ? {
-						error: connectionError,
-						connectionError: true
-					} : {}
-				};
-			} catch (error) {
-				return {
-					connectorId: instance.connectorId,
-					checkedAt,
-					error: errorMessage(error)
-				};
-			}
-		}));
 		const connections = listConnectorConnections({ principalId: "local-owner" });
 		return c.json({
 			ok: true,
-			payload: { instances: projectComposioRuntimeStatus(instances, connections, probes) }
+			payload: { instances: projectComposioConnectionStatus(instances, connections) }
 		});
 	});
 	authenticated.post("/api/connectors/setup/request-secret", strictRateLimitMiddleware, async (c) => {
@@ -118,6 +86,54 @@ function registerConnectorRoutes(authenticated, deps) {
 			}, 400);
 		}
 	});
+	authenticated.get("/api/connectors/learning", (c) => {
+		return c.json({
+			ok: true,
+			payload: { jobs: listConnectorLearningJobs({ limit: 100 }) }
+		});
+	});
+	authenticated.post("/api/connectors/composio/connections/:id/learning", strictRateLimitMiddleware, async (c) => {
+		try {
+			await listComposioConnections();
+			const config = service.currentConfig;
+			if (!config.userContext.memory.sources.includes("connectedSources")) {
+				config.userContext.memory.sources = [...config.userContext.memory.sources, "connectedSources"];
+				const saved = await service.saveConfig(config);
+				if (!saved.saved) return c.json({
+					ok: false,
+					error: saved.error
+				}, 500);
+			}
+			const job = service.requestConnectorLearning(c.req.param("id"), { reason: "manual" });
+			if (!job) return c.json({
+				ok: false,
+				error: "The connection is not active or does not support learning."
+			}, 409);
+			return c.json({
+				ok: true,
+				payload: { job }
+			}, 202);
+		} catch (error) {
+			return c.json({
+				ok: false,
+				error: errorMessage(error)
+			}, 400);
+		}
+	});
+	authenticated.post("/api/connectors/composio/connections/:id/learning/pause", strictRateLimitMiddleware, (c) => {
+		const changed = service.setConnectorLearningPaused(c.req.param("id"), true);
+		return c.json({
+			ok: true,
+			payload: { changed }
+		});
+	});
+	authenticated.post("/api/connectors/composio/connections/:id/learning/resume", strictRateLimitMiddleware, (c) => {
+		const changed = service.setConnectorLearningPaused(c.req.param("id"), false);
+		return c.json({
+			ok: true,
+			payload: { changed }
+		});
+	});
 	authenticated.patch("/api/connectors/composio/connections/:id", strictRateLimitMiddleware, async (c) => {
 		const body = await c.req.json().catch(() => ({}));
 		const row = body && typeof body === "object" && !Array.isArray(body) ? body : {};
@@ -153,7 +169,9 @@ function registerConnectorRoutes(authenticated, deps) {
 	});
 	authenticated.delete("/api/connectors/composio/connections/:id", strictRateLimitMiddleware, async (c) => {
 		try {
-			await revokeComposioConnection(c.req.param("id"));
+			const connectionId = c.req.param("id");
+			await revokeComposioConnection(connectionId);
+			service.setConnectorLearningPaused(connectionId, true);
 			return c.json({
 				ok: true,
 				payload: { revoked: true }
@@ -275,7 +293,7 @@ function registerConnectorRoutes(authenticated, deps) {
 		const body = await c.req.json().catch(() => ({}));
 		try {
 			const event = await appendComposioTriggerEvent(service.currentConfig, body);
-			service.requestConnectorMemorySync(event.toolkit);
+			if (event.toolkit) service.requestConnectorLearningForToolkit(event.toolkit);
 			return c.json({
 				ok: true,
 				payload: { event }
@@ -313,43 +331,6 @@ function registerConnectorRoutes(authenticated, deps) {
 			})
 		});
 	});
-	authenticated.get("/api/connectors/:id/memory-sync-profile", (c) => {
-		const profile = getComposioMemorySyncProfile(service.currentConfig, c.req.param("id"));
-		return c.json({
-			ok: true,
-			payload: { profile: profile ?? null }
-		});
-	});
-	authenticated.patch("/api/connectors/:id/memory-sync-profile", strictRateLimitMiddleware, async (c) => {
-		const body = await c.req.json().catch(() => ({}));
-		const row = body && typeof body === "object" && !Array.isArray(body) ? body : {};
-		try {
-			const config = service.currentConfig;
-			const profile = updateComposioMemorySyncProfile(config, c.req.param("id"), {
-				enabled: row.enabled === true,
-				actionId: typeof row.actionId === "string" ? row.actionId : "",
-				arguments: row.arguments && typeof row.arguments === "object" && !Array.isArray(row.arguments) ? row.arguments : {},
-				agentId: typeof row.agentId === "string" ? row.agentId : "",
-				connectionId: typeof row.connectionId === "string" ? row.connectionId : void 0,
-				intervalMinutes: Number(row.intervalMinutes),
-				triggerSync: row.triggerSync !== false
-			});
-			const saved = await service.saveConfig(config);
-			if (!saved.saved) return c.json({
-				ok: false,
-				error: saved.error
-			}, 500);
-			return c.json({
-				ok: true,
-				payload: { profile }
-			});
-		} catch (error) {
-			return c.json({
-				ok: false,
-				error: errorMessage(error)
-			}, 400);
-		}
-	});
 	authenticated.get("/api/connectors/:id", (c) => {
 		const connectorId = c.req.param("id");
 		const connector = getConnectorDefinition(connectorId);
@@ -395,48 +376,6 @@ function registerConnectorRoutes(authenticated, deps) {
 			payload: { health }
 		});
 	});
-	authenticated.post("/api/connectors/:id/memory-sync", strictRateLimitMiddleware, async (c) => {
-		const body = await c.req.json().catch(() => ({}));
-		const row = body && typeof body === "object" && !Array.isArray(body) ? body : {};
-		const actionId = typeof row.actionId === "string" ? row.actionId.trim() : "";
-		const config = service.currentConfig;
-		const agentId = typeof row.agentId === "string" && row.agentId.trim() ? row.agentId.trim() : resolveDefaultAgentId(config);
-		try {
-			const connectorId = c.req.param("id");
-			if (getConnectorDefinition(connectorId)?.runtime.type === "memorySource") {
-				const result = await syncLocalFolderToMemory({
-					config,
-					connectorId,
-					agentId
-				});
-				return c.json({
-					ok: true,
-					payload: result
-				});
-			}
-			if (!actionId) return c.json({
-				ok: false,
-				error: "actionId is required for Composio memory sync."
-			}, 400);
-			const result = await syncComposioResultToMemory({
-				config,
-				connectorId,
-				actionId,
-				agentId,
-				connectionId: typeof row.connectionId === "string" ? row.connectionId : void 0,
-				arguments: row.arguments && typeof row.arguments === "object" && !Array.isArray(row.arguments) ? row.arguments : {}
-			});
-			return c.json({
-				ok: true,
-				payload: result
-			});
-		} catch (error) {
-			return c.json({
-				ok: false,
-				error: errorMessage(error)
-			}, 400);
-		}
-	});
 	authenticated.get("/api/connectors/composio/:toolkit/policy", (c) => {
 		const config = service.currentConfig;
 		try {
@@ -632,6 +571,25 @@ function registerConnectorRoutes(authenticated, deps) {
 			}, 500);
 		}
 	});
+	authenticated.post("/api/connectors/:id/source-sync", strictRateLimitMiddleware, async (c) => {
+		const config = service.currentConfig;
+		try {
+			const result = await ingestLocalFolderSource({
+				config,
+				connectorId: c.req.param("id"),
+				agentId: resolveDefaultAgentId(config)
+			});
+			return c.json({
+				ok: true,
+				payload: result
+			});
+		} catch (error) {
+			return c.json({
+				ok: false,
+				error: errorMessage(error)
+			}, 400);
+		}
+	});
 	authenticated.post("/api/connectors/:id/config", strictRateLimitMiddleware, async (c) => {
 		const instanceId = c.req.param("id");
 		const body = await c.req.json().catch(() => ({}));

package/dist/src/gateway/hono/routes/local-apps.js

@@ -1,6 +1,6 @@
 import { readLocalAppAcceptanceConfig } from "../../../local-apps/acceptance.js";
-import { extensionAssetMimeType } from "../lib/extension-assets.js";
 import { LOCAL_APP_RUNTIME_BRIDGE_HASH, injectLocalAppRuntimeBridge } from "../../../local-apps/preview-runtime-bridge.js";
+import { extensionAssetMimeType } from "../lib/extension-assets.js";
 import { relative, resolve } from "node:path";
 import { existsSync, readFileSync, statSync } from "node:fs";
 //#region src/gateway/hono/routes/local-apps.ts

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/marketplace-service.js

@@ -4,9 +4,9 @@ import { init_logger } from "../../utils/logger.js";
 import { init_paths, resolveExtensionsDir } from "../../config/paths.js";
 import { createSkillConfigManager } from "../../agent/skills/config.js";
 import { resolveWorkspaceSkillsDir, resolveWorkspaceSkillsLockPath } from "../../agent/skills/workspace-skills-dir.js";
-import { normalizeSkillInstallTarget } from "../../agent/skills/install-target.js";
 import { removeSkillsLockEntry } from "../../agent/skills/hub-lock.js";
 import { deleteManagedSkill, installSkillFromZip, listManagedSkillDirs } from "../../agent/skills/managed-store.js";
+import { normalizeSkillInstallTarget } from "../../agent/skills/install-target.js";
 import { getExtensionLockfileManager } from "../../extensions/lockfile.js";
 import { existsSync, rmSync } from "node:fs";
 //#region src/gateway/service/marketplace-service.ts

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,8 +44,10 @@ 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 { LocalAppService } from "../local-apps/service.js";
+import "../local-apps/index.js";
 import { assertGatewayAuthConfigured, extractToken, resolveGatewayAuth, validateToken } from "./auth.js";
 import { reconcileDreamingAutomations } from "./dreaming-automation-reconciler.js";
 import { FocusService } from "../proactive/focus-service.js";
@@ -77,8 +79,6 @@ import { auditGatewayConfig } from "./security/audit.js";
 import { ModelCatalogSyncService } from "../providers/model-catalog-sync-service.js";
 import { runBootstrapMigrationsSync } from "../migrations/runner.js";
 import { MobileNotificationService } from "../mobile/notification-service.js";
-import { LocalAppService } from "../local-apps/service.js";
-import "../local-apps/index.js";
 import { createRuntimeBrowserRecipeService } from "../browser/recipes/runtime-service.js";
 import "../browser/recipes/index.js";
 import { scheduleGatewayUpdateCheck } from "../infra/update-startup.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/heartbeat/index.js

@@ -1,6 +1,6 @@
 import { DEFAULT_ACK_MAX_CHARS, HEARTBEAT_OK, NO_REPLY, shouldSilence, stripHeartbeatToken } from "./tokens.js";
-import { appendCronEventLines } from "./event-prompt.js";
 import { isWithinActiveHours } from "./active-hours.js";
 import { isHeartbeatContentEmpty } from "./content-check.js";
+import { appendCronEventLines } from "./event-prompt.js";
 import { createHeartbeatWake } from "./wake.js";
 export { DEFAULT_ACK_MAX_CHARS, HEARTBEAT_OK, NO_REPLY, appendCronEventLines, createHeartbeatWake, isHeartbeatContentEmpty, isWithinActiveHours, shouldSilence, stripHeartbeatToken };

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>;
+}