@xopcai/xopc 0.0.170 → 0.0.172

package/dist/src/storage/sqlite/transcript-repository.js

@@ -1,10 +1,9 @@
 import { getSqliteDatabase, runSqliteWriteTransaction } from "./transaction.js";
-import { buildSessionContextForLlm } from "../../session/session-context-for-llm.js";
+import { buildSessionContextForLlm, isRuntimeOnlyTranscriptMessage } from "../../session/session-context-for-llm.js";
 import { classifyStoredRow, estimateTokensFromMessages, extractFtsContent, transcriptEntryRowToStoredRow } from "./row-mappers.js";
 import { getCurrentSessionId, readCurrentSessionId } from "./session-repository.js";
 import { randomUUID } from "node:crypto";
 //#region src/storage/sqlite/transcript-repository.ts
-const MAX_CHECKPOINTS_PER_TRANSCRIPT = 15;
 function nextSeq(db, sessionId) {
 	return (db.prepare(`SELECT COALESCE(MAX(seq), 0) AS max_seq FROM transcript_entries WHERE session_id = ?`).get(sessionId).max_seq ?? 0) + 1;
 }
@@ -34,6 +33,7 @@ function isUserMessageRow(row) {
 	return classified.entryKind === "message" && classified.role === "user";
 }
 function appendTranscriptEntry(sessionKey, row, opts) {
+	if (isRuntimeOnlyTranscriptMessage(row)) throw new Error("Runtime-only messages cannot be persisted in a session transcript");
 	return runSqliteWriteTransaction((db) => {
 		const sessionId = opts?.sessionId ?? readCurrentSessionId(db, sessionKey);
 		if (!sessionId) throw new Error(`Session not found: ${sessionKey}`);
@@ -58,6 +58,31 @@ function appendTranscriptEntry(sessionKey, row, opts) {
 		return inserted;
 	});
 }
+function appendCompactionBoundary(sessionKey, row) {
+	return runSqliteWriteTransaction((db) => {
+		const sessionId = readCurrentSessionId(db, sessionKey);
+		if (!sessionId) throw new Error(`Session not found: ${sessionKey}`);
+		const boundary = {
+			...row,
+			baseSeq: nextSeq(db, sessionId) - 1
+		};
+		const inserted = insertEntry(db, {
+			sessionId,
+			sessionKey,
+			row: boundary
+		});
+		const now = Date.now();
+		db.prepare(`UPDATE sessions SET
+        message_count = ?,
+        estimated_tokens = ?,
+        compacted_count = compacted_count + 1,
+        updated_at = ?,
+        last_accessed_at = ?,
+        last_interaction_at = ?
+       WHERE session_key = ?`).run(boundary.messages.length, boundary.tokensAfter, now, now, now, sessionKey);
+		return inserted;
+	});
+}
 function loadTranscriptRowsForSession(sessionKey) {
 	const sessionId = getCurrentSessionId(sessionKey);
 	if (!sessionId) return [];
@@ -79,25 +104,30 @@ function loadTranscriptRows(sessionId) {
        ORDER BY seq ASC`).all(sessionId).map(transcriptEntryRowToStoredRow);
 }
 function loadLlmMessagesForSession(sessionKey) {
-	return buildSessionContextForLlm(loadTranscriptRowsForSession(sessionKey));
+	const sessionId = getCurrentSessionId(sessionKey);
+	if (!sessionId) return [];
+	return buildSessionContextForLlm(getSqliteDatabase().prepare(`SELECT entry_id, session_id, seq, entry_kind, role, payload_json, created_at
+       FROM transcript_entries
+       WHERE session_id = ?
+         AND seq >= COALESCE(
+           (SELECT MAX(seq) FROM transcript_entries WHERE session_id = ? AND entry_kind = 'compaction'),
+           1
+         )
+       ORDER BY seq ASC`).all(sessionId, sessionId).map(transcriptEntryRowToStoredRow));
 }
-function replaceTranscriptRows(sessionKey, rows, opts) {
+function replaceTranscriptRows(sessionKey, rows) {
+	if (rows.some(isRuntimeOnlyTranscriptMessage)) throw new Error("Runtime-only messages cannot be persisted in a session transcript");
 	runSqliteWriteTransaction((db) => {
 		const sessionId = readCurrentSessionId(db, sessionKey);
 		if (!sessionId) throw new Error(`Session not found: ${sessionKey}`);
 		db.prepare(`DELETE FROM transcript_fts WHERE session_id = ?`).run(sessionId);
 		db.prepare(`DELETE FROM transcript_entries WHERE session_id = ?`).run(sessionId);
-		const toWrite = [...rows];
-		if (opts?.appendCompaction) toWrite.push({
-			type: "compaction",
-			...opts.appendCompaction
-		});
-		for (const row of toWrite) insertEntry(db, {
+		for (const row of rows) insertEntry(db, {
 			sessionId,
 			sessionKey,
 			row
 		});
-		const llm = buildSessionContextForLlm(toWrite);
+		const llm = buildSessionContextForLlm(rows);
 		const now = Date.now();
 		const hiddenUpdate = llm.some((message) => message.role === "user") ? `hidden_from_session_list = 0,` : "";
 		db.prepare(`UPDATE sessions SET
@@ -110,14 +140,6 @@ function replaceTranscriptRows(sessionKey, rows, opts) {
       WHERE session_key = ?`).run(llm.length, estimateTokensFromMessages(llm), now, now, now, sessionKey);
 	});
 }
-function loadCheckpointRows(sessionKey, checkpointId) {
-	const db = getSqliteDatabase();
-	if (!db.prepare(`SELECT checkpoint_id FROM compaction_checkpoints
-       WHERE session_key = ? AND checkpoint_id = ?`).get(sessionKey, checkpointId)) return [];
-	return db.prepare(`SELECT payload_json FROM checkpoint_entries
-       WHERE checkpoint_id = ?
-       ORDER BY seq ASC`).all(checkpointId).map((entry) => JSON.parse(entry.payload_json));
-}
 function paginateTranscriptMessages(sessionKey, options = {}) {
 	const sessionId = getCurrentSessionId(sessionKey);
 	if (!sessionId) return {
@@ -171,86 +193,70 @@ function paginateTranscriptMessages(sessionKey, options = {}) {
 		endSeq: rows[rows.length - 1]?.seq ?? 0
 	};
 }
-function captureCompactionCheckpoint(sessionKey) {
-	return runSqliteWriteTransaction((db) => {
-		const sessionId = readCurrentSessionId(db, sessionKey);
-		if (!sessionId) return null;
-		const entries = db.prepare(`SELECT entry_id, session_id, seq, entry_kind, role, payload_json, created_at
-         FROM transcript_entries WHERE session_id = ? ORDER BY seq ASC`).all(sessionId);
-		if (entries.length === 0) return null;
-		const checkpointId = randomUUID();
-		const now = Date.now();
-		const messageCount = entries.filter((e) => e.entry_kind === "message").length;
-		const sizeBytes = entries.reduce((sum, e) => sum + e.payload_json.length, 0);
-		db.prepare(`INSERT INTO compaction_checkpoints
-        (checkpoint_id, session_id, session_key, created_at, message_count, size_bytes)
-       VALUES (?, ?, ?, ?, ?, ?)`).run(checkpointId, sessionId, sessionKey, now, messageCount, sizeBytes);
-		const insertCheckpointEntry = db.prepare(`INSERT INTO checkpoint_entries (checkpoint_id, seq, entry_kind, role, payload_json)
-       VALUES (?, ?, ?, ?, ?)`);
-		for (const entry of entries) insertCheckpointEntry.run(checkpointId, entry.seq, entry.entry_kind, entry.role, entry.payload_json);
-		pruneCompactionCheckpoints(db, sessionId);
-		return checkpointId;
+function listCompactionBoundaries(sessionKey) {
+	const db = getSqliteDatabase();
+	const sessionId = getCurrentSessionId(sessionKey);
+	if (!sessionId) return [];
+	return db.prepare(`SELECT entry_id, seq, payload_json, created_at
+       FROM transcript_entries
+       WHERE session_id = ? AND entry_kind = 'compaction'
+       ORDER BY seq DESC`).all(sessionId).map((row) => {
+		const payload = JSON.parse(row.payload_json);
+		return {
+			id: row.entry_id,
+			seq: row.seq,
+			createdAt: new Date(row.created_at).toISOString(),
+			messageCount: payload.messages.length,
+			tokensBefore: payload.tokensBefore,
+			tokensAfter: payload.tokensAfter,
+			summaryPreview: payload.summary.slice(0, 500),
+			restoredFromCompactionId: payload.restoredFromCompactionId
+		};
 	});
 }
-function pruneCompactionCheckpoints(db, sessionId) {
-	const rows = db.prepare(`SELECT checkpoint_id FROM compaction_checkpoints
-       WHERE session_id = ?
-       ORDER BY created_at ASC`).all(sessionId);
-	if (rows.length <= MAX_CHECKPOINTS_PER_TRANSCRIPT) return;
-	const toDelete = rows.slice(0, rows.length - MAX_CHECKPOINTS_PER_TRANSCRIPT);
-	const del = db.prepare(`DELETE FROM compaction_checkpoints WHERE checkpoint_id = ?`);
-	for (const row of toDelete) del.run(row.checkpoint_id);
-}
-function listCompactionCheckpoints(sessionKey) {
-	return getSqliteDatabase().prepare(`SELECT checkpoint_id, created_at, message_count, size_bytes
-       FROM compaction_checkpoints
-       WHERE session_key = ?
-       ORDER BY created_at DESC`).all(sessionKey).map((row) => ({
-		id: row.checkpoint_id,
-		sizeBytes: row.size_bytes,
-		modifiedAt: new Date(row.created_at).toISOString()
-	}));
-}
-function getCompactionCheckpointDetail(sessionKey, checkpointId) {
-	const row = getSqliteDatabase().prepare(`SELECT checkpoint_id, created_at, message_count, size_bytes
-       FROM compaction_checkpoints
-       WHERE session_key = ? AND checkpoint_id = ?`).get(sessionKey, checkpointId);
-	if (!row) return null;
-	return {
-		id: row.checkpoint_id,
-		sizeBytes: row.size_bytes,
-		modifiedAt: new Date(row.created_at).toISOString(),
-		messageCount: row.message_count
-	};
-}
-function restoreCompactionCheckpoint(sessionKey, checkpointId) {
+function restoreBeforeCompactionBoundary(sessionKey, compactionId) {
 	runSqliteWriteTransaction((db) => {
 		const sessionId = readCurrentSessionId(db, sessionKey);
 		if (!sessionId) throw new Error(`Session not found: ${sessionKey}`);
-		if (!db.prepare(`SELECT checkpoint_id FROM compaction_checkpoints
-         WHERE session_key = ? AND checkpoint_id = ?`).get(sessionKey, checkpointId)) throw new Error(`Checkpoint not found: ${checkpointId}`);
-		const entries = db.prepare(`SELECT seq, entry_kind, role, payload_json
-         FROM checkpoint_entries
-         WHERE checkpoint_id = ?
-         ORDER BY seq ASC`).all(checkpointId);
-		db.prepare(`DELETE FROM transcript_fts WHERE session_id = ?`).run(sessionId);
-		db.prepare(`DELETE FROM transcript_entries WHERE session_id = ?`).run(sessionId);
-		for (const entry of entries) insertEntry(db, {
+		const boundary = db.prepare(`SELECT seq FROM transcript_entries
+         WHERE session_id = ? AND entry_id = ? AND entry_kind = 'compaction'`).get(sessionId, compactionId);
+		if (!boundary) throw new Error(`Compaction boundary not found: ${compactionId}`);
+		const restoredMessages = buildSessionContextForLlm(db.prepare(`SELECT entry_id, session_id, seq, entry_kind, role, payload_json, created_at
+         FROM transcript_entries
+         WHERE session_id = ? AND seq < ?
+         ORDER BY seq ASC`).all(sessionId, boundary.seq).map(transcriptEntryRowToStoredRow));
+		if (restoredMessages.length === 0) throw new Error(`No restorable context exists before compaction boundary: ${compactionId}`);
+		const current = db.prepare(`SELECT estimated_tokens FROM sessions WHERE session_key = ?`).get(sessionKey);
+		const tokensAfter = estimateTokensFromMessages(restoredMessages);
+		const baseSeq = nextSeq(db, sessionId) - 1;
+		insertEntry(db, {
 			sessionId,
 			sessionKey,
-			row: JSON.parse(entry.payload_json),
-			createdAt: Date.now()
+			row: {
+				type: "compaction",
+				at: (/* @__PURE__ */ new Date()).toISOString(),
+				baseSeq,
+				plannerVersion: 2,
+				summaryModelRef: "logical-restore",
+				qualityAudit: "disabled",
+				summary: `Restored the effective context that existed before compaction boundary ${compactionId}.`,
+				messages: restoredMessages,
+				firstKeptIndex: 0,
+				tokensBefore: current.estimated_tokens,
+				tokensAfter,
+				restoredFromCompactionId: compactionId
+			}
 		});
-		const llm = buildSessionContextForLlm(entries.map((e) => JSON.parse(e.payload_json)));
 		const now = Date.now();
 		db.prepare(`UPDATE sessions SET
         message_count = ?,
         estimated_tokens = ?,
+        compacted_count = compacted_count + 1,
         updated_at = ?,
         last_accessed_at = ?,
         last_interaction_at = ?
-      WHERE session_key = ?`).run(llm.length, estimateTokensFromMessages(llm), now, now, now, sessionKey);
+      WHERE session_key = ?`).run(restoredMessages.length, tokensAfter, now, now, now, sessionKey);
 	});
 }
 //#endregion
-export { appendTranscriptEntry, captureCompactionCheckpoint, getCompactionCheckpointDetail, listCompactionCheckpoints, loadCheckpointRows, loadLlmMessagesForSession, loadTranscriptHistoryRowsForSession, loadTranscriptRows, loadTranscriptRowsForSession, paginateTranscriptMessages, replaceTranscriptRows, restoreCompactionCheckpoint };
+export { appendCompactionBoundary, appendTranscriptEntry, listCompactionBoundaries, loadLlmMessagesForSession, loadTranscriptHistoryRowsForSession, loadTranscriptRows, loadTranscriptRowsForSession, paginateTranscriptMessages, replaceTranscriptRows, restoreBeforeCompactionBoundary };

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

@@ -0,0 +1,101 @@
+export type UserEntityType = 'person' | 'project' | 'organization';
+export type UserEntityHandleType = 'email' | 'provider_user' | 'display_name';
+export type UserClaimClass = 'relationship' | 'project' | 'routine';
+export type UserClaimState = 'provisional' | 'active' | 'rejected' | 'stale';
+export type UserClaimUserState = 'auto' | 'confirmed' | 'rejected';
+export type UserEntity = {
+    id: string;
+    type: UserEntityType;
+    canonicalLabel: string;
+    createdAt: string;
+    updatedAt: string;
+};
+export type UserClaim = {
+    id: string;
+    agentId: string;
+    class: UserClaimClass;
+    key: string;
+    subjectEntityId?: string;
+    value: Record<string, unknown>;
+    state: UserClaimState;
+    userState: UserClaimUserState;
+    confidence: number;
+    independentEvidenceCount: number;
+    activeDayCount: number;
+    firstObservedAt: string;
+    lastReinforcedAt: string;
+    memoryRecordId?: string;
+    createdAt: string;
+    updatedAt: string;
+};
+export declare function resolveUserEntity(input: {
+    type: UserEntityType;
+    canonicalLabel: string;
+    handles: Array<{
+        type: UserEntityHandleType;
+        value: string;
+        sourceScope: string;
+        verified: boolean;
+    }>;
+    nowMs?: number;
+}): UserEntity;
+export declare function reinforceUserClaim(input: {
+    agentId: string;
+    class: UserClaimClass;
+    key: string;
+    subjectEntityId?: string;
+    value: Record<string, unknown>;
+    evidence: Array<{
+        logicalEventKey: string;
+        sourceItemId: string;
+        sourceInstanceId: string;
+        relation: 'supports' | 'contradicts';
+        observedAt: string;
+    }>;
+    nowMs?: number;
+}): UserClaim;
+export declare function removeUserClaimEvidenceForSource(sourceInstanceId: string): {
+    deletedClaimCount: number;
+    deletedMemoryRecordIds: string[];
+    retainedClaims: Array<{
+        memoryRecordId: string;
+        state: UserClaimState;
+    }>;
+};
+export declare function setUserClaimDecision(claimId: string, userState: Exclude<UserClaimUserState, 'auto'>): UserClaim | undefined;
+export declare function linkUserClaimMemoryRecord(claimId: string, memoryRecordId: string): void;
+export declare function getUserClaim(claimId: string): UserClaim | undefined;
+export declare function listUserClaims(options?: {
+    agentId?: string;
+    state?: UserClaimState;
+    limit?: number;
+}): UserClaim[];
+export declare function listUserClaimEvidence(claimId: string): Array<{
+    logicalEventKey: string;
+    sourceItemId: string;
+    sourceInstanceId: string;
+    relation: string;
+    observedAt: string;
+}>;
+export declare function listUserPeopleGraphRows(): {
+    people: Array<UserEntity & {
+        handles: Array<{
+            type: UserEntityHandleType;
+            value: string;
+        }>;
+    }>;
+    edges: Array<{
+        entityId: string;
+        sourceInstanceId: string;
+        mentionCount: number;
+        lastObservedAt: string;
+    }>;
+    evidenceCount: number;
+};
+export declare function listUserClaimStatsBySource(): Record<string, {
+    evidenceCount: number;
+    provisionalClaims: number;
+    activeClaims: number;
+    resolvedEntities: number;
+    lastEvidenceAt?: string;
+}>;

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

@@ -0,0 +1,241 @@
+import { getSqliteDatabase, runSqliteWriteTransaction } from "./transaction.js";
+import { randomUUID } from "node:crypto";
+//#region src/storage/sqlite/user-claims-repository.ts
+function entityFromRow(row) {
+	return {
+		id: row.entity_id,
+		type: row.entity_type,
+		canonicalLabel: row.canonical_label,
+		createdAt: new Date(row.created_at).toISOString(),
+		updatedAt: new Date(row.updated_at).toISOString()
+	};
+}
+function claimFromRow(row) {
+	return {
+		id: row.claim_id,
+		agentId: row.agent_id,
+		class: row.claim_class,
+		key: row.claim_key,
+		...row.subject_entity_id ? { subjectEntityId: row.subject_entity_id } : {},
+		value: JSON.parse(row.value_json),
+		state: row.state,
+		userState: row.user_state,
+		confidence: row.confidence,
+		independentEvidenceCount: row.independent_evidence_count,
+		activeDayCount: row.active_day_count,
+		firstObservedAt: new Date(row.first_observed_at).toISOString(),
+		lastReinforcedAt: new Date(row.last_reinforced_at).toISOString(),
+		...row.memory_record_id ? { memoryRecordId: row.memory_record_id } : {},
+		createdAt: new Date(row.created_at).toISOString(),
+		updatedAt: new Date(row.updated_at).toISOString()
+	};
+}
+function resolveUserEntity(input) {
+	const now = input.nowMs ?? Date.now();
+	return runSqliteWriteTransaction((db) => {
+		const handles = input.handles.map((handle) => ({
+			...handle,
+			value: handle.value.trim().toLowerCase()
+		})).filter((handle) => handle.value);
+		const strong = handles.filter((handle) => handle.verified);
+		let row;
+		for (const handle of strong) {
+			row = db.prepare(`SELECT e.* FROM user_entities e JOIN user_entity_handles h ON h.entity_id = e.entity_id
+        WHERE h.handle_type = ? AND h.normalized_value = ? AND h.source_scope = ?`).get(handle.type, handle.value, handle.sourceScope);
+			if (row) break;
+		}
+		if (!row) {
+			const fallback = handles[0];
+			if (fallback) row = db.prepare(`SELECT e.* FROM user_entities e JOIN user_entity_handles h ON h.entity_id = e.entity_id
+          WHERE h.handle_type = ? AND h.normalized_value = ? AND h.source_scope = ?`).get(fallback.type, fallback.value, fallback.sourceScope);
+		}
+		const entityId = row?.entity_id ?? randomUUID();
+		if (!row) db.prepare(`INSERT INTO user_entities (entity_id, entity_type, canonical_label, created_at, updated_at)
+        VALUES (?, ?, ?, ?, ?)`).run(entityId, input.type, input.canonicalLabel, now, now);
+		else {
+			const incomingHumanName = input.canonicalLabel.includes(" ") && !input.canonicalLabel.includes("@");
+			const existingHumanName = row.canonical_label.includes(" ") && !row.canonical_label.includes("@");
+			if (incomingHumanName && (!existingHumanName || input.canonicalLabel.length > row.canonical_label.length)) db.prepare("UPDATE user_entities SET canonical_label = ?, updated_at = ? WHERE entity_id = ?").run(input.canonicalLabel, now, entityId);
+		}
+		for (const handle of handles) db.prepare(`INSERT OR IGNORE INTO user_entity_handles
+        (entity_id, handle_type, normalized_value, source_scope, verified, created_at)
+        VALUES (?, ?, ?, ?, ?, ?)`).run(entityId, handle.type, handle.value, handle.sourceScope, handle.verified ? 1 : 0, now);
+		return entityFromRow(db.prepare("SELECT * FROM user_entities WHERE entity_id = ?").get(entityId));
+	});
+}
+function thresholds(claimClass) {
+	return claimClass === "routine" ? {
+		evidence: 3,
+		days: 3
+	} : {
+		evidence: 3,
+		days: 2
+	};
+}
+function refreshUserClaim(db, row, now) {
+	const stats = db.prepare(`SELECT
+    SUM(CASE WHEN relation = 'supports' THEN 1 ELSE 0 END) AS evidence_count,
+    SUM(CASE WHEN relation = 'contradicts' THEN 1 ELSE 0 END) AS contradiction_count,
+    COUNT(DISTINCT CASE WHEN relation = 'supports' THEN date(observed_at / 1000, 'unixepoch') END) AS active_days,
+    MAX(observed_at) AS last_observed
+    FROM user_claim_evidence WHERE claim_id = ?`).get(row.claim_id);
+	const evidenceCount = stats.evidence_count ?? 0;
+	const contradictionCount = stats.contradiction_count ?? 0;
+	const limit = thresholds(row.claim_class);
+	const state = row.user_state === "rejected" ? "rejected" : row.user_state === "confirmed" ? "active" : contradictionCount >= evidenceCount && contradictionCount > 0 ? "stale" : evidenceCount >= limit.evidence && stats.active_days >= limit.days ? "active" : "provisional";
+	const confidence = Math.max(.1, Math.min(.92, .48 + Math.min(evidenceCount, 8) * .035 + Math.min(stats.active_days, 5) * .045 - Math.min(contradictionCount, 5) * .08));
+	db.prepare(`UPDATE user_claims SET state = ?, confidence = ?, independent_evidence_count = ?,
+    active_day_count = ?, last_reinforced_at = ?, updated_at = ? WHERE claim_id = ?`).run(state, confidence, evidenceCount, stats.active_days, stats.last_observed ?? row.last_reinforced_at, now, row.claim_id);
+	return claimFromRow(db.prepare("SELECT * FROM user_claims WHERE claim_id = ?").get(row.claim_id));
+}
+function reinforceUserClaim(input) {
+	const now = input.nowMs ?? Date.now();
+	return runSqliteWriteTransaction((db) => {
+		let row = db.prepare("SELECT * FROM user_claims WHERE agent_id = ? AND claim_class = ? AND claim_key = ?").get(input.agentId, input.class, input.key);
+		const claimId = row?.claim_id ?? randomUUID();
+		if (!row) {
+			const firstObserved = Math.min(...input.evidence.map((item) => Date.parse(item.observedAt)), now);
+			db.prepare(`INSERT INTO user_claims (
+        claim_id, agent_id, claim_class, claim_key, subject_entity_id, value_json, state, user_state,
+        confidence, independent_evidence_count, active_day_count, first_observed_at, last_reinforced_at,
+        created_at, updated_at
+      ) VALUES (?, ?, ?, ?, ?, ?, 'provisional', 'auto', 0, 0, 0, ?, ?, ?, ?)`).run(claimId, input.agentId, input.class, input.key, input.subjectEntityId ?? null, JSON.stringify(input.value), firstObserved, now, now, now);
+		}
+		for (const evidence of input.evidence) db.prepare(`INSERT INTO user_claim_evidence (
+        claim_id, logical_event_key, source_item_id, source_instance_id, relation, observed_at, created_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(claim_id, logical_event_key) DO UPDATE SET
+        source_item_id = excluded.source_item_id,
+        source_instance_id = excluded.source_instance_id,
+        relation = excluded.relation,
+        observed_at = excluded.observed_at`).run(claimId, evidence.logicalEventKey, evidence.sourceItemId, evidence.sourceInstanceId, evidence.relation, Date.parse(evidence.observedAt), now);
+		db.prepare("UPDATE user_claims SET subject_entity_id = ?, value_json = ? WHERE claim_id = ?").run(input.subjectEntityId ?? null, JSON.stringify(input.value), claimId);
+		row = db.prepare("SELECT * FROM user_claims WHERE claim_id = ?").get(claimId);
+		return refreshUserClaim(db, row, now);
+	});
+}
+function removeUserClaimEvidenceForSource(sourceInstanceId) {
+	return runSqliteWriteTransaction((db) => {
+		const affected = db.prepare(`SELECT DISTINCT c.* FROM user_claims c
+      JOIN user_claim_evidence e ON e.claim_id = c.claim_id
+      WHERE e.source_instance_id = ?`).all(sourceInstanceId);
+		db.prepare("DELETE FROM user_claim_evidence WHERE source_instance_id = ?").run(sourceInstanceId);
+		const deletedMemoryRecordIds = [];
+		const retainedClaims = [];
+		let deletedClaimCount = 0;
+		const now = Date.now();
+		for (const row of affected) {
+			if (db.prepare("SELECT COUNT(*) AS count FROM user_claim_evidence WHERE claim_id = ?").get(row.claim_id).count === 0) {
+				if (row.memory_record_id) deletedMemoryRecordIds.push(row.memory_record_id);
+				db.prepare("DELETE FROM user_claims WHERE claim_id = ?").run(row.claim_id);
+				deletedClaimCount += 1;
+				continue;
+			}
+			const claim = refreshUserClaim(db, row, now);
+			if (claim.memoryRecordId) retainedClaims.push({
+				memoryRecordId: claim.memoryRecordId,
+				state: claim.state
+			});
+		}
+		return {
+			deletedClaimCount,
+			deletedMemoryRecordIds,
+			retainedClaims
+		};
+	});
+}
+function setUserClaimDecision(claimId, userState) {
+	runSqliteWriteTransaction((db) => {
+		db.prepare(`UPDATE user_claims SET user_state = ?, state = ?, updated_at = ? WHERE claim_id = ?`).run(userState, userState === "confirmed" ? "active" : "rejected", Date.now(), claimId);
+	});
+	return getUserClaim(claimId);
+}
+function linkUserClaimMemoryRecord(claimId, memoryRecordId) {
+	runSqliteWriteTransaction((db) => {
+		db.prepare("UPDATE user_claims SET memory_record_id = ?, updated_at = ? WHERE claim_id = ?").run(memoryRecordId, Date.now(), claimId);
+	});
+}
+function getUserClaim(claimId) {
+	const row = getSqliteDatabase().prepare("SELECT * FROM user_claims WHERE claim_id = ?").get(claimId);
+	return row ? claimFromRow(row) : void 0;
+}
+function listUserClaims(options = {}) {
+	const where = [];
+	const params = [];
+	if (options.agentId) {
+		where.push("agent_id = ?");
+		params.push(options.agentId);
+	}
+	if (options.state) {
+		where.push("state = ?");
+		params.push(options.state);
+	}
+	const limit = Math.max(1, Math.min(options.limit ?? 100, 500));
+	return getSqliteDatabase().prepare(`SELECT * FROM user_claims
+    ${where.length ? `WHERE ${where.join(" AND ")}` : ""}
+    ORDER BY confidence DESC, last_reinforced_at DESC LIMIT ?`).all(...params, limit).map(claimFromRow);
+}
+function listUserClaimEvidence(claimId) {
+	return getSqliteDatabase().prepare(`SELECT logical_event_key, source_item_id, source_instance_id, relation, observed_at
+    FROM user_claim_evidence WHERE claim_id = ? ORDER BY observed_at DESC`).all(claimId).map((row) => ({
+		logicalEventKey: row.logical_event_key,
+		sourceItemId: row.source_item_id,
+		sourceInstanceId: row.source_instance_id,
+		relation: row.relation,
+		observedAt: new Date(row.observed_at).toISOString()
+	}));
+}
+function listUserPeopleGraphRows() {
+	const db = getSqliteDatabase();
+	const entities = db.prepare(`SELECT * FROM user_entities e WHERE entity_type = 'person'
+    AND EXISTS (SELECT 1 FROM user_claims c JOIN user_claim_evidence ce ON ce.claim_id = c.claim_id
+      WHERE c.subject_entity_id = e.entity_id)`).all();
+	const handles = db.prepare(`SELECT entity_id, handle_type, normalized_value FROM user_entity_handles
+    WHERE entity_id IN (SELECT entity_id FROM user_entities WHERE entity_type = 'person')`).all();
+	const byEntity = /* @__PURE__ */ new Map();
+	for (const handle of handles) {
+		const values = byEntity.get(handle.entity_id) ?? [];
+		values.push({
+			type: handle.handle_type,
+			value: handle.normalized_value
+		});
+		byEntity.set(handle.entity_id, values);
+	}
+	const edgeRows = db.prepare(`SELECT c.subject_entity_id AS entity_id, e.source_instance_id,
+      COUNT(*) AS mention_count, MAX(e.observed_at) AS last_observed_at
+    FROM user_claims c JOIN user_claim_evidence e ON e.claim_id = c.claim_id
+    WHERE c.claim_class = 'relationship' AND c.subject_entity_id IS NOT NULL AND e.relation = 'supports'
+    GROUP BY c.subject_entity_id, e.source_instance_id`).all();
+	return {
+		people: entities.map((row) => ({
+			...entityFromRow(row),
+			handles: byEntity.get(row.entity_id) ?? []
+		})),
+		edges: edgeRows.map((row) => ({
+			entityId: row.entity_id,
+			sourceInstanceId: row.source_instance_id,
+			mentionCount: row.mention_count,
+			lastObservedAt: new Date(row.last_observed_at).toISOString()
+		})),
+		evidenceCount: edgeRows.reduce((sum, row) => sum + row.mention_count, 0)
+	};
+}
+function listUserClaimStatsBySource() {
+	const rows = getSqliteDatabase().prepare(`SELECT e.source_instance_id,
+      COUNT(*) AS evidence_count,
+      COUNT(DISTINCT CASE WHEN c.state = 'provisional' THEN c.claim_id END) AS provisional_claims,
+      COUNT(DISTINCT CASE WHEN c.state = 'active' THEN c.claim_id END) AS active_claims,
+      COUNT(DISTINCT c.subject_entity_id) AS resolved_entities,
+      MAX(e.observed_at) AS last_evidence_at
+    FROM user_claim_evidence e JOIN user_claims c ON c.claim_id = e.claim_id
+    GROUP BY e.source_instance_id`).all();
+	return Object.fromEntries(rows.map((row) => [row.source_instance_id, {
+		evidenceCount: row.evidence_count,
+		provisionalClaims: row.provisional_claims,
+		activeClaims: row.active_claims,
+		resolvedEntities: row.resolved_entities,
+		...row.last_evidence_at == null ? {} : { lastEvidenceAt: new Date(row.last_evidence_at).toISOString() }
+	}]));
+}
+//#endregion
+export { getUserClaim, linkUserClaimMemoryRecord, listUserClaimEvidence, listUserClaimStatsBySource, listUserClaims, listUserPeopleGraphRows, reinforceUserClaim, removeUserClaimEvidenceForSource, resolveUserEntity, setUserClaimDecision };