@xopcai/xopc 0.0.248 → 0.0.249

package/dist/src/config/schema.d.ts

@@ -1322,8 +1322,8 @@ export declare const UpdateAutoConfigSchema: z.ZodOptional<z.ZodObject<{
 export declare const UpdateConfigSchema: z.ZodOptional<z.ZodObject<{
     checkOnStart: z.ZodDefault<z.ZodBoolean>;
     channel: z.ZodDefault<z.ZodEnum<{
-        beta: "beta";
         stable: "stable";
+        beta: "beta";
         dev: "dev";
     }>>;
     auto: z.ZodOptional<z.ZodObject<{
@@ -1428,79 +1428,60 @@ export declare const ConfigSchema: z.ZodDefault<z.ZodObject<{
                 "zh-CN": "zh-CN";
             }>>;
         }, z.core.$strict>>;
-        memory: z.ZodDefault<z.ZodObject<{
-            mode: z.ZodDefault<z.ZodEnum<{
-                off: "off";
-                auto: "auto";
-                readOnly: "readOnly";
-                confirmWrite: "confirmWrite";
-            }>>;
-            sources: z.ZodDefault<z.ZodArray<z.ZodEnum<{
-                session: "session";
-                workspace: "workspace";
-                understanding: "understanding";
-                agentProfile: "agentProfile";
-            }>>>;
-            writePolicy: z.ZodOptional<z.ZodObject<{
-                agentProfile: z.ZodOptional<z.ZodEnum<{
-                    allow: "allow";
-                    confirm: "confirm";
-                    deny: "deny";
-                }>>;
-                understanding: z.ZodOptional<z.ZodEnum<{
-                    allow: "allow";
-                    confirm: "confirm";
-                    deny: "deny";
-                }>>;
-                workspace: z.ZodOptional<z.ZodEnum<{
-                    allow: "allow";
-                    confirm: "confirm";
-                    deny: "deny";
-                }>>;
-            }, z.core.$strict>>;
-            retention: z.ZodOptional<z.ZodObject<{
-                compaction: z.ZodDefault<z.ZodObject<{
-                    enabled: z.ZodDefault<z.ZodBoolean>;
-                    triggerThreshold: z.ZodDefault<z.ZodNumber>;
-                    reserveTokens: z.ZodDefault<z.ZodNumber>;
-                    minMessagesBeforeCompact: z.ZodDefault<z.ZodNumber>;
-                    keepRecentTokens: z.ZodDefault<z.ZodNumber>;
-                    recentTurnsPreserve: z.ZodDefault<z.ZodNumber>;
-                    summaryMaxTokens: z.ZodDefault<z.ZodNumber>;
-                    summaryChunkTokens: z.ZodDefault<z.ZodNumber>;
-                    summaryTimeoutMs: z.ZodDefault<z.ZodNumber>;
-                    summaryRetries: z.ZodDefault<z.ZodNumber>;
-                    qualityGuard: z.ZodDefault<z.ZodBoolean>;
-                    gapAudit: z.ZodDefault<z.ZodBoolean>;
-                    model: z.ZodOptional<z.ZodString>;
-                    minToolResultKeepChars: z.ZodDefault<z.ZodNumber>;
-                    maxActiveTranscriptBytes: z.ZodDefault<z.ZodNumber>;
-                    postCompactionSections: z.ZodDefault<z.ZodArray<z.ZodString>>;
-                }, z.core.$strict>>;
-                maxAgeDays: z.ZodOptional<z.ZodNumber>;
-                maxItems: z.ZodOptional<z.ZodNumber>;
-                maxChars: z.ZodOptional<z.ZodNumber>;
-            }, z.core.$strict>>;
-        }, z.core.$strict>>;
-        understanding: z.ZodDefault<z.ZodObject<{
+        userModel: z.ZodDefault<z.ZodObject<{
             enabled: z.ZodDefault<z.ZodBoolean>;
+            writePolicy: z.ZodDefault<z.ZodEnum<{
+                allow: "allow";
+                confirm: "confirm";
+                deny: "deny";
+            }>>;
+            sensitiveWritePolicy: z.ZodDefault<z.ZodEnum<{
+                allow: "allow";
+                confirm: "confirm";
+                deny: "deny";
+            }>>;
             processingPolicy: z.ZodDefault<z.ZodEnum<{
                 local_only: "local_only";
                 remote_allowed: "remote_allowed";
             }>>;
-            adaptiveCadence: z.ZodDefault<z.ZodBoolean>;
-            reviewIntervalTurns: z.ZodDefault<z.ZodNumber>;
-            maxHistoryMessages: z.ZodDefault<z.ZodNumber>;
-            maxDurationMs: z.ZodDefault<z.ZodNumber>;
+            extraction: z.ZodDefault<z.ZodObject<{
+                reviewIntervalTurns: z.ZodDefault<z.ZodNumber>;
+                maxHistoryMessages: z.ZodDefault<z.ZodNumber>;
+                maxDurationMs: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strict>>;
+            maintenance: z.ZodDefault<z.ZodObject<{
+                enabled: z.ZodDefault<z.ZodBoolean>;
+                timezone: z.ZodOptional<z.ZodString>;
+                temporalSweepMinutes: z.ZodDefault<z.ZodNumber>;
+                dailyTime: z.ZodDefault<z.ZodString>;
+                weeklyDay: z.ZodDefault<z.ZodEnum<{
+                    sun: "sun";
+                    mon: "mon";
+                    tue: "tue";
+                    wed: "wed";
+                    thu: "thu";
+                    fri: "fri";
+                    sat: "sat";
+                }>>;
+                weeklyTime: z.ZodDefault<z.ZodString>;
+                evidenceThreshold: z.ZodDefault<z.ZodNumber>;
+                limit: z.ZodDefault<z.ZodNumber>;
+                staleRetentionDays: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strict>>;
         }, z.core.$strict>>;
-        privacy: z.ZodDefault<z.ZodObject<{
-            sensitiveWritePolicy: z.ZodDefault<z.ZodEnum<{
+        knowledgeMemory: z.ZodDefault<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            writePolicy: z.ZodDefault<z.ZodEnum<{
                 allow: "allow";
                 confirm: "confirm";
                 deny: "deny";
             }>>;
-        }, z.core.$strict>>;
-        providerRouting: z.ZodDefault<z.ZodObject<{
+            sources: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+                project: "project";
+                session: "session";
+                workspace: "workspace";
+                connector: "connector";
+            }>>>;
             searchStrategy: z.ZodDefault<z.ZodEnum<{
                 "local-first": "local-first";
                 "external-first": "external-first";
@@ -1519,17 +1500,29 @@ export declare const ConfigSchema: z.ZodDefault<z.ZodObject<{
             allowedProviderIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
             autoWriteKinds: z.ZodOptional<z.ZodArray<z.ZodString>>;
         }, z.core.$strict>>;
-        dreaming: z.ZodDefault<z.ZodObject<{
-            mode: z.ZodDefault<z.ZodEnum<{
-                off: "off";
-                review: "review";
-            }>>;
-            timezone: z.ZodOptional<z.ZodString>;
-            schedule: z.ZodDefault<z.ZodObject<{
-                time: z.ZodDefault<z.ZodString>;
+        contextPlanning: z.ZodDefault<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            maxAssertions: z.ZodDefault<z.ZodNumber>;
+            maxKnowledge: z.ZodDefault<z.ZodNumber>;
+            maxChars: z.ZodDefault<z.ZodNumber>;
+            compaction: z.ZodDefault<z.ZodObject<{
+                enabled: z.ZodDefault<z.ZodBoolean>;
+                triggerThreshold: z.ZodDefault<z.ZodNumber>;
+                reserveTokens: z.ZodDefault<z.ZodNumber>;
+                minMessagesBeforeCompact: z.ZodDefault<z.ZodNumber>;
+                keepRecentTokens: z.ZodDefault<z.ZodNumber>;
+                recentTurnsPreserve: z.ZodDefault<z.ZodNumber>;
+                summaryMaxTokens: z.ZodDefault<z.ZodNumber>;
+                summaryChunkTokens: z.ZodDefault<z.ZodNumber>;
+                summaryTimeoutMs: z.ZodDefault<z.ZodNumber>;
+                summaryRetries: z.ZodDefault<z.ZodNumber>;
+                qualityGuard: z.ZodDefault<z.ZodBoolean>;
+                gapAudit: z.ZodDefault<z.ZodBoolean>;
+                model: z.ZodOptional<z.ZodString>;
+                minToolResultKeepChars: z.ZodDefault<z.ZodNumber>;
+                maxActiveTranscriptBytes: z.ZodDefault<z.ZodNumber>;
+                postCompactionSections: z.ZodDefault<z.ZodArray<z.ZodString>>;
             }, z.core.$strict>>;
-            minEvidenceSources: z.ZodDefault<z.ZodNumber>;
-            limit: z.ZodDefault<z.ZodNumber>;
         }, z.core.$strict>>;
     }, z.core.$strict>>;
     agents: z.ZodDefault<z.ZodObject<{
@@ -2275,8 +2268,8 @@ export declare const ConfigSchema: z.ZodDefault<z.ZodObject<{
     update: z.ZodOptional<z.ZodObject<{
         checkOnStart: z.ZodDefault<z.ZodBoolean>;
         channel: z.ZodDefault<z.ZodEnum<{
-            beta: "beta";
             stable: "stable";
+            beta: "beta";
             dev: "dev";
         }>>;
         auto: z.ZodOptional<z.ZodObject<{

package/dist/src/config/schema.js

@@ -2,7 +2,7 @@ import { __esmMin } from "../../_virtual/_rolldown/runtime.js";
 import { AgentModelsOverrideSchema, AgentsConfigSchema as AgentsConfigSchema$1, DEFAULT_AGENT_MODEL_REF, ImageGenerationRouteSchema, ModelRouteSchema } from "../agent-config/schema.js";
 import { init_agent_config } from "../agent-config/index.js";
 import { checkCacheDir, init_cache_dir_policy } from "../browser/cache-dir-policy.js";
-import { UserContextConfigSchema, init_config } from "../user-context/config.js";
+import { DEFAULT_CONTEXT_COMPACTION_POLICY, UserContextConfigSchema, init_config } from "../user-context/config.js";
 import { init_default_model } from "./default-model.js";
 import { init_public_url, validatePublicUrl } from "./public-url.js";
 import { TelegramAccountConfigSchema, TelegramConfigSchema, TelegramGroupConfigSchema, TelegramTopicConfigSchema, init_config_schema } from "../../extensions/telegram/src/config-schema.js";
@@ -1007,30 +1007,41 @@ workDiscoveryOnboarding: z.boolean().default(true) }).strict().default({ workDis
 		userContext: {
 			enabled: true,
 			preferences: { responseLanguage: "auto" },
-			memory: {
-				mode: "confirmWrite",
-				sources: ["session", "understanding"],
-				writePolicy: { understanding: "confirm" }
-			},
-			understanding: {
+			userModel: {
 				enabled: true,
+				writePolicy: "confirm",
+				sensitiveWritePolicy: "confirm",
 				processingPolicy: "remote_allowed",
-				adaptiveCadence: true,
-				reviewIntervalTurns: 10,
-				maxHistoryMessages: 80,
-				maxDurationMs: 12e4
+				extraction: {
+					reviewIntervalTurns: 10,
+					maxHistoryMessages: 80,
+					maxDurationMs: 12e4
+				},
+				maintenance: {
+					enabled: true,
+					temporalSweepMinutes: 60,
+					dailyTime: "03:00",
+					weeklyDay: "sun",
+					weeklyTime: "04:00",
+					evidenceThreshold: 2,
+					limit: 1e3,
+					staleRetentionDays: 30
+				}
 			},
-			privacy: { sensitiveWritePolicy: "confirm" },
-			providerRouting: {
+			knowledgeMemory: {
+				enabled: true,
+				writePolicy: "confirm",
+				sources: ["session", "workspace"],
 				searchStrategy: "fanout",
 				writeStrategy: "local-first",
 				allowExternalWrites: false
 			},
-			dreaming: {
-				mode: "review",
-				schedule: { time: "03:00" },
-				minEvidenceSources: 2,
-				limit: 500
+			contextPlanning: {
+				enabled: true,
+				maxAssertions: 20,
+				maxKnowledge: 12,
+				maxChars: 6e3,
+				compaction: DEFAULT_CONTEXT_COMPACTION_POLICY
 			}
 		},
 		agents: {

package/dist/src/config/web-patch.d.ts

@@ -26,7 +26,7 @@ export declare function resolveSessionConfigForWeb(config: Config): {
 };
 export declare function resolveUpdateConfigForWeb(config: Config): {
     checkOnStart: boolean;
-    channel: "beta" | "stable" | "dev";
+    channel: "stable" | "beta" | "dev";
     auto: {
         enabled: boolean;
         stableDelayHours: number;

package/dist/src/connectors/auth-provider-registry.js

@@ -1,7 +1,7 @@
 import { startComposioAuthorize } from "./composio.js";
-import { getMcpOAuthManager } from "../agent/mcp/oauth/mcp-oauth-manager.js";
 import { isManagedConnectorServer } from "./materialize.js";
 import { getConnectorInstance } from "./instances.js";
+import { getMcpOAuthManager } from "../agent/mcp/oauth/mcp-oauth-manager.js";
 //#region src/connectors/auth-provider-registry.ts
 async function startConnectorAuthorization(definition, config, instanceId) {
 	if (definition.auth.mode !== "oauth") throw new Error(`Connector "${definition.id}" does not use OAuth.`);

package/dist/src/connectors/composio-managed-client.js

@@ -73,8 +73,12 @@ var ManagedComposioClient = class {
 					}
 				})).item;
 			},
-			search: async () => {
-				return (await this.request({ path: `/connectors/composio/toolkits/${encodeURIComponent(toolkit())}/tools` })).result;
+			search: async ({ query }) => {
+				const results = await Promise.all([...new Set(toolkits)].map(async (slug) => {
+					return (await this.request({ path: `/connectors/composio/toolkits/${encodeURIComponent(slug)}/tools?query=${encodeURIComponent(query)}` })).result;
+				}));
+				if (results.length === 1) return results[0];
+				return { toolSchemas: Object.assign({}, ...results.map((result) => result.toolSchemas ?? {})) };
 			},
 			execute: async (toolSlug, args = {}, options) => {
 				const selected = options?.account ?? connectedAccounts[toolkit()]?.[0];

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

@@ -6,8 +6,8 @@ import { ComposioSessionsAdapter } from "./composio-sessions.js";
 import { decodeConnectedSourceCursor, encodeConnectedSourceCursor } from "./connected-source-cursor.js";
 import { scopeForComposioAction } from "./composio.js";
 import { getConnectorDefinition } from "./catalog.js";
-import { getWorkspacePath } from "../config/workspace-path-helpers.js";
 import { getConnectorInstance } from "./instances.js";
+import { getWorkspacePath } from "../config/workspace-path-helpers.js";
 import { KnowledgeIngestionService } from "../knowledge/ingestion-service.js";
 import { ConnectedKnowledgePipeline } from "../knowledge/connected-knowledge-pipeline.js";
 import { LocalFolderKnowledgeSourceAdapter } from "../knowledge/local-folder-adapter.js";

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

@@ -1,4 +1,3 @@
-import type { MemoryManager } from '../agent/memory/manager.js';
 import type { Config } from '../config/schema.js';
 import type { KnowledgeSourceItem } from '../knowledge/types.js';
 import type { UnderstandingSourceItem } from '../user-context/sources/types.js';
@@ -10,11 +9,10 @@ export declare function deriveConnectedSourceUnderstanding(input: {
     sourceInstanceId: string;
     sourceRunId: string;
     processingPolicy: 'local_only' | 'remote_allowed';
-    memoryManager: MemoryManager;
     analyze?: typeof analyzeUnderstandingSources;
 }): Promise<{
     created: number;
-    focusCount: number;
+    knowledgeCount: number;
     status: 'completed' | 'partial' | 'failed';
     error?: string;
 }>;

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

@@ -1,8 +1,11 @@
 import { finishContextExtractionRun } from "../storage/sqlite/context-extraction-repository.js";
+import { createContextEvidence } from "../storage/sqlite/context-evidence-repository.js";
 import { listKnowledgeSourceItems } from "../storage/sqlite/knowledge-repository.js";
 import "../storage/sqlite/index.js";
-import { focusLifecycle } from "../user-context/focus-lifecycle.js";
-import { upsertUserFocus } from "../user-context/sources/repository.js";
+import { writeKnowledgeItem } from "../knowledge-memory/repository.js";
+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 { allowsRemoteSourceProcessing } from "../user-context/sources/processing-policy.js";
 import { analyzeUnderstandingSources } from "../work-discovery/analyzer.js";
@@ -20,11 +23,11 @@ function normalizedValue(item) {
 function text(value) {
 	return typeof value === "string" && value.trim() ? value.trim() : void 0;
 }
-function itemType(itemType) {
-	if (itemType === "email") return "mail";
-	if (itemType === "calendar_event") return "calendar_event";
-	if (itemType === "external_task") return "task";
-	if (itemType === "development_activity" || itemType === "repository") return "code_activity";
+function itemType(value) {
+	if (value === "email") return "mail";
+	if (value === "calendar_event") return "calendar_event";
+	if (value === "external_task") return "task";
+	if (value === "development_activity" || value === "repository") return "code_activity";
 	return "document";
 }
 function timestamp(value) {
@@ -32,14 +35,8 @@ function timestamp(value) {
 	const parsed = Date.parse(value);
 	return Number.isFinite(parsed) ? parsed : void 0;
 }
-function contentPriority(item) {
-	const value = normalizedValue(item);
-	if (item.itemType === "connected_content") return 3;
-	if (text(value.content)) return 2;
-	return 1;
-}
 function connectedItemsForUnderstanding(items) {
-	return [...items].sort((left, right) => contentPriority(right) - contentPriority(left)).slice(0, MAX_CONNECTED_ITEMS).flatMap((item) => {
+	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);
 		const title = text(value.title) ?? text(value.subject) ?? text(value.fullName) ?? text(value.repository) ?? `${text(item.metadata.toolkit) ?? "Connected source"} ${item.itemType}`;
 		const normalizedText = item.normalizedText?.trim();
@@ -59,62 +56,38 @@ function connectedItemsForUnderstanding(items) {
 		}];
 	});
 }
-function isConnectedPortraitCandidate(candidate) {
+function isPortraitCandidate(candidate) {
 	return candidate.category === "preference" || candidate.category === "routine";
 }
-function understandingCandidate(candidate) {
-	return {
-		kind: candidate.category,
-		content: candidate.statement,
-		canonicalKey: `understanding:${candidate.category}:${candidate.factKey}`,
-		confidence: candidate.confidence === "high" ? .9 : candidate.confidence === "medium" ? .72 : .55,
-		importance: .68,
-		explicitness: "inferred",
-		durability: candidate.category === "routine" ? "recurring" : "durable",
-		sensitivity: "personal",
-		disclosurePolicy: "referenceable"
-	};
-}
-function hasLongVerbatimOverlap(value, sourceTexts, minimumLength = 32) {
-	const normalized = value.replace(/\s+/g, " ").trim();
-	if (normalized.length < minimumLength) return false;
-	return sourceTexts.some((source) => source.replace(/\s+/g, " ").includes(normalized));
-}
-function evidenceDate(item) {
-	const timestamp = item.occurredAt ?? item.modifiedAt;
-	return timestamp == null ? void 0 : new Date(timestamp).toISOString().slice(0, 10);
-}
-function durableConnectedEvidence(candidate, itemsByRef) {
-	if (candidate.confidence !== "high") return [];
-	const items = [...new Set(candidate.evidenceRefs ?? [])].flatMap((ref) => itemsByRef.get(ref) ?? []);
-	if (items.some((item) => item.ownerAttribution !== "user")) return [];
+function durableEvidence(candidate, items) {
+	const evidence = [...new Set(candidate.evidenceRefs ?? [])].flatMap((ref) => items.get(ref) ?? []);
 	const required = candidate.category === "routine" ? 3 : 2;
-	const dates = new Set(items.map(evidenceDate).filter((value) => Boolean(value)));
-	return items.length >= required && dates.size >= required ? 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 : [];
 }
 async function deriveConnectedSourceUnderstanding(input) {
-	const knowledgeItems = listKnowledgeSourceItems({
+	const sourceItems = listKnowledgeSourceItems({
 		agentId: input.agentId,
 		sourceInstanceId: input.sourceInstanceId,
 		includeDeleted: false,
 		limit: MAX_CONNECTED_ITEMS
 	});
-	const items = connectedItemsForUnderstanding(knowledgeItems);
+	const items = connectedItemsForUnderstanding(sourceItems);
 	if (!items.length) return {
 		created: 0,
-		focusCount: 0,
+		knowledgeCount: 0,
 		status: "completed"
 	};
 	const extraction = claimRegisteredExtraction({
 		extractorId: "connector-semantic",
 		sourceRef: `understanding-source-run:${input.sourceRunId}`,
-		contentForHash: knowledgeItems.map((item) => `${item.id}:${item.sourceUpdatedAt ?? ""}`).join("\n"),
+		contentForHash: sourceItems.map((item) => `${item.id}:${item.sourceUpdatedAt ?? ""}`).join("\n"),
 		processingPolicy: input.processingPolicy,
 		destination: "remote_model"
 	});
 	if (!allowsRemoteSourceProcessing([input.processingPolicy]) || !extraction.shouldExecute) return {
 		created: 0,
-		focusCount: 0,
+		knowledgeCount: 0,
 		status: "completed"
 	};
 	try {
@@ -122,63 +95,77 @@ async function deriveConnectedSourceUnderstanding(input) {
 			config: input.config,
 			items
 		});
-		const rawTexts = items.flatMap((item) => item.text ? [item.text] : []);
-		const itemsByRef = new Map(items.map((item) => [item.evidenceRef, item]));
-		const profileCandidates = analysis.profileCandidates.filter(isConnectedPortraitCandidate).filter((candidate) => !hasLongVerbatimOverlap(candidate.statement, rawTexts) && durableConnectedEvidence(candidate, itemsByRef).length > 0);
-		const reviewed = {
-			created: 0,
-			writeOutputs: []
-		};
-		for (const candidate of profileCandidates) {
-			const evidenceItems = durableConnectedEvidence(candidate, itemsByRef);
-			const applied = await input.memoryManager.applyUnderstandingCandidates([understandingCandidate(candidate)], {
-				agentId: input.agentId,
-				sourceItemIds: evidenceItems.map((item) => item.id).slice(0, 20),
-				sourceText: "Bounded semantic synthesis from explicitly connected work sources.",
-				source: {
-					provider: "connected-sources",
-					sourceInstanceId: input.sourceInstanceId
-				},
-				reviewSource: "background",
-				extractionRunId: extraction.run.id
-			});
-			reviewed.created += applied.created;
-			reviewed.writeOutputs.push(...applied.writeOutputs ?? []);
+		const byRef = new Map(items.map((item) => [item.evidenceRef, item]));
+		let created = 0;
+		for (const candidate of analysis.profileCandidates.filter(isPortraitCandidate)) {
+			const evidenceItems = durableEvidence(candidate, byRef);
+			if (!evidenceItems.length) continue;
+			for (const [index, evidenceItem] of evidenceItems.entries()) {
+				const evidence = createContextEvidence({
+					sourceType: "connector",
+					sourceInstanceId: input.sourceInstanceId,
+					sourceRef: evidenceItem.evidenceRef,
+					redactedExcerpt: evidenceItem.title.slice(0, 600),
+					trustLevel: "owner",
+					observedAt: evidenceItem.occurredAt ?? evidenceItem.modifiedAt ?? Date.now()
+				});
+				const result = reconcileAssertion({
+					subject: {
+						type: "user",
+						id: "self"
+					},
+					predicate: `${candidate.category}.connected.${candidate.factKey}`,
+					cardinality: "single",
+					scope: {
+						type: "agent",
+						id: input.agentId
+					},
+					kind: candidate.category,
+					value: candidate.statement,
+					normalizedValue: candidate.statement.toLocaleLowerCase(),
+					statement: candidate.statement,
+					authority: "user_observed",
+					confidence: candidate.confidence === "high" ? .9 : .7,
+					inferredImportance: .65,
+					consequence: "medium",
+					actionability: .6,
+					volatility: candidate.category === "routine" ? "slow" : "stable",
+					sensitivity: "personal",
+					disclosurePolicy: "referenceable",
+					observedAt: evidenceItem.occurredAt ?? evidenceItem.modifiedAt ?? Date.now(),
+					createdBy: "connector",
+					evidenceId: evidence.id,
+					evidenceConfidence: .9
+				});
+				if (index === 0 && result.action === "created") created += 1;
+			}
 		}
-		const focuses = analysis.workThreadCandidates.filter((candidate) => !hasLongVerbatimOverlap(candidate.title, rawTexts) && !hasLongVerbatimOverlap(candidate.summary, rawTexts)).map((candidate) => upsertUserFocus({
-			canonicalKey: `connected-focus:${candidate.topicKey}`,
-			title: candidate.title,
-			summary: candidate.summary,
-			horizon: candidate.horizon,
-			status: "candidate",
-			confidence: candidate.confidence === "high" ? .9 : candidate.confidence === "medium" ? .72 : .55,
-			evidenceRefs: candidate.evidenceRefs,
-			sourceRunId: input.sourceRunId,
-			...focusLifecycle(candidate.horizon)
-		}));
+		let knowledgeCount = 0;
+		for (const thread of analysis.workThreadCandidates) if (writeKnowledgeItem({
+			kind: "project_fact",
+			scope: {
+				type: "agent",
+				id: input.agentId
+			},
+			content: `${thread.title}: ${thread.summary}`,
+			canonicalKey: `connected-thread:${input.sourceInstanceId}:${thread.topicKey}`,
+			confidence: thread.confidence === "high" ? .9 : thread.confidence === "medium" ? .72 : .55,
+			importance: thread.horizon === "current" ? .75 : .5,
+			originClass: "untrusted",
+			sourceAgentId: input.agentId,
+			source: {
+				sourceRunId: input.sourceRunId,
+				evidenceRefs: thread.evidenceRefs
+			}
+		}).created) knowledgeCount += 1;
 		finishContextExtractionRun({
 			runId: extraction.run.id,
-			status: "completed",
-			outputs: [...(reviewed.writeOutputs ?? []).map((output) => ({
-				candidateKey: output.candidateKey,
-				...output.objectId ? {
-					objectType: "understanding",
-					objectId: output.objectId
-				} : {},
-				...output.versionId ? { versionId: output.versionId } : {},
-				outcome: output.outcome
-			})), ...focuses.map((focus) => ({
-				candidateKey: focus.canonicalKey,
-				objectType: "focus",
-				objectId: focus.id,
-				versionId: focus.versionId,
-				outcome: "created"
-			}))]
+			status: "completed"
 		});
 		const sourceStatus = analysis.sourceStatuses.find((item) => item.sourceId === "connected-work");
 		return {
-			created: reviewed.created,
-			focusCount: focuses.length,
+			created,
+			knowledgeCount,
 			status: sourceStatus?.status ?? "failed",
 			...sourceStatus?.error ? { error: sourceStatus.error } : {}
 		};

package/dist/src/connectors/connection-candidates.d.ts

@@ -0,0 +1,11 @@
+export declare function connectionCandidates(query: string): {
+    candidateRef: string;
+    label: string;
+    capabilities: string[];
+}[];
+export declare function resolveConnectionCandidate(ref: string): {
+    key: string;
+    connectorId: string;
+    label: string;
+    capabilities: string[];
+};

package/dist/src/connectors/connection-candidates.js

@@ -0,0 +1,58 @@
+import { getConnectorDefinition } from "./catalog.js";
+//#region src/connectors/connection-candidates.ts
+const CANDIDATES = [
+	{
+		toolkit: "outlook",
+		pattern: /outlook/i,
+		capabilities: ["email.search", "email.read"]
+	},
+	{
+		toolkit: "gmail",
+		pattern: /gmail|mail|email|邮件|邮箱/i,
+		capabilities: ["email.search", "email.read"]
+	},
+	{
+		toolkit: "googlecalendar",
+		pattern: /google.*calendar|calendar|日历|日程/i,
+		capabilities: ["calendar.read"]
+	},
+	{
+		toolkit: "googledrive",
+		pattern: /google.*drive|云盘|谷歌.*文档/i,
+		capabilities: ["files.search", "files.read"]
+	},
+	{
+		toolkit: "slack",
+		pattern: /slack/i,
+		capabilities: ["messages.search"]
+	},
+	{
+		toolkit: "notion",
+		pattern: /notion/i,
+		capabilities: ["pages.search", "pages.read"]
+	}
+];
+function connectionCandidates(query) {
+	return CANDIDATES.filter((item) => item.pattern.test(query)).flatMap((item) => {
+		const connectorId = `composio-${item.toolkit}`;
+		const definition = getConnectorDefinition(connectorId);
+		return definition ? [{
+			candidateRef: connectorId,
+			label: definition.displayName,
+			capabilities: item.capabilities
+		}] : [];
+	});
+}
+function resolveConnectionCandidate(ref) {
+	const item = CANDIDATES.find((item) => `composio-${item.toolkit}` === ref);
+	const definition = item ? getConnectorDefinition(ref) : void 0;
+	if (!item || !definition) throw new Error("Unknown connection candidate. Search for a supported app first.");
+	return {
+		key: `${ref}:default`,
+		connectorId: ref,
+		label: definition.displayName,
+		capabilities: item.capabilities
+	};
+}
+//#endregion
+export { connectionCandidates, resolveConnectionCandidate };

package/dist/src/connectors/connection-capabilities.d.ts

@@ -0,0 +1,4 @@
+import type { ConnectionNeed } from '@xopcai/gateway-contract';
+export declare function isToolInputSchema(value: unknown): value is Record<string, unknown>;
+export declare function capabilityActions(need: Pick<ConnectionNeed, 'connectorId' | 'capabilities'>): string[][];
+export declare function missingConnectionCapabilities(need: Pick<ConnectionNeed, 'connectorId' | 'capabilities'>, actions: Set<string>): string[];