@xopcai/xopc 0.0.325 → 0.0.330

package/dist/src/config/schema.js

@@ -1,9 +1,9 @@
 import { __esmMin } from "../../_virtual/_rolldown/runtime.js";
+import { ComputerConfigSchema, init_config } from "../computer/config.js";
 import { AgentModelsOverrideSchema, ImageGenerationRouteSchema, ModelRouteSchema } from "../agent-config/schema.js";
 import { resolveEffectiveAgentConfig } from "../agent-config/resolver.js";
 import { init_agent_config } from "../agent-config/index.js";
 import { AgentCatalogRepository, init_repository } from "../agent-catalog/repository.js";
-import { ComputerConfigSchema, init_config } from "../computer/config.js";
 import { DEFAULT_CONTEXT_COMPACTION_POLICY, UserContextConfigSchema, init_config as init_config$1 } from "../user-context/config.js";
 import { init_public_url, validatePublicUrl } from "./public-url.js";
 import { PlatformConfigSchema, init_contracts } from "../platform/contracts.js";
@@ -685,7 +685,7 @@ enabled: z.boolean().default(false) }).default({ enabled: false });
 	}).catchall(SttProviderConfigCatchallSchema);
 	STTFallbackConfigSchema = z.object({
 		enabled: z.boolean().default(false),
-		order: z.array(z.string().min(1)).default(["xopc-local"])
+		order: z.array(z.string().min(1)).default([])
 	});
 	MediaUnderstandingCapabilitiesSchema = z.array(z.enum([
 		"image",
@@ -705,12 +705,12 @@ enabled: z.boolean().default(false) }).default({ enabled: false });
 		prompt: z.string().optional()
 	}).catchall(SttProviderConfigCatchallSchema);
 	STTConfigSchema = z.object({
-		enabled: z.boolean().default(true),
+		enabled: z.boolean().default(false),
 		/** Primary provider id — any registered MediaUnderstandingProvider id. */
-		provider: z.string().min(1).default("xopc-local"),
+		provider: z.string().min(1).default("openai"),
 		fallback: STTFallbackConfigSchema.default({
 			enabled: false,
-			order: ["xopc-local"]
+			order: []
 		}),
 		timeoutMs: z.number().int().min(1e3).max(18e4).optional(),
 		/** Ordered model entries for this capability (OpenClaw `tools.media.audio.models`). */

package/dist/src/connectors/china-catalog.js

@@ -52,7 +52,7 @@ const CHINA_CONNECTORS = [
 	{
 		id: "wecom-workspace",
 		version: "1.3.0",
-		displayName: "企业微信办公",
+		displayName: "企业微信",
 		description: "扫码连接企业微信，搜索和读取文档、查询联系人和待办，并按权限创建待办。",
 		category: "docs",
 		kind: "cli",
@@ -67,6 +67,10 @@ const CHINA_CONNECTORS = [
 			"联系人",
 			"待办"
 		],
+		branding: {
+			logoUrl: "/connector-icons/wecom.svg",
+			source: "builtin"
+		},
 		verificationLevel: "beta",
 		auth: { mode: "cli" },
 		setup: {},

package/dist/src/connectors/connected-source-ingestion.js

@@ -71,6 +71,7 @@ function personEntities(record) {
 		"username",
 		"owner",
 		"owners",
+		"organizer",
 		"assignee",
 		"attendees",
 		"participants"
@@ -97,7 +98,11 @@ function connectionIdentities(identity) {
 	return [...new Set(Object.values(identity).filter((value) => typeof value === "string").map((value) => value.trim().toLowerCase()).filter(Boolean))];
 }
 function hasOwnerAttribution(toolkit, people, ownerIdentities) {
-	const attributableRoles = toolkit === "gmail" ? new Set(["sender", "from"]) : toolkit === "googlecalendar" ? new Set(["organizer"]) : new Set([
+	const attributableRoles = toolkit === "gmail" ? new Set(["sender", "from"]) : toolkit === "googlecalendar" ? new Set(["organizer", "attendees"]) : toolkit === "linear" ? new Set([
+		"author",
+		"user",
+		"assignee"
+	]) : new Set([
 		"author",
 		"user",
 		"username",

package/dist/src/connectors/connected-source-observations.d.ts

@@ -0,0 +1,10 @@
+import type { KnowledgeSourceItem } from '../knowledge/types.js';
+import { type UserModelObservation } from '../user-model/index.js';
+import type { UnderstandingConsentReceipt } from '../user-context/sources/types.js';
+/** Stores content-free, owner-attributed observations before optional model analysis. */
+export declare function recordConnectedSourceObservations(input: {
+    items: KnowledgeSourceItem[];
+    consent?: UnderstandingConsentReceipt;
+    sourceGrantId?: string;
+    nowMs?: number;
+}): UserModelObservation[];

package/dist/src/connectors/connected-source-observations.js

@@ -0,0 +1,80 @@
+import { recordUserModelObservation } from "../user-model/observation-repository.js";
+import "../user-model/index.js";
+//#region src/connectors/connected-source-observations.ts
+const DAY_MS = 864e5;
+function timestamp(value) {
+	if (!value) return void 0;
+	const parsed = Date.parse(value);
+	return Number.isFinite(parsed) ? parsed : void 0;
+}
+function observationShape(toolkit, item) {
+	const occurredAt = timestamp(item.occurredAt) ?? timestamp(item.sourceUpdatedAt);
+	const common = {
+		itemType: item.itemType,
+		...occurredAt === void 0 ? {} : { occurredAt }
+	};
+	if (toolkit === "gmail") return {
+		domain: "behavior",
+		type: "sent_message_activity",
+		value: common
+	};
+	if (toolkit === "googlecalendar") return {
+		domain: "goals",
+		type: "calendar_commitment",
+		value: common
+	};
+	if (toolkit === "github") return {
+		domain: "capabilities",
+		type: "authored_code_activity",
+		value: common
+	};
+	if (toolkit === "linear") return {
+		domain: "goals",
+		type: "assigned_work_activity",
+		value: common
+	};
+	if (toolkit === "googledrive") return {
+		domain: "digital_life",
+		type: "document_activity",
+		value: common
+	};
+}
+/** Stores content-free, owner-attributed observations before optional model analysis. */
+function recordConnectedSourceObservations(input) {
+	if (!input.consent || !input.sourceGrantId) return [];
+	const now = input.nowMs ?? Date.now();
+	return input.items.flatMap((item) => {
+		if (item.metadata.actorAttributed !== true) return [];
+		const toolkit = typeof item.metadata.toolkit === "string" ? item.metadata.toolkit : "";
+		const shape = observationShape(toolkit, item);
+		if (!shape || !input.consent.allowedDomains.includes(shape.domain) || input.consent.deniedDomains.includes(shape.domain)) return [];
+		const observedAt = timestamp(item.occurredAt) ?? timestamp(item.sourceUpdatedAt) ?? now;
+		const value = {
+			...input.consent.allowedFields.includes("status") ? { itemType: shape.value.itemType } : {},
+			...input.consent.allowedFields.includes("timestamps") && shape.value.occurredAt !== void 0 ? { occurredAt: shape.value.occurredAt } : {}
+		};
+		if (!Object.keys(value).length) return [];
+		return [recordUserModelObservation({
+			domain: shape.domain,
+			type: shape.type,
+			subject: {
+				type: "user",
+				id: "self"
+			},
+			value,
+			context: {
+				toolkit,
+				collectionScope: item.collectionScope
+			},
+			sensitivityCategories: [],
+			ownerAttribution: "user",
+			observedAt,
+			deleteAfter: Math.max(now, observedAt) + input.consent.rawRetentionDays * DAY_MS,
+			sourceGrantId: input.sourceGrantId,
+			sourceItemId: item.id,
+			contentHash: `connected:${item.sourceInstanceId}:${item.contentHash}:${shape.type}`
+		})];
+	});
+}
+//#endregion
+export { recordConnectedSourceObservations };

package/dist/src/connectors/connected-source-understanding.js

@@ -9,6 +9,9 @@ import "../knowledge-memory/index.js";
 import { reconcileAssertion } from "../user-model/repository.js";
 import "../user-model/index.js";
 import { claimRegisteredExtraction } from "../user-context/extraction/registry.js";
+import { recordConnectedSourceObservations } from "./connected-source-observations.js";
+import { getActiveUnderstandingConsent } from "../user-context/sources/consent-repository.js";
+import { getUnderstandingSourceRun } from "../user-context/sources/repository.js";
 import { allowsRemoteSourceProcessing } from "../user-context/sources/processing-policy.js";
 import { analyzeUnderstandingSources } from "../work-discovery/analyzer.js";
 import { createHash } from "node:crypto";
@@ -45,6 +48,90 @@ function timestamp(value) {
 	const parsed = Date.parse(value);
 	return Number.isFinite(parsed) ? parsed : void 0;
 }
+const CONSENT_FIELD_KEYS = {
+	title: new Set([
+		"title",
+		"subject",
+		"name",
+		"fullName",
+		"repository"
+	]),
+	content: new Set([
+		"content",
+		"body",
+		"text",
+		"snippet",
+		"description",
+		"summary"
+	]),
+	participants: new Set([
+		"from",
+		"to",
+		"cc",
+		"bcc",
+		"sender",
+		"author",
+		"organizer",
+		"attendees",
+		"participants",
+		"assignee",
+		"owners"
+	]),
+	status: new Set([
+		"status",
+		"state",
+		"labels"
+	]),
+	timestamps: new Set([
+		"createdAt",
+		"updatedAt",
+		"modifiedAt",
+		"start",
+		"end",
+		"created_at",
+		"updated_at",
+		"modified_at"
+	]),
+	owner_activity: new Set([
+		"user",
+		"username",
+		"owner"
+	])
+};
+function consentFilteredText(textValue, allowedFields) {
+	if (!textValue) return void 0;
+	try {
+		const parsed = JSON.parse(textValue);
+		if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return void 0;
+		const allowedKeys = new Set([...allowedFields].flatMap((field) => [...CONSENT_FIELD_KEYS[field] ?? []]));
+		const filtered = Object.fromEntries(Object.entries(parsed).filter(([key]) => allowedKeys.has(key)));
+		return Object.keys(filtered).length ? JSON.stringify(filtered) : void 0;
+	} catch {
+		return allowedFields.has("content") ? textValue.slice(0, 24e3) : void 0;
+	}
+}
+function itemsAllowedByConsent(items, consent) {
+	if (!consent) return [];
+	const allowed = new Set(consent.allowedFields);
+	return items.map((item) => {
+		const filteredText = consentFilteredText(item.text, allowed);
+		return {
+			id: item.id,
+			sourceId: item.sourceId,
+			type: item.type,
+			title: allowed.has("title") ? item.title : item.type,
+			...filteredText ? { text: filteredText } : {},
+			...allowed.has("owner_activity") ? { ownerAttribution: item.ownerAttribution } : { ownerAttribution: "unknown" },
+			...allowed.has("timestamps") && item.occurredAt !== void 0 ? { occurredAt: item.occurredAt } : {},
+			...allowed.has("timestamps") && item.modifiedAt !== void 0 ? { modifiedAt: item.modifiedAt } : {},
+			...allowed.has("timestamps") && item.startsAt !== void 0 ? { startsAt: item.startsAt } : {},
+			...allowed.has("timestamps") && item.endsAt !== void 0 ? { endsAt: item.endsAt } : {},
+			...allowed.has("status") && item.group ? { group: item.group } : {},
+			evidenceRef: item.evidenceRef,
+			sensitivity: item.sensitivity
+		};
+	});
+}
 function connectedItemsForUnderstanding(items) {
 	return [...items].sort((left, right) => Number(right.itemType === "connected_content") - Number(left.itemType === "connected_content")).slice(0, MAX_CONNECTED_ITEMS).flatMap((item) => {
 		const value = normalizedValue(item);
@@ -67,7 +154,7 @@ function connectedItemsForUnderstanding(items) {
 	});
 }
 function isPortraitCandidate(candidate) {
-	return candidate.category === "preference" || candidate.category === "routine" || candidate.category === "communication";
+	return candidate.category === "role" || candidate.category === "responsibility" || candidate.category === "capability" || candidate.category === "preference" || candidate.category === "routine" || candidate.category === "communication";
 }
 function durableEvidence(candidate, items) {
 	const evidence = [...new Set(candidate.evidenceRefs ?? [])].flatMap((ref) => items.get(ref) ?? []);
@@ -75,6 +162,23 @@ function durableEvidence(candidate, items) {
 	const dates = new Set(evidence.map((item) => item.occurredAt ?? item.modifiedAt).filter((value) => value !== void 0).map((value) => new Date(value).toISOString().slice(0, 10)));
 	return candidate.confidence === "high" && evidence.every((item) => item.ownerAttribution === "user") && evidence.length >= required && dates.size >= required ? evidence : [];
 }
+function candidatePolicy(candidate) {
+	const statement = candidate.statement.toLocaleLowerCase();
+	const sensitivityCategories = [
+		["health", /\b(health|medical|diagnos|medication|therapy|disability)\b|健康|疾病|诊断|用药|治疗|残疾/i],
+		["financial", /\b(salary|income|debt|bank|account balance|credit card)\b|工资|收入|债务|银行|余额|信用卡/i],
+		["political", /\b(political|party|election|vote[dr]?)\b|政治|政党|选举|投票/i],
+		["religious", /\b(religio|church|mosque|temple|faith)\b|宗教|教会|清真寺|寺庙|信仰/i],
+		["sexuality", /\b(sexual|orientation|gender identity)\b|性取向|性别认同/i],
+		["trauma", /\b(trauma|abuse|assault)\b|创伤|虐待|侵害/i],
+		["credential", /\b(password|secret key|api key|token)\b|密码|密钥|令牌/i]
+	].filter(([, pattern]) => pattern.test(statement)).map(([name]) => name);
+	return {
+		domain: candidate.category === "role" ? "identity" : candidate.category === "responsibility" ? "goals" : candidate.category === "capability" ? "capabilities" : candidate.category === "routine" ? "behavior" : "preferences",
+		sensitivity: sensitivityCategories.length ? sensitivityCategories.includes("health") || sensitivityCategories.includes("financial") ? "regulated" : "personal" : "normal",
+		sensitivityCategories
+	};
+}
 async function deriveConnectedSourceUnderstanding(input) {
 	const sourceItems = [...new Set(input.sourceItemIds)].slice(0, MAX_CONNECTED_ITEMS).flatMap((itemId) => getKnowledgeSourceItem(itemId) ?? []).filter((item) => item.sourceInstanceId === input.sourceInstanceId && item.metadata.agentId === input.agentId && !item.deletedAt);
 	const items = connectedItemsForUnderstanding(sourceItems);
@@ -91,14 +195,23 @@ async function deriveConnectedSourceUnderstanding(input) {
 			status: "completed"
 		};
 	}
+	const sourceRun = getUnderstandingSourceRun(input.sourceRunId);
+	const consentReceipt = sourceRun ? getActiveUnderstandingConsent(sourceRun.grantId) ?? void 0 : void 0;
+	const modelItems = itemsAllowedByConsent(items, consentReceipt);
+	recordConnectedSourceObservations({
+		items: sourceItems,
+		consent: consentReceipt,
+		sourceGrantId: sourceRun?.grantId
+	});
+	const effectiveProcessingPolicy = input.processingPolicy === "remote_allowed" && consentReceipt?.processingPolicy === "remote_allowed" ? "remote_allowed" : "local_only";
 	const extraction = claimRegisteredExtraction({
 		extractorId: "connector-semantic",
 		sourceRef: `understanding-source-run:${input.sourceRunId}`,
 		contentForHash: sourceItems.map((item) => `${item.id}:${item.contentHash}`).join("\n"),
-		processingPolicy: input.processingPolicy,
+		processingPolicy: effectiveProcessingPolicy,
 		destination: "remote_model"
 	});
-	if (!allowsRemoteSourceProcessing([input.processingPolicy]) || !extraction.shouldExecute) return {
+	if (!allowsRemoteSourceProcessing([effectiveProcessingPolicy]) || !extraction.shouldExecute) return {
 		created: 0,
 		knowledgeCount: 0,
 		status: "completed"
@@ -106,16 +219,17 @@ async function deriveConnectedSourceUnderstanding(input) {
 	try {
 		const analysis = await (input.analyze ?? analyzeUnderstandingSources)({
 			config: input.config,
-			items
+			items: modelItems
 		});
 		input.assertAuthorized?.();
-		const byRef = new Map(items.map((item) => [item.evidenceRef, item]));
+		const byRef = new Map(modelItems.map((item) => [item.evidenceRef, item]));
 		const outputs = [];
 		let created = 0;
 		for (const candidate of analysis.profileCandidates.filter(isPortraitCandidate)) {
+			const policy = candidatePolicy(candidate);
 			const evidenceItems = durableEvidence(candidate, byRef);
 			const candidateKey = `connected-profile:${candidate.category}:${candidate.factKey}`;
-			if (!evidenceItems.length) {
+			if (!evidenceItems.length || !consentReceipt || !consentReceipt.allowedDomains.includes(policy.domain) || consentReceipt.deniedDomains.includes(policy.domain)) {
 				outputs.push({
 					candidateKey,
 					outcome: "rejected"
@@ -141,7 +255,7 @@ async function deriveConnectedSourceUnderstanding(input) {
 					predicate: `${candidate.category}.connected.${candidate.factKey}`,
 					cardinality: "single",
 					scope: { type: "global" },
-					kind: candidate.category === "communication" ? "preference" : candidate.category,
+					kind: candidate.category === "role" ? "identity" : candidate.category === "responsibility" ? "derived_insight" : candidate.category === "communication" ? "preference" : candidate.category,
 					value: candidate.statement,
 					normalizedValue: candidate.statement.toLocaleLowerCase(),
 					statement: candidate.statement,
@@ -151,7 +265,18 @@ async function deriveConnectedSourceUnderstanding(input) {
 					consequence: "medium",
 					actionability: .6,
 					volatility: candidate.category === "routine" || candidate.category === "communication" ? "slow" : "stable",
-					sensitivity: "normal",
+					sensitivity: policy.sensitivity,
+					domain: policy.domain,
+					layer: "pattern",
+					sensitivityCategories: policy.sensitivityCategories,
+					purposeIds: ["personalization", "work_assistance"],
+					allowedUses: [
+						"answer",
+						"rank",
+						"recommend"
+					],
+					allowedAgentIds: consentReceipt.allowedAgentIds,
+					consentReceiptId: consentReceipt.id,
 					disclosurePolicy: "referenceable",
 					observedAt: evidenceItem.occurredAt ?? evidenceItem.modifiedAt ?? Date.now(),
 					createdBy: "connector",
@@ -182,6 +307,71 @@ async function deriveConnectedSourceUnderstanding(input) {
 				});
 				continue;
 			}
+			const goalEvidence = evidenceRefs.flatMap((ref) => {
+				const item = byRef.get(ref);
+				return item?.ownerAttribution === "user" ? [item] : [];
+			});
+			if (consentReceipt?.allowedDomains.includes("goals") && !consentReceipt.deniedDomains.includes("goals") && thread.confidence !== "low" && goalEvidence.length) {
+				const observedAt = Math.max(...goalEvidence.map((item) => item.occurredAt ?? item.modifiedAt ?? Date.now()));
+				const validityDays = thread.horizon === "current" ? 30 : thread.horizon === "ongoing" ? 90 : 365;
+				let goalCreated = false;
+				for (const evidenceItem of goalEvidence) {
+					const evidence = createContextEvidence({
+						sourceType: "connector",
+						sourceInstanceId: input.sourceInstanceId,
+						sourceRef: evidenceItem.evidenceRef,
+						redactedExcerpt: evidenceItem.title.slice(0, 600),
+						trustLevel: "owner",
+						observedAt: evidenceItem.occurredAt ?? evidenceItem.modifiedAt ?? observedAt
+					});
+					const result = reconcileAssertion({
+						subject: {
+							type: "goal",
+							id: thread.topicKey
+						},
+						predicate: "goal.connected.current_state",
+						cardinality: "single",
+						scope: { type: "global" },
+						kind: "current_state",
+						value: {
+							title: thread.title,
+							summary: thread.summary,
+							status: thread.status
+						},
+						normalizedValue: `${thread.status}:${thread.title}:${thread.summary}`.toLocaleLowerCase(),
+						statement: `${thread.title}: ${thread.summary}`,
+						authority: "user_observed",
+						confidence: thread.confidence === "high" ? .9 : .72,
+						inferredImportance: thread.horizon === "current" ? .8 : .65,
+						consequence: "medium",
+						actionability: .85,
+						volatility: "event",
+						sensitivity: "normal",
+						domain: "goals",
+						layer: "fact",
+						sensitivityCategories: [],
+						purposeIds: ["personalization", "work_assistance"],
+						allowedUses: [
+							"answer",
+							"rank",
+							"recommend",
+							"remind"
+						],
+						allowedAgentIds: consentReceipt.allowedAgentIds,
+						consentReceiptId: consentReceipt.id,
+						disclosurePolicy: "referenceable",
+						observedAt,
+						validFrom: observedAt,
+						validTo: observedAt + validityDays * 864e5,
+						reviewAt: observedAt + Math.min(validityDays, 14) * 864e5,
+						createdBy: "connector",
+						evidenceId: evidence.id,
+						evidenceConfidence: thread.confidence === "high" ? .9 : .72
+					});
+					goalCreated ||= result.action === "created" || result.action === "superseded";
+				}
+				if (goalCreated) created += 1;
+			}
 			const result = writeKnowledgeItem({
 				kind: "work_thread",
 				scope: { type: "global" },

package/dist/src/connectors/learning-coordinator.js

@@ -3,19 +3,18 @@ import { init_logger } from "../utils/logger.js";
 import { claimNextConnectorLearningJob, enqueueConnectorLearningJob, listConnectorLearningJobs, recoverStaleConnectorLearningJobs, setConnectorLearningPaused, updateConnectorLearningJob } from "../storage/sqlite/connector-learning-repository.js";
 import { getConnectorAccount, reconcileConnectorAccount } from "../storage/sqlite/connector-account-repository.js";
 import { getConnectorInstallation, listConnectorConnections, upsertConnectorConnection } from "../storage/sqlite/connector-repository.js";
+import { pruneBoundedKnowledgeSourceItems } from "../storage/sqlite/knowledge-repository.js";
 import { getConnectorSyncPolicyForConnection } from "../storage/sqlite/connector-sync-policy-repository.js";
 import { init_sqlite } from "../storage/sqlite/index.js";
 import { connectorIdentityKey, normalizeConnectorIdentity } from "./connector-identity.js";
 import { ComposioSessionsAdapter } from "./composio-sessions.js";
 import { buildConnectorLearningArguments, getConnectorLearningPlan } from "./learning-recipes.js";
 import { getConnectorDefinition } from "./catalog.js";
-import { getWorkspacePath } from "../config/workspace-path-helpers.js";
-import { ConnectedKnowledgePipeline } from "../knowledge/connected-knowledge-pipeline.js";
-import "../knowledge/index.js";
 import { ingestComposioConnectedSource } from "./connected-source-ingestion.js";
+import { getActiveUnderstandingConsent, grantUnderstandingConsent } from "../user-context/sources/consent-repository.js";
+import { getConnectorUnderstandingSourceRun, getOrCreateConnectorUnderstandingSourceRun, getUnderstandingSourceGrant, listUnderstandingSourceGrants, updateUnderstandingSourceGrantCheckpoint, updateUnderstandingSourceRun, upsertUnderstandingSourceGrant } from "../user-context/sources/repository.js";
 import { deriveConnectedSourceUnderstanding } from "./connected-source-understanding.js";
 import { listConnectedContentCandidates, readConnectedContent } from "./content-enrichment.js";
-import { getConnectorUnderstandingSourceRun, getOrCreateConnectorUnderstandingSourceRun, getUnderstandingSourceGrant, listUnderstandingSourceGrants, updateUnderstandingSourceGrantCheckpoint, updateUnderstandingSourceRun, upsertUnderstandingSourceGrant } from "../user-context/sources/repository.js";
 //#region src/connectors/learning-coordinator.ts
 init_sqlite();
 init_logger();
@@ -33,25 +32,60 @@ function connectorSourceCategory(toolkit) {
 	if (toolkit === "github" || toolkit === "linear") return "code_activity";
 	return "files";
 }
-function ensureUnderstandingSourceRun(job, toolkit, displayName) {
+function ensureUnderstandingSourceRun(job, toolkit, displayName, config) {
 	const existing = listUnderstandingSourceGrants({ includeRevoked: true }).find((grant) => grant.sourceKey === `connector-account:${job.accountId}`);
 	if (existing?.status === "revoked") throw new Error("Source authorization was revoked.");
+	const grant = existing ?? upsertUnderstandingSourceGrant({
+		sourceKey: `connector-account:${job.accountId}`,
+		adapterId: `connector:${job.connectorId}`,
+		category: connectorSourceCategory(toolkit),
+		platform: "all",
+		displayName,
+		accessMode: "continuous",
+		retentionPolicy: config.userContext.userModel.processingPolicy === "remote_allowed" ? "derived_only" : "bounded_raw",
+		processingPolicy: config.userContext.userModel.processingPolicy,
+		config: {
+			connectorId: job.connectorId,
+			accountId: job.accountId,
+			readOnly: true
+		}
+	});
+	if (!getActiveUnderstandingConsent(grant.id)) grantUnderstandingConsent({
+		grantId: grant.id,
+		purposes: ["personalization", "work_assistance"],
+		allowedDomains: [
+			"identity",
+			"goals",
+			"capabilities",
+			"behavior",
+			"preferences",
+			"relationships",
+			"environment",
+			"digital_life"
+		],
+		deniedDomains: [
+			"health",
+			"emotion",
+			"life_history",
+			"resources_constraints"
+		],
+		allowedFields: [
+			"title",
+			"content",
+			"timestamps",
+			"participants",
+			"owner_activity",
+			"status"
+		],
+		accessMode: grant.accessMode,
+		lookbackDays: getConnectorLearningPlan(toolkit)?.bootstrapWindowDays ?? 30,
+		rawRetentionDays: grant.retentionPolicy === "bounded_raw" ? 7 : 0,
+		processingPolicy: grant.processingPolicy,
+		allowedAgentIds: [job.agentId],
+		disclosureVersion: "connector-understanding-v1"
+	});
 	return getOrCreateConnectorUnderstandingSourceRun({
-		grantId: (existing ?? upsertUnderstandingSourceGrant({
-			sourceKey: `connector-account:${job.accountId}`,
-			adapterId: `connector:${job.connectorId}`,
-			category: connectorSourceCategory(toolkit),
-			platform: "all",
-			displayName,
-			accessMode: "continuous",
-			retentionPolicy: "bounded_raw",
-			processingPolicy: "remote_allowed",
-			config: {
-				connectorId: job.connectorId,
-				accountId: job.accountId,
-				readOnly: true
-			}
-		})).id,
+		grantId: grant.id,
 		connectorLearningJobId: job.id,
 		kind: job.mode,
 		status: "queued",
@@ -105,7 +139,7 @@ function startConnectorLearningCoordinator(options) {
 			idempotencyKey: request.idempotencyKey ?? (mode === "bootstrap" ? `bootstrap:${connection.accountId}:v1` : `incremental:${connection.accountId}:${request.reason ?? "manual"}:${bucket}`),
 			nextRunAt: request.nextRunAt
 		});
-		ensureUnderstandingSourceRun(job, definition.runtime.toolkit, definition.displayName);
+		ensureUnderstandingSourceRun(job, definition.runtime.toolkit, definition.displayName, options.getConfig());
 		publish(job);
 		queueMicrotask(() => void runNow());
 		return job;
@@ -123,7 +157,7 @@ function startConnectorLearningCoordinator(options) {
 		if (definition?.runtime.type !== "composio" || definition.runtime.role !== "toolkit") throw new Error(`Connector learning is unavailable for ${job.connectorId}.`);
 		const plan = getConnectorLearningPlan(definition.runtime.toolkit);
 		if (!plan) throw new Error(`Connector learning has no plan for ${definition.runtime.toolkit}.`);
-		const sourceRun = ensureUnderstandingSourceRun(job, plan.toolkit, definition.displayName);
+		const sourceRun = ensureUnderstandingSourceRun(job, plan.toolkit, definition.displayName, options.getConfig());
 		updateUnderstandingSourceRun(sourceRun.id, { status: "running" });
 		let connection = listConnectorConnections().find((candidate) => candidate.id === job.connectionId);
 		if (!connection) throw new Error("Connector account no longer exists.");
@@ -286,10 +320,13 @@ function startConnectorLearningCoordinator(options) {
 			lastCollectedAt: Date.now()
 		});
 		publish(completed);
-		const retention = new ConnectedKnowledgePipeline({
-			agentId: job.agentId,
-			workspaceId: getWorkspacePath(options.getConfig())
-		}).pruneBoundedRetention(job.sourceInstanceId, Date.now() - plan.bootstrapWindowDays * 24 * 60 * 6e4);
+		const sourceGrant = getUnderstandingSourceGrant(sourceRun.grantId);
+		const activeConsent = getActiveUnderstandingConsent(sourceRun.grantId);
+		const rawRetentionDays = sourceGrant?.retentionPolicy === "bounded_raw" ? activeConsent?.rawRetentionDays ?? 7 : 0;
+		const retention = {
+			rawDeleted: pruneBoundedKnowledgeSourceItems(job.sourceInstanceId, rawRetentionDays === 0 ? Date.now() + 1 : Date.now() - rawRetentionDays * 864e5),
+			derivedDeleted: 0
+		};
 		if (retention.rawDeleted || retention.derivedDeleted) log.info({
 			jobId: job.id,
 			sourceInstanceId: job.sourceInstanceId,

package/dist/src/connectors/learning-recipes.js

@@ -12,9 +12,16 @@ function buildConnectorLearningArguments(plan, stream, input, identity) {
 	}
 	if (plan.toolkit === "gmail") {
 		const after = cursor?.checkpoint ? Math.floor(Date.parse(cursor.checkpoint) / 1e3) : NaN;
+		const baseQuery = typeof stream.arguments.query === "string" ? stream.arguments.query.trim() : "";
+		const incrementalQuery = Number.isFinite(after) ? `after:${after}` : "";
 		return {
 			...stream.arguments,
-			...Number.isFinite(after) ? { query: `after:${after} -in:spam -in:trash` } : {},
+			...baseQuery || incrementalQuery ? { query: [
+				baseQuery,
+				incrementalQuery,
+				"-in:spam",
+				"-in:trash"
+			].filter(Boolean).join(" ") } : {},
 			...cursor?.pageToken ? { page_token: cursor.pageToken } : {}
 		};
 	}
@@ -39,6 +46,16 @@ const PLANS = {
 		toolkit: "gmail",
 		identityProbe: { actionId: "GMAIL_GET_PROFILE" },
 		streams: [{
+			scope: "sent-messages",
+			actionId: "GMAIL_FETCH_EMAILS",
+			kind: "activity",
+			arguments: {
+				max_results: 30,
+				include_payload: true,
+				verbose: false,
+				query: "in:sent newer_than:30d"
+			}
+		}, {
 			scope: "messages",
 			actionId: "GMAIL_FETCH_EMAILS",
 			kind: "activity",
@@ -46,7 +63,7 @@ const PLANS = {
 				max_results: 30,
 				include_payload: true,
 				verbose: false,
-				query: "newer_than:30d -in:spam -in:trash"
+				query: "newer_than:30d -in:sent"
 			}
 		}],
 		bootstrapWindowDays: 30,

package/dist/src/discussions/audio-repair.d.ts

@@ -1,4 +1,4 @@
-import type { DecodedPcmAudio } from '../voice/local/wav.js';
+import type { DecodedPcmAudio } from '../voice/audio/wav.js';
 export interface AudioRange {
     startedAtMs: number;
     endedAtMs: number;

package/dist/src/discussions/live-worker.js

@@ -51,9 +51,7 @@ var DiscussionLiveWorker = class {
 	}
 	resolveConcurrency() {
 		if (this.deps.transcribeSegment) return this.concurrency;
-		const config = this.deps.getConfig();
-		const sttConfig = mergeSttConfigFromAppConfig(config.tools?.media?.audio, config.tools?.media);
-		return sttConfig.provider === "xopc-local" || sttConfig.provider === "local" ? 1 : this.concurrency;
+		return this.concurrency;
 	}
 	async processOne() {
 		const segment = claimNextDiscussionTranscriptSegment(this.owner);

package/dist/src/discussions/recording.js

@@ -1,11 +1,11 @@
 import { getSqliteDatabase, init_transaction, runSqliteWriteTransaction } from "../storage/sqlite/transaction.js";
 import { DISCUSSION_MAX_DURATION_MS } from "../../packages/gateway-contract/src/discussions.js";
 import { init_src } from "../../packages/gateway-contract/src/index.js";
-import { decodeWavToMonoFloat32 } from "../voice/local/wav.js";
-import { forEachNormalizedAudioSegment } from "../voice/audio/normalize.js";
 import { resolveNoteMediaDir } from "../notes/paths.js";
 import { DiscussionServiceError } from "./errors.js";
 import { getDiscussionCapture, updateDiscussionCapture } from "./repository.js";
+import { decodeWavToMonoFloat32 } from "../voice/audio/wav.js";
+import { forEachNormalizedAudioSegment } from "../voice/audio/normalize.js";
 import { join } from "node:path";
 import { createReadStream } from "node:fs";
 import { createHash, randomUUID } from "node:crypto";