@xopcai/xopc 0.0.189 → 0.0.190

package/dist/src/user-context/sources/catalog.js

@@ -0,0 +1,149 @@
+//#region src/user-context/sources/catalog.ts
+const COMMON = [
+	{
+		id: "local-work-folders",
+		category: "files",
+		platform: "all",
+		displayName: "Work folders",
+		description: "Discover likely work folders and analyze only folders you approve.",
+		availability: "available",
+		permission: "not_requested",
+		defaultAccessMode: "continuous",
+		supportedAccessModes: ["once", "continuous"],
+		recommended: true,
+		sensitive: false
+	},
+	{
+		id: "connector-github",
+		category: "code_activity",
+		platform: "all",
+		displayName: "GitHub",
+		description: "Repositories, pull requests, issues, and recent code activity from an account you connect.",
+		availability: "available",
+		permission: "not_requested",
+		defaultAccessMode: "continuous",
+		supportedAccessModes: ["once", "continuous"],
+		recommended: true,
+		sensitive: false
+	},
+	{
+		id: "connector-calendar",
+		category: "calendar",
+		platform: "all",
+		displayName: "Connected calendar",
+		description: "Calendar commitments and recurring work rhythms from a connected account.",
+		availability: "available",
+		permission: "not_requested",
+		defaultAccessMode: "continuous",
+		supportedAccessModes: ["once", "continuous"],
+		recommended: true,
+		sensitive: true
+	},
+	{
+		id: "connector-drive",
+		category: "files",
+		platform: "all",
+		displayName: "Cloud documents",
+		description: "Selected cloud documents and metadata from a connected workspace.",
+		availability: "available",
+		permission: "not_requested",
+		defaultAccessMode: "continuous",
+		supportedAccessModes: ["once", "continuous"],
+		recommended: false,
+		sensitive: true
+	},
+	{
+		id: "connector-mail",
+		category: "mail",
+		platform: "all",
+		displayName: "Mail",
+		description: "Work themes and commitments from explicitly connected mail.",
+		availability: "available",
+		permission: "not_requested",
+		defaultAccessMode: "continuous",
+		supportedAccessModes: ["once", "continuous"],
+		recommended: false,
+		sensitive: true
+	},
+	{
+		id: "connector-messages",
+		category: "messages",
+		platform: "all",
+		displayName: "Messages",
+		description: "Work themes from explicitly connected collaboration messages.",
+		availability: "available",
+		permission: "not_requested",
+		defaultAccessMode: "continuous",
+		supportedAccessModes: ["once", "continuous"],
+		recommended: false,
+		sensitive: true
+	}
+];
+const PLATFORM = {
+	darwin: [
+		[
+			"apple-notes",
+			"notes",
+			"Apple Notes",
+			"Recent unlocked notes selected through macOS Automation",
+			true
+		],
+		[
+			"apple-calendar",
+			"calendar",
+			"Apple Calendar",
+			"Recent and upcoming calendar events",
+			true
+		],
+		[
+			"apple-reminders",
+			"tasks",
+			"Apple Reminders",
+			"Open and recently completed reminders",
+			true
+		]
+	].map(([id, category, displayName, description, sensitive]) => ({
+		id: String(id),
+		category,
+		platform: "darwin",
+		displayName: String(displayName),
+		description: String(description),
+		availability: "available",
+		permission: "not_requested",
+		defaultAccessMode: "once",
+		supportedAccessModes: ["once"],
+		recommended: category !== "notes",
+		sensitive: Boolean(sensitive)
+	})),
+	win32: [{
+		id: "windows-recent-documents",
+		category: "recent_documents",
+		platform: "win32",
+		displayName: "Recent documents",
+		description: "Metadata for files in Windows Recent Items",
+		availability: "available",
+		permission: "granted",
+		defaultAccessMode: "once",
+		supportedAccessModes: ["once"],
+		recommended: true,
+		sensitive: false
+	}],
+	linux: [{
+		id: "linux-recent-documents",
+		category: "recent_documents",
+		platform: "linux",
+		displayName: "Recent documents",
+		description: "Metadata from the freedesktop recent-files list",
+		availability: "available",
+		permission: "granted",
+		defaultAccessMode: "once",
+		supportedAccessModes: ["once"],
+		recommended: true,
+		sensitive: false
+	}]
+};
+function listUnderstandingSourceDefinitions(platform = process.platform) {
+	return [...COMMON, ...PLATFORM[platform] ?? []];
+}
+//#endregion
+export { listUnderstandingSourceDefinitions };

package/dist/src/user-context/sources/index.d.ts

@@ -0,0 +1,3 @@
+export * from './catalog.js';
+export * from './repository.js';
+export * from './types.js';

package/dist/src/user-context/sources/index.js

@@ -0,0 +1,3 @@
+import { createUnderstandingSourceRun, getUnderstandingSourceGrant, getUnderstandingSourceRun, listUnderstandingSourceGrants, listUnderstandingSourceRuns, listUserFocuses, revokeUnderstandingSourceGrant, setUserFocusStatus, updateUnderstandingSourceGrantCheckpoint, updateUnderstandingSourceRun, upsertUnderstandingSourceGrant, upsertUserFocus } from "./repository.js";
+import { listUnderstandingSourceDefinitions } from "./catalog.js";
+export { createUnderstandingSourceRun, getUnderstandingSourceGrant, getUnderstandingSourceRun, listUnderstandingSourceDefinitions, listUnderstandingSourceGrants, listUnderstandingSourceRuns, listUserFocuses, revokeUnderstandingSourceGrant, setUserFocusStatus, updateUnderstandingSourceGrantCheckpoint, updateUnderstandingSourceRun, upsertUnderstandingSourceGrant, upsertUserFocus };

package/dist/src/user-context/sources/repository.d.ts

@@ -0,0 +1,40 @@
+import type { UnderstandingSourceGrant, UnderstandingSourceRun, UserFocus } from './types.js';
+export declare function listUnderstandingSourceGrants(options?: {
+    includeRevoked?: boolean;
+}): UnderstandingSourceGrant[];
+export declare function getUnderstandingSourceGrant(id: string): UnderstandingSourceGrant | null;
+export declare function upsertUnderstandingSourceGrant(input: Omit<UnderstandingSourceGrant, 'id' | 'status' | 'checkpoint' | 'lastCollectedAt' | 'createdAt' | 'updatedAt'> & {
+    checkpoint?: Record<string, unknown>;
+    lastCollectedAt?: number;
+    nowMs?: number;
+}): UnderstandingSourceGrant;
+export declare function updateUnderstandingSourceGrantCheckpoint(id: string, input: {
+    checkpoint?: Record<string, unknown>;
+    lastCollectedAt?: number;
+    nowMs?: number;
+}): UnderstandingSourceGrant | null;
+export declare function revokeUnderstandingSourceGrant(id: string, nowMs?: number): UnderstandingSourceGrant | null;
+export declare function createUnderstandingSourceRun(input: {
+    grantId: string;
+    kind: UnderstandingSourceRun['kind'];
+    status?: UnderstandingSourceRun['status'];
+    cursorBefore?: string;
+    metadata?: Record<string, unknown>;
+    nowMs?: number;
+}): UnderstandingSourceRun;
+export declare function getUnderstandingSourceRun(id: string): UnderstandingSourceRun | null;
+export declare function listUnderstandingSourceRuns(grantId: string, limit?: number): UnderstandingSourceRun[];
+export declare function updateUnderstandingSourceRun(id: string, patch: {
+    status?: UnderstandingSourceRun['status'];
+    cursorAfter?: string;
+    itemsSeen?: number;
+    metadata?: Record<string, unknown>;
+    errorMessage?: string;
+    completed?: boolean;
+    nowMs?: number;
+}): UnderstandingSourceRun | null;
+export declare function upsertUserFocus(input: Omit<UserFocus, 'id' | 'createdAt' | 'updatedAt'> & {
+    nowMs?: number;
+}): UserFocus;
+export declare function listUserFocuses(statuses?: UserFocus['status'][]): UserFocus[];
+export declare function setUserFocusStatus(id: string, status: UserFocus['status'], nowMs?: number): UserFocus | null;

package/dist/src/user-context/sources/repository.js

@@ -0,0 +1,164 @@
+import { getSqliteDatabase, runSqliteWriteTransaction } from "../../storage/sqlite/transaction.js";
+import { randomUUID } from "node:crypto";
+//#region src/user-context/sources/repository.ts
+function record(value) {
+	try {
+		return JSON.parse(value);
+	} catch {
+		return {};
+	}
+}
+function strings(value) {
+	try {
+		const parsed = JSON.parse(value);
+		return Array.isArray(parsed) ? parsed.filter((item) => typeof item === "string") : [];
+	} catch {
+		return [];
+	}
+}
+function grantFromRow(row) {
+	return {
+		id: row.grant_id,
+		sourceKey: row.source_key,
+		adapterId: row.adapter_id,
+		category: row.category,
+		platform: row.platform,
+		displayName: row.display_name,
+		status: row.status,
+		accessMode: row.access_mode,
+		retentionPolicy: row.retention_policy,
+		processingPolicy: row.processing_policy,
+		config: record(row.config_json),
+		checkpoint: record(row.checkpoint_json),
+		...row.last_collected_at == null ? {} : { lastCollectedAt: row.last_collected_at },
+		createdAt: row.created_at,
+		updatedAt: row.updated_at
+	};
+}
+function runFromRow(row) {
+	return {
+		id: row.run_id,
+		grantId: row.grant_id,
+		kind: row.kind,
+		status: row.status,
+		...row.cursor_before ? { cursorBefore: row.cursor_before } : {},
+		...row.cursor_after ? { cursorAfter: row.cursor_after } : {},
+		itemsSeen: row.items_seen,
+		metadata: record(row.metadata_json),
+		...row.error_message ? { errorMessage: row.error_message } : {},
+		startedAt: row.started_at,
+		...row.completed_at == null ? {} : { completedAt: row.completed_at }
+	};
+}
+function focusFromRow(row) {
+	return {
+		id: row.focus_id,
+		canonicalKey: row.canonical_key,
+		title: row.title,
+		summary: row.summary,
+		horizon: row.horizon,
+		status: row.status,
+		confidence: row.confidence,
+		...row.project_id ? { projectId: row.project_id } : {},
+		evidenceRefs: strings(row.evidence_refs_json),
+		...row.source_run_id ? { sourceRunId: row.source_run_id } : {},
+		createdAt: row.created_at,
+		updatedAt: row.updated_at
+	};
+}
+function listUnderstandingSourceGrants(options = {}) {
+	return getSqliteDatabase().prepare(`SELECT * FROM understanding_source_grants ${options.includeRevoked ? "" : "WHERE status = 'active'"} ORDER BY updated_at DESC`).all().map(grantFromRow);
+}
+function getUnderstandingSourceGrant(id) {
+	const row = getSqliteDatabase().prepare("SELECT * FROM understanding_source_grants WHERE grant_id = ?").get(id);
+	return row ? grantFromRow(row) : null;
+}
+function upsertUnderstandingSourceGrant(input) {
+	const id = randomUUID();
+	const now = input.nowMs ?? Date.now();
+	const existingRow = getSqliteDatabase().prepare("SELECT * FROM understanding_source_grants WHERE source_key = ?").get(input.sourceKey);
+	const existing = existingRow ? grantFromRow(existingRow) : void 0;
+	runSqliteWriteTransaction((db) => db.prepare(`
+    INSERT INTO understanding_source_grants (
+      grant_id, source_key, adapter_id, category, platform, display_name, status, access_mode,
+      retention_policy, processing_policy, config_json, checkpoint_json, last_collected_at, created_at, updated_at
+    ) VALUES (?, ?, ?, ?, ?, ?, 'active', ?, ?, ?, ?, ?, ?, ?, ?)
+    ON CONFLICT(source_key) DO UPDATE SET
+      adapter_id = excluded.adapter_id, category = excluded.category, platform = excluded.platform,
+      display_name = excluded.display_name, status = 'active', access_mode = excluded.access_mode,
+      retention_policy = excluded.retention_policy, processing_policy = excluded.processing_policy,
+      config_json = excluded.config_json, checkpoint_json = excluded.checkpoint_json,
+      last_collected_at = COALESCE(excluded.last_collected_at, understanding_source_grants.last_collected_at),
+      updated_at = excluded.updated_at
+  `).run(id, input.sourceKey, input.adapterId, input.category, input.platform, input.displayName, input.accessMode, input.retentionPolicy, input.processingPolicy, JSON.stringify(input.config), JSON.stringify(input.checkpoint ?? existing?.checkpoint ?? {}), input.lastCollectedAt ?? null, now, now));
+	return grantFromRow(getSqliteDatabase().prepare("SELECT * FROM understanding_source_grants WHERE source_key = ?").get(input.sourceKey));
+}
+function updateUnderstandingSourceGrantCheckpoint(id, input) {
+	const current = getUnderstandingSourceGrant(id);
+	if (!current) return null;
+	const now = input.nowMs ?? Date.now();
+	runSqliteWriteTransaction((db) => db.prepare(`
+    UPDATE understanding_source_grants
+    SET checkpoint_json = ?, last_collected_at = ?, updated_at = ?
+    WHERE grant_id = ?
+  `).run(JSON.stringify(input.checkpoint ?? current.checkpoint), input.lastCollectedAt ?? current.lastCollectedAt ?? null, now, id));
+	return getUnderstandingSourceGrant(id);
+}
+function revokeUnderstandingSourceGrant(id, nowMs = Date.now()) {
+	runSqliteWriteTransaction((db) => db.prepare("UPDATE understanding_source_grants SET status = 'revoked', updated_at = ? WHERE grant_id = ?").run(nowMs, id));
+	return getUnderstandingSourceGrant(id);
+}
+function createUnderstandingSourceRun(input) {
+	const id = randomUUID();
+	const now = input.nowMs ?? Date.now();
+	runSqliteWriteTransaction((db) => db.prepare(`
+    INSERT INTO understanding_source_runs (
+      run_id, grant_id, kind, status, cursor_before, metadata_json, started_at
+    ) VALUES (?, ?, ?, ?, ?, ?, ?)
+  `).run(id, input.grantId, input.kind, input.status ?? "running", input.cursorBefore ?? null, JSON.stringify(input.metadata ?? {}), now));
+	return getUnderstandingSourceRun(id);
+}
+function getUnderstandingSourceRun(id) {
+	const row = getSqliteDatabase().prepare("SELECT * FROM understanding_source_runs WHERE run_id = ?").get(id);
+	return row ? runFromRow(row) : null;
+}
+function listUnderstandingSourceRuns(grantId, limit = 20) {
+	return getSqliteDatabase().prepare("SELECT * FROM understanding_source_runs WHERE grant_id = ? ORDER BY started_at DESC LIMIT ?").all(grantId, Math.max(1, Math.min(100, limit))).map(runFromRow);
+}
+function updateUnderstandingSourceRun(id, patch) {
+	const current = getUnderstandingSourceRun(id);
+	if (!current) return null;
+	const completedAt = patch.completed ? patch.nowMs ?? Date.now() : current.completedAt ?? null;
+	runSqliteWriteTransaction((db) => db.prepare(`
+    UPDATE understanding_source_runs SET status = ?, cursor_after = ?, items_seen = ?, metadata_json = ?,
+      error_message = ?, completed_at = ? WHERE run_id = ?
+  `).run(patch.status ?? current.status, patch.cursorAfter ?? current.cursorAfter ?? null, patch.itemsSeen ?? current.itemsSeen, JSON.stringify(patch.metadata ?? current.metadata), patch.errorMessage ?? current.errorMessage ?? null, completedAt, id));
+	return getUnderstandingSourceRun(id);
+}
+function upsertUserFocus(input) {
+	const id = randomUUID();
+	const now = input.nowMs ?? Date.now();
+	runSqliteWriteTransaction((db) => db.prepare(`
+    INSERT INTO user_focuses (
+      focus_id, canonical_key, title, summary, horizon, status, confidence, project_id,
+      evidence_refs_json, source_run_id, created_at, updated_at
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    ON CONFLICT(canonical_key) DO UPDATE SET title = excluded.title, summary = excluded.summary,
+      horizon = excluded.horizon, status = excluded.status, confidence = excluded.confidence,
+      project_id = excluded.project_id, evidence_refs_json = excluded.evidence_refs_json,
+      source_run_id = excluded.source_run_id, updated_at = excluded.updated_at
+  `).run(id, input.canonicalKey, input.title, input.summary, input.horizon, input.status, input.confidence, input.projectId ?? null, JSON.stringify(input.evidenceRefs), input.sourceRunId ?? null, now, now));
+	return focusFromRow(getSqliteDatabase().prepare("SELECT * FROM user_focuses WHERE canonical_key = ?").get(input.canonicalKey));
+}
+function listUserFocuses(statuses) {
+	if (!statuses?.length) return getSqliteDatabase().prepare("SELECT * FROM user_focuses ORDER BY updated_at DESC").all().map(focusFromRow);
+	const placeholders = statuses.map(() => "?").join(", ");
+	return getSqliteDatabase().prepare(`SELECT * FROM user_focuses WHERE status IN (${placeholders}) ORDER BY updated_at DESC`).all(...statuses).map(focusFromRow);
+}
+function setUserFocusStatus(id, status, nowMs = Date.now()) {
+	runSqliteWriteTransaction((db) => db.prepare("UPDATE user_focuses SET status = ?, updated_at = ? WHERE focus_id = ?").run(status, nowMs, id));
+	const row = getSqliteDatabase().prepare("SELECT * FROM user_focuses WHERE focus_id = ?").get(id);
+	return row ? focusFromRow(row) : null;
+}
+//#endregion
+export { createUnderstandingSourceRun, getUnderstandingSourceGrant, getUnderstandingSourceRun, listUnderstandingSourceGrants, listUnderstandingSourceRuns, listUserFocuses, revokeUnderstandingSourceGrant, setUserFocusStatus, updateUnderstandingSourceGrantCheckpoint, updateUnderstandingSourceRun, upsertUnderstandingSourceGrant, upsertUserFocus };

package/dist/src/user-context/sources/types.d.ts

@@ -0,0 +1,83 @@
+export type UnderstandingSourcePlatform = 'darwin' | 'win32' | 'linux' | 'all';
+export type UnderstandingSourceCategory = 'files' | 'recent_documents' | 'calendar' | 'tasks' | 'notes' | 'mail' | 'messages' | 'code_activity';
+export type UnderstandingSourceAccessMode = 'once' | 'continuous';
+export type UnderstandingSourceRetentionPolicy = 'metadata_only' | 'derived_only' | 'bounded_raw';
+export type UnderstandingSourceProcessingPolicy = 'local_only' | 'remote_allowed';
+export interface UnderstandingSourceDefinition {
+    id: string;
+    category: UnderstandingSourceCategory;
+    platform: UnderstandingSourcePlatform;
+    displayName: string;
+    description: string;
+    availability: 'available' | 'unavailable';
+    permission: 'not_requested' | 'granted' | 'denied' | 'unavailable';
+    defaultAccessMode: UnderstandingSourceAccessMode;
+    supportedAccessModes: UnderstandingSourceAccessMode[];
+    recommended: boolean;
+    sensitive: boolean;
+}
+export interface UnderstandingSourceGrant {
+    id: string;
+    sourceKey: string;
+    adapterId: string;
+    category: UnderstandingSourceCategory;
+    platform: UnderstandingSourcePlatform;
+    displayName: string;
+    status: 'active' | 'revoked';
+    accessMode: UnderstandingSourceAccessMode;
+    retentionPolicy: UnderstandingSourceRetentionPolicy;
+    processingPolicy: UnderstandingSourceProcessingPolicy;
+    config: Record<string, unknown>;
+    checkpoint: Record<string, unknown>;
+    lastCollectedAt?: number;
+    createdAt: number;
+    updatedAt: number;
+}
+export interface UnderstandingSourceItem {
+    id: string;
+    sourceId: string;
+    type: 'document' | 'calendar_event' | 'task' | 'note' | 'mail' | 'message' | 'code_activity';
+    title: string;
+    text?: string;
+    group?: string;
+    occurredAt?: number;
+    modifiedAt?: number;
+    startsAt?: number;
+    endsAt?: number;
+    ownerAttribution: 'user' | 'other' | 'shared' | 'unknown';
+    sensitivity: 'normal' | 'personal' | 'secret' | 'regulated';
+    evidenceRef: string;
+}
+export interface UnderstandingSourceCollectionResult {
+    sourceId: string;
+    status: 'completed' | 'denied' | 'failed';
+    items: UnderstandingSourceItem[];
+    error?: string;
+}
+export interface UnderstandingSourceRun {
+    id: string;
+    grantId: string;
+    kind: 'preview' | 'bootstrap' | 'incremental' | 'fingerprint';
+    status: 'queued' | 'running' | 'completed' | 'partial' | 'failed' | 'canceled';
+    cursorBefore?: string;
+    cursorAfter?: string;
+    itemsSeen: number;
+    metadata: Record<string, unknown>;
+    errorMessage?: string;
+    startedAt: number;
+    completedAt?: number;
+}
+export interface UserFocus {
+    id: string;
+    canonicalKey: string;
+    title: string;
+    summary: string;
+    horizon: 'current' | 'ongoing' | 'long_term';
+    status: 'candidate' | 'active' | 'paused' | 'completed' | 'rejected';
+    confidence: number;
+    projectId?: string;
+    evidenceRefs: string[];
+    sourceRunId?: string;
+    createdAt: number;
+    updatedAt: number;
+}

package/dist/src/work-discovery/analyzer.d.ts

@@ -1,5 +1,6 @@
 import type { Config } from '../config/schema.js';
-import type { WorkContextSnapshot, WorkDiscoveryCandidate, WorkDiscoveryPersonalContextItem, WorkDiscoveryProfileCandidate, WorkDiscoveryResult, WorkUnderstandingThreadCandidate } from './types.js';
+import type { UnderstandingSourceItem } from '../user-context/sources/types.js';
+import type { WorkContextSnapshot, WorkDiscoveryCandidate, WorkDiscoveryProfileCandidate, WorkDiscoveryResult, WorkUnderstandingThreadCandidate } from './types.js';
 export declare function analyzeWorkContext(input: {
     config: Config;
     snapshot: WorkContextSnapshot;
@@ -9,9 +10,9 @@ export declare function analyzeWorkContext(input: {
     modelRef: string;
     result: WorkDiscoveryResult;
 }>;
-export declare function analyzePersonalContext(input: {
+export declare function analyzeUnderstandingSources(input: {
     config: Config;
-    items: WorkDiscoveryPersonalContextItem[];
+    items: UnderstandingSourceItem[];
     workContext?: Pick<WorkDiscoveryResult, 'projectSummary' | 'currentState' | 'uncertainties' | 'workThreads'>;
     signal?: AbortSignal;
 }): Promise<{

package/dist/src/work-discovery/analyzer.js

@@ -6,7 +6,7 @@ import { randomUUID } from "node:crypto";
 init_schema();
 init_providers();
 const MAX_MODEL_CONTEXT_CHARS = 12e4;
-const MAX_PERSONAL_CONTEXT_CHARS = 1e5;
+const MAX_UNDERSTANDING_SOURCE_CHARS = 1e5;
 const WORK_ANALYSIS_MAX_TOKENS = 6e3;
 function extractText(content) {
 	if (typeof content === "string") return content;
@@ -234,43 +234,48 @@ async function analyzeWorkContext(input) {
 		}
 	};
 }
-async function analyzePersonalContext(input) {
+async function analyzeUnderstandingSources(input) {
 	const modelRef = getAgentDefaultModelRef(input.config);
 	if (!modelRef) throw new Error("No default model configured");
-	let remaining = MAX_PERSONAL_CONTEXT_CHARS;
-	const items = input.items.slice(0, 150).flatMap((item, index) => {
+	let remaining = MAX_UNDERSTANDING_SOURCE_CHARS;
+	const items = input.items.filter((item) => item.sensitivity !== "secret" && item.sensitivity !== "regulated").slice(0, 150).flatMap((item) => {
 		if (remaining <= 0) return [];
-		const content = item.content.slice(0, remaining);
-		remaining -= content.length;
+		const text = (item.text ?? "").slice(0, remaining);
+		remaining -= text.length;
 		return [{
-			ref: `${item.source}:${index + 1}`,
-			source: item.source,
+			ref: item.evidenceRef,
+			source: item.sourceId,
+			type: item.type,
 			title: item.title,
 			group: item.group,
-			createdAt: item.createdAt,
+			occurredAt: item.occurredAt,
 			modifiedAt: item.modifiedAt,
 			startsAt: item.startsAt,
 			endsAt: item.endsAt,
-			content
+			ownerAttribution: item.ownerAttribution,
+			sensitivity: item.sensitivity,
+			text
 		}];
 	});
-	if (!items.some((item) => item.title.trim() || item.content.trim())) return {
+	if (!items.some((item) => item.title.trim() || item.text.trim())) return {
 		modelRef,
 		profileCandidates: [],
 		workThreadCandidates: []
 	};
 	const prompt = [
-		"Analyze the bounded personal work context that the user explicitly chose to connect from Apple Notes, Calendar, and Reminders.",
+		"Analyze bounded context from sources the user explicitly chose to connect.",
 		"Return only one JSON object with profileCandidates and workThreads.",
 		"profileCandidates contains at most 6 stable, useful work-related facts.",
 		"Each item has category (role, focus, technology, workflow, or preference), statement, confidence, and evidence.",
 		"workThreads contains at most 3 evidence-backed current, ongoing, or long-term work streams.",
 		"Each work thread has topicKey, title, summary, status, horizon, confidence, and evidenceRefs.",
-		"evidenceRefs must contain only the supplied source:index refs. Do not create a thread without direct support.",
+		"evidenceRefs must contain only supplied refs. Do not create a thread without direct support.",
+		"Synthesize across source types. Repeated independent signals are stronger than a single item.",
+		"Treat ownerAttribution other/shared/unknown conservatively: it may describe someone else and must not become a user fact without user-owned corroboration.",
 		"Prefer recurring work themes and durable preferences. Do not turn one-off errands or stale notes into user facts.",
 		"Do not infer sensitive identity, health, finances, political views, relationships, passwords, credentials, or private contact details.",
 		"Evidence must be a short paraphrase and must not quote private note content verbatim.",
-		"Calendar and reminder titles may establish commitments and timing, but must not be treated as stable preferences without repeated evidence.",
+		"Calendar events and tasks may establish commitments and timing, but must not be treated as stable preferences without repeated evidence.",
 		"When a work-directory summary is supplied, reconcile it with the personal sources: identify corroboration, conflicts, and whether an apparent focus is current or merely stale.",
 		"Do not repeat the directory summary as a personal fact unless at least one supplied personal source supports it.",
 		"Use Simplified Chinese when the supplied items are mainly Chinese; otherwise use English.",
@@ -288,7 +293,7 @@ async function analyzePersonalContext(input) {
 	});
 	const raw = extractText(response.content);
 	const parsed = parseJson(raw);
-	if (!parsed) throw invalidJsonError("Personal context analysis", response, raw);
+	if (!parsed) throw invalidJsonError("Understanding source analysis", response, raw);
 	const profileCandidates = Array.isArray(parsed.profileCandidates) ? parsed.profileCandidates.map(validateProfileCandidate).filter((value) => Boolean(value)).slice(0, 6) : [];
 	const allowedRefs = new Set(items.map((item) => item.ref));
 	return {
@@ -317,4 +322,4 @@ function workDiscoveryResultMarkdown(result) {
 	return lines.join("\n");
 }
 //#endregion
-export { analyzePersonalContext, analyzeWorkContext, workDiscoveryResultMarkdown };
+export { analyzeUnderstandingSources, analyzeWorkContext, workDiscoveryResultMarkdown };

package/dist/src/work-discovery/incremental-repository.js

@@ -1,55 +1,57 @@
-import { requireXopcDatabase } from "../storage/sqlite/connection.js";
-import { runSqliteWriteTransaction } from "../storage/sqlite/transaction.js";
+import { createUnderstandingSourceRun, listUnderstandingSourceGrants, listUnderstandingSourceRuns, updateUnderstandingSourceRun } from "../user-context/sources/repository.js";
 import { workDiscoveryFingerprintsEqual } from "./incremental.js";
-import { randomUUID } from "node:crypto";
+import { getWorkDiscoveryRun } from "./repository.js";
 //#region src/work-discovery/incremental-repository.ts
-function parseFingerprint(value) {
-	if (!value) return void 0;
-	try {
-		return JSON.parse(value);
-	} catch {
-		return;
-	}
-}
-function fromRow(row) {
+function refreshFromRun(run) {
+	const previousFingerprint = run.metadata.previousFingerprint;
 	return {
-		id: row.refresh_id,
-		sourceId: row.source_id,
-		changed: row.changed === 1,
-		...parseFingerprint(row.previous_fingerprint_json) ? { previousFingerprint: parseFingerprint(row.previous_fingerprint_json) } : {},
-		currentFingerprint: parseFingerprint(row.current_fingerprint_json),
-		status: row.status,
-		...row.discovery_run_id ? { discoveryRunId: row.discovery_run_id } : {},
-		checkedAt: row.checked_at
+		id: run.id,
+		sourceId: run.grantId,
+		changed: run.metadata.changed === true,
+		...previousFingerprint ? { previousFingerprint } : {},
+		currentFingerprint: run.metadata.currentFingerprint,
+		status: run.status === "running" ? "queued" : run.status,
+		...typeof run.metadata.discoveryRunId === "string" ? { discoveryRunId: run.metadata.discoveryRunId } : {},
+		checkedAt: run.startedAt
 	};
 }
 function recordWorkDiscoverySourceRefresh(input) {
-	const id = randomUUID();
-	runSqliteWriteTransaction((db) => {
-		db.prepare(`INSERT INTO work_discovery_source_refreshes (
-        refresh_id, source_id, discovery_run_id, changed, previous_fingerprint_json,
-        current_fingerprint_json, status, checked_at
-      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(id, input.sourceId, input.discoveryRunId ?? null, input.changed ? 1 : 0, input.previousFingerprint ? JSON.stringify(input.previousFingerprint) : null, JSON.stringify(input.currentFingerprint), input.status ?? "checked", input.checkedAt ?? Date.now());
-	});
-	const { db } = requireXopcDatabase();
-	return fromRow(db.prepare("SELECT * FROM work_discovery_source_refreshes WHERE refresh_id = ?").get(id));
+	const status = input.status === "queued" ? "running" : input.status === "failed" ? "failed" : "completed";
+	return refreshFromRun(createUnderstandingSourceRun({
+		grantId: input.sourceId,
+		kind: "fingerprint",
+		status,
+		metadata: {
+			changed: input.changed,
+			...input.previousFingerprint ? { previousFingerprint: input.previousFingerprint } : {},
+			currentFingerprint: input.currentFingerprint,
+			...input.discoveryRunId ? { discoveryRunId: input.discoveryRunId } : {}
+		},
+		...input.checkedAt != null ? { nowMs: input.checkedAt } : {}
+	}));
 }
 function listWorkDiscoverySourceRefreshes(sourceId, limit = 20) {
-	const { db } = requireXopcDatabase();
-	return db.prepare("SELECT * FROM work_discovery_source_refreshes WHERE source_id = ? ORDER BY checked_at DESC LIMIT ?").all(sourceId, Math.max(1, Math.min(100, limit))).map(fromRow);
+	return listUnderstandingSourceRuns(sourceId, limit).filter((run) => run.kind === "fingerprint").map(refreshFromRun);
 }
 function findActiveWorkDiscoverySourceRefresh(sourceId, fingerprint) {
-	const { db } = requireXopcDatabase();
-	return db.prepare(`SELECT refresh.* FROM work_discovery_source_refreshes refresh
-     JOIN work_discovery_runs run ON run.id = refresh.discovery_run_id
-     WHERE refresh.source_id = ? AND refresh.status = 'queued'
-       AND run.status IN ('queued', 'probing', 'analyzing')
-     ORDER BY refresh.checked_at DESC`).all(sourceId).map(fromRow).find((refresh) => workDiscoveryFingerprintsEqual(refresh.currentFingerprint, fingerprint)) ?? null;
+	return listWorkDiscoverySourceRefreshes(sourceId, 100).find((refresh) => {
+		if (refresh.status !== "queued" || !refresh.discoveryRunId) return false;
+		const run = getWorkDiscoveryRun(refresh.discoveryRunId);
+		return Boolean(run && [
+			"queued",
+			"probing",
+			"analyzing"
+		].includes(run.status) && workDiscoveryFingerprintsEqual(refresh.currentFingerprint, fingerprint));
+	}) ?? null;
 }
 function updateWorkDiscoverySourceRefreshForRun(runId, status) {
-	runSqliteWriteTransaction((db) => {
-		db.prepare("UPDATE work_discovery_source_refreshes SET status = ? WHERE discovery_run_id = ?").run(status, runId);
-	});
+	for (const source of listUnderstandingSourceGrants()) {
+		const refresh = listUnderstandingSourceRuns(source.id, 100).find((item) => item.kind === "fingerprint" && item.metadata.discoveryRunId === runId);
+		if (refresh) updateUnderstandingSourceRun(refresh.id, {
+			status,
+			completed: true
+		});
+	}
 }
 //#endregion
 export { findActiveWorkDiscoverySourceRefresh, listWorkDiscoverySourceRefreshes, recordWorkDiscoverySourceRefresh, updateWorkDiscoverySourceRefreshForRun };