@xopcai/xopc 0.0.188 → 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/user-context/understandingQuality.d.ts

@@ -0,0 +1,5 @@
+import type { MemoryKind } from '../agent/memory/types.js';
+export declare function isStandaloneUnderstandingContent(content: string): boolean;
+export declare function isActionableUnderstandingContent(content: string): boolean;
+export declare function isDurableUnderstandingCandidate(kind: MemoryKind, content: string): boolean;
+export declare function isNearDuplicateUnderstanding(left: string, right: string): boolean;

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

@@ -0,0 +1,44 @@
+//#region src/user-context/understandingQuality.ts
+const INCOMPLETE_PREFIX = /^(?:and\b|also\b|then\b|plus\b|as\s+well\s+as\b|which\b|that\b|并且|并将|以及|然后|同时|另外|还有|而且|或者|的事项|事项[，,、：:]?)/i;
+const DEFERRED_OR_NEGATED_ACTION = /(?:not\s+now|no\s+need\s+to|do\s+not\s+(?:start|proceed)|don't\s+(?:start|proceed)|later\s+maybe|暂时不用|暂时不(?:用|要|开始)?|先不用|无需|不用开始|不要推进|不需要推进)/i;
+const ONE_OFF_ACTION_PREFIX = /^(?:please\s+|update\b|investigate\b|summari[sz]e\b|fix\b|write\b|add\b|record\b|track\b)|^(?:请|帮我|更新|调查|汇总|整理|修复|写入|加入|记录|跟进)/i;
+function meaningfulLength(content) {
+	return content.normalize("NFKC").replace(/[\p{P}\p{S}\s]/gu, "").length;
+}
+function isStandaloneUnderstandingContent(content) {
+	const normalized = content.normalize("NFKC").trim();
+	return meaningfulLength(normalized) >= 4 && !INCOMPLETE_PREFIX.test(normalized) && !DEFERRED_OR_NEGATED_ACTION.test(normalized);
+}
+function isActionableUnderstandingContent(content) {
+	return meaningfulLength(content) >= 8 && isStandaloneUnderstandingContent(content);
+}
+function isDurableUnderstandingCandidate(kind, content) {
+	if (!isStandaloneUnderstandingContent(content)) return false;
+	if ((kind === "commitment" || kind === "long_term_goal") && ONE_OFF_ACTION_PREFIX.test(content.trim())) return false;
+	return true;
+}
+function comparableText(content) {
+	return content.normalize("NFKC").toLocaleLowerCase().replace(/[\p{P}\p{S}\s]/gu, "");
+}
+function bigrams(content) {
+	const result = /* @__PURE__ */ new Set();
+	for (let index = 0; index < content.length - 1; index += 1) result.add(content.slice(index, index + 2));
+	return result;
+}
+function isNearDuplicateUnderstanding(left, right) {
+	const a = comparableText(left);
+	const b = comparableText(right);
+	if (!a || !b) return false;
+	if (a === b) return true;
+	const shorter = a.length <= b.length ? a : b;
+	const longer = a.length > b.length ? a : b;
+	if (shorter.length >= 8 && longer.includes(shorter) && shorter.length / longer.length >= .55) return true;
+	if (shorter.length < 4) return false;
+	const aPairs = bigrams(a);
+	const bPairs = bigrams(b);
+	let overlap = 0;
+	for (const pair of aPairs) if (bPairs.has(pair)) overlap += 1;
+	return 2 * overlap / (aPairs.size + bPairs.size) >= .78;
+}
+//#endregion
+export { isActionableUnderstandingContent, isDurableUnderstandingCandidate, isNearDuplicateUnderstanding, isStandaloneUnderstandingContent };

package/dist/src/utils/logger/log-stream.d.ts

@@ -1,15 +1,8 @@
-/**
- * Log Streaming Module - SSE real-time log delivery
- */
+/** In-process live log fan-out. */
 import type { LogLevel, LogEntry } from './types.js';
 export type { LogLevel, LogEntry };
+type LogSubscriber = (entry: LogEntry) => void;
+export declare function subscribeToLogs(subscriber: LogSubscriber): () => void;
 export declare function hasSubscribers(): boolean;
 /** @internal Called from Pino live emit stream */
 export declare function emitLogEntry(entry: LogEntry): void;
-/** Hono handler for `GET /api/logs/stream`. */
-export declare function createLogSSEHandler(): (c: {
-    req: {
-        raw: Request;
-        url: string;
-    };
-}) => Promise<Response>;

package/dist/src/utils/logger/log-stream.js

@@ -4,9 +4,6 @@ function subscribeToLogs(subscriber) {
 	subscribers.add(subscriber);
 	return () => subscribers.delete(subscriber);
 }
-function getSubscriberCount() {
-	return subscribers.size;
-}
 function hasSubscribers() {
 	return subscribers.size > 0;
 }
@@ -17,78 +14,10 @@ function emitLogEntry(entry) {
 		subscriber(entry);
 	} catch {}
 }
-function parseAllowedLevels(levelsParam) {
-	if (!levelsParam) return [
-		"info",
-		"warn",
-		"error",
-		"fatal"
-	];
-	return levelsParam.split(",").filter((l) => VALID_LEVELS.includes(l));
-}
-function createLogSseResponse(req, allowedLevels, moduleFilter) {
-	const stream = new ReadableStream({ start(controller) {
-		const encoder = new TextEncoder();
-		const sendEvent = (data) => {
-			const message = `data: ${JSON.stringify(data)}\n\n`;
-			controller.enqueue(encoder.encode(message));
-		};
-		sendEvent({
-			type: "connected",
-			message: "Log stream started"
-		});
-		const unsubscribe = subscribeToLogs((entry) => {
-			if (!allowedLevels.includes(entry.level)) return;
-			if (moduleFilter && entry.module !== moduleFilter) return;
-			sendEvent(entry);
-		});
-		const heartbeat = setInterval(() => {
-			try {
-				sendEvent({
-					type: "heartbeat",
-					subscribers: getSubscriberCount()
-				});
-			} catch {
-				clearInterval(heartbeat);
-			}
-		}, 3e4);
-		req.signal.addEventListener("abort", () => {
-			unsubscribe();
-			clearInterval(heartbeat);
-			try {
-				controller.close();
-			} catch {}
-		});
-	} });
-	return new Response(stream, { headers: {
-		"Content-Type": "text/event-stream",
-		"Cache-Control": "no-cache",
-		Connection: "keep-alive",
-		"X-Accel-Buffering": "no"
-	} });
-}
-/** Hono handler for `GET /api/logs/stream`. */
-function createLogSSEHandler() {
-	return async (c) => {
-		const url = new URL(c.req.url);
-		const allowedLevels = parseAllowedLevels(url.searchParams.get("levels"));
-		const moduleFilter = url.searchParams.get("module");
-		return createLogSseResponse(c.req.raw, allowedLevels, moduleFilter);
-	};
-}
-var subscribers, VALID_LEVELS;
+var subscribers;
 var init_log_stream = __esmMin((() => {
 	subscribers = /* @__PURE__ */ new Set();
-	VALID_LEVELS = [
-		"trace",
-		"debug",
-		"info",
-		"warn",
-		"error",
-		"fatal",
-		"silent"
-	];
 }));
 //#endregion
 init_log_stream();
-export { createLogSSEHandler, emitLogEntry, hasSubscribers, init_log_stream };
+export { emitLogEntry, hasSubscribers, init_log_stream, subscribeToLogs };

package/dist/src/utils/logger/pino-record.d.ts

@@ -1,5 +1,5 @@
 /**
- * Shared Pino JSON record → LogEntry conversion for file query and live SSE.
+ * Shared Pino JSON record → LogEntry conversion for file query and live realtime delivery.
  */
 import type { LogEntry } from './types.js';
 /** Convert a parsed Pino JSON object into a normalized LogEntry. */

package/dist/src/utils/logger/streams.js

@@ -32,7 +32,7 @@ function createLogStream(filePath) {
 		encoding: "utf-8"
 	});
 }
-/** Push parsed Pino lines to live SSE subscribers when any are connected. */
+/** Push parsed Pino lines to live realtime subscribers when any are connected. */
 function createLiveEmitStream() {
 	return new Writable({ write(chunk, _encoding, callback) {
 		if (hasSubscribers()) try {

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<{