@xopcai/xopc 0.0.208 → 0.0.211

package/dist/src/storage/sqlite/user-context-quality-repository.js

@@ -1,9 +1,39 @@
 import { getSqliteDatabase } from "./transaction.js";
 import { USER_CONTEXT_PRINCIPAL_ID } from "../../user-context/domain.js";
 //#region src/storage/sqlite/user-context-quality-repository.ts
+function summarizeUnderstandingFeedback(understandingIds) {
+	const ids = [...new Set(understandingIds.filter(Boolean))].slice(0, 1e3);
+	if (!ids.length) return [];
+	const rows = getSqliteDatabase().prepare(`
+    SELECT object_id, rating, COUNT(*) AS count
+    FROM context_feedback
+    WHERE object_type = 'understanding' AND object_id IN (${ids.map(() => "?").join(", ")})
+    GROUP BY object_id, rating
+  `).all(...ids);
+	const summaries = /* @__PURE__ */ new Map();
+	for (const row of rows) {
+		const current = summaries.get(row.object_id) ?? {
+			understandingId: row.object_id,
+			helpful: 0,
+			irrelevant: 0,
+			total: 0
+		};
+		if (row.rating === "helpful") current.helpful += row.count;
+		if (row.rating === "irrelevant") current.irrelevant += row.count;
+		current.total += row.count;
+		summaries.set(row.object_id, current);
+	}
+	return [...summaries.values()];
+}
 function rate(numerator, denominator) {
 	return denominator > 0 ? Math.round(numerator / denominator * 1e4) / 1e4 : null;
 }
+function median(values) {
+	if (!values.length) return null;
+	const sorted = values.toSorted((left, right) => left - right);
+	const middle = Math.floor(sorted.length / 2);
+	return sorted.length % 2 ? sorted[middle] : Math.round((sorted[middle - 1] + sorted[middle]) / 2);
+}
 function summarizeUserUnderstandingQuality(options = {}) {
 	const nowMs = options.nowMs ?? Date.now();
 	const windowDays = Math.max(1, Math.min(365, Math.floor(options.windowDays ?? 30)));
@@ -59,6 +89,12 @@ function summarizeUserUnderstandingQuality(options = {}) {
 		helpfulRate: null
 	};
 	recall.helpfulRate = rate(recall.helpful, recall.total);
+	const sourceRows = db.prepare(`SELECT last_collected_at
+    FROM understanding_source_grants WHERE status = 'active'`).all();
+	const bootstrapRows = db.prepare(`SELECT status, started_at, finished_at
+    FROM connector_learning_jobs WHERE mode = 'bootstrap' AND created_at >= ?`).all(sinceMs);
+	const completedBootstraps = bootstrapRows.filter((row) => row.status === "completed");
+	const bootstrapDurations = completedBootstraps.flatMap((row) => row.started_at !== null && row.finished_at !== null && row.finished_at >= row.started_at ? [row.finished_at - row.started_at] : []);
 	return {
 		windowDays,
 		since: new Date(sinceMs).toISOString(),
@@ -67,8 +103,16 @@ function summarizeUserUnderstandingQuality(options = {}) {
 			total: recentDecisions.length,
 			acceptanceRate: rate(accepted, recentDecisions.length)
 		},
-		recall
+		recall,
+		quickUnderstanding: {
+			sourcesAuthorized: sourceRows.length,
+			sourcesCollected: sourceRows.filter((row) => row.last_collected_at !== null).length,
+			sourceCoverage: rate(sourceRows.filter((row) => row.last_collected_at !== null).length, sourceRows.length),
+			bootstrapJobs: bootstrapRows.length,
+			successfulBootstrapRate: rate(completedBootstraps.length, bootstrapRows.length),
+			medianBootstrapDurationMs: median(bootstrapDurations)
+		}
 	};
 }
 //#endregion
-export { summarizeUserUnderstandingQuality };
+export { summarizeUnderstandingFeedback, summarizeUserUnderstandingQuality };

package/dist/src/storage/sqlite/user-context-repository.d.ts

@@ -10,6 +10,10 @@ export type CreateUnderstandingInput = Omit<UserUnderstanding, 'id' | 'versionId
 export declare function createUnderstanding(input: CreateUnderstandingInput, principalId?: string): UserUnderstanding;
 export declare function getUnderstanding(id: string): UserUnderstanding | undefined;
 export declare function listUnderstandings(statuses?: UnderstandingStatus[], principalId?: string): UserUnderstanding[];
+export declare function searchActiveUnderstandings(query: string, limit?: number): Array<{
+    understanding: UserUnderstanding;
+    score: number;
+}>;
 export declare function reviseUnderstanding(id: string, statement: string, options: {
     payload?: Record<string, unknown>;
     canonicalKey?: string;

package/dist/src/storage/sqlite/user-context-repository.js

@@ -1,5 +1,7 @@
 import { getSqliteDatabase, runSqliteWriteTransaction } from "./transaction.js";
 import { USER_CONTEXT_PRINCIPAL_ID } from "../../user-context/domain.js";
+import { retrievalQueryAuditValue } from "../../retrieval/audit.js";
+import { buildFts5SearchQuery, fts5RankToScore } from "./fts.js";
 import { randomUUID } from "node:crypto";
 //#region src/storage/sqlite/user-context-repository.ts
 const UNDERSTANDING_SELECT = `
@@ -132,6 +134,29 @@ function listUnderstandings(statuses, principalId = USER_CONTEXT_PRINCIPAL_ID) {
 	const placeholders = statuses.map(() => "?").join(", ");
 	return db.prepare(`${UNDERSTANDING_SELECT} WHERE u.principal_id = ? AND u.status IN (${placeholders}) ORDER BY u.updated_at DESC`).all(principalId, ...statuses).map(understandingFromRow);
 }
+function searchActiveUnderstandings(query, limit = 50) {
+	const ftsQuery = buildFts5SearchQuery(query);
+	if (!ftsQuery) return [];
+	const boundedLimit = Math.max(1, Math.min(200, Math.floor(limit)));
+	const rows = getSqliteDatabase().prepare(`
+    SELECT u.*, v.statement, v.payload_json, bm25(user_understanding_fts) AS search_rank
+    FROM user_understanding_fts
+    JOIN user_understandings u
+      ON u.understanding_id = user_understanding_fts.understanding_id
+    JOIN user_understanding_versions v
+      ON v.version_id = u.current_version_id
+    WHERE user_understanding_fts MATCH ? AND u.principal_id = ? AND u.status = 'active'
+    ORDER BY search_rank
+    LIMIT ?
+  `).all(ftsQuery, USER_CONTEXT_PRINCIPAL_ID, boundedLimit);
+	if (!rows.length) return [];
+	const bestRank = Math.min(...rows.map((row) => row.search_rank));
+	const worstRank = Math.max(...rows.map((row) => row.search_rank));
+	return rows.map((row) => ({
+		understanding: understandingFromRow(row),
+		score: fts5RankToScore(row.search_rank, bestRank, worstRank)
+	}));
+}
 function reviseUnderstanding(id, statement, options) {
 	const current = getUnderstanding(id);
 	if (!current) throw new Error(`User understanding not found: ${id}`);
@@ -282,16 +307,17 @@ function listUnderstandingEvidence(understandingId, relation) {
 	}));
 }
 function recordContextRun(input) {
+	const auditedQuery = retrievalQueryAuditValue(input.query);
 	const existing = getSqliteDatabase().prepare("SELECT context_run_id FROM context_runs WHERE turn_id = ?").get(input.turnId);
 	const runId = existing?.context_run_id ?? randomUUID();
 	runSqliteWriteTransaction((db) => {
 		if (existing) {
 			db.prepare(`UPDATE context_runs SET principal_id = ?, session_key = ?, query = ?, budget = ?, duration_ms = ?
-        WHERE context_run_id = ?`).run(input.principalId ?? "local-owner", input.sessionKey, input.query, input.budget, input.durationMs, runId);
+        WHERE context_run_id = ?`).run(input.principalId ?? "local-owner", input.sessionKey, auditedQuery, input.budget, input.durationMs, runId);
 			db.prepare("DELETE FROM context_run_items WHERE context_run_id = ?").run(runId);
 		} else db.prepare(`INSERT INTO context_runs (
         context_run_id, principal_id, turn_id, session_key, query, budget, duration_ms, created_at
-      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(runId, input.principalId ?? "local-owner", input.turnId, input.sessionKey, input.query, input.budget, input.durationMs, Date.now());
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(runId, input.principalId ?? "local-owner", input.turnId, input.sessionKey, auditedQuery, input.budget, input.durationMs, Date.now());
 		const insert = db.prepare(`INSERT INTO context_run_items (
       context_run_id, object_type, object_id, version_id, decision, reason, content_snapshot,
       source_label, rank, score, injected_chars
@@ -380,4 +406,4 @@ function decideContextConsent(id, decision) {
 	return Number(result.changes) > 0;
 }
 //#endregion
-export { consumeContextConsent, createCollaborationRule, createContextEvidence, createUnderstanding, decideContextConsent, deleteCollaborationRule, deleteUnderstanding, ensureContextConsent, getCollaborationRule, getTurnPersonalization, getUnderstanding, getUserProfile, hasContextConsent, isUnderstandingSuppressed, linkUnderstandingEvidence, listCollaborationRules, listUnderstandingEvidence, listUnderstandings, recordContextFeedback, recordContextRun, rejectUnderstanding, reviseCollaborationRule, reviseUnderstanding, setCollaborationRuleStatus, setUnderstandingStatus, updateUserProfile };
+export { consumeContextConsent, createCollaborationRule, createContextEvidence, createUnderstanding, decideContextConsent, deleteCollaborationRule, deleteUnderstanding, ensureContextConsent, getCollaborationRule, getTurnPersonalization, getUnderstanding, getUserProfile, hasContextConsent, isUnderstandingSuppressed, linkUnderstandingEvidence, listCollaborationRules, listUnderstandingEvidence, listUnderstandings, recordContextFeedback, recordContextRun, rejectUnderstanding, reviseCollaborationRule, reviseUnderstanding, searchActiveUnderstandings, setCollaborationRuleStatus, setUnderstandingStatus, updateUserProfile };

package/dist/src/tasks/home-query-service.d.ts

@@ -14,6 +14,7 @@ type HomeAttention = HomeResponse['attention'][number];
 type HomeBriefingWin = HomeResponse['briefing']['wins'][number];
 type HomeAutomation = HomeResponse['upcomingAutomations'][number];
 type HomeFocusItem = HomeResponse['focusItems'][number];
+type HomeRecentTask = HomeResponse['recentTasks'][number];
 type HomeWorkflowRun = {
     id: string;
     definitionId: string;
@@ -151,7 +152,8 @@ export declare function buildHomeFocusItems(input: {
     activeWorkflowRuns: HomeWorkflowRun[];
     runningTasks: HomeResponse['tasks']['running'];
     wins: HomeBriefingWin[];
-    nextScheduled?: HomeAutomation;
+    scheduled: HomeAutomation[];
+    recentTasks: HomeRecentTask[];
     inboxCount: number;
     nowMs: number;
 }): HomeFocusItem[];

package/dist/src/tasks/home-query-service.js

@@ -124,6 +124,10 @@ function homeActionCopy(locale) {
 		viewProgress: "查看进度",
 		viewResult: "查看结果",
 		viewSchedule: "查看计划",
+		remaining: "项待继续",
+		taskCompleted: "任务已完成",
+		workflowCompleted: "工作流已完成",
+		automationCompleted: "自动化已完成",
 		runningTask: "任务正在推进",
 		runningWorkflow: "工作流正在推进",
 		scheduled: "下一项定时工作",
@@ -142,6 +146,10 @@ function homeActionCopy(locale) {
 		viewProgress: "View progress",
 		viewResult: "View result",
 		viewSchedule: "View schedule",
+		remaining: "remaining",
+		taskCompleted: "Task completed",
+		workflowCompleted: "Workflow completed",
+		automationCompleted: "Automation completed",
 		runningTask: "Task in progress",
 		runningWorkflow: "Workflow in progress",
 		scheduled: "Next scheduled work",
@@ -153,23 +161,26 @@ function homeActionCopy(locale) {
 		askAi: "Ask an agent"
 	};
 }
+function formatScheduleDistance(value, nowMs, locale) {
+	const distanceMs = Math.max(0, Date.parse(value) - nowMs);
+	const formatter = new Intl.RelativeTimeFormat(locale, { numeric: "always" });
+	const minutes = Math.max(1, Math.ceil(distanceMs / 6e4));
+	if (minutes < 60) return formatter.format(minutes, "minute");
+	const hours = Math.ceil(distanceMs / 36e5);
+	if (hours < 48) return formatter.format(hours, "hour");
+	return formatter.format(Math.ceil(distanceMs / 864e5), "day");
+}
 function buildHomeFocusItems(input) {
 	const copy = homeActionCopy(input.locale);
 	const decisions = input.decisions.map((decision) => {
 		const openAction = decision.kind === "agent_judgment" && decision.judgment ? {
-			type: "open",
+			type: "review_judgment",
 			label: copy.review,
-			target: "inbox_judgment",
-			targetId: decision.judgment.inboxItemId
-		} : decision.kind === "task" ? {
-			type: "open",
-			label: copy.review,
-			target: "task",
-			targetId: decision.id.replace(/^task:/, "")
+			itemId: decision.judgment.inboxItemId
 		} : {
 			type: "open",
 			label: copy.review,
-			target: "work"
+			href: decision.href
 		};
 		const connectorActions = decision.response?.kind === "connector_approval" ? {
 			primaryAction: {
@@ -196,7 +207,6 @@ function buildHomeFocusItems(input) {
 			summary: decision.detail || copy.review,
 			statusLabel: copy.review,
 			updatedAt: decision.updatedAt,
-			pinnable: false,
 			openAction,
 			...connectorActions
 		};
@@ -208,22 +218,10 @@ function buildHomeFocusItems(input) {
 		title: item.title,
 		summary: item.detail,
 		updatedAt: item.updatedAt,
-		pinnable: false,
-		openAction: item.kind === "workflow_run" ? item.sessionKey ? {
-			type: "open",
-			label: copy.review,
-			target: "session",
-			sessionKey: item.sessionKey
-		} : {
-			type: "open",
-			label: copy.review,
-			target: "workflow_run",
-			targetId: item.runId
-		} : {
+		openAction: {
 			type: "open",
 			label: copy.review,
-			target: "automation",
-			targetId: item.runId
+			href: item.href
 		},
 		primaryAction: {
 			type: "retry_run",
@@ -239,16 +237,10 @@ function buildHomeFocusItems(input) {
 		}]
 	}));
 	const workflows = input.activeWorkflowRuns.map((run) => {
-		const openAction = run.sessionKey ? {
-			type: "open",
-			label: copy.viewProgress,
-			target: "session",
-			sessionKey: run.sessionKey
-		} : {
+		const openAction = {
 			type: "open",
 			label: copy.viewProgress,
-			target: "workflow_run",
-			targetId: run.id
+			href: run.sessionKey ? `/chat/${encodeURIComponent(run.sessionKey)}` : `/workflows?runId=${encodeURIComponent(run.id)}`
 		};
 		return {
 			id: `workflow:${run.id}`,
@@ -258,7 +250,6 @@ function buildHomeFocusItems(input) {
 			summary: copy.runningWorkflow,
 			statusLabel: run.metrics.agentCount > 0 ? `${run.metrics.doneAgentCount}/${run.metrics.agentCount}` : void 0,
 			updatedAt: run.startedAtMs ?? run.createdAtMs,
-			pinnable: true,
 			openAction,
 			primaryAction: openAction,
 			secondaryActions: []
@@ -268,8 +259,7 @@ function buildHomeFocusItems(input) {
 		const openAction = {
 			type: "open",
 			label: copy.viewProgress,
-			target: "task",
-			targetId: task.id
+			href: `/tasks/${encodeURIComponent(task.id)}`
 		};
 		return {
 			id: `task:${task.id}`,
@@ -278,73 +268,82 @@ function buildHomeFocusItems(input) {
 			title: task.title,
 			summary: copy.runningTask,
 			updatedAt: task.updatedAt,
-			pinnable: true,
 			openAction,
 			primaryAction: openAction,
 			secondaryActions: []
 		};
 	});
 	const results = input.wins.map((win) => {
-		const openAction = win.kind === "workflow_run" ? {
-			type: "open",
-			label: copy.viewResult,
-			target: "workflow_run",
-			targetId: win.id.replace(/^workflow:/, "")
-		} : win.kind === "automation_run" ? {
-			type: "open",
-			label: copy.viewResult,
-			target: "automation",
-			targetId: win.id.replace(/^automation:/, "")
-		} : {
+		const openAction = {
 			type: "open",
 			label: copy.viewResult,
-			target: "task",
-			targetId: win.id.replace(/^task:/, "")
+			href: win.href
 		};
 		return {
 			id: win.id,
 			kind: "result",
 			priority: 40,
 			title: win.title,
-			summary: copy.viewResult,
+			summary: win.kind === "workflow_run" ? copy.workflowCompleted : win.kind === "automation_run" ? copy.automationCompleted : copy.taskCompleted,
 			updatedAt: win.completedAt,
-			pinnable: true,
 			openAction,
 			primaryAction: openAction,
 			secondaryActions: []
 		};
 	});
-	const scheduled = input.nextScheduled ? [{
-		id: `automation:${input.nextScheduled.id}:scheduled`,
+	const taskResults = input.recentTasks.map(({ taskId, taskTitle, receipt }) => {
+		const openAction = {
+			type: "open",
+			label: copy.viewResult,
+			href: `/tasks/${encodeURIComponent(taskId)}`
+		};
+		return {
+			id: `task-result:${taskId}:${receipt.runId}`,
+			kind: "result",
+			priority: 40,
+			title: taskTitle,
+			summary: receipt.summary,
+			statusLabel: receipt.remainingWork.length > 0 ? `${receipt.remainingWork.length} ${copy.remaining}` : void 0,
+			updatedAt: receipt.finalizedAt,
+			openAction,
+			primaryAction: openAction,
+			secondaryActions: []
+		};
+	});
+	const scheduled = input.scheduled.map((automation) => ({
+		id: `automation:${automation.id}:scheduled`,
 		kind: "scheduled",
 		priority: 30,
-		title: input.nextScheduled.name || input.nextScheduled.id,
+		title: automation.name || automation.id,
 		summary: copy.scheduled,
-		statusLabel: new Date(input.nextScheduled.nextRunAt).toLocaleString(input.locale),
-		updatedAt: Date.parse(input.nextScheduled.nextRunAt),
-		pinnable: true,
+		statusLabel: formatScheduleDistance(automation.nextRunAt, input.nowMs, input.locale),
+		updatedAt: Date.parse(automation.nextRunAt),
 		openAction: {
 			type: "open",
 			label: copy.viewSchedule,
-			target: "automation",
-			targetId: input.nextScheduled.id
+			href: `/automations?automation=${encodeURIComponent(automation.id)}`
 		},
 		primaryAction: {
 			type: "open",
 			label: copy.viewSchedule,
-			target: "automation",
-			targetId: input.nextScheduled.id
+			href: `/automations?automation=${encodeURIComponent(automation.id)}`
 		},
 		secondaryActions: []
-	}] : [];
+	}));
 	const items = [
 		...decisions,
 		...failures,
 		...workflows,
 		...tasks,
 		...results,
+		...taskResults,
 		...scheduled
-	].sort((left, right) => right.priority - left.priority || right.updatedAt - left.updatedAt);
+	].sort((left, right) => {
+		const priorityDelta = right.priority - left.priority;
+		if (priorityDelta !== 0) return priorityDelta;
+		if (left.kind === "scheduled" && right.kind === "scheduled") return left.updatedAt - right.updatedAt;
+		return right.updatedAt - left.updatedAt;
+	});
 	if (items.length > 0) return items;
 	if (input.inboxCount > 0) return [{
 		id: "suggestion:organize-inbox",
@@ -353,16 +352,15 @@ function buildHomeFocusItems(input) {
 		title: `${copy.organizeInbox} · ${input.inboxCount}`,
 		summary: copy.organizeInboxSummary,
 		updatedAt: input.nowMs,
-		pinnable: false,
 		openAction: {
 			type: "open",
 			label: copy.openInbox,
-			target: "inbox"
+			href: "/notes?status=inbox"
 		},
 		primaryAction: {
 			type: "open",
 			label: copy.openInbox,
-			target: "inbox"
+			href: "/notes?status=inbox"
 		},
 		secondaryActions: []
 	}];
@@ -373,7 +371,6 @@ function buildHomeFocusItems(input) {
 		title: copy.startSomething,
 		summary: copy.startSomethingSummary,
 		updatedAt: input.nowMs,
-		pinnable: false,
 		primaryAction: {
 			type: "ask_ai",
 			label: copy.askAi
@@ -525,7 +522,7 @@ var HomeQueryService = class {
 			id: `automation:${run.id}`,
 			kind: "automation_run",
 			title: run.automationName || run.automationId,
-			href: "/automations",
+			href: `/automations?automation=${encodeURIComponent(run.automationId)}&run=${encodeURIComponent(run.id)}`,
 			completedAt: run.endedAtMs ?? run.createdAtMs
 		}))].sort((left, right) => right.completedAt - left.completedAt);
 		const runningTasks = tasks.filter((task) => {
@@ -542,6 +539,11 @@ var HomeQueryService = class {
 			nextScheduled: upcomingAutomations[0],
 			nowMs
 		});
+		const recentTasks = tasks.flatMap((task) => this.#runs.listReceipts(task.id, 3).map((receipt) => ({
+			taskId: task.id,
+			taskTitle: task.title,
+			receipt
+		}))).sort((a, b) => b.receipt.finalizedAt - a.receipt.finalizedAt).slice(0, 8);
 		return {
 			focusItems: buildHomeFocusItems({
 				locale,
@@ -550,7 +552,8 @@ var HomeQueryService = class {
 				activeWorkflowRuns,
 				runningTasks,
 				wins,
-				nextScheduled: upcomingAutomations[0],
+				scheduled: upcomingAutomations.slice(0, 3),
+				recentTasks: recentTasks.slice(0, 3),
 				inboxCount: inbox.total,
 				nowMs
 			}),
@@ -590,7 +593,7 @@ var HomeQueryService = class {
 			},
 			upcomingAutomations,
 			tasks: { running: runningTasks },
-			recentTasks: tasks.flatMap((task) => this.#runs.listReceipts(task.id, 3)).sort((a, b) => b.finalizedAt - a.finalizedAt).slice(0, 8),
+			recentTasks,
 			recentAutomationRuns: automationRuns.slice(0, 5).map(toHomeAutomationRun)
 		};
 	}

package/dist/src/tui/backends/embedded-backend.js

@@ -1,8 +1,8 @@
 import { createLogger } from "../../utils/logger/index.js";
 import { init_logger } from "../../utils/logger.js";
 import { openXopcDatabase } from "../../storage/sqlite/connection.js";
-import { appendComposerInputHistory, listComposerInputHistory } from "../../storage/sqlite/composer-input-history-repository.js";
 import { init_agent_session_key, resolveAgentIdFromSessionKey } from "../../routing/agent-session-key.js";
+import { appendComposerInputHistory, listComposerInputHistory } from "../../storage/sqlite/composer-input-history-repository.js";
 import { getSessionMetadata } from "../../storage/sqlite/session-repository.js";
 import "../../storage/sqlite/index.js";
 import { getAgentDefaultModelRef, init_schema } from "../../config/schema.js";
@@ -30,6 +30,7 @@ import { buildWorkflowChildTools } from "../../agent/workflow/workflow-child-too
 import { WorkflowRunService } from "../../workflows/service/workflow-run-service.js";
 import { WorkflowSessionBridge } from "../../workflows/service/workflow-session-bridge.js";
 import { ChatStreamMapper } from "../../gateway/chat-stream/mapper.js";
+import { getXopcCloudCatalogCoordinator } from "../../providers/xopc-cloud-catalog-coordinator.js";
 import { fuzzySearchWorkspaceFiles } from "../../gateway/workspace-file-search.js";
 import { sessionMetadataToTuiItem } from "../tui-session-format.js";
 import { buildTuiTranscriptTree, transcriptTreeEntryIdToRowNumber } from "../tui-transcript-tree.js";
@@ -148,9 +149,16 @@ var EmbeddedBackend = class {
 	}
 	async refreshXopcCloudModels() {
 		try {
-			const { XopcCloudModelSource } = await import("../../providers/xopc-cloud-model-source.js");
-			const result = await new XopcCloudModelSource().refresh();
-			if (result.status === "updated") log.info({ modelCount: result.modelCount }, `XOPC Cloud model catalog refreshed: ${result.modelCount} models`);
+			const readiness = await getXopcCloudCatalogCoordinator().ensure({
+				reason: "agent-run",
+				network: "if-empty",
+				timeoutMs: 1e4
+			});
+			if (!readiness.error) return;
+			log.warn({
+				errorMessage: readiness.error.message,
+				phase: "model_catalog_refresh"
+			}, `XOPC Cloud model catalog refresh failed: ${readiness.error.message}`);
 		} catch (err) {
 			const errorMessage = err instanceof Error ? err.message : String(err);
 			log.warn({

package/dist/src/tui/tui-oauth-login.js

@@ -2,6 +2,7 @@ import { createLogger } from "../utils/logger/index.js";
 import { init_logger } from "../utils/logger.js";
 import { CredentialResolver, init_credentials } from "../auth/credentials.js";
 import { getProviderDisplayName, init_providers } from "../providers/index.js";
+import { getXopcCloudCatalogCoordinator } from "../providers/xopc-cloud-catalog-coordinator.js";
 import { selectListTheme, theme } from "./theme.js";
 import { formatKeyIds } from "./format-tui-hotkeys.js";
 import { getOAuthProvider, getSupportedOAuthProviders } from "../cli/utils/oauth-providers.js";
@@ -170,6 +171,10 @@ async function runTuiOAuthLogin(provider, deps) {
 			activeCleanups
 		}));
 		await new CredentialResolver().saveOAuthCredentials(selectedProvider, credentials);
+		if (selectedProvider === "xopc-cloud") {
+			const catalog = await getXopcCloudCatalogCoordinator().refresh("oauth");
+			if (catalog.error) deps.chatLog.addSystem(`Authorization succeeded, but model catalog sync failed: ${catalog.error.message}`);
+		}
 		deps.chatLog.addSystem(`OAuth login completed for ${selectedProvider}.`);
 	} finally {
 		for (const cleanup of [...activeCleanups]) cleanup();

package/dist/src/tui/tui-startup-resources.js

@@ -5,9 +5,9 @@ import { resolveBootstrapFilesSync } from "../agent/bootstrap/bootstrap-files.js
 import { createSkillConfigManager, isSkillEnabled } from "../agent/skills/config.js";
 import { loadSkills } from "../agent/skills/index.js";
 import { createWorkflowCatalog } from "../agent/workflow/catalog.js";
-import { listConnectorInstances } from "../connectors/instances.js";
 import { getWorkspacePath } from "../config/workspace-path-helpers.js";
 import "../config/index.js";
+import { listConnectorInstances } from "../connectors/instances.js";
 import { basename } from "node:path";
 //#region src/tui/tui-startup-resources.ts
 init_paths();

package/dist/src/user-context/planner.d.ts

@@ -2,6 +2,7 @@ import type { AgentMessage } from '@earendil-works/pi-agent-core';
 import type { UserContextPlan } from '../agent/memory/context/types.js';
 export declare function prependAgentContext(message: AgentMessage, block: string): AgentMessage;
 export declare class UserContextPlanner {
+    private readonly retriever;
     plan(params: {
         sessionKey: string;
         workspaceId: string;

package/dist/src/user-context/planner.js

@@ -1,8 +1,10 @@
-import { consumeContextConsent, ensureContextConsent, getUserProfile, listCollaborationRules, listUnderstandings, recordContextRun } from "../storage/sqlite/user-context-repository.js";
+import { consumeContextConsent, ensureContextConsent, getUserProfile, listCollaborationRules, recordContextRun } from "../storage/sqlite/user-context-repository.js";
 import "../storage/sqlite/index.js";
 import { readAgentMessageContent } from "../agent/memory/agent-message-access.js";
 import { buildUserContextBlock } from "../agent/memory/context-fence.js";
 import { listUserFocuses } from "./sources/repository.js";
+import { matchesUserContextScope } from "./scope.js";
+import { UserUnderstandingRetriever } from "./retriever.js";
 import { randomUUID } from "node:crypto";
 //#region src/user-context/planner.ts
 const DEFAULT_MAX_CONTEXT_CHARS = 6e3;
@@ -33,28 +35,6 @@ function prependAgentContext(message, block) {
 	}
 	return message;
 }
-function scopeMatches(scope, input) {
-	if (scope.type === "global") return true;
-	if (scope.type === "session") return scope.id === input.sessionKey;
-	if (scope.type === "workspace") return scope.id === input.workspaceId;
-	return Boolean(input.projectId && scope.id === input.projectId);
-}
-function terms(value) {
-	const normalized = value.toLocaleLowerCase().replace(/[^\p{L}\p{N}]+/gu, " ").trim();
-	const words = normalized.split(/\s+/).filter((word) => word.length > 1);
-	const cjk = [...normalized.replace(/[^\p{Script=Han}]/gu, "")];
-	for (let index = 0; index < cjk.length - 1; index += 1) words.push(`${cjk[index]}${cjk[index + 1]}`);
-	return new Set(words);
-}
-function relevance(query, item) {
-	const queryTerms = terms(query);
-	const itemTerms = terms(item.statement);
-	const shared = [...queryTerms].filter((term) => itemTerms.has(term)).length;
-	const lexical = queryTerms.size ? shared / queryTerms.size : 0;
-	const baseline = item.kind === "boundary" && item.explicitness === "explicit" ? .8 : item.kind === "preference" && item.explicitness === "explicit" ? .35 : 0;
-	const explicitness = item.explicitness === "explicit" ? .1 : item.explicitness === "observed" ? .05 : 0;
-	return Math.min(1, Math.max(baseline, lexical * .75 + item.confidence * .15 + explicitness));
-}
 function sectionFor(item) {
 	if (item.kind === "boundary") return "safety";
 	if ([
@@ -77,18 +57,19 @@ function sourceLabel(item) {
 function rejectionReason(item, input, now) {
 	if (item.status === "needs_review" || item.status === "stale" || item.status === "candidate") return "needs_review";
 	if (item.status === "archived" || item.status === "rejected") return "disabled";
-	if (!scopeMatches(item.scope, input)) return "scope_mismatch";
+	if (!matchesUserContextScope(item.scope, input)) return "scope_mismatch";
 	if (item.validFrom && item.validFrom > now) return "not_yet_valid";
 	if (item.validTo && item.validTo < now || item.expiresAt && item.expiresAt < now) return "expired";
 	if (item.sensitivity === "secret" || item.sensitivity === "regulated") return "sensitive";
 	if (item.conflictGroupId) return "conflict";
 }
 function ruleMatches(rule, input) {
-	if (rule.status !== "active" || !scopeMatches(rule.scope, input)) return false;
+	if (rule.status !== "active" || !matchesUserContextScope(rule.scope, input)) return false;
 	const channel = typeof rule.conditions.channel === "string" ? rule.conditions.channel : void 0;
 	return !channel || channel === input.channel;
 }
 var UserContextPlanner = class {
+	retriever = new UserUnderstandingRetriever();
 	plan(params) {
 		const traceId = randomUUID();
 		const query = params.query.trim();
@@ -176,10 +157,16 @@ var UserContextPlanner = class {
 				injectedChars: rule.statement.length
 			});
 		}
-		const ranked = listUnderstandings(["active"]).filter((item) => !excluded.has(item.id)).map((item) => ({
-			item,
-			score: relevance(query, item)
-		})).sort((left, right) => right.score - left.score).slice(0, Math.max(maxResults * 5, 50));
+		const ranked = this.retriever.retrieve({
+			query,
+			sessionKey: params.sessionKey,
+			workspaceId: params.workspaceId,
+			...params.projectId ? { projectId: params.projectId } : {},
+			maxCandidates: Math.max(maxResults * 5, 50)
+		}).filter((result) => !excluded.has(result.understanding.id)).map((result) => ({
+			item: result.understanding,
+			score: result.score
+		}));
 		for (const { item, score } of ranked) {
 			if (items.length >= maxResults) {
 				rejected.push({

package/dist/src/user-context/retriever.d.ts

@@ -0,0 +1,15 @@
+import type { UserUnderstanding } from './domain.js';
+export interface UnderstandingRetrievalResult {
+    understanding: UserUnderstanding;
+    score: number;
+    reasons: string[];
+}
+export declare class UserUnderstandingRetriever {
+    retrieve(params: {
+        query: string;
+        sessionKey: string;
+        workspaceId: string;
+        projectId?: string;
+        maxCandidates: number;
+    }): UnderstandingRetrievalResult[];
+}