@xopcai/xopc 0.0.248 → 0.0.249

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

@@ -1,535 +0,0 @@
-import { getSqliteDatabase, runSqliteWriteTransaction } from "./transaction.js";
-import { USER_CONTEXT_PRINCIPAL_ID } from "../../user-context/domain.js";
-import { notifyUserContextChange } from "../../user-context/changes.js";
-import { retrievalQueryAuditValue } from "../../retrieval/audit.js";
-import { buildFts5SearchQuery, fts5RankToScore } from "./fts.js";
-import { createHash, randomUUID } from "node:crypto";
-//#region src/storage/sqlite/user-context-repository.ts
-function insertUnderstandingStatusEvent(db, input) {
-	db.prepare(`INSERT INTO understanding_status_events (
-    event_id, understanding_id, from_status, to_status, actor_type, source, created_at
-  ) VALUES (?, ?, ?, ?, ?, ?, ?)`).run(randomUUID(), input.understandingId, input.fromStatus ?? null, input.toStatus, input.actorType, input.source, input.createdAt);
-}
-function evidenceFromRow(row) {
-	return {
-		id: row.evidence_id,
-		sourceType: row.source_type,
-		...row.source_instance_id ? { sourceInstanceId: row.source_instance_id } : {},
-		sourceRef: row.source_ref,
-		...row.source_run_id ? { sourceRunId: row.source_run_id } : {},
-		...row.source_item_id ? { sourceItemId: row.source_item_id } : {},
-		...row.session_id ? { sessionId: row.session_id } : {},
-		...row.turn_id ? { turnId: row.turn_id } : {},
-		...row.message_id ? { messageId: row.message_id } : {},
-		...row.content_hash ? { contentHash: row.content_hash } : {},
-		...row.retention_policy ? { retentionPolicy: row.retention_policy } : {},
-		...row.processing_policy ? { processingPolicy: row.processing_policy } : {},
-		...row.extractor_id ? { extractorId: row.extractor_id } : {},
-		...row.extractor_version ? { extractorVersion: row.extractor_version } : {},
-		...row.redacted_excerpt ? { redactedExcerpt: row.redacted_excerpt } : {},
-		trustLevel: row.trust_level,
-		observedAt: row.observed_at,
-		ingestedAt: row.ingested_at ?? row.created_at,
-		createdAt: row.created_at
-	};
-}
-const UNDERSTANDING_SELECT = `
-  SELECT u.*, v.statement, v.payload_json
-  FROM user_understandings u
-  JOIN user_understanding_versions v ON v.version_id = u.current_version_id
-`;
-function scopeFromRow(type, id) {
-	return id ? {
-		type,
-		id
-	} : { type };
-}
-function understandingFromRow(row) {
-	return {
-		id: row.understanding_id,
-		kind: row.kind,
-		canonicalKey: row.canonical_key,
-		status: row.status,
-		scope: scopeFromRow(row.scope_type, row.scope_id),
-		explicitness: row.explicitness,
-		durability: row.durability,
-		sensitivity: row.sensitivity,
-		disclosurePolicy: row.disclosure_policy,
-		confidence: row.confidence,
-		statement: row.statement,
-		payload: JSON.parse(row.payload_json),
-		versionId: row.current_version_id,
-		...row.valid_from === null ? {} : { validFrom: row.valid_from },
-		...row.valid_to === null ? {} : { validTo: row.valid_to },
-		...row.expires_at === null ? {} : { expiresAt: row.expires_at },
-		...row.review_at === null ? {} : { reviewAt: row.review_at },
-		...row.conflict_group_id ? { conflictGroupId: row.conflict_group_id } : {},
-		...row.supersedes_id ? { supersedesId: row.supersedes_id } : {},
-		createdAt: row.created_at,
-		updatedAt: row.updated_at
-	};
-}
-function ruleFromRow(row) {
-	return {
-		id: row.rule_id,
-		category: row.category,
-		status: row.status,
-		priority: row.priority,
-		scope: scopeFromRow(row.scope_type, row.scope_id),
-		conditions: JSON.parse(row.conditions_json),
-		statement: row.statement,
-		revisionId: row.current_revision_id,
-		createdAt: row.created_at,
-		updatedAt: row.updated_at
-	};
-}
-function getUserProfile(principalId = USER_CONTEXT_PRINCIPAL_ID) {
-	const row = getSqliteDatabase().prepare("SELECT * FROM user_profiles WHERE principal_id = ?").get(principalId);
-	if (!row) return {
-		callName: "",
-		role: "",
-		primaryGoal: "",
-		pronouns: "",
-		timezone: "",
-		locale: "",
-		accessibility: {},
-		createdAt: 0,
-		updatedAt: 0
-	};
-	return {
-		callName: row.call_name,
-		role: row.role,
-		primaryGoal: row.primary_goal,
-		pronouns: row.pronouns,
-		timezone: row.timezone,
-		locale: row.locale,
-		accessibility: JSON.parse(row.accessibility_json),
-		createdAt: row.created_at,
-		updatedAt: row.updated_at
-	};
-}
-function updateUserProfile(patch, principalId = USER_CONTEXT_PRINCIPAL_ID) {
-	notifyUserContextChange({
-		kind: "profile",
-		id: "profile"
-	});
-	const current = getUserProfile(principalId);
-	const now = Date.now();
-	const next = {
-		...current,
-		...patch,
-		createdAt: current.createdAt || now,
-		updatedAt: now
-	};
-	runSqliteWriteTransaction((db) => {
-		db.prepare(`
-      INSERT INTO user_profiles (
-        principal_id, call_name, role, primary_goal, pronouns, timezone, locale, accessibility_json, created_at, updated_at
-      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-      ON CONFLICT(principal_id) DO UPDATE SET
-        call_name = excluded.call_name,
-        role = excluded.role,
-        primary_goal = excluded.primary_goal,
-        pronouns = excluded.pronouns,
-        timezone = excluded.timezone,
-        locale = excluded.locale,
-        accessibility_json = excluded.accessibility_json,
-        updated_at = excluded.updated_at
-    `).run(principalId, next.callName, next.role, next.primaryGoal, next.pronouns, next.timezone, next.locale, JSON.stringify(next.accessibility), next.createdAt, next.updatedAt);
-	});
-	return next;
-}
-function createUnderstanding(input, principalId = USER_CONTEXT_PRINCIPAL_ID) {
-	const id = randomUUID();
-	const versionId = randomUUID();
-	const now = Date.now();
-	runSqliteWriteTransaction((db) => {
-		db.prepare(`INSERT INTO user_understandings (
-      understanding_id, principal_id, kind, canonical_key, status, scope_type, scope_id,
-      explicitness, durability, sensitivity, disclosure_policy, confidence, valid_from,
-      valid_to, expires_at, review_at, current_version_id, conflict_group_id, supersedes_id,
-      created_at, updated_at
-    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(id, principalId, input.kind, input.canonicalKey, input.status, input.scope.type, input.scope.id ?? null, input.explicitness, input.durability, input.sensitivity, input.disclosurePolicy, input.confidence, input.validFrom ?? null, input.validTo ?? null, input.expiresAt ?? null, input.reviewAt ?? null, versionId, input.conflictGroupId ?? null, input.supersedesId ?? null, now, now);
-		db.prepare(`INSERT INTO user_understanding_versions (
-      version_id, understanding_id, statement, payload_json, created_by, change_reason, created_at
-    ) VALUES (?, ?, ?, ?, ?, ?, ?)`).run(versionId, id, input.statement.trim(), JSON.stringify(input.payload ?? {}), input.createdBy, input.changeReason, now);
-		db.prepare("INSERT INTO user_understanding_fts (statement, understanding_id, version_id) VALUES (?, ?, ?)").run(input.statement.trim(), id, versionId);
-		insertUnderstandingStatusEvent(db, {
-			understandingId: id,
-			toStatus: input.status,
-			actorType: input.createdBy === "user" ? "user" : "runtime",
-			source: `create:${input.changeReason}`,
-			createdAt: now
-		});
-	});
-	return getUnderstanding(id);
-}
-function getUnderstanding(id) {
-	const row = getSqliteDatabase().prepare(`${UNDERSTANDING_SELECT} WHERE u.understanding_id = ?`).get(id);
-	return row ? understandingFromRow(row) : void 0;
-}
-function listUnderstandings(statuses, principalId = USER_CONTEXT_PRINCIPAL_ID, limit) {
-	const db = getSqliteDatabase();
-	const maxRows = limit === void 0 ? -1 : Math.max(1, Math.min(500, Math.floor(limit)));
-	if (!statuses?.length) return db.prepare(`${UNDERSTANDING_SELECT} WHERE u.principal_id = ? ORDER BY u.updated_at DESC LIMIT ?`).all(principalId, maxRows).map(understandingFromRow);
-	const placeholders = statuses.map(() => "?").join(", ");
-	return db.prepare(`${UNDERSTANDING_SELECT} WHERE u.principal_id = ? AND u.status IN (${placeholders}) ORDER BY u.updated_at DESC LIMIT ?`).all(principalId, ...statuses, maxRows).map(understandingFromRow);
-}
-function searchActiveUnderstandings(query, limit = 50) {
-	const ftsQuery = buildFts5SearchQuery(query);
-	if (!ftsQuery) return [];
-	const boundedLimit = Math.max(1, Math.min(200, Math.floor(limit)));
-	const rows = getSqliteDatabase().prepare(`
-    SELECT u.*, v.statement, v.payload_json, bm25(user_understanding_fts) AS search_rank
-    FROM user_understanding_fts
-    JOIN user_understandings u
-      ON u.understanding_id = user_understanding_fts.understanding_id
-    JOIN user_understanding_versions v
-      ON v.version_id = u.current_version_id
-    WHERE user_understanding_fts MATCH ? AND u.principal_id = ? AND u.status = 'active'
-    ORDER BY search_rank
-    LIMIT ?
-  `).all(ftsQuery, USER_CONTEXT_PRINCIPAL_ID, boundedLimit);
-	if (!rows.length) return [];
-	const bestRank = Math.min(...rows.map((row) => row.search_rank));
-	const worstRank = Math.max(...rows.map((row) => row.search_rank));
-	return rows.map((row) => ({
-		understanding: understandingFromRow(row),
-		score: fts5RankToScore(row.search_rank, bestRank, worstRank)
-	}));
-}
-function reviseUnderstanding(id, statement, options) {
-	notifyUserContextChange({
-		kind: "understanding",
-		id
-	});
-	const current = getUnderstanding(id);
-	if (!current) throw new Error(`User understanding not found: ${id}`);
-	const versionId = randomUUID();
-	const now = Date.now();
-	runSqliteWriteTransaction((db) => {
-		db.prepare(`INSERT INTO user_understanding_versions (
-      version_id, understanding_id, statement, payload_json, created_by, change_reason, created_at
-    ) VALUES (?, ?, ?, ?, 'user', ?, ?)`).run(versionId, id, statement.trim(), JSON.stringify(options.payload ?? current.payload), options.changeReason, now);
-		db.prepare(`UPDATE user_understandings
-      SET current_version_id = ?, canonical_key = ?, explicitness = ?, confidence = ?, updated_at = ?
-      WHERE understanding_id = ?`).run(versionId, options.canonicalKey ?? current.canonicalKey, options.explicitness ?? current.explicitness, options.confidence ?? current.confidence, now, id);
-		db.prepare("DELETE FROM user_understanding_fts WHERE understanding_id = ?").run(id);
-		db.prepare("INSERT INTO user_understanding_fts (statement, understanding_id, version_id) VALUES (?, ?, ?)").run(statement.trim(), id, versionId);
-	});
-	return getUnderstanding(id);
-}
-function setUnderstandingStatus(id, status, options) {
-	notifyUserContextChange({
-		kind: "understanding",
-		id
-	});
-	const current = getUnderstanding(id);
-	if (!current) throw new Error(`User understanding not found: ${id}`);
-	const now = Date.now();
-	runSqliteWriteTransaction((db) => {
-		db.prepare(`UPDATE user_understandings
-      SET status = ?,
-          explicitness = COALESCE(?, explicitness),
-          confidence = COALESCE(?, confidence),
-          updated_at = ?
-      WHERE understanding_id = ?`).run(status, options?.explicitness ?? null, options?.confidence ?? null, now, id);
-		const assertionStatus = status === "active" ? "active" : status === "archived" ? "closed" : status === "rejected" ? "rejected" : "candidate";
-		db.prepare(`UPDATE context_temporal_assertions
-      SET status = ?, updated_at = ? WHERE object_type = 'understanding' AND object_id = ?`).run(assertionStatus, now, id);
-		if (current.status !== status) insertUnderstandingStatusEvent(db, {
-			understandingId: id,
-			fromStatus: current.status,
-			toStatus: status,
-			actorType: options?.actorType ?? "runtime",
-			source: options?.source ?? "repository-status-change",
-			createdAt: now
-		});
-	});
-	const result = getUnderstanding(id);
-	if (!result) throw new Error(`User understanding not found: ${id}`);
-	return result;
-}
-function closeUnderstandingValidity(id, validTo = Date.now()) {
-	notifyUserContextChange({
-		kind: "understanding",
-		id
-	});
-	getSqliteDatabase().prepare(`UPDATE user_understandings SET valid_to = ?, updated_at = ?
-    WHERE understanding_id = ?`).run(validTo, validTo, id);
-	const result = getUnderstanding(id);
-	if (!result) throw new Error(`User understanding not found: ${id}`);
-	return result;
-}
-function rejectUnderstanding(id, reason, actorType = "runtime") {
-	notifyUserContextChange({
-		kind: "understanding",
-		id
-	});
-	const current = getUnderstanding(id);
-	if (!current) throw new Error(`User understanding not found: ${id}`);
-	const now = Date.now();
-	runSqliteWriteTransaction((db) => {
-		db.prepare("UPDATE user_understandings SET status = 'rejected', updated_at = ? WHERE understanding_id = ?").run(now, id);
-		if (current.status !== "rejected") insertUnderstandingStatusEvent(db, {
-			understandingId: id,
-			fromStatus: current.status,
-			toStatus: "rejected",
-			actorType,
-			source: reason,
-			createdAt: now
-		});
-		db.prepare(`INSERT INTO context_suppressions (
-      suppression_id, principal_id, canonical_key, scope_type, scope_id, reason, expires_at, created_at
-    ) VALUES (?, ?, ?, ?, ?, ?, NULL, ?)
-    ON CONFLICT DO UPDATE SET reason = excluded.reason, expires_at = NULL`).run(randomUUID(), USER_CONTEXT_PRINCIPAL_ID, current.canonicalKey, current.scope.type, current.scope.id ?? null, reason, now);
-	});
-	return getUnderstanding(id);
-}
-function listUnderstandingStatusEvents(id) {
-	return getSqliteDatabase().prepare(`SELECT * FROM understanding_status_events
-    WHERE understanding_id = ? ORDER BY created_at DESC, rowid DESC`).all(id).map((row) => ({
-		id: row.event_id,
-		understandingId: row.understanding_id,
-		...row.from_status ? { fromStatus: row.from_status } : {},
-		toStatus: row.to_status,
-		actorType: row.actor_type,
-		source: row.source,
-		createdAt: row.created_at
-	}));
-}
-function deleteUnderstanding(id) {
-	notifyUserContextChange({
-		kind: "understanding",
-		id
-	});
-	return runSqliteWriteTransaction((db) => {
-		db.prepare("DELETE FROM user_understanding_fts WHERE understanding_id = ?").run(id);
-		return Number(db.prepare("DELETE FROM user_understandings WHERE understanding_id = ?").run(id).changes) > 0;
-	});
-}
-function isUnderstandingSuppressed(canonicalKey, scope, principalId = USER_CONTEXT_PRINCIPAL_ID) {
-	const row = getSqliteDatabase().prepare(`SELECT 1 FROM context_suppressions
-    WHERE principal_id = ? AND canonical_key = ? AND scope_type = ?
-      AND COALESCE(scope_id, '') = COALESCE(?, '')
-      AND (expires_at IS NULL OR expires_at > ?)`).get(principalId, canonicalKey, scope.type, scope.id ?? null, Date.now());
-	return Boolean(row);
-}
-function createCollaborationRule(input, principalId = USER_CONTEXT_PRINCIPAL_ID) {
-	const id = randomUUID();
-	const revisionId = randomUUID();
-	const now = Date.now();
-	runSqliteWriteTransaction((db) => {
-		db.prepare(`INSERT INTO collaboration_rules (
-      rule_id, principal_id, category, status, priority, scope_type, scope_id,
-      conditions_json, current_revision_id, created_at, updated_at
-    ) VALUES (?, ?, ?, 'active', ?, ?, ?, ?, ?, ?, ?)`).run(id, principalId, input.category, input.priority, input.scope.type, input.scope.id ?? null, JSON.stringify(input.conditions), revisionId, now, now);
-		db.prepare(`INSERT INTO collaboration_rule_revisions (
-      revision_id, rule_id, statement, created_by, created_at
-    ) VALUES (?, ?, ?, 'user', ?)`).run(revisionId, id, input.statement.trim(), now);
-	});
-	return getCollaborationRule(id);
-}
-function getCollaborationRule(id) {
-	const row = getSqliteDatabase().prepare(`SELECT r.*, v.statement FROM collaboration_rules r
-    JOIN collaboration_rule_revisions v ON v.revision_id = r.current_revision_id
-    WHERE r.rule_id = ?`).get(id);
-	return row ? ruleFromRow(row) : void 0;
-}
-function listCollaborationRules(principalId = USER_CONTEXT_PRINCIPAL_ID) {
-	return getSqliteDatabase().prepare(`SELECT r.*, v.statement FROM collaboration_rules r
-    JOIN collaboration_rule_revisions v ON v.revision_id = r.current_revision_id
-    WHERE r.principal_id = ? ORDER BY r.priority ASC, r.updated_at DESC`).all(principalId).map(ruleFromRow);
-}
-function reviseCollaborationRule(id, statement) {
-	if (!getCollaborationRule(id)) throw new Error(`Collaboration rule not found: ${id}`);
-	const revisionId = randomUUID();
-	const now = Date.now();
-	runSqliteWriteTransaction((db) => {
-		db.prepare(`INSERT INTO collaboration_rule_revisions (
-      revision_id, rule_id, statement, created_by, created_at
-    ) VALUES (?, ?, ?, 'user', ?)`).run(revisionId, id, statement.trim(), now);
-		db.prepare("UPDATE collaboration_rules SET current_revision_id = ?, updated_at = ? WHERE rule_id = ?").run(revisionId, now, id);
-	});
-	return getCollaborationRule(id);
-}
-function setCollaborationRuleStatus(id, status) {
-	getSqliteDatabase().prepare("UPDATE collaboration_rules SET status = ?, updated_at = ? WHERE rule_id = ?").run(status, Date.now(), id);
-	const result = getCollaborationRule(id);
-	if (!result) throw new Error(`Collaboration rule not found: ${id}`);
-	return result;
-}
-function deleteCollaborationRule(id) {
-	return Number(getSqliteDatabase().prepare("DELETE FROM collaboration_rules WHERE rule_id = ?").run(id).changes) > 0;
-}
-function createContextEvidence(input, principalId = USER_CONTEXT_PRINCIPAL_ID) {
-	const existing = getSqliteDatabase().prepare(`SELECT * FROM context_evidence
-    WHERE principal_id = ? AND source_type = ?
-      AND COALESCE(source_instance_id, '') = COALESCE(?, '') AND source_ref = ?`).get(principalId, input.sourceType, input.sourceInstanceId ?? null, input.sourceRef);
-	const derivedHash = input.contentHash ?? (input.redactedExcerpt ? createHash("sha256").update(input.redactedExcerpt).digest("hex") : void 0);
-	if (existing) {
-		notifyUserContextChange({ kind: "policy" });
-		getSqliteDatabase().prepare(`UPDATE context_evidence SET
-      source_run_id = COALESCE(source_run_id, ?), source_item_id = COALESCE(source_item_id, ?),
-      session_id = COALESCE(session_id, ?), turn_id = COALESCE(turn_id, ?),
-      message_id = COALESCE(message_id, ?), content_hash = COALESCE(content_hash, ?),
-      retention_policy = COALESCE(retention_policy, ?),
-      processing_policy = CASE
-        WHEN processing_policy = 'local_only' OR ? = 'local_only' THEN 'local_only'
-        ELSE COALESCE(processing_policy, ?)
-      END,
-      extractor_id = COALESCE(extractor_id, ?), extractor_version = COALESCE(extractor_version, ?),
-      ingested_at = COALESCE(ingested_at, ?)
-      WHERE evidence_id = ?`).run(input.sourceRunId ?? null, input.sourceItemId ?? null, input.sessionId ?? null, input.turnId ?? null, input.messageId ?? null, derivedHash ?? null, input.retentionPolicy ?? null, input.processingPolicy ?? null, input.processingPolicy ?? null, input.extractorId ?? null, input.extractorVersion ?? null, input.ingestedAt ?? Date.now(), existing.evidence_id);
-		return evidenceFromRow(getSqliteDatabase().prepare("SELECT * FROM context_evidence WHERE evidence_id = ?").get(existing.evidence_id));
-	}
-	const createdAt = Date.now();
-	const evidence = {
-		...input,
-		id: randomUUID(),
-		...derivedHash ? { contentHash: derivedHash } : {},
-		ingestedAt: input.ingestedAt ?? createdAt,
-		createdAt
-	};
-	getSqliteDatabase().prepare(`INSERT INTO context_evidence (
-    evidence_id, principal_id, source_type, source_instance_id, source_ref, source_run_id,
-    source_item_id, session_id, turn_id, message_id, content_hash, retention_policy,
-    processing_policy, extractor_id, extractor_version, redacted_excerpt, trust_level,
-    observed_at, ingested_at, created_at
-  ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(evidence.id, principalId, evidence.sourceType, evidence.sourceInstanceId ?? null, evidence.sourceRef, evidence.sourceRunId ?? null, evidence.sourceItemId ?? null, evidence.sessionId ?? null, evidence.turnId ?? null, evidence.messageId ?? null, evidence.contentHash ?? null, evidence.retentionPolicy ?? null, evidence.processingPolicy ?? null, evidence.extractorId ?? null, evidence.extractorVersion ?? null, evidence.redactedExcerpt ?? null, evidence.trustLevel, evidence.observedAt, evidence.ingestedAt, evidence.createdAt);
-	return evidence;
-}
-function linkUnderstandingEvidence(versionId, evidenceId, relation, confidence) {
-	const owner = getSqliteDatabase().prepare("SELECT understanding_id AS id FROM user_understanding_versions WHERE version_id = ?").get(versionId);
-	if (owner) notifyUserContextChange({
-		kind: "understanding",
-		id: owner.id
-	});
-	getSqliteDatabase().prepare(`INSERT INTO understanding_evidence_links (
-    version_id, evidence_id, relation, confidence
-  ) VALUES (?, ?, ?, ?)
-  ON CONFLICT(version_id, evidence_id, relation) DO UPDATE SET confidence = excluded.confidence`).run(versionId, evidenceId, relation, confidence);
-}
-function listUnderstandingEvidence(understandingId, relation) {
-	return getSqliteDatabase().prepare(`SELECT DISTINCT e.* FROM context_evidence e
-    JOIN understanding_evidence_links l ON l.evidence_id = e.evidence_id
-    JOIN user_understanding_versions v ON v.version_id = l.version_id
-    WHERE v.understanding_id = ? AND (? IS NULL OR l.relation = ?)
-    ORDER BY e.observed_at DESC`).all(understandingId, relation ?? null, relation ?? null).map(evidenceFromRow);
-}
-/** Latest source labels for ranking, without fetching evidence bodies per candidate. */
-function understandingSourceBuckets(ids) {
-	if (!ids.length) return /* @__PURE__ */ new Map();
-	const rows = getSqliteDatabase().prepare(`
-    SELECT understanding_id, source_type, source_instance_id, source_ref FROM (
-      SELECT v.understanding_id, e.source_type, e.source_instance_id, e.source_ref,
-        ROW_NUMBER() OVER (PARTITION BY v.understanding_id ORDER BY e.observed_at DESC) AS rank
-      FROM context_evidence e JOIN understanding_evidence_links l ON l.evidence_id = e.evidence_id
-      JOIN user_understanding_versions v ON v.version_id = l.version_id
-      WHERE v.understanding_id IN (${ids.map(() => "?").join(",")})
-    ) WHERE rank = 1
-  `).all(...ids);
-	return new Map(rows.map((row) => [row.understanding_id, `${row.source_type}:${row.source_instance_id ?? row.source_ref.split(":entry:")[0]}`]));
-}
-function recordContextRun(input) {
-	const auditedQuery = retrievalQueryAuditValue(input.query);
-	const existing = getSqliteDatabase().prepare("SELECT context_run_id FROM context_runs WHERE turn_id = ?").get(input.turnId);
-	const runId = existing?.context_run_id ?? randomUUID();
-	runSqliteWriteTransaction((db) => {
-		if (existing) {
-			db.prepare(`UPDATE context_runs SET principal_id = ?, session_key = ?, query = ?, budget = ?, duration_ms = ?
-        WHERE context_run_id = ?`).run(input.principalId ?? "local-owner", input.sessionKey, auditedQuery, input.budget, input.durationMs, runId);
-			db.prepare("DELETE FROM context_run_items WHERE context_run_id = ?").run(runId);
-		} else db.prepare(`INSERT INTO context_runs (
-        context_run_id, principal_id, turn_id, session_key, query, budget, duration_ms, created_at
-      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(runId, input.principalId ?? "local-owner", input.turnId, input.sessionKey, auditedQuery, input.budget, input.durationMs, Date.now());
-		const insert = db.prepare(`INSERT INTO context_run_items (
-      context_run_id, object_type, object_id, version_id, decision, reason, content_snapshot,
-      source_label, origin, rank, score, injected_chars
-    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
-		for (const item of input.items) insert.run(runId, item.objectType, item.objectId, item.versionId ?? null, item.decision, item.reason, item.content, item.sourceLabel, item.origin, item.rank ?? null, item.score ?? null, item.injectedChars);
-	});
-	return runId;
-}
-function getTurnPersonalization(turnId) {
-	const db = getSqliteDatabase();
-	const run = db.prepare("SELECT context_run_id FROM context_runs WHERE turn_id = ?").get(turnId);
-	if (!run) return void 0;
-	const rows = db.prepare("SELECT * FROM context_run_items WHERE context_run_id = ? ORDER BY rank ASC, object_type ASC").all(run.context_run_id);
-	return {
-		runId: run.context_run_id,
-		items: rows.map((row) => ({
-			objectType: row.object_type,
-			objectId: row.object_id,
-			...row.version_id ? { versionId: row.version_id } : {},
-			decision: row.decision,
-			reason: row.reason,
-			content: row.content_snapshot,
-			sourceLabel: row.source_label,
-			origin: row.origin,
-			...row.rank === null ? {} : { rank: row.rank },
-			...row.score === null ? {} : { score: row.score },
-			injectedChars: row.injected_chars
-		}))
-	};
-}
-function recordContextFeedback(input) {
-	if (Boolean(input.objectType) !== Boolean(input.objectId)) throw new Error("objectType and objectId must be provided together");
-	getSqliteDatabase().prepare(`INSERT INTO context_feedback (
-    feedback_id, turn_id, context_run_id, object_type, object_id, rating, reason, created_at
-  ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-  ON CONFLICT DO UPDATE SET rating = excluded.rating, reason = excluded.reason, created_at = excluded.created_at`).run(randomUUID(), input.turnId, input.runId, input.objectType ?? null, input.objectId ?? null, input.rating, input.reason ?? null, Date.now());
-}
-function hasContextConsent(understandingId, sessionKey) {
-	const now = Date.now();
-	return Boolean(getSqliteDatabase().prepare(`SELECT 1 FROM context_consents
-    WHERE understanding_id = ? AND status = 'granted'
-      AND (grant_scope = 'always' OR session_key = ?)
-      AND (expires_at IS NULL OR expires_at > ?)
-    LIMIT 1`).get(understandingId, sessionKey, now));
-}
-function consumeContextConsent(understandingId, sessionKey) {
-	const db = getSqliteDatabase();
-	const now = Date.now();
-	const granted = db.prepare(`SELECT consent_id, grant_scope FROM context_consents
-    WHERE understanding_id = ? AND status = 'granted'
-      AND (grant_scope = 'always' OR session_key = ?)
-      AND (expires_at IS NULL OR expires_at > ?)
-    ORDER BY CASE grant_scope WHEN 'once' THEN 0 WHEN 'session' THEN 1 ELSE 2 END
-    LIMIT 1`).get(understandingId, sessionKey, now);
-	if (granted) {
-		if (granted.grant_scope === "once") db.prepare("UPDATE context_consents SET status = 'consumed', updated_at = ? WHERE consent_id = ?").run(now, granted.consent_id);
-		return "granted";
-	}
-	return db.prepare(`SELECT 1 FROM context_consents
-    WHERE understanding_id = ? AND session_key = ? AND status = 'denied' LIMIT 1`).get(understandingId, sessionKey) ? "denied" : "missing";
-}
-function ensureContextConsent(understandingId, sessionKey, purpose) {
-	const db = getSqliteDatabase();
-	const existing = db.prepare(`SELECT consent_id, purpose FROM context_consents
-    WHERE understanding_id = ? AND session_key = ? AND status = 'pending'`).get(understandingId, sessionKey);
-	if (existing) return {
-		id: existing.consent_id,
-		understandingId,
-		purpose: existing.purpose
-	};
-	const id = randomUUID();
-	const now = Date.now();
-	db.prepare(`INSERT INTO context_consents (
-    consent_id, principal_id, understanding_id, session_key, purpose, status,
-    grant_scope, expires_at, created_at, updated_at
-  ) VALUES (?, ?, ?, ?, ?, 'pending', NULL, NULL, ?, ?)`).run(id, USER_CONTEXT_PRINCIPAL_ID, understandingId, sessionKey, purpose, now, now);
-	return {
-		id,
-		understandingId,
-		purpose
-	};
-}
-function decideContextConsent(id, decision) {
-	const expiresAt = decision === "once" ? Date.now() + 5 * 6e4 : null;
-	const result = getSqliteDatabase().prepare(`UPDATE context_consents
-    SET status = ?, grant_scope = ?, expires_at = ?, updated_at = ? WHERE consent_id = ?`).run(decision === "deny" ? "denied" : "granted", decision === "deny" ? null : decision, expiresAt, Date.now(), id);
-	return Number(result.changes) > 0;
-}
-//#endregion
-export { closeUnderstandingValidity, consumeContextConsent, createCollaborationRule, createContextEvidence, createUnderstanding, decideContextConsent, deleteCollaborationRule, deleteUnderstanding, ensureContextConsent, getCollaborationRule, getTurnPersonalization, getUnderstanding, getUserProfile, hasContextConsent, isUnderstandingSuppressed, linkUnderstandingEvidence, listCollaborationRules, listUnderstandingEvidence, listUnderstandingStatusEvents, listUnderstandings, recordContextFeedback, recordContextRun, rejectUnderstanding, reviseCollaborationRule, reviseUnderstanding, searchActiveUnderstandings, setCollaborationRuleStatus, setUnderstandingStatus, understandingSourceBuckets, updateUserProfile };

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

@@ -1,17 +0,0 @@
-import { type RemoteContextKind } from '../storage/sqlite/remote-context-repository.js';
-import type { UserContextScopeTarget } from './scope.js';
-export interface AutomaticContextReference {
-    kind: RemoteContextKind | 'profile';
-    id: string;
-    version: string;
-}
-export interface AutomaticContextSelection {
-    block: string;
-    references: AutomaticContextReference[];
-}
-/** Read-only background selection. Never consumes consent or starts a model turn. */
-export declare function selectAutomaticContext(input: UserContextScopeTarget & {
-    query: string;
-    maxChars: number;
-    deadline: number;
-}): AutomaticContextSelection;

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

@@ -1,85 +0,0 @@
-import { getUserProfile, listUnderstandings } from "../storage/sqlite/user-context-repository.js";
-import { listUserFocuses } from "./sources/repository.js";
-import { UserUnderstandingRetriever } from "./retriever.js";
-import { allowsAutomaticDisclosure, focusRejectionReason, focusScore, rejectionReason } from "./selection-policy.js";
-import { remoteContextEligibleIds } from "../storage/sqlite/remote-context-repository.js";
-//#region src/user-context/automatic-context.ts
-/** Read-only background selection. Never consumes consent or starts a model turn. */
-function selectAutomaticContext(input) {
-	const references = [];
-	const facts = [];
-	const profile = {};
-	const render = () => JSON.stringify({ backgroundMemory: {
-		profile,
-		facts
-	} });
-	const withinDeadline = () => performance.now() < input.deadline;
-	if (input.maxChars < 128 || !withinDeadline()) return {
-		block: "",
-		references
-	};
-	const user = getUserProfile();
-	for (const key of [
-		"callName",
-		"locale",
-		"timezone",
-		"pronouns",
-		"role",
-		"primaryGoal"
-	]) {
-		if (!user[key] || user[key].length > 300) continue;
-		profile[key] = user[key];
-		if (render().length > input.maxChars) delete profile[key];
-	}
-	if (Object.keys(profile).length) references.push({
-		kind: "profile",
-		id: "profile",
-		version: JSON.stringify(user)
-	});
-	const query = input.query.trim();
-	const candidates = !withinDeadline() ? [] : query ? new UserUnderstandingRetriever().retrieve({
-		...input,
-		maxCandidates: 50
-	}) : listUnderstandings(["active"], void 0, 200).filter((item) => item.explicitness === "explicit" && ["preference", "boundary"].includes(item.kind) && item.durability === "durable").map((understanding) => ({
-		understanding,
-		score: 1
-	}));
-	const now = Date.now();
-	const eligible = candidates.filter(({ understanding: item, score }) => item.status === "active" && allowsAutomaticDisclosure(item) && !rejectionReason(item, input, now, []) && score > .25);
-	const allowed = withinDeadline() ? remoteContextEligibleIds("understanding", eligible.map(({ understanding }) => understanding.id)) : /* @__PURE__ */ new Set();
-	const append = (text, origin, reference) => {
-		if (!withinDeadline() || facts.length >= 6 || !text.trim()) return;
-		facts.push({
-			text,
-			origin
-		});
-		if (render().length > input.maxChars) {
-			facts.pop();
-			return;
-		}
-		references.push(reference);
-	};
-	for (const { understanding: item } of eligible) if (allowed.has(item.id)) append(item.statement, item.explicitness, {
-		kind: "understanding",
-		id: item.id,
-		version: item.versionId
-	});
-	if (query && withinDeadline() && facts.length < 6) {
-		const focuses = listUserFocuses(["active"], 50).filter((item) => allowsAutomaticDisclosure(item) && !focusRejectionReason(item, input, now)).map((item) => ({
-			item,
-			score: focusScore(item, query, input)
-		})).filter(({ score }) => score > .25).sort((a, b) => b.score - a.score);
-		const allowedFocuses = remoteContextEligibleIds("focus", focuses.map(({ item }) => item.id));
-		for (const { item } of focuses) if (allowedFocuses.has(item.id)) append(`${item.title}: ${item.summary}`, item.explicitness, {
-			kind: "focus",
-			id: item.id,
-			version: item.versionId ?? String(item.updatedAt)
-		});
-	}
-	return {
-		block: references.length ? render() : "",
-		references
-	};
-}
-//#endregion
-export { selectAutomaticContext };

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

@@ -1,27 +0,0 @@
-import type { Config } from '../config/schema.js';
-import { type ContextConsolidationRun } from '../storage/sqlite/index.js';
-export declare const USER_CONTEXT_CONSOLIDATION_TOKEN = "__xopc_user_context_consolidation__";
-export declare const USER_CONTEXT_CONSOLIDATION_AUTOMATION_ID = "system-user-context-consolidation";
-type ConsolidationMetrics = {
-    scanned: number;
-    needsReview: number;
-    stale: number;
-    globalCandidates: number;
-};
-export declare function resolveContextConsolidationConfig(config: Config): {
-    enabled: boolean;
-    timezone: string;
-    time: string;
-    minEvidenceSources: number;
-    limit: number;
-};
-export declare function compileContextConsolidationCron(time: string): string;
-export declare function runContextConsolidation(input: {
-    config: Config;
-    triggerKind: 'schedule' | 'manual';
-    now?: number;
-}): Promise<{
-    run: ContextConsolidationRun;
-    metrics: ConsolidationMetrics;
-}>;
-export {};