@xopcai/xopc 0.0.247 → 0.0.249

package/dist/src/gateway/chat-stream/protocol.d.ts

@@ -1,5 +1,5 @@
 import type { ToolActivity, TurnOutcome } from '@xopcai/gateway-contract';
-export type ChatStreamStatus = 'success' | 'error' | 'cancelled';
+export type ChatStreamStatus = 'success' | 'error' | 'cancelled' | 'suspended';
 export type PetFeedbackTaskState = 'working' | 'waiting' | 'success' | 'error';
 export type PetFeedbackSensitivity = 'public' | 'private';
 export type PetFeedbackReassurance = 'making_progress' | 'waiting_safely' | 'completed' | 'work_preserved' | 'details_available';
@@ -205,28 +205,6 @@ export type ClarifyRequestEvent = ChatStreamEnvelope<'clarify_request', {
     default?: string;
     petFeedback: PetFeedback;
 }>;
-export type MemoryConsentRequiredEvent = ChatStreamEnvelope<'memory_consent_required', {
-    requests: Array<{
-        id: string;
-        recordId: string;
-        statement: string;
-        purpose: string;
-    }>;
-}>;
-export type MemoryCapturedEvent = ChatStreamEnvelope<'memory_captured', {
-    records: Array<{
-        id: string;
-        content: string;
-        kind: string;
-    }>;
-}>;
-export type MemoryCandidateEvent = ChatStreamEnvelope<'memory_candidate', {
-    records: Array<{
-        id: string;
-        content: string;
-        kind: string;
-    }>;
-}>;
 export type RunEndEvent = ChatStreamEnvelope<'run_end', {
     status: ChatStreamStatus;
     summary?: string;
@@ -238,4 +216,4 @@ export type StreamErrorEvent = ChatStreamEnvelope<'error', {
     recoverable?: boolean;
     petFeedback: PetFeedback;
 }>;
-export type ChatStreamEvent = RunStartEvent | UserMessageEvent | UserTranscriptEvent | AssistantMessageStartEvent | AssistantDeltaEvent | ThinkingDeltaEvent | ThinkingEndEvent | ToolStartEvent | ToolUpdateEvent | ToolEndEvent | CommandStartedEvent | CommandOutputDeltaEvent | CommandCompletedEvent | PatchAppliedEvent | TurnPlanUpdatedEvent | TaskPlanUpdatedEvent | TurnDiffEvent | TurnOutcomeEvent | ReviewStartEvent | ReviewDeltaEvent | ReviewEndEvent | ReviewEvent | AssistantMessageEndEvent | ProgressEvent | CompactionEvent | TtsAudioEvent | ClarifyRequestEvent | MemoryConsentRequiredEvent | MemoryCapturedEvent | MemoryCandidateEvent | RunEndEvent | StreamErrorEvent;
+export type ChatStreamEvent = RunStartEvent | UserMessageEvent | UserTranscriptEvent | AssistantMessageStartEvent | AssistantDeltaEvent | ThinkingDeltaEvent | ThinkingEndEvent | ToolStartEvent | ToolUpdateEvent | ToolEndEvent | CommandStartedEvent | CommandOutputDeltaEvent | CommandCompletedEvent | PatchAppliedEvent | TurnPlanUpdatedEvent | TaskPlanUpdatedEvent | TurnDiffEvent | TurnOutcomeEvent | ReviewStartEvent | ReviewDeltaEvent | ReviewEndEvent | ReviewEvent | AssistantMessageEndEvent | ProgressEvent | CompactionEvent | TtsAudioEvent | ClarifyRequestEvent | RunEndEvent | StreamErrorEvent;

package/dist/src/gateway/clarify-bridge.d.ts

@@ -4,11 +4,15 @@ export type ClarifyStreamEvent = {
 /** User inactivity window before pending clarification is rejected (web/Telegram, etc.). */
 export declare const CLARIFY_USER_RESPONSE_TIMEOUT_MS: number;
 export interface ClarifyBridgeRequest {
+    kind?: 'approval';
     question: string;
     choices?: string[];
     default?: string;
 }
 export interface StartClarifyRequestOptions {
+    /** null delegates the deadline to the owning ephemeral session. */
+    timeoutMs?: number | null;
+    beforeResponse?: () => boolean;
     sessionKey: string;
     /** Present for in-flight webchat runs. */
     runId?: string;

package/dist/src/gateway/clarify-bridge.js

@@ -23,21 +23,24 @@ var ClarifyBridge = class {
 				const e = this.deletePending(requestId);
 				if (e) e.reject(err instanceof Error ? err : new Error(String(err)));
 			};
-			const timeout = setTimeout(() => {
+			const timeoutMs = opts.timeoutMs === void 0 ? CLARIFY_USER_RESPONSE_TIMEOUT_MS : opts.timeoutMs;
+			const timeout = timeoutMs === null ? void 0 : setTimeout(() => {
 				const entry = this.deletePending(requestId);
-				if (entry) entry.reject(/* @__PURE__ */ new Error("Clarification timeout: user did not respond within 5 minutes"));
-			}, CLARIFY_USER_RESPONSE_TIMEOUT_MS);
+				if (entry) entry.reject(/* @__PURE__ */ new Error(`Clarification timeout: user did not respond within ${timeoutMs / 6e4} minutes`));
+			}, timeoutMs);
 			this.pending.set(requestId, {
 				runId: runId ?? "",
 				sessionKey,
 				choices: hasChoices ? request.choices : void 0,
 				resolve,
 				reject,
-				timeout
+				timeout,
+				beforeResponse: opts.beforeResponse
 			});
 			if (needsFreeText) this.pendingFreeTextBySession.set(sessionKey, requestId);
 			const payload = {
 				type: "clarify_request",
+				kind: request.kind,
 				requestId,
 				question: request.question,
 				choices: request.choices,
@@ -84,6 +87,8 @@ var ClarifyBridge = class {
 		return this.handleResponse(requestId, entry.choices[choiceIndex]);
 	}
 	handleResponse(requestId, answer) {
+		const pending = this.pending.get(requestId);
+		if (!pending || pending.beforeResponse?.() === false) return false;
 		const entry = this.deletePending(requestId);
 		if (!entry) return false;
 		entry.resolve(answer.trim());

package/dist/src/gateway/heartbeat/service.js

@@ -1,9 +1,9 @@
 import { createLogger } from "../../utils/logger/index.js";
 import { init_logger } from "../../utils/logger.js";
 import { shouldSilence, stripHeartbeatToken } from "../../heartbeat/tokens.js";
+import { appendCronEventLines } from "../../heartbeat/event-prompt.js";
 import { isWithinActiveHours } from "../../heartbeat/active-hours.js";
 import { isHeartbeatContentEmpty } from "../../heartbeat/content-check.js";
-import { appendCronEventLines } from "../../heartbeat/event-prompt.js";
 import { createHeartbeatWake } from "../../heartbeat/wake.js";
 import { resolveHeartbeatMdPath } from "../workspace-heartbeat-path.js";
 import { readFile } from "fs/promises";

package/dist/src/gateway/hono/lib/config-payload.d.ts

@@ -218,38 +218,60 @@ export declare function buildSafeWebConfigPayload(service: GatewayService, optio
         preferences: {
             responseLanguage: "en" | "auto" | "zh-CN";
         };
-        dreaming: {
-            mode: "off" | "review";
-            schedule: {
-                time: string;
+        userModel: {
+            enabled: boolean;
+            writePolicy: "allow" | "confirm" | "deny";
+            sensitiveWritePolicy: "allow" | "confirm" | "deny";
+            processingPolicy: "local_only" | "remote_allowed";
+            extraction: {
+                reviewIntervalTurns: number;
+                maxHistoryMessages: number;
+                maxDurationMs: number;
+            };
+            maintenance: {
+                enabled: boolean;
+                temporalSweepMinutes: number;
+                dailyTime: string;
+                weeklyDay: "sun" | "mon" | "tue" | "wed" | "thu" | "fri" | "sat";
+                weeklyTime: string;
+                evidenceThreshold: number;
+                limit: number;
+                staleRetentionDays: number;
+                timezone?: string;
             };
-            minEvidenceSources: number;
-            limit: number;
-            timezone?: string;
         };
-        privacy: {
-            sensitiveWritePolicy: "allow" | "confirm" | "deny";
+        knowledgeMemory: {
+            enabled: boolean;
+            writePolicy: "allow" | "confirm" | "deny";
+            sources: ("project" | "session" | "workspace" | "connector")[];
+            searchStrategy: "local-first" | "external-first" | "fanout" | "local-only" | "external-only";
+            writeStrategy: "local-first" | "external-first" | "local-only" | "external-only" | "write-through";
+            allowExternalWrites: boolean;
+            allowedProviderIds?: string[];
+            autoWriteKinds?: string[];
         };
-        memory: {
-            retention: {
-                compaction: {
-                    enabled: boolean;
-                    triggerThreshold: number;
-                    reserveTokens: number;
-                    minMessagesBeforeCompact: number;
-                    keepRecentTokens: number;
-                    recentTurnsPreserve: number;
-                    summaryMaxTokens: number;
-                    summaryChunkTokens: number;
-                    summaryTimeoutMs: number;
-                    summaryRetries: number;
-                    qualityGuard: boolean;
-                    gapAudit: boolean;
-                    minToolResultKeepChars: number;
-                    maxActiveTranscriptBytes: number;
-                    postCompactionSections: string[];
-                    model?: string;
-                };
+        contextPlanning: {
+            enabled: boolean;
+            maxAssertions: number;
+            maxKnowledge: number;
+            maxChars: number;
+            compaction: {
+                enabled: boolean;
+                triggerThreshold: number;
+                reserveTokens: number;
+                minMessagesBeforeCompact: number;
+                keepRecentTokens: number;
+                recentTurnsPreserve: number;
+                summaryMaxTokens: number;
+                summaryChunkTokens: number;
+                summaryTimeoutMs: number;
+                summaryRetries: number;
+                qualityGuard: boolean;
+                gapAudit: boolean;
+                minToolResultKeepChars: number;
+                maxActiveTranscriptBytes: number;
+                postCompactionSections: string[];
+                model?: string;
             };
         };
     };
@@ -271,7 +293,7 @@ export declare function buildSafeWebConfigPayload(service: GatewayService, optio
     };
     update: {
         checkOnStart: boolean;
-        channel: "beta" | "stable" | "dev";
+        channel: "stable" | "beta" | "dev";
         auto: {
             enabled: boolean;
             stableDelayHours: number;

package/dist/src/gateway/hono/lib/config-payload.js

@@ -1,4 +1,4 @@
-import { ContextCompactionPolicySchema, UserContextDreamingSchema, UserContextPrivacySchema, init_config } from "../../../user-context/config.js";
+import { ContextPlanningConfigSchema, KnowledgeMemoryConfigSchema, UserModelConfigSchema, init_config } from "../../../user-context/config.js";
 import { init_agent_scope, listAgentEntries, normalizeAgentId, resolveDefaultAgentId } from "../../../agent/agent-scope.js";
 import { resolveModelsJsonPath } from "../../../config/paths.js";
 import { buildChannelCatalogForConfig, buildChannelCatalogFromSnapshot, getChannelSetupStatus, init_channel_catalog_service } from "../../../channels/catalog/channel-catalog-service.js";
@@ -176,9 +176,9 @@ async function buildSafeWebConfigPayload(service, options = {}) {
 		session: resolveSessionConfigForWeb(config),
 		userContext: {
 			preferences: config.userContext?.preferences ?? { responseLanguage: "auto" },
-			dreaming: UserContextDreamingSchema.parse(config.userContext?.dreaming),
-			privacy: UserContextPrivacySchema.parse(config.userContext?.privacy),
-			memory: { retention: { compaction: ContextCompactionPolicySchema.parse(config.userContext?.memory.retention?.compaction) } }
+			userModel: UserModelConfigSchema.parse(config.userContext?.userModel),
+			knowledgeMemory: KnowledgeMemoryConfigSchema.parse(config.userContext?.knowledgeMemory),
+			contextPlanning: ContextPlanningConfigSchema.parse(config.userContext?.contextPlanning)
 		},
 		tui: { defaultAgent: config.tui?.defaultAgent ?? "coder" },
 		tunnel: {

package/dist/src/gateway/hono/lib/extension-store.js

@@ -1,33 +1,16 @@
-import { init_write_file_atomic, writeTextAtomic } from "../../../infra/write-file-atomic.js";
-import { homedir } from "node:os";
-import { join } from "node:path";
-import { readFile } from "node:fs/promises";
+import { DurableState } from "../../../storage/sqlite/durable-state.js";
 //#region src/gateway/hono/lib/extension-store.ts
-init_write_file_atomic();
-/** Extension UI: write-through JSON KV per namespace under ~/.xopc/extensions/{namespace}/storage.json */
-const extensionStoreCache = /* @__PURE__ */ new Map();
-function getExtensionStorePath(namespace) {
-	const safeNamespace = namespace.replace(/[^a-zA-Z0-9_-]/g, "_");
-	return join(homedir(), ".xopc", "extensions", safeNamespace, "storage.json");
+const state = new DurableState("extension-ui");
+function validateNamespace(namespace) {
+	if (!namespace.trim()) throw new Error("Extension namespace is required");
 }
 async function loadExtensionStore(namespace) {
-	const cached = extensionStoreCache.get(namespace);
-	if (cached) return cached;
-	const filePath = getExtensionStorePath(namespace);
-	try {
-		const raw = await readFile(filePath, "utf-8");
-		const data = JSON.parse(raw);
-		extensionStoreCache.set(namespace, data);
-		return data;
-	} catch {
-		const empty = {};
-		extensionStoreCache.set(namespace, empty);
-		return empty;
-	}
+	validateNamespace(namespace);
+	return state.get(namespace) ?? {};
 }
 async function saveExtensionStore(namespace, data) {
-	await writeTextAtomic(getExtensionStorePath(namespace), JSON.stringify(data, null, 2));
-	extensionStoreCache.set(namespace, data);
+	validateNamespace(namespace);
+	state.set(namespace, data);
 }
 //#endregion
 export { loadExtensionStore, saveExtensionStore };

package/dist/src/gateway/hono/middleware/auth.js

@@ -39,10 +39,9 @@ function extractTokenFromQuery(url) {
 	return new URL(url).searchParams.get("token");
 }
 const AGENT_AVATAR_GET_PATH = /^\/api\/agents\/[^/]+\/avatar$/;
-const USER_AVATAR_GET_PATH = "/api/you/avatar";
 /** Exported for gateway security tests. */
 function isQueryTokenAllowedPath(path, method) {
-	if (method === "GET" && (AGENT_AVATAR_GET_PATH.test(path) || path === USER_AVATAR_GET_PATH)) return true;
+	if (method === "GET" && AGENT_AVATAR_GET_PATH.test(path)) return true;
 	return false;
 }
 function resolveRemoteAddress(c) {

package/dist/src/gateway/hono/routes/config-patch/misc.d.ts

@@ -2,7 +2,7 @@
  * `PATCH /api/config` — tail sections that are each <50 lines:
  *   update / session / gateway.{skillsMarketplaceProvider,
  *   skillsStoreBaseUrl} / providers / providersConfig / stt / tts / tools /
- *   userContext.memory.retention.compaction / tunnel / bindings / mcp.
+ *   userContext / tunnel / bindings / mcp.
  *
  * Most of these delegate to a `mergeXxxConfigPatch(config, body) → { ok,
  * message? }` helper that lives next to the schema, so this file is mostly

package/dist/src/gateway/hono/routes/config-patch/misc.js

@@ -1,4 +1,4 @@
-import { ContextCompactionPolicySchema, UserContextDreamingSchema, UserContextPrivacySchema, init_config } from "../../../../user-context/config.js";
+import { ContextPlanningConfigSchema, KnowledgeMemoryConfigSchema, UserContextConfigSchema, UserModelConfigSchema, init_config } from "../../../../user-context/config.js";
 import { BindingsConfigSchema, BrowserConfigSchema, McpConfigSchema, VoiceConfigSchema, init_schema } from "../../../../config/schema.js";
 import { CredentialResolver, init_credentials } from "../../../../auth/credentials.js";
 import { canonicalizeConfiguredMcpServer } from "../../../../config/mcp-config-normalize.js";
@@ -28,44 +28,88 @@ async function applyMiscPatch(config, body) {
 	if (body.userContext !== void 0) {
 		if (typeof body.userContext !== "object" || body.userContext === null || Array.isArray(body.userContext)) return patchError("userContext must be an object");
 		const userContextPatch = body.userContext;
-		if (userContextPatch.dreaming !== void 0) {
-			const parsed = UserContextDreamingSchema.safeParse(userContextPatch.dreaming);
+		const unknownKeys = Object.keys(userContextPatch).filter((key) => ![
+			"enabled",
+			"preferences",
+			"userModel",
+			"knowledgeMemory",
+			"contextPlanning"
+		].includes(key));
+		if (unknownKeys.length) return patchError(`Unknown userContext settings: ${unknownKeys.join(", ")}`);
+		if (userContextPatch.enabled !== void 0) {
+			if (typeof userContextPatch.enabled !== "boolean") return patchError("userContext.enabled must be a boolean");
+			config.userContext = {
+				...config.userContext,
+				enabled: userContextPatch.enabled
+			};
+		}
+		if (userContextPatch.preferences !== void 0) {
+			const preferences = userContextPatch.preferences;
+			if (!preferences || typeof preferences !== "object" || Array.isArray(preferences)) return patchError("userContext.preferences must be an object");
+			config.userContext = {
+				...config.userContext,
+				preferences: {
+					...config.userContext.preferences,
+					...preferences
+				}
+			};
+		}
+		if (userContextPatch.userModel !== void 0) {
+			const patch = userContextPatch.userModel;
+			if (typeof patch !== "object" || patch === null || Array.isArray(patch)) return patchError("userContext.userModel must be an object");
+			const raw = patch;
+			const parsed = UserModelConfigSchema.safeParse({
+				...config.userContext.userModel,
+				...raw,
+				...raw.extraction && typeof raw.extraction === "object" ? { extraction: {
+					...config.userContext.userModel.extraction,
+					...raw.extraction
+				} } : {},
+				...raw.maintenance && typeof raw.maintenance === "object" ? { maintenance: {
+					...config.userContext.userModel.maintenance,
+					...raw.maintenance
+				} } : {}
+			});
 			if (!parsed.success) return patchError(parsed.error.issues.map((issue) => issue.message).join("; "));
 			config.userContext = {
 				...config.userContext,
-				dreaming: parsed.data
+				userModel: parsed.data
 			};
 		}
-		if (userContextPatch.privacy !== void 0) {
-			const parsed = UserContextPrivacySchema.safeParse(userContextPatch.privacy);
+		if (userContextPatch.knowledgeMemory !== void 0) {
+			const patch = userContextPatch.knowledgeMemory;
+			if (typeof patch !== "object" || patch === null || Array.isArray(patch)) return patchError("userContext.knowledgeMemory must be an object");
+			const parsed = KnowledgeMemoryConfigSchema.safeParse({
+				...config.userContext.knowledgeMemory,
+				...patch
+			});
 			if (!parsed.success) return patchError(parsed.error.issues.map((issue) => issue.message).join("; "));
 			config.userContext = {
 				...config.userContext,
-				privacy: parsed.data
+				knowledgeMemory: parsed.data
 			};
 		}
-		if (userContextPatch.memory !== void 0) {
-			if (typeof userContextPatch.memory !== "object" || userContextPatch.memory === null || Array.isArray(userContextPatch.memory)) return patchError("userContext.memory must be an object");
-			const memoryPatch = userContextPatch.memory;
-			if (memoryPatch.retention !== void 0) {
-				if (typeof memoryPatch.retention !== "object" || memoryPatch.retention === null || Array.isArray(memoryPatch.retention)) return patchError("userContext.memory.retention must be an object");
-				const retentionPatch = memoryPatch.retention;
-				if (retentionPatch.compaction !== void 0) {
-					const parsed = ContextCompactionPolicySchema.safeParse(retentionPatch.compaction);
-					if (!parsed.success) return patchError(parsed.error.issues.map((issue) => issue.message).join("; "));
-					config.userContext = {
-						...config.userContext,
-						memory: {
-							...config.userContext?.memory,
-							retention: {
-								...config.userContext?.memory?.retention,
-								compaction: parsed.data
-							}
-						}
-					};
-				}
-			}
+		if (userContextPatch.contextPlanning !== void 0) {
+			const patch = userContextPatch.contextPlanning;
+			if (typeof patch !== "object" || patch === null || Array.isArray(patch)) return patchError("userContext.contextPlanning must be an object");
+			const raw = patch;
+			const parsed = ContextPlanningConfigSchema.safeParse({
+				...config.userContext.contextPlanning,
+				...raw,
+				...raw.compaction && typeof raw.compaction === "object" ? { compaction: {
+					...config.userContext.contextPlanning.compaction,
+					...raw.compaction
+				} } : {}
+			});
+			if (!parsed.success) return patchError(parsed.error.issues.map((issue) => issue.message).join("; "));
+			config.userContext = {
+				...config.userContext,
+				contextPlanning: parsed.data
+			};
 		}
+		const parsedUserContext = UserContextConfigSchema.safeParse(config.userContext);
+		if (!parsedUserContext.success) return patchError(parsedUserContext.error.issues.map((issue) => issue.message).join("; "));
+		config.userContext = parsedUserContext.data;
 	}
 	if (body.tui !== void 0) {
 		if (typeof body.tui !== "object" || body.tui === null || Array.isArray(body.tui)) return patchError("tui must be an object");

package/dist/src/gateway/hono/routes/connection-waits.d.ts

@@ -0,0 +1,3 @@
+import type { Hono } from 'hono';
+import type { AuthenticatedRouteDeps } from './deps.js';
+export declare function registerConnectionWaitRoutes(app: Hono, { service, strictRateLimitMiddleware }: AuthenticatedRouteDeps): void;

package/dist/src/gateway/hono/routes/connection-waits.js

@@ -0,0 +1,58 @@
+import { z } from "zod";
+//#region src/gateway/hono/routes/connection-waits.ts
+const actionSchema = z.object({
+	waitId: z.string().min(1),
+	expectedSessionId: z.string().min(1),
+	expectedVersion: z.number().int().positive(),
+	idempotencyKey: z.string().min(1).max(200),
+	action: z.enum([
+		"connect",
+		"check",
+		"continue",
+		"skip",
+		"cancel",
+		"select_account",
+		"confirm_scope",
+		"replace_source"
+	]),
+	candidateRef: z.string().optional(),
+	needKey: z.string().optional(),
+	accountId: z.string().optional()
+}).strict();
+function registerConnectionWaitRoutes(app, { service, strictRateLimitMiddleware }) {
+	app.get("/api/sessions/:sessionKey/connection-wait", (c) => {
+		try {
+			return c.json({
+				ok: true,
+				payload: service.connectionRecovery.snapshot(c.req.param("sessionKey"))
+			});
+		} catch {
+			return c.json({
+				ok: false,
+				error: "Session unavailable"
+			}, 404);
+		}
+	});
+	app.post("/api/sessions/:sessionKey/connection-wait/actions", strictRateLimitMiddleware, async (c) => {
+		const parsed = actionSchema.safeParse(await c.req.json().catch(() => null));
+		if (!parsed.success) return c.json({
+			ok: false,
+			error: "Invalid connection action"
+		}, 400);
+		try {
+			const payload = await service.connectionRecovery.act(c.req.param("sessionKey"), parsed.data);
+			return c.json({
+				ok: true,
+				payload
+			});
+		} catch (error) {
+			const message = error instanceof Error ? error.message : "Connection check failed";
+			return c.json({
+				ok: false,
+				error: message
+			}, ["SESSION_CHANGED", "WAIT_CHANGED"].includes(message) ? 409 : 400);
+		}
+	});
+}
+//#endregion
+export { registerConnectionWaitRoutes };

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

@@ -11,7 +11,6 @@ import { createConnectorSetupSecretRequest, submitConnectorSetupSecret } from ".
 import { configureComposioApiKey, executeComposioTool, getComposioInstallationPolicy, getComposioToolkitAuthState, getComposioToolkitScope, inspectComposioConnectorHealth, listComposioConnections, listComposioTools, refreshComposioConnection, revokeComposioConnection, setComposioToolkitScope, updateComposioConnection, updateComposioInstallationPolicy } from "../../../connectors/composio.js";
 import { listConnectorProviders } from "../../../connectors/providers.js";
 import { getConnectorDefinition, listConnectorCatalog } from "../../../connectors/catalog.js";
-import { listUnderstandingSourceGrants, revokeUnderstandingSourceGrant } from "../../../user-context/sources/repository.js";
 import { recordConnectorHealthUsage } from "../../../connectors/usage.js";
 import { getConnectorInstance, getInstalledConnectorDefinition, listConnectorInstances } from "../../../connectors/instances.js";
 import { installConnector, installConnectorDefinition, uninstallConnector, updateConnectorConfig } from "../../../connectors/install.js";
@@ -23,9 +22,10 @@ import { inspectManagedComposioStatus } from "../../../connectors/composio-manag
 import { appendComposioTriggerEvent, listComposioTriggerEvents } from "../../../connectors/composio-triggers.js";
 import { ingestLocalFolderSource } from "../../../connectors/connected-source-ingestion.js";
 import { previewConnectorDefinition, testConnectorInstance } from "../../../connectors/health.js";
+import { listUnderstandingSourceGrants, revokeUnderstandingSourceGrant } from "../../../user-context/sources/repository.js";
 import { setConnectorEnabled } from "../../../connectors/lifecycle.js";
 import { projectComposioConnectionStatus } from "../../../connectors/runtime-status.js";
-import { applySourceRevocationChoices, sourceRevocationImpact } from "./understanding-sources.js";
+import { markContextSourceAssertionsForReview } from "./context-sources.js";
 //#region src/gateway/hono/routes/connectors.ts
 init_agent_scope();
 function errorMessage(error) {
@@ -196,12 +196,8 @@ function registerConnectorRoutes(authenticated, deps) {
 			service.setConnectorLearningPaused(connectionId, true);
 			const grant = listUnderstandingSourceGrants().find((item) => item.sourceKey === `connector-account:${account.id}`);
 			if (grant) {
-				const impact = sourceRevocationImpact(grant.id);
+				markContextSourceAssertionsForReview(grant.id);
 				revokeUnderstandingSourceGrant(grant.id);
-				if (impact) applySourceRevocationChoices(impact, {
-					derived: "retain",
-					raw: "retain"
-				});
 			}
 		} else if (connectionId && previous?.scanEnabled === false) {
 			if (service.setConnectorLearningPaused(connectionId, false) === 0) service.requestConnectorLearning(connectionId, {
@@ -295,12 +291,8 @@ function registerConnectorRoutes(authenticated, deps) {
 			if (connection?.accountId) {
 				const grant = listUnderstandingSourceGrants().find((item) => item.sourceKey === `connector-account:${connection.accountId}`);
 				if (grant) {
-					const impact = sourceRevocationImpact(grant.id);
+					markContextSourceAssertionsForReview(grant.id);
 					revokeUnderstandingSourceGrant(grant.id);
-					if (impact) applySourceRevocationChoices(impact, {
-						derived: "retain",
-						raw: "retain"
-					});
 				}
 			}
 			return c.json({

package/dist/src/gateway/hono/routes/context-sources.d.ts

@@ -0,0 +1,4 @@
+import type { Hono } from 'hono';
+import type { AuthenticatedRouteDeps } from './deps.js';
+export declare function markContextSourceAssertionsForReview(grantId: string): number;
+export declare function registerContextSourceRoutes(authenticated: Hono, deps: AuthenticatedRouteDeps): void;