@xopcai/xopc 0.0.170 → 0.0.172

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/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/sessions.js

@@ -5,7 +5,6 @@ import { evictEmbeddedSessionRunner } from "../../../agent/embedded/session-runn
 import { messagesToClientHistory } from "../../../session/client-history.js";
 import { deleteMediaUrisNoLongerReferenced } from "../../../media/session-references.js";
 import { createGatewayRouteLogger, logRouteError } from "../lib/route-logger.js";
-import { computeUserRoundDeleteRange } from "../../../session/user-round-delete.js";
 import { respondStartupUnavailable } from "../lib/startup-unavailable.js";
 import { randomUUID } from "node:crypto";
 //#region src/gateway/hono/routes/sessions.ts
@@ -459,48 +458,35 @@ function registerSessionsRoutes(authenticated, deps) {
 		evictEmbeddedSessionRunner(key, "gateway_bash_execution_appended");
 		return c.json({ ok: true });
 	});
-	authenticated.get("/api/sessions/:key/compaction/checkpoints", async (c) => {
+	authenticated.get("/api/sessions/:key/compaction/boundaries", async (c) => {
 		const key = c.req.param("key");
 		if (!await service.sessionIndexInstance.getSessionMetadata(key)) return c.json({
 			ok: false,
 			error: "Session not found"
 		}, 404);
-		const checkpoints = await service.sessions.listCompactionCheckpoints(key);
+		const boundaries = await service.sessions.listCompactionBoundaries(key);
 		return c.json({
 			ok: true,
-			payload: { checkpoints }
-		});
-	});
-	authenticated.get("/api/sessions/:key/compaction/checkpoints/:checkpointId", async (c) => {
-		const key = c.req.param("key");
-		const checkpointId = c.req.param("checkpointId");
-		const checkpoint = await service.sessions.getCompactionCheckpoint(key, checkpointId);
-		if (!checkpoint) return c.json({
-			ok: false,
-			error: "Checkpoint not found"
-		}, 404);
-		return c.json({
-			ok: true,
-			payload: { checkpoint }
+			payload: { boundaries }
 		});
 	});
 	authenticated.post("/api/sessions/:key/compaction/restore", async (c) => {
 		const key = c.req.param("key");
 		const body = await c.req.json().catch(() => ({}));
-		const checkpointId = typeof body.checkpointId === "string" ? body.checkpointId.trim() : "";
-		if (!checkpointId) return c.json({
+		const compactionId = typeof body.compactionId === "string" ? body.compactionId.trim() : "";
+		if (!compactionId) return c.json({
 			ok: false,
-			error: "checkpointId required"
+			error: "compactionId required"
 		}, 400);
 		try {
-			await service.sessions.restoreCompactionCheckpoint(key, checkpointId);
+			await service.sessions.restoreBeforeCompactionBoundary(key, compactionId);
 		} catch (err) {
 			logRouteError(log, c, err, "gateway.route.sessions", {
-				operation: "restoreCheckpoint",
+				operation: "restoreCompactionBoundary",
 				sessionKey: key
 			});
 			const msg = err instanceof Error ? err.message : String(err);
-			if (msg.includes("not found") || msg.includes("Invalid")) return c.json({
+			if (msg.includes("not found")) return c.json({
 				ok: false,
 				error: msg
 			}, 404);
@@ -695,30 +681,19 @@ function registerSessionsRoutes(authenticated, deps) {
 	authenticated.delete("/api/sessions/:key/messages", async (c) => {
 		const key = c.req.param("key");
 		const body = await c.req.json().catch(() => ({}));
-		const loaded = await service.sessionIndexInstance.loadMessages(key);
-		if (!loaded) return c.json({ error: "Session not found" }, 404);
-		let startIndex = typeof body.startIndex === "number" ? body.startIndex : -1;
-		let count = typeof body.count === "number" ? body.count : 0;
 		const userRoundIndex = typeof body.userRoundIndex === "number" ? body.userRoundIndex : void 0;
-		if (userRoundIndex !== void 0) {
-			const range = computeUserRoundDeleteRange(loaded, userRoundIndex);
-			if (!range) return c.json({ error: "User round index out of range" }, 400);
-			startIndex = range.startIndex;
-			count = range.count;
-		}
-		if (startIndex < 0 || count <= 0) return c.json({ error: "Invalid startIndex or count" }, 400);
-		if (startIndex >= loaded.length) return c.json({ error: "Index out of range" }, 400);
-		const deleteCount = Math.min(count, loaded.length - startIndex);
-		const removed = loaded.slice(startIndex, startIndex + deleteCount);
-		const next = loaded.slice(0, startIndex).concat(loaded.slice(startIndex + deleteCount));
-		await service.sessionIndexInstance.saveMessages(key, next);
+		if (userRoundIndex === void 0 || !Number.isInteger(userRoundIndex) || userRoundIndex < 0) return c.json({ error: "userRoundIndex must be a non-negative integer" }, 400);
+		const result = await service.sessionIndexInstance.deleteUserRound(key, userRoundIndex);
+		if (!result) return c.json({ error: "User round index out of range" }, 400);
 		await deleteMediaUrisNoLongerReferenced({
-			removed,
-			remaining: next
+			removed: result.removedMessages,
+			remaining: result.remainingMessages
 		});
+		evictEmbeddedSessionRunner(key, "gateway_user_round_deleted");
+		service.agentService.evictSessionAgent(key);
 		return c.json({
 			ok: true,
-			deleted: deleteCount
+			deleted: result.deleted
 		});
 	});
 	authenticated.post("/api/sessions/:key/reset", async (c) => {

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/sessions-api.d.ts

@@ -92,9 +92,8 @@ export declare class GatewaySessionsApi {
         verboseLevel?: string;
         workingDirectory?: string;
     }): Promise<import("../../agent/session/session-config-service.js").PatchSessionAgentConfigResult>;
-    listCompactionCheckpoints(key: string): Promise<import("../../session/types.js").CompactionCheckpointSummary[]>;
-    getCompactionCheckpoint(key: string, checkpointId: string): Promise<import("../../session/types.js").CompactionCheckpointDetail>;
-    restoreCompactionCheckpoint(key: string, checkpointId: string): Promise<void>;
+    listCompactionBoundaries(key: string): Promise<import("../../session/types.js").CompactionBoundarySummary[]>;
+    restoreBeforeCompactionBoundary(key: string, compactionId: string): Promise<void>;
     runCompaction(key: string, options?: {
         instructions?: string;
         force?: boolean;

package/dist/src/gateway/service/sessions-api.js

@@ -93,14 +93,11 @@ var GatewaySessionsApi = class {
 	patchAgentConfig(sessionKey, body) {
 		return this.opts.getAgentService().sessionConfig.patch(sessionKey, body);
 	}
-	listCompactionCheckpoints(key) {
-		return this.opts.sessionIndex.listCompactionCheckpoints(key);
+	listCompactionBoundaries(key) {
+		return this.opts.sessionIndex.listCompactionBoundaries(key);
 	}
-	getCompactionCheckpoint(key, checkpointId) {
-		return this.opts.sessionIndex.getCompactionCheckpointDetail(key, checkpointId);
-	}
-	async restoreCompactionCheckpoint(key, checkpointId) {
-		await this.opts.sessionIndex.restoreCompactionCheckpoint(key, checkpointId);
+	async restoreBeforeCompactionBoundary(key, compactionId) {
+		await this.opts.sessionIndex.restoreBeforeCompactionBoundary(key, compactionId);
 		this.opts.getAgentService().evictSessionAgent(key);
 	}
 	async runCompaction(key, options) {

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).
      */