@xopcai/xopc 0.0.247 → 0.0.249

package/dist/src/memory-maintenance/service.d.ts

@@ -0,0 +1,28 @@
+export type MemoryMaintenanceJob = 'temporal_sweep' | 'daily_reconciliation' | 'weekly_knowledge' | 'manual_repair';
+export interface MemoryMaintenanceMetrics {
+    scanned: number;
+    stale: number;
+    needsReview: number;
+    activated: number;
+    expiredPriorities: number;
+    archived: number;
+    repairedIndexes: number;
+}
+export interface MemoryMaintenanceResult {
+    runId: string;
+    jobType: MemoryMaintenanceJob;
+    status: 'running' | 'completed' | 'failed';
+    skipped: boolean;
+    metrics: MemoryMaintenanceMetrics;
+}
+export interface RunMemoryMaintenanceInput {
+    jobType: MemoryMaintenanceJob;
+    principalId?: string;
+    now?: number;
+    idempotencyKey?: string;
+    limit?: number;
+    staleRetentionDays?: number;
+    evidenceThreshold?: number;
+}
+export declare function runMemoryMaintenance(input: RunMemoryMaintenanceInput): MemoryMaintenanceResult;
+export declare function listMemoryMaintenanceRuns(limit?: number): Array<Record<string, unknown>>;

package/dist/src/memory-maintenance/service.js

@@ -0,0 +1,216 @@
+import { getSqliteDatabase, runSqliteWriteTransaction } from "../storage/sqlite/transaction.js";
+import "../user-model/domain.js";
+import { randomUUID } from "node:crypto";
+//#region src/memory-maintenance/service.ts
+const ALGORITHM_VERSION = "user-model-maintenance-v1";
+function emptyMetrics() {
+	return {
+		scanned: 0,
+		stale: 0,
+		needsReview: 0,
+		activated: 0,
+		expiredPriorities: 0,
+		archived: 0,
+		repairedIndexes: 0
+	};
+}
+function periodKey(job, now) {
+	const date = new Date(now);
+	if (job === "temporal_sweep") return date.toISOString().slice(0, 13);
+	if (job === "daily_reconciliation") return date.toISOString().slice(0, 10);
+	if (job === "weekly_knowledge") {
+		const monday = new Date(Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate()));
+		const day = monday.getUTCDay() || 7;
+		monday.setUTCDate(monday.getUTCDate() - day + 1);
+		return monday.toISOString().slice(0, 10);
+	}
+	return String(now);
+}
+function addDecision(db, runId, objectType, objectId, action, reason, before, after, now) {
+	db.prepare(`INSERT INTO memory_maintenance_decisions (
+    decision_id, run_id, object_type, object_id, action, reason, before_json, after_json, created_at
+  ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(randomUUID(), runId, objectType, objectId, action, reason, before === void 0 ? null : JSON.stringify(before), after === void 0 ? null : JSON.stringify(after), now);
+}
+function transitionAssertions(db, runId, now, limit, metrics) {
+	const expired = db.prepare(`SELECT assertion_id, status, valid_to FROM user_assertions
+    WHERE status = 'active' AND valid_to IS NOT NULL AND valid_to < ? LIMIT ?`).all(now, limit);
+	metrics.scanned += expired.length;
+	for (const row of expired) {
+		db.prepare("UPDATE user_assertions SET status = 'stale' WHERE assertion_id = ? AND status = 'active'").run(row.assertion_id);
+		db.prepare(`INSERT INTO user_assertion_status_events (
+      event_id, assertion_id, from_status, to_status, actor_type, reason, source_run_id, created_at
+    ) VALUES (?, ?, 'active', 'stale', 'maintenance', 'Validity interval ended.', ?, ?)`).run(randomUUID(), row.assertion_id, runId, now);
+		addDecision(db, runId, "assertion", row.assertion_id, "stale", "validity_ended", row, { status: "stale" }, now);
+		metrics.stale += 1;
+	}
+	const reviewDue = db.prepare(`SELECT assertion_id, status, review_at FROM user_assertions
+    WHERE status = 'active' AND review_at IS NOT NULL AND review_at <= ? LIMIT ?`).all(now, Math.max(0, limit - expired.length));
+	metrics.scanned += reviewDue.length;
+	for (const row of reviewDue) {
+		db.prepare("UPDATE user_assertions SET status = 'needs_review' WHERE assertion_id = ? AND status = 'active'").run(row.assertion_id);
+		db.prepare(`INSERT INTO user_assertion_status_events (
+      event_id, assertion_id, from_status, to_status, actor_type, reason, source_run_id, created_at
+    ) VALUES (?, ?, 'active', 'needs_review', 'maintenance', 'Scheduled review became due.', ?, ?)`).run(randomUUID(), row.assertion_id, runId, now);
+		addDecision(db, runId, "assertion", row.assertion_id, "needs_review", "review_due", row, { status: "needs_review" }, now);
+		metrics.needsReview += 1;
+	}
+}
+function transitionPriorities(db, runId, principalId, now, limit, metrics) {
+	const rows = db.prepare(`SELECT priority_id, status, valid_to FROM user_priority_windows
+    WHERE principal_id = ? AND status = 'active' AND valid_to < ? LIMIT ?`).all(principalId, now, limit);
+	metrics.scanned += rows.length;
+	for (const row of rows) {
+		db.prepare("UPDATE user_priority_windows SET status = 'expired', updated_at = ? WHERE priority_id = ?").run(now, row.priority_id);
+		addDecision(db, runId, "priority", row.priority_id, "expired", "priority_window_ended", row, { status: "expired" }, now);
+		metrics.expiredPriorities += 1;
+	}
+}
+function transitionKnowledge(db, runId, principalId, now, limit, metrics) {
+	const expired = db.prepare(`SELECT knowledge_id, status, expires_at FROM knowledge_items
+    WHERE principal_id = ? AND status = 'active' AND expires_at IS NOT NULL AND expires_at < ? LIMIT ?`).all(principalId, now, limit);
+	metrics.scanned += expired.length;
+	for (const row of expired) {
+		db.prepare("UPDATE knowledge_items SET status = 'stale', updated_at = ? WHERE knowledge_id = ?").run(now, row.knowledge_id);
+		addDecision(db, runId, "knowledge", row.knowledge_id, "stale", "retention_expired", row, { status: "stale" }, now);
+		metrics.stale += 1;
+	}
+	const reviewDue = db.prepare(`SELECT knowledge_id, status, review_at FROM knowledge_items
+    WHERE principal_id = ? AND status = 'active' AND review_at IS NOT NULL AND review_at <= ? LIMIT ?`).all(principalId, now, Math.max(0, limit - expired.length));
+	metrics.scanned += reviewDue.length;
+	for (const row of reviewDue) {
+		db.prepare("UPDATE knowledge_items SET status = 'needs_review', updated_at = ? WHERE knowledge_id = ?").run(now, row.knowledge_id);
+		addDecision(db, runId, "knowledge", row.knowledge_id, "needs_review", "review_due", row, { status: "needs_review" }, now);
+		metrics.needsReview += 1;
+	}
+}
+function reconcileEvidence(db, runId, principalId, now, limit, evidenceThreshold, metrics) {
+	const contradicted = db.prepare(`SELECT DISTINCT a.assertion_id, a.status
+    FROM user_assertions a
+    JOIN user_assertion_slots s ON s.slot_id = a.slot_id
+    JOIN user_assertion_evidence ae ON ae.assertion_id = a.assertion_id AND ae.relation = 'contradicts'
+    WHERE s.principal_id = ? AND a.status = 'active' LIMIT ?`).all(principalId, limit);
+	metrics.scanned += contradicted.length;
+	for (const row of contradicted) {
+		db.prepare("UPDATE user_assertions SET status = 'needs_review' WHERE assertion_id = ?").run(row.assertion_id);
+		db.prepare(`INSERT INTO user_assertion_status_events (
+      event_id, assertion_id, from_status, to_status, actor_type, reason, source_run_id, created_at
+    ) VALUES (?, ?, 'active', 'needs_review', 'maintenance', 'Contradictory evidence exists.', ?, ?)`).run(randomUUID(), row.assertion_id, runId, now);
+		addDecision(db, runId, "assertion", row.assertion_id, "needs_review", "contradictory_evidence", row, { status: "needs_review" }, now);
+		metrics.needsReview += 1;
+	}
+	const candidates = db.prepare(`SELECT a.assertion_id, a.status, COUNT(DISTINCT
+      e.source_type || ':' || COALESCE(e.source_instance_id, '') || ':' || e.source_ref
+    ) AS evidence_count
+    FROM user_assertions a
+    JOIN user_assertion_slots s ON s.slot_id = a.slot_id
+    JOIN user_assertion_evidence ae ON ae.assertion_id = a.assertion_id AND ae.relation = 'supports'
+    JOIN context_evidence e ON e.evidence_id = ae.evidence_id AND e.trust_level = 'owner'
+    WHERE s.principal_id = ? AND a.status = 'candidate'
+      AND a.authority IN ('user_observed', 'system_inferred')
+    GROUP BY a.assertion_id HAVING evidence_count >= ? LIMIT ?`).all(principalId, evidenceThreshold, limit);
+	metrics.scanned += candidates.length;
+	for (const row of candidates) {
+		db.prepare("UPDATE user_assertions SET status = 'active' WHERE assertion_id = ? AND status = 'candidate'").run(row.assertion_id);
+		db.prepare(`INSERT INTO user_assertion_status_events (
+      event_id, assertion_id, from_status, to_status, actor_type, reason, source_run_id, created_at
+    ) VALUES (?, ?, 'candidate', 'active', 'maintenance', 'Independent owner evidence threshold met.', ?, ?)`).run(randomUUID(), row.assertion_id, runId, now);
+		addDecision(db, runId, "assertion", row.assertion_id, "activated", "owner_evidence_threshold", row, { status: "active" }, now);
+		metrics.activated += 1;
+	}
+}
+function repairIndexes(db, runId, now, metrics) {
+	const assertionMissing = db.prepare(`SELECT COUNT(*) AS count FROM user_assertions a
+    LEFT JOIN user_assertions_fts f ON f.assertion_id = a.assertion_id
+    WHERE f.assertion_id IS NULL`).get();
+	const knowledgeMissing = db.prepare(`SELECT COUNT(*) AS count FROM knowledge_items k
+    LEFT JOIN knowledge_items_fts f ON f.knowledge_id = k.knowledge_id
+    WHERE f.knowledge_id IS NULL`).get();
+	if (assertionMissing.count) db.prepare(`INSERT INTO user_assertions_fts(statement, assertion_id, slot_id)
+      SELECT a.statement, a.assertion_id, a.slot_id FROM user_assertions a
+      LEFT JOIN user_assertions_fts f ON f.assertion_id = a.assertion_id WHERE f.assertion_id IS NULL`).run();
+	if (knowledgeMissing.count) db.prepare(`INSERT INTO knowledge_items_fts(content, knowledge_id)
+      SELECT k.content, k.knowledge_id FROM knowledge_items k
+      LEFT JOIN knowledge_items_fts f ON f.knowledge_id = k.knowledge_id WHERE f.knowledge_id IS NULL`).run();
+	metrics.repairedIndexes = assertionMissing.count + knowledgeMissing.count;
+	if (metrics.repairedIndexes) addDecision(db, runId, "index", "fts", "repair", "missing_index_rows", { missing: metrics.repairedIndexes }, { missing: 0 }, now);
+}
+function archiveOldKnowledge(db, runId, principalId, cutoff, now, limit, metrics) {
+	const rows = db.prepare(`SELECT knowledge_id, status, updated_at FROM knowledge_items
+    WHERE principal_id = ? AND status = 'stale' AND updated_at < ? LIMIT ?`).all(principalId, cutoff, limit);
+	metrics.scanned += rows.length;
+	for (const row of rows) {
+		db.prepare("UPDATE knowledge_items SET status = 'archived', updated_at = ? WHERE knowledge_id = ?").run(now, row.knowledge_id);
+		addDecision(db, runId, "knowledge", row.knowledge_id, "archived", "stale_retention_elapsed", row, { status: "archived" }, now);
+		metrics.archived += 1;
+	}
+}
+function runMemoryMaintenance(input) {
+	const now = input.now ?? Date.now();
+	const principalId = input.principalId ?? "local-owner";
+	const limit = Math.max(1, Math.min(1e4, input.limit ?? 1e3));
+	const evidenceThreshold = Math.max(2, Math.min(10, input.evidenceThreshold ?? 2));
+	const idempotencyKey = input.idempotencyKey ?? `${principalId}:${input.jobType}:${periodKey(input.jobType, now)}`;
+	const existing = getSqliteDatabase().prepare(`SELECT run_id, status, metrics_json
+    FROM memory_maintenance_runs WHERE idempotency_key = ?`).get(idempotencyKey);
+	if (existing && existing.status !== "failed") return {
+		runId: existing.run_id,
+		jobType: input.jobType,
+		status: existing.status,
+		skipped: true,
+		metrics: JSON.parse(existing.metrics_json)
+	};
+	const runId = existing?.run_id ?? randomUUID();
+	const metrics = emptyMetrics();
+	const snapshot = JSON.stringify({
+		limit,
+		staleRetentionDays: input.staleRetentionDays ?? 30,
+		evidenceThreshold
+	});
+	runSqliteWriteTransaction((db) => {
+		if (existing) db.prepare(`UPDATE memory_maintenance_runs SET status = 'running', config_snapshot_json = ?,
+        cursor_json = '{}', metrics_json = '{}', error_message = NULL, started_at = ?, finished_at = NULL
+        WHERE run_id = ?`).run(snapshot, now, runId);
+		else db.prepare(`INSERT INTO memory_maintenance_runs (
+        run_id, principal_id, job_type, idempotency_key, algorithm_version,
+        config_snapshot_json, status, started_at
+      ) VALUES (?, ?, ?, ?, ?, ?, 'running', ?)`).run(runId, principalId, input.jobType, idempotencyKey, ALGORITHM_VERSION, snapshot, now);
+	});
+	try {
+		runSqliteWriteTransaction((db) => {
+			transitionAssertions(db, runId, now, limit, metrics);
+			transitionPriorities(db, runId, principalId, now, limit, metrics);
+			transitionKnowledge(db, runId, principalId, now, limit, metrics);
+			if (input.jobType === "daily_reconciliation" || input.jobType === "manual_repair") {
+				reconcileEvidence(db, runId, principalId, now, limit, evidenceThreshold, metrics);
+				repairIndexes(db, runId, now, metrics);
+			}
+			if (input.jobType === "weekly_knowledge" || input.jobType === "manual_repair") archiveOldKnowledge(db, runId, principalId, now - (input.staleRetentionDays ?? 30) * 24 * 60 * 60 * 1e3, now, limit, metrics);
+			db.prepare(`UPDATE memory_maintenance_runs SET status = 'completed', metrics_json = ?, finished_at = ?
+        WHERE run_id = ?`).run(JSON.stringify(metrics), now, runId);
+		});
+		return {
+			runId,
+			jobType: input.jobType,
+			status: "completed",
+			skipped: false,
+			metrics
+		};
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		getSqliteDatabase().prepare(`UPDATE memory_maintenance_runs SET status = 'failed',
+      metrics_json = ?, error_message = ?, finished_at = ? WHERE run_id = ?`).run(JSON.stringify(metrics), message, now, runId);
+		throw error;
+	}
+}
+function listMemoryMaintenanceRuns(limit = 20) {
+	return getSqliteDatabase().prepare(`SELECT run_id AS runId, principal_id AS principalId,
+    job_type AS jobType, idempotency_key AS idempotencyKey, algorithm_version AS algorithmVersion,
+    status, metrics_json AS metricsJson, error_message AS errorMessage,
+    started_at AS startedAt, finished_at AS finishedAt
+    FROM memory_maintenance_runs ORDER BY started_at DESC LIMIT ?`).all(Math.max(1, Math.min(100, limit))).map(({ metricsJson, ...row }) => ({
+		...row,
+		metrics: typeof metricsJson === "string" ? JSON.parse(metricsJson) : {}
+	}));
+}
+//#endregion
+export { listMemoryMaintenanceRuns, runMemoryMaintenance };

package/dist/src/notes/index.d.ts

@@ -2,5 +2,5 @@ export { NotesStore } from './store.js';
 export { NotesService } from './service.js';
 export { buildNoteAgentContext, buildNoteAgentContextArtifact, getCachedNoteAgentContextArtifact } from './agent-context.js';
 export type { NoteAgentContextArtifact, NoteAgentAttachmentContext } from './agent-context.js';
-export { resolveNotesDir, resolveNotesIndexPath, resolveNoteItemPath, resolveNoteMediaDir, resolveNoteHistoryDir } from './paths.js';
+export { resolveNotesDir, resolveNoteMediaDir } from './paths.js';
 export type { Note, NoteKind, NoteStatus, NoteAttachment, NoteAiMeta, NoteAiDeepMeta, NoteIndexEntry, NoteSnapshot, NoteSnapshotEntry, NotesIndexFile, NotesListQuery, CaptureSource, CaptureChannel, CreateNoteParams, SnapshotTrigger, NoteTaskMeta, NoteGroup, } from './types.js';

package/dist/src/notes/index.js

@@ -1,5 +1,5 @@
-import { resolveNoteHistoryDir, resolveNoteItemPath, resolveNoteMediaDir, resolveNotesDir, resolveNotesIndexPath } from "./paths.js";
+import { resolveNoteMediaDir, resolveNotesDir } from "./paths.js";
 import { NotesStore } from "./store.js";
 import { buildNoteAgentContext, buildNoteAgentContextArtifact, getCachedNoteAgentContextArtifact } from "./agent-context.js";
 import { NotesService } from "./service.js";
-export { NotesService, NotesStore, buildNoteAgentContext, buildNoteAgentContextArtifact, getCachedNoteAgentContextArtifact, resolveNoteHistoryDir, resolveNoteItemPath, resolveNoteMediaDir, resolveNotesDir, resolveNotesIndexPath };
+export { NotesService, NotesStore, buildNoteAgentContext, buildNoteAgentContextArtifact, getCachedNoteAgentContextArtifact, resolveNoteMediaDir, resolveNotesDir };

package/dist/src/notes/paths.d.ts

@@ -1,5 +1,2 @@
 export declare function resolveNotesDir(): string;
-export declare function resolveNotesIndexPath(): string;
-export declare function resolveNoteItemPath(noteId: string): string;
 export declare function resolveNoteMediaDir(noteId: string): string;
-export declare function resolveNoteHistoryDir(noteId: string): string;

package/dist/src/notes/paths.js

@@ -5,17 +5,8 @@ init_paths_state();
 function resolveNotesDir() {
 	return join(resolveStateDir(), "notes");
 }
-function resolveNotesIndexPath() {
-	return join(resolveNotesDir(), "index.json");
-}
-function resolveNoteItemPath(noteId) {
-	return join(resolveNotesDir(), "items", `${noteId}.json`);
-}
 function resolveNoteMediaDir(noteId) {
 	return join(resolveNotesDir(), "media", noteId);
 }
-function resolveNoteHistoryDir(noteId) {
-	return join(resolveNotesDir(), "history", noteId);
-}
 //#endregion
-export { resolveNoteHistoryDir, resolveNoteItemPath, resolveNoteMediaDir, resolveNotesDir, resolveNotesIndexPath };
+export { resolveNoteMediaDir, resolveNotesDir };

package/dist/src/notes/service.d.ts

@@ -46,6 +46,7 @@ export declare class NotesService {
         offset: number;
         hasMore: boolean;
     }>;
+    listProjectSummaries(): import("./types.js").NoteProjectSummary[];
     addAttachment(noteId: string, file: {
         name: string;
         buffer: Buffer;
@@ -63,7 +64,6 @@ export declare class NotesService {
     listNoteHistory(noteId: string): Promise<NoteSnapshotEntry[]>;
     getNoteSnapshot(noteId: string, timestamp: number): Promise<NoteSnapshot | null>;
     restoreNoteSnapshot(noteId: string, timestamp: number): Promise<Note | null>;
-    flush(): Promise<void>;
     moveToGroup(noteId: string, groupId: string | null): Promise<Note | null>;
     createTask(title: string, source: CaptureSource, opts?: {
         dueAt?: number;

package/dist/src/notes/service.js

@@ -2,6 +2,7 @@ import { createLogger } from "../utils/logger/index.js";
 import { init_logger } from "../utils/logger.js";
 import { buildNoteAttachmentRef } from "./attachment-ref.js";
 import { parseNoteMarkdown } from "./note-markdown.js";
+import { listNoteProjectSummaries } from "../storage/sqlite/notes-repository.js";
 import { changedFieldsFromPatch, emitActivity, previewText, systemActivityActor, systemActivitySource } from "../activity/emitter.js";
 import { getDefaultModelSync, init_providers, resolveModel } from "../providers/index.js";
 import { completeWithResolvedCredentials } from "../providers/model-call.js";
@@ -280,6 +281,7 @@ var NotesService = class {
 		const contentTouched = patch.markdown !== void 0 || patch.title !== void 0;
 		if (contentTouched) await this.maybeSaveSnapshot(existing, trigger);
 		const normalizedPatch = { ...patch };
+		if (contentTouched) normalizedPatch.lastEditTrigger = trigger;
 		if (patch.markdown !== void 0) normalizedPatch.kind = patch.kind ?? inferKind(patch.markdown, Boolean(existing.attachments?.length), existing.attachments);
 		if (contentTouched || patch.attachments) {
 			normalizedPatch.remoteVersion = (existing.remoteVersion ?? 1) + 1;
@@ -483,6 +485,9 @@ var NotesService = class {
 	async listNotes(query = {}) {
 		return this.store.listNotes(query);
 	}
+	listProjectSummaries() {
+		return listNoteProjectSummaries();
+	}
 	async addAttachment(noteId, file, idempotencyKey) {
 		if (!idempotencyKey) return this.addAttachmentWithId(noteId, file, randomUUID());
 		const attachmentId = noteAttachmentId(noteId, idempotencyKey);
@@ -555,12 +560,10 @@ var NotesService = class {
 			markdown: snapshot.markdown,
 			tags: snapshot.tags,
 			kind: snapshot.kind,
-			status: snapshot.status
+			status: snapshot.status,
+			lastEditTrigger: "restore"
 		});
 	}
-	async flush() {
-		await this.store.flush();
-	}
 	async moveToGroup(noteId, groupId) {
 		return this.updateNote(noteId, { groupId: groupId ?? void 0 });
 	}

package/dist/src/notes/store.d.ts

@@ -25,7 +25,5 @@ export declare class NotesStore {
     getSnapshot(noteId: string, timestamp: number): Promise<NoteSnapshot | null>;
     pruneSnapshots(noteId: string, maxCount: number): Promise<void>;
     deleteAllSnapshots(noteId: string): Promise<void>;
-    /** No-op: SQLite writes are synchronous. Kept for API compatibility with tests. */
-    flush(): Promise<void>;
 }
 export { buildNoteIndexMeta };

package/dist/src/notes/store.js

@@ -1,17 +1,16 @@
 import { createLogger } from "../utils/logger/index.js";
 import { init_logger } from "../utils/logger.js";
 import { requireXopcDatabase } from "../storage/sqlite/connection.js";
+import { runSqliteWriteTransaction } from "../storage/sqlite/transaction.js";
 import { buildNoteIndexMeta } from "./note-index-meta.js";
 import { deleteNoteRecord, getNoteRecord, listNoteRecords, upsertNoteRecord } from "../storage/sqlite/notes-repository.js";
 import { deleteNoteAgentContextRecord } from "../storage/sqlite/note-agent-context-repository.js";
 import "../storage/sqlite/index.js";
-import { init_write_file_atomic, writeTextAtomic } from "../infra/write-file-atomic.js";
-import { resolveNoteHistoryDir, resolveNoteMediaDir } from "./paths.js";
+import { resolveNoteMediaDir } from "./paths.js";
 import { join } from "node:path";
 import { randomUUID } from "node:crypto";
-import { mkdir, readFile, readdir, rm, writeFile } from "node:fs/promises";
+import { mkdir, rm, writeFile } from "node:fs/promises";
 //#region src/notes/store.ts
-init_write_file_atomic();
 init_logger();
 const log = createLogger("NotesStore");
 var NotesStore = class {
@@ -81,91 +80,45 @@ var NotesStore = class {
 		});
 	}
 	async saveSnapshot(note, trigger) {
-		const historyDir = resolveNoteHistoryDir(note.id);
-		await mkdir(historyDir, { recursive: true });
-		const snapshot = {
-			noteId: note.id,
-			timestamp: Date.now(),
-			trigger,
-			title: note.title,
-			markdown: note.markdown,
-			tags: note.tags,
-			kind: note.kind,
-			status: note.status
-		};
-		await writeTextAtomic(join(historyDir, `${snapshot.timestamp}.json`), JSON.stringify(snapshot, null, 2));
-		log.debug({
-			noteId: note.id,
-			trigger,
-			timestamp: snapshot.timestamp
-		}, "Snapshot saved");
+		requireXopcDatabase();
+		runSqliteWriteTransaction((db) => {
+			const row = db.prepare("SELECT MAX(timestamp) AS timestamp FROM note_snapshots WHERE note_id = ?").get(note.id);
+			const snapshot = {
+				noteId: note.id,
+				timestamp: Math.max(Date.now(), (row.timestamp ?? 0) + 1),
+				trigger,
+				title: note.title,
+				markdown: note.markdown,
+				tags: note.tags,
+				kind: note.kind,
+				status: note.status
+			};
+			db.prepare("INSERT INTO note_snapshots(note_id, timestamp, payload) VALUES (?, ?, ?)").run(note.id, snapshot.timestamp, JSON.stringify(snapshot));
+		});
 	}
 	async listSnapshots(noteId) {
-		const historyDir = resolveNoteHistoryDir(noteId);
-		let files;
-		try {
-			files = await readdir(historyDir);
-		} catch {
-			return [];
-		}
-		const entries = [];
-		for (const file of files) {
-			if (!file.endsWith(".json")) continue;
-			const timestamp = parseInt(file.slice(0, -5), 10);
-			if (!Number.isFinite(timestamp)) continue;
-			try {
-				const content = await readFile(join(historyDir, file), "utf-8");
-				const snapshot = JSON.parse(content);
-				const rawText = snapshot.markdown ?? "";
-				entries.push({
-					timestamp: snapshot.timestamp,
-					trigger: snapshot.trigger,
-					snippet: rawText.slice(0, 80) || void 0
-				});
-			} catch {
-				log.debug({
-					noteId,
-					file
-				}, "Skipped unreadable snapshot");
-			}
-		}
-		entries.sort((a, b) => b.timestamp - a.timestamp);
-		return entries;
+		return requireXopcDatabase().db.prepare("SELECT payload FROM note_snapshots WHERE note_id = ? ORDER BY timestamp DESC").all(noteId).map((row) => {
+			const snapshot = JSON.parse(row.payload);
+			return {
+				timestamp: snapshot.timestamp,
+				trigger: snapshot.trigger,
+				snippet: snapshot.markdown?.slice(0, 80) || void 0
+			};
+		});
 	}
 	async getSnapshot(noteId, timestamp) {
-		const filePath = join(resolveNoteHistoryDir(noteId), `${timestamp}.json`);
-		try {
-			const content = await readFile(filePath, "utf-8");
-			return JSON.parse(content);
-		} catch {
-			return null;
-		}
+		const row = requireXopcDatabase().db.prepare("SELECT payload FROM note_snapshots WHERE note_id = ? AND timestamp = ?").get(noteId, timestamp);
+		return row ? JSON.parse(row.payload) : null;
 	}
 	async pruneSnapshots(noteId, maxCount) {
-		const historyDir = resolveNoteHistoryDir(noteId);
-		let files;
-		try {
-			files = await readdir(historyDir);
-		} catch {
-			return;
-		}
-		const jsonFiles = files.filter((f) => f.endsWith(".json")).sort();
-		if (jsonFiles.length <= maxCount) return;
-		const toDelete = jsonFiles.slice(0, jsonFiles.length - maxCount);
-		for (const file of toDelete) await rm(join(historyDir, file), { force: true }).catch(() => void 0);
-		log.debug({
-			noteId,
-			deleted: toDelete.length
-		}, "Pruned old snapshots");
+		if (!Number.isSafeInteger(maxCount) || maxCount < 0) throw new Error("Invalid snapshot retention count");
+		requireXopcDatabase().db.prepare(`DELETE FROM note_snapshots WHERE note_id = ? AND timestamp NOT IN (
+      SELECT timestamp FROM note_snapshots WHERE note_id = ? ORDER BY timestamp DESC LIMIT ?
+    )`).run(noteId, noteId, maxCount);
 	}
 	async deleteAllSnapshots(noteId) {
-		await rm(resolveNoteHistoryDir(noteId), {
-			recursive: true,
-			force: true
-		}).catch(() => void 0);
+		requireXopcDatabase().db.prepare("DELETE FROM note_snapshots WHERE note_id = ?").run(noteId);
 	}
-	/** No-op: SQLite writes are synchronous. Kept for API compatibility with tests. */
-	async flush() {}
 };
 //#endregion
 export { NotesStore, buildNoteIndexMeta };

package/dist/src/notes/types.d.ts

@@ -113,6 +113,8 @@ export interface Note {
     status: NoteStatus;
     /** Canonical note body. Markdown is the only content truth. */
     markdown: string;
+    /** Provenance of the latest content edit, independent of snapshot throttling. */
+    lastEditTrigger?: SnapshotTrigger;
     attachments?: NoteAttachment[];
     createdAt: number;
     updatedAt: number;
@@ -149,6 +151,18 @@ export interface NoteIndexEntry {
     taskCount?: number;
     uncheckedTaskCount?: number;
     linkCount?: number;
+    projects?: Array<{
+        id: string;
+        name: string;
+    }>;
+    lastEditTrigger?: SnapshotTrigger;
+}
+export interface NoteProjectSummary {
+    id: string;
+    name: string;
+    description?: string;
+    noteCount: number;
+    updatedAt?: number;
 }
 export interface NotesIndexFile {
     version: number;
@@ -175,6 +189,8 @@ export interface NotesListQuery {
     kind?: NoteKind;
     tag?: string;
     projectId?: string;
+    unassigned?: boolean;
+    agentEdited?: boolean;
     pinned?: boolean;
     search?: string;
     limit?: number;

package/dist/src/proactive/execution/context.d.ts

@@ -15,8 +15,8 @@ export declare class InternalObjectContextProvider implements ContextProvider {
     supports(): boolean;
     collect(input: ContextInput): Promise<ResolvedContext>;
 }
-export declare class UserUnderstandingContextProvider implements ContextProvider {
-    readonly id = "user_understanding";
+export declare class UserModelContextProvider implements ContextProvider {
+    readonly id = "user_model";
     supports(): boolean;
     collect(input: ContextInput): Promise<ResolvedContext>;
 }

package/dist/src/proactive/execution/context.js

@@ -1,7 +1,8 @@
 import { getSqliteDatabase } from "../../storage/sqlite/transaction.js";
-import { listUnderstandings } from "../../storage/sqlite/user-context-repository.js";
 import { getKnowledgeSourceItem } from "../../storage/sqlite/knowledge-repository.js";
 import { getConnectorSyncPolicyForConnection } from "../../storage/sqlite/connector-sync-policy-repository.js";
+import { getAssertionSlot, listUserAssertions } from "../../user-model/repository.js";
+import "../../user-model/index.js";
 import { wrapExternalContent } from "../../gateway/security/external-content.js";
 //#region src/proactive/execution/context.ts
 const MAX_EVENT_COUNT = 50;
@@ -154,28 +155,32 @@ var InternalObjectContextProvider = class {
 		};
 	}
 };
-var UserUnderstandingContextProvider = class {
-	id = "user_understanding";
+var UserModelContextProvider = class {
+	id = "user_model";
 	supports() {
 		return true;
 	}
 	async collect(input) {
 		const scope = eventRows(input.eventIds).at(-1);
 		if (!scope) return emptyContext();
-		const records = listUnderstandings(["active"]).filter((record) => {
+		const records = listUserAssertions({
+			statuses: ["active"],
+			limit: 500
+		}).filter((record) => {
 			const now = Date.now();
-			const scopeMatches = record.scope.type === "global" || record.scope.type === "workspace" && record.scope.id === scope.workspace_id || record.scope.type === "project" && record.scope.id === scope.project_id;
-			return record.disclosurePolicy === "referenceable" && record.sensitivity !== "secret" && record.sensitivity !== "regulated" && scopeMatches && (!record.validFrom || record.validFrom <= now) && (!record.validTo || record.validTo >= now) && (!record.expiresAt || record.expiresAt >= now) && !record.conflictGroupId && (record.explicitness === "explicit" || record.confidence >= .7);
+			const assertionScope = getAssertionSlot(record.slotId)?.scope;
+			const scopeMatches = assertionScope?.type === "global" || assertionScope?.type === "workspace" && assertionScope.id === scope.workspace_id || assertionScope?.type === "project" && assertionScope.id === scope.project_id || assertionScope?.type === "agent" && assertionScope.id === scope.agent_id;
+			return record.disclosurePolicy === "referenceable" && record.sensitivity !== "secret" && record.sensitivity !== "regulated" && scopeMatches && (!record.validFrom || record.validFrom <= now) && (!record.validTo || record.validTo >= now) && (record.authority === "user_explicit" || record.confidence >= .7);
 		}).slice(0, 20);
 		return {
 			content: { records: records.map((record) => ({
-				evidenceId: `understanding:${record.id}`,
+				evidenceId: `assertion:${record.id}`,
 				kind: record.kind,
 				content: boundedText(record.statement, 1e3),
 				confidence: record.confidence,
-				updatedAt: record.updatedAt
+				recordedAt: record.recordedAt
 			})) },
-			evidenceIds: records.map((record) => `understanding:${record.id}`)
+			evidenceIds: records.map((record) => `assertion:${record.id}`)
 		};
 	}
 };
@@ -295,7 +300,7 @@ var ContextProviderRegistry = class {
 		new EventBatchContextProvider(),
 		new ConnectedSourceContextProvider(),
 		new InternalObjectContextProvider(),
-		new UserUnderstandingContextProvider(),
+		new UserModelContextProvider(),
 		new MeetingWorkspaceContextProvider(),
 		new ProjectStateContextProvider(),
 		new AutomationStateContextProvider()
@@ -315,4 +320,4 @@ var ContextProviderRegistry = class {
 	}
 };
 //#endregion
-export { AutomationStateContextProvider, ConnectedSourceContextProvider, ContextProviderRegistry, EventBatchContextProvider, InternalObjectContextProvider, MeetingWorkspaceContextProvider, ProjectStateContextProvider, UserUnderstandingContextProvider };
+export { AutomationStateContextProvider, ConnectedSourceContextProvider, ContextProviderRegistry, EventBatchContextProvider, InternalObjectContextProvider, MeetingWorkspaceContextProvider, ProjectStateContextProvider, UserModelContextProvider };

package/dist/src/proactive/index.d.ts

@@ -8,7 +8,7 @@ export type { SignalBatch } from './routing/batch-repository.js';
 export { ProactiveEventService } from './service.js';
 export { ProactiveScenarioService } from './scenarios/service.js';
 export type { PromptRevision, ScenarioDefinition, ScenarioSubscription } from './scenarios/types.js';
-export { AutomationStateContextProvider, ConnectedSourceContextProvider, ContextProviderRegistry, EventBatchContextProvider, InternalObjectContextProvider, MeetingWorkspaceContextProvider, ProjectStateContextProvider, UserUnderstandingContextProvider, } from './execution/context.js';
+export { AutomationStateContextProvider, ConnectedSourceContextProvider, ContextProviderRegistry, EventBatchContextProvider, InternalObjectContextProvider, MeetingWorkspaceContextProvider, ProjectStateContextProvider, UserModelContextProvider, } from './execution/context.js';
 export { ReadonlyProactiveAgentExecutor } from './execution/agent-executor.js';
 export { listInsights } from './execution/repository.js';
 export { ProactiveWorker } from './execution/worker.js';

package/dist/src/proactive/index.js

@@ -3,11 +3,11 @@ import { normalizeEventEnvelope } from "./events/envelope.js";
 import { mapProductEventToProactive } from "./events/product-event-bridge.js";
 import { matchScenario, matchesCondition } from "./routing/matcher.js";
 import { ProactiveEventService } from "./service.js";
-import { AutomationStateContextProvider, ConnectedSourceContextProvider, ContextProviderRegistry, EventBatchContextProvider, InternalObjectContextProvider, MeetingWorkspaceContextProvider, ProjectStateContextProvider, UserUnderstandingContextProvider } from "./execution/context.js";
+import { AutomationStateContextProvider, ConnectedSourceContextProvider, ContextProviderRegistry, EventBatchContextProvider, InternalObjectContextProvider, MeetingWorkspaceContextProvider, ProjectStateContextProvider, UserModelContextProvider } from "./execution/context.js";
 import { ReadonlyProactiveAgentExecutor } from "./execution/agent-executor.js";
 import { listInsights } from "./execution/repository.js";
 import { ProactiveWorker } from "./execution/worker.js";
 import { ProactiveTemporalWorker } from "./temporal/worker.js";
 import { ProactiveInboxService } from "./inbox/service.js";
 import { ProactiveInboxWorker } from "./inbox/worker.js";
-export { AutomationStateContextProvider, ConnectedSourceContextProvider, ContextProviderRegistry, EventBatchContextProvider, InternalObjectContextProvider, MeetingWorkspaceContextProvider, ProactiveEventService, ProactiveInboxService, ProactiveInboxWorker, ProactiveScenarioService, ProactiveTemporalWorker, ProactiveWorker, ProjectStateContextProvider, ReadonlyProactiveAgentExecutor, UserUnderstandingContextProvider, listInsights, mapProductEventToProactive, matchScenario, matchesCondition, normalizeEventEnvelope };
+export { AutomationStateContextProvider, ConnectedSourceContextProvider, ContextProviderRegistry, EventBatchContextProvider, InternalObjectContextProvider, MeetingWorkspaceContextProvider, ProactiveEventService, ProactiveInboxService, ProactiveInboxWorker, ProactiveScenarioService, ProactiveTemporalWorker, ProactiveWorker, ProjectStateContextProvider, ReadonlyProactiveAgentExecutor, UserModelContextProvider, listInsights, mapProductEventToProactive, matchScenario, matchesCondition, normalizeEventEnvelope };