@xopcai/xopc 0.0.373 → 0.0.375

package/dist/src/infra/rate-limit/keyed-store.js

@@ -1,49 +1,54 @@
+import { __esmMin } from "../../../_virtual/_rolldown/runtime.js";
 //#region src/infra/rate-limit/keyed-store.ts
-var KeyedStore = class {
-	map = /* @__PURE__ */ new Map();
-	maxEntries;
-	overflow;
-	clock;
-	staleAfterMs;
-	cleanupTimer;
-	constructor(opts) {
-		this.maxEntries = Math.max(1, opts.maxEntries ?? 1e4);
-		this.clock = opts.clock ?? Date.now;
-		this.staleAfterMs = Math.max(1e3, opts.staleAfterMs);
-		const interval = Math.min(600 * 1e3, Math.max(1e3, opts.cleanupIntervalMs ?? Math.floor(this.staleAfterMs / 4)));
-		this.cleanupTimer = setInterval(() => this.sweep(), interval);
-		this.cleanupTimer.unref?.();
-	}
-	get(key) {
-		return this.map.get(key) ?? (this.map.size >= this.maxEntries ? this.overflow : void 0);
-	}
-	set(key, value) {
-		if (this.map.has(key) || this.map.size < this.maxEntries) this.map.set(key, value);
-		else this.overflow ??= value;
-	}
-	delete(key) {
-		this.map.delete(key);
-	}
-	size() {
-		return this.map.size;
-	}
-	clear() {
-		this.map.clear();
-		this.overflow = void 0;
-	}
-	destroy() {
-		if (this.cleanupTimer) {
-			clearInterval(this.cleanupTimer);
-			this.cleanupTimer = void 0;
-		}
-		this.map.clear();
-		this.overflow = void 0;
-	}
-	sweep() {
-		const now = this.clock();
-		if (this.overflow && now - this.overflow.lastTouchedMs > this.staleAfterMs) this.overflow = void 0;
-		for (const [k, v] of this.map.entries()) if (now - v.lastTouchedMs > this.staleAfterMs) this.map.delete(k);
-	}
-};
+var KeyedStore;
+var init_keyed_store = __esmMin((() => {
+	KeyedStore = class {
+		map = /* @__PURE__ */ new Map();
+		maxEntries;
+		overflow;
+		clock;
+		staleAfterMs;
+		cleanupTimer;
+		constructor(opts) {
+			this.maxEntries = Math.max(1, opts.maxEntries ?? 1e4);
+			this.clock = opts.clock ?? Date.now;
+			this.staleAfterMs = Math.max(1e3, opts.staleAfterMs);
+			const interval = Math.min(600 * 1e3, Math.max(1e3, opts.cleanupIntervalMs ?? Math.floor(this.staleAfterMs / 4)));
+			this.cleanupTimer = setInterval(() => this.sweep(), interval);
+			this.cleanupTimer.unref?.();
+		}
+		get(key) {
+			return this.map.get(key) ?? (this.map.size >= this.maxEntries ? this.overflow : void 0);
+		}
+		set(key, value) {
+			if (this.map.has(key) || this.map.size < this.maxEntries) this.map.set(key, value);
+			else this.overflow ??= value;
+		}
+		delete(key) {
+			this.map.delete(key);
+		}
+		size() {
+			return this.map.size;
+		}
+		clear() {
+			this.map.clear();
+			this.overflow = void 0;
+		}
+		destroy() {
+			if (this.cleanupTimer) {
+				clearInterval(this.cleanupTimer);
+				this.cleanupTimer = void 0;
+			}
+			this.map.clear();
+			this.overflow = void 0;
+		}
+		sweep() {
+			const now = this.clock();
+			if (this.overflow && now - this.overflow.lastTouchedMs > this.staleAfterMs) this.overflow = void 0;
+			for (const [k, v] of this.map.entries()) if (now - v.lastTouchedMs > this.staleAfterMs) this.map.delete(k);
+		}
+	};
+}));
 //#endregion
-export { KeyedStore };
+init_keyed_store();
+export { KeyedStore, init_keyed_store };

package/dist/src/infra/rate-limit/rate-limiter.js

@@ -1,63 +1,60 @@
-import { KeyedStore } from "./keyed-store.js";
+import { __esmMin } from "../../../_virtual/_rolldown/runtime.js";
+import { KeyedStore, init_keyed_store } from "./keyed-store.js";
 //#region src/infra/rate-limit/rate-limiter.ts
-/**
-* Per-key fixed-window request-rate limiter. Every `consume()` counts toward
-* the limit; once the window's count hits `maxRequests`, subsequent consumes
-* return `allowed: false` until the window rolls over.
-*
-* Use this for *throughput* limiting (e.g. "15 req/min on /admin"). For
-* *failure-rate* limiting with lockout (e.g. brute-force protection), use
-* {@link FailureLimiter} instead.
-*/
-var RateLimiter = class {
-	store;
-	clock;
-	maxRequests;
-	windowMs;
-	constructor(cfg) {
-		this.maxRequests = Math.max(1, Math.floor(cfg.maxRequests));
-		this.windowMs = Math.max(1, Math.floor(cfg.windowMs));
-		this.clock = cfg.clock ?? Date.now;
-		this.store = new KeyedStore({
-			staleAfterMs: cfg.staleAfterMs ?? this.windowMs * 4,
-			clock: this.clock
-		});
-	}
-	consume(key) {
-		const now = this.clock();
-		let state = this.store.get(key);
-		if (!state) {
-			state = {
-				windowStart: now,
-				count: 0,
-				lastTouchedMs: now
+var RateLimiter;
+var init_rate_limiter = __esmMin((() => {
+	init_keyed_store();
+	RateLimiter = class {
+		store;
+		clock;
+		maxRequests;
+		windowMs;
+		constructor(cfg) {
+			this.maxRequests = Math.max(1, Math.floor(cfg.maxRequests));
+			this.windowMs = Math.max(1, Math.floor(cfg.windowMs));
+			this.clock = cfg.clock ?? Date.now;
+			this.store = new KeyedStore({
+				staleAfterMs: cfg.staleAfterMs ?? this.windowMs * 4,
+				clock: this.clock
+			});
+		}
+		consume(key) {
+			const now = this.clock();
+			let state = this.store.get(key);
+			if (!state) {
+				state = {
+					windowStart: now,
+					count: 0,
+					lastTouchedMs: now
+				};
+				this.store.set(key, state);
+			}
+			if (now - state.windowStart >= this.windowMs) {
+				state.windowStart = now;
+				state.count = 0;
+			}
+			state.lastTouchedMs = now;
+			if (state.count >= this.maxRequests) return {
+				allowed: false,
+				remaining: 0,
+				retryAfterMs: Math.max(0, state.windowStart + this.windowMs - now)
+			};
+			state.count += 1;
+			return {
+				allowed: true,
+				remaining: this.maxRequests - state.count,
+				retryAfterMs: 0
 			};
-			this.store.set(key, state);
 		}
-		if (now - state.windowStart >= this.windowMs) {
-			state.windowStart = now;
-			state.count = 0;
+		/** @internal Test hook. */
+		resetForTests() {
+			this.store.clear();
+		}
+		destroy() {
+			this.store.destroy();
 		}
-		state.lastTouchedMs = now;
-		if (state.count >= this.maxRequests) return {
-			allowed: false,
-			remaining: 0,
-			retryAfterMs: Math.max(0, state.windowStart + this.windowMs - now)
-		};
-		state.count += 1;
-		return {
-			allowed: true,
-			remaining: this.maxRequests - state.count,
-			retryAfterMs: 0
-		};
-	}
-	/** @internal Test hook. */
-	resetForTests() {
-		this.store.clear();
-	}
-	destroy() {
-		this.store.destroy();
-	}
-};
+	};
+}));
 //#endregion
-export { RateLimiter };
+init_rate_limiter();
+export { RateLimiter, init_rate_limiter };

package/dist/src/infra/update-service-refresh.js

@@ -1,9 +1,10 @@
 import { createLogger } from "../utils/logger/index.js";
 import { init_logger } from "../utils/logger.js";
-import { SERVICE_VERSION_ENV_KEY, formatGatewayServiceDescription } from "../daemon/constants.js";
+import { SERVICE_VERSION_ENV_KEY, formatGatewayServiceDescription, init_constants } from "../daemon/constants.js";
 import path from "node:path";
 import fs from "node:fs/promises";
 //#region src/infra/update-service-refresh.ts
+init_constants();
 init_logger();
 const log = createLogger("UpdateServiceRefresh");
 function resolveBinPath(bin) {

package/dist/src/knowledge/chunks.d.ts

@@ -0,0 +1,10 @@
+import type { DatabaseSync } from 'node:sqlite';
+/** Index the retained source text; source deletion removes chunks through the FK. */
+export declare function replaceKnowledgeChunks(db: DatabaseSync, item: {
+    id: string;
+    contentHash: string;
+    normalizedText?: string;
+    sensitivity: string;
+    deletedAt?: string;
+    consentReceiptId?: string;
+}): void;

package/dist/src/knowledge/chunks.js

@@ -0,0 +1,28 @@
+import { __esmMin } from "../../_virtual/_rolldown/runtime.js";
+import { createHash } from "node:crypto";
+//#region src/knowledge/chunks.ts
+/** Index the retained source text; source deletion removes chunks through the FK. */
+function replaceKnowledgeChunks(db, item) {
+	db.prepare("DELETE FROM knowledge_source_chunks WHERE source_item_id = ?").run(item.id);
+	if (!item.normalizedText || item.deletedAt || item.sensitivity === "secret" || item.sensitivity === "regulated") return;
+	const text = item.normalizedText;
+	for (let offset = 0, ordinal = 0; offset < text.length; ordinal += 1) {
+		let end = Math.min(text.length, offset + 2400);
+		if (end < text.length) {
+			const boundary = text.lastIndexOf("\n", end);
+			if (boundary > offset + 1200) end = boundary + 1;
+		}
+		const id = createHash("sha256").update(`${item.id}:${item.contentHash}:${ordinal}`).digest("hex");
+		db.prepare(`INSERT INTO knowledge_source_chunks(chunk_id, source_item_id, source_version, consent_receipt_id, ordinal, locator, text)
+      VALUES (?, ?, ?, ?, ?, ?, ?)`).run(id, item.id, item.contentHash, item.consentReceiptId ?? null, ordinal, JSON.stringify({
+			startChar: offset,
+			endChar: end
+		}), text.slice(offset, end));
+		if (end === text.length) break;
+		offset = end - 150;
+	}
+}
+var init_chunks = __esmMin((() => {}));
+//#endregion
+init_chunks();
+export { init_chunks, replaceKnowledgeChunks };

package/dist/src/knowledge/connected-knowledge-pipeline.js

@@ -1,11 +1,20 @@
 import { createLogger } from "../utils/logger/index.js";
 import { init_logger } from "../utils/logger.js";
-import { claimKnowledgeSourceItems, completeKnowledgeSourceItemSynthesis, listKnowledgeSourceItems, pruneBoundedKnowledgeSourceItems } from "../storage/sqlite/knowledge-repository.js";
+import { getSqliteDatabase, init_transaction, runSqliteWriteTransaction } from "../storage/sqlite/transaction.js";
+import { createContextEvidence, init_context_evidence_repository } from "../storage/sqlite/context-evidence-repository.js";
+import { init_chunks, replaceKnowledgeChunks } from "./chunks.js";
+import { claimKnowledgeSourceItems, completeKnowledgeSourceItemSynthesis, pruneBoundedKnowledgeSourceItems } from "../storage/sqlite/knowledge-repository.js";
 import { init_sqlite } from "../storage/sqlite/index.js";
+import { getActiveUnderstandingConsent } from "../user-context/sources/consent-repository.js";
+import { clearMemoryAudit } from "../user-context/memory-suppression.js";
 import { listKnowledgeItems, transitionKnowledgeStatus, writeKnowledgeItem } from "../knowledge-memory/repository.js";
 import "../knowledge-memory/index.js";
+import { consentFilteredText } from "../user-context/sources/consent-fields.js";
 import { randomUUID } from "node:crypto";
 //#region src/knowledge/connected-knowledge-pipeline.ts
+init_chunks();
+init_context_evidence_repository();
+init_transaction();
 init_sqlite();
 init_logger();
 const log = createLogger("ConnectedKnowledge");
@@ -49,7 +58,7 @@ var ConnectedKnowledgePipeline = class {
 			recordIds: []
 		};
 		for (const item of claimed) try {
-			const content = boundedText(item);
+			let content = boundedText(item);
 			const existing = listKnowledgeItems({
 				recordClass: "source_index",
 				limit: 2e3
@@ -78,7 +87,43 @@ var ConnectedKnowledgePipeline = class {
 				result.ignored += 1;
 				continue;
 			}
+			const grant = getSqliteDatabase().prepare(`SELECT grant_id FROM understanding_source_grants
+          WHERE status = 'active' AND json_extract(config_json, '$.sourceInstanceId') = ? LIMIT 1`).get(item.sourceInstanceId);
+			const consent = grant ? getActiveUnderstandingConsent(grant.grant_id) : void 0;
+			const filtered = consent ? item.itemType === "local_file" ? consent.allowedFields.includes("content") ? item.normalizedText : void 0 : consentFilteredText(item.normalizedText, new Set(consent.allowedFields)) : void 0;
+			if (consent) content = (filtered ?? "").slice(0, MAX_ITEM_CHARS);
+			replaceKnowledgeChunks(getSqliteDatabase(), {
+				...item,
+				normalizedText: filtered,
+				consentReceiptId: consent?.id
+			});
+			if (!content.trim()) {
+				completeKnowledgeSourceItemSynthesis({
+					itemId: item.id,
+					workerId: this.workerId,
+					status: "ignored"
+				});
+				result.ignored += 1;
+				continue;
+			}
+			const evidence = createContextEvidence({
+				sourceType: "connector",
+				sourceInstanceId: item.sourceInstanceId,
+				sourceItemId: item.id,
+				sourceRef: `knowledge-source://${item.id}`,
+				contentHash: item.contentHash,
+				trustLevel: "untrusted",
+				observedAt: Date.parse(item.sourceUpdatedAt ?? item.updatedAt)
+			});
 			const written = writeKnowledgeItem({
+				verification: "supported",
+				claimMode: "reported",
+				sensitivity: item.sensitivity,
+				evidence: [{
+					id: evidence.id,
+					contentHash: item.contentHash,
+					consentReceiptId: consent?.id
+				}],
 				kind: "workspace_fact",
 				scope: {
 					type: "workspace",
@@ -97,7 +142,8 @@ var ConnectedKnowledgePipeline = class {
 					provider: providerId(item),
 					sourceInstanceId: item.sourceInstanceId,
 					sourceItemId: item.id,
-					payloadRef: item.payloadRef
+					payloadRef: item.payloadRef,
+					consentReceiptId: consent?.id
 				},
 				replaceExisting: true
 			});
@@ -126,36 +172,24 @@ var ConnectedKnowledgePipeline = class {
 		return result;
 	}
 	pruneBoundedRetention(sourceInstanceId, olderThanMs) {
-		const expired = [];
-		for (let offset = 0;; offset += 500) {
-			const page = listKnowledgeSourceItems({
-				sourceInstanceId,
-				retentionClass: "bounded",
-				retentionBeforeMs: olderThanMs,
-				includeDeleted: true,
-				limit: 500,
-				offset
-			});
-			expired.push(...page);
-			if (page.length < 500) break;
-		}
-		let derivedDeleted = 0;
-		const expiredIds = new Set(expired.map((item) => item.id));
-		for (const item of listKnowledgeItems({
-			recordClass: "source_index",
-			limit: 2e3
-		})) if (typeof item.source.sourceItemId === "string" && expiredIds.has(item.source.sourceItemId)) {
-			if (transitionKnowledgeStatus({
-				id: item.id,
-				status: "archived",
-				actor: "maintenance",
-				reason: "Connected source retention window expired."
-			})) derivedDeleted += 1;
-		}
-		return {
-			rawDeleted: pruneBoundedKnowledgeSourceItems(sourceInstanceId, olderThanMs),
-			derivedDeleted
-		};
+		return runSqliteWriteTransaction((db) => {
+			const expiredSourceQuery = `SELECT item_id FROM knowledge_source_items
+        WHERE source_instance_id = ? AND retention_class = 'bounded'
+          AND COALESCE(source_updated_at, occurred_at, updated_at) < ?`;
+			const indexes = db.prepare(`SELECT knowledge_id FROM knowledge_items
+        WHERE record_class = 'source_index'
+          AND json_extract(source_json, '$.sourceItemId') IN (${expiredSourceQuery})`).all(sourceInstanceId, olderThanMs);
+			for (const item of indexes) {
+				clearMemoryAudit(db, "knowledge", item.knowledge_id);
+				db.prepare("DELETE FROM knowledge_items WHERE knowledge_id = ?").run(item.knowledge_id);
+			}
+			db.prepare(`UPDATE context_evidence SET redacted_excerpt = NULL
+        WHERE source_item_id IN (${expiredSourceQuery})`).run(sourceInstanceId, olderThanMs);
+			return {
+				rawDeleted: pruneBoundedKnowledgeSourceItems(sourceInstanceId, olderThanMs),
+				derivedDeleted: indexes.length
+			};
+		});
 	}
 };
 //#endregion

package/dist/src/knowledge/index.js

@@ -1,5 +1,5 @@
-import { KnowledgeIngestionService, SqliteKnowledgeSourceStateStore } from "./ingestion-service.js";
 import { ConnectedKnowledgePipeline } from "./connected-knowledge-pipeline.js";
+import { KnowledgeIngestionService, SqliteKnowledgeSourceStateStore } from "./ingestion-service.js";
 import { startConnectedKnowledgeCoordinator } from "./coordinator.js";
 import { LocalFolderKnowledgeSourceAdapter } from "./local-folder-adapter.js";
 export { ConnectedKnowledgePipeline, KnowledgeIngestionService, LocalFolderKnowledgeSourceAdapter, SqliteKnowledgeSourceStateStore, startConnectedKnowledgeCoordinator };

package/dist/src/knowledge/ingestion-service.js

@@ -120,7 +120,11 @@ var KnowledgeIngestionService = class {
 				cursorAfter = pulled.nextCursor;
 				if (!pulled.hasMore) break;
 				if (!pulled.nextCursor || pulled.nextCursor === pullCursor) throw new Error("Knowledge source returned an invalid pagination cursor.");
-				if (page === MAX_PULL_PAGES - 1) throw new Error(`Knowledge source exceeded the ${MAX_PULL_PAGES}-page safety limit.`);
+				if (page === MAX_PULL_PAGES - 1) {
+					warnings.push(`Knowledge source paused after ${MAX_PULL_PAGES} pages; resume from the saved cursor.`);
+					snapshotComplete = false;
+					break;
+				}
 				pullCursor = pulled.nextCursor;
 			}
 			const tombstones = deletionInputs(params.instanceId, params.collectionScope, snapshotComplete ? snapshotExternalIds : void 0);

package/dist/src/knowledge/local-folder-adapter.d.ts

@@ -1,7 +1,8 @@
 import type { KnowledgePullInput, KnowledgePullResult, KnowledgeSourceAdapter } from './types.js';
 export declare class LocalFolderKnowledgeSourceAdapter implements KnowledgeSourceAdapter {
     private readonly rootPath;
+    private readonly pageSize;
     readonly kind = "local-folder";
-    constructor(rootPath: string);
+    constructor(rootPath: string, pageSize?: number);
     pull(input: KnowledgePullInput): Promise<KnowledgePullResult>;
 }

package/dist/src/knowledge/local-folder-adapter.js

@@ -1,3 +1,4 @@
+import { inferMemorySensitivity } from "../agent/memory/sensitivity.js";
 import { extname, relative, resolve, sep } from "node:path";
 import { createHash } from "node:crypto";
 import { readFile, readdir, realpath, stat } from "node:fs/promises";
@@ -21,22 +22,19 @@ const MAX_FILES = 2e3;
 const MAX_FILE_BYTES = 2 * 1024 * 1024;
 var LocalFolderKnowledgeSourceAdapter = class {
 	kind = "local-folder";
-	constructor(rootPath) {
+	constructor(rootPath, pageSize = MAX_FILES) {
 		this.rootPath = rootPath;
+		this.pageSize = pageSize;
 	}
 	async pull(input) {
 		const scanStartedAt = (/* @__PURE__ */ new Date()).toISOString();
 		const root = await realpath(resolve(this.rootPath));
 		if (!(await stat(root)).isDirectory()) throw new Error(`Local knowledge source is not a directory: ${root}`);
-		const cursorMs = input.cursor ? Date.parse(input.cursor) : NaN;
-		const windowMs = input.windowStart ? Date.parse(input.windowStart) : NaN;
-		const changedAfter = Math.max(Number.isFinite(cursorMs) ? cursorMs : 0, Number.isFinite(windowMs) ? windowMs : 0);
 		const paths = [];
 		const warnings = [];
 		const walk = async (directory) => {
 			if (input.signal.aborted) throw input.signal.reason ?? /* @__PURE__ */ new Error("Local folder sync aborted.");
 			for (const entry of await readdir(directory, { withFileTypes: true })) {
-				if (paths.length >= MAX_FILES) return;
 				if (entry.isSymbolicLink()) continue;
 				const path = resolve(directory, entry.name);
 				if (entry.isDirectory()) {
@@ -47,14 +45,24 @@ var LocalFolderKnowledgeSourceAdapter = class {
 			}
 		};
 		await walk(root);
-		if (paths.length >= MAX_FILES) warnings.push(`Local folder sync was limited to ${MAX_FILES} files.`);
+		paths.sort((left, right) => left.localeCompare(right));
+		let after;
+		try {
+			after = JSON.parse(input.cursor ?? "{}").after;
+		} catch {}
+		const remaining = after ? paths.filter((path) => relative(root, path).localeCompare(after) > 0) : paths;
+		const page = remaining.slice(0, this.pageSize);
+		const hasMore = remaining.length > page.length;
 		const items = [];
-		for (const path of paths) {
+		for (const path of page) {
 			if (input.signal.aborted) throw input.signal.reason ?? /* @__PURE__ */ new Error("Local folder sync aborted.");
 			const fileStat = await stat(path);
-			if (fileStat.size > MAX_FILE_BYTES || fileStat.mtimeMs <= changedAfter) continue;
 			const canonicalPath = await realpath(path);
 			if (canonicalPath !== root && !canonicalPath.startsWith(`${root}${sep}`)) continue;
+			if (fileStat.size > MAX_FILE_BYTES) {
+				warnings.push(`File exceeds ${MAX_FILE_BYTES} bytes and was excluded: ${relative(root, canonicalPath)}`);
+				continue;
+			}
 			const normalizedText = await readFile(canonicalPath, "utf8");
 			const externalId = relative(root, canonicalPath).split(sep).join("/");
 			items.push({
@@ -62,7 +70,7 @@ var LocalFolderKnowledgeSourceAdapter = class {
 				collectionScope: "files",
 				externalId,
 				itemType: "local_file",
-				authorRole: "user",
+				authorRole: "unknown",
 				sourceUpdatedAt: fileStat.mtime.toISOString(),
 				contentHash: createHash("sha256").update(normalizedText).digest("hex"),
 				normalizedText,
@@ -70,16 +78,17 @@ var LocalFolderKnowledgeSourceAdapter = class {
 					path: externalId,
 					rootPath: root
 				},
-				sensitivity: "personal",
-				retentionClass: "durable",
+				sensitivity: inferMemorySensitivity(normalizedText),
+				retentionClass: "bounded",
 				synthesisPipeline: "connected_knowledge"
 			});
 		}
 		return {
 			items,
-			nextCursor: scanStartedAt,
+			nextCursor: hasMore ? JSON.stringify({ after: relative(root, page.at(-1)).split(sep).join("/") }) : scanStartedAt,
+			hasMore,
 			warnings,
-			snapshotExternalIds: paths.length < MAX_FILES ? paths.map((path) => relative(root, path).split(sep).join("/")) : void 0
+			snapshotExternalIds: warnings.length ? void 0 : paths.map((path) => relative(root, path).split(sep).join("/"))
 		};
 	}
 };

package/dist/src/knowledge-memory/domain.d.ts

@@ -12,6 +12,10 @@ export interface KnowledgeReadPolicy {
     contentSources: readonly KnowledgeContentSource[];
 }
 export interface KnowledgeItem {
+    retrievalSnippet?: string;
+    claimMode?: 'explicit' | 'observed' | 'inferred' | 'reported';
+    verification?: 'supported' | 'tentative' | 'conflicted';
+    sensitivity?: 'normal' | 'personal' | 'secret' | 'regulated';
     id: string;
     principalId: string;
     kind: KnowledgeKind;

package/dist/src/knowledge-memory/index.d.ts

@@ -1,2 +1,3 @@
 export * from './domain.js';
 export * from './repository.js';
+export * from './usage-policy.js';

package/dist/src/knowledge-memory/index.js

@@ -1,2 +1,3 @@
+import { canUseKnowledge, knowledgeContentSources, knowledgeExclusion } from "./usage-policy.js";
 import { KnowledgeReviewConflictError, classifyKnowledgeContentSource, deleteKnowledgeItem, getKnowledgeItem, isKnowledgeCurrent, knowledgeItemAllowed, listKnowledgeItems, listKnowledgeStatusEvents, reviewKnowledgeItem, searchKnowledgeItems, transitionKnowledgeStatus, writeKnowledgeItem } from "./repository.js";
-export { KnowledgeReviewConflictError, classifyKnowledgeContentSource, deleteKnowledgeItem, getKnowledgeItem, isKnowledgeCurrent, knowledgeItemAllowed, listKnowledgeItems, listKnowledgeStatusEvents, reviewKnowledgeItem, searchKnowledgeItems, transitionKnowledgeStatus, writeKnowledgeItem };
+export { KnowledgeReviewConflictError, canUseKnowledge, classifyKnowledgeContentSource, deleteKnowledgeItem, getKnowledgeItem, isKnowledgeCurrent, knowledgeContentSources, knowledgeExclusion, knowledgeItemAllowed, listKnowledgeItems, listKnowledgeStatusEvents, reviewKnowledgeItem, searchKnowledgeItems, transitionKnowledgeStatus, writeKnowledgeItem };

package/dist/src/knowledge-memory/repair-evidence.d.ts

@@ -0,0 +1,2 @@
+/** Legacy summaries are usable only when their original retained source can still be verified. */
+export declare function repairLegacyKnowledgeEvidence(): number;

package/dist/src/knowledge-memory/repair-evidence.js

@@ -0,0 +1,57 @@
+import { createContextEvidence, init_context_evidence_repository } from "../storage/sqlite/context-evidence-repository.js";
+import { getKnowledgeSourceItem, init_knowledge_repository } from "../storage/sqlite/knowledge-repository.js";
+import { getActiveUnderstandingConsent } from "../user-context/sources/consent-repository.js";
+import { getUnderstandingSourceRun } from "../user-context/sources/repository.js";
+import { listKnowledgeItems, writeKnowledgeItem } from "./repository.js";
+//#region src/knowledge-memory/repair-evidence.ts
+init_context_evidence_repository();
+init_knowledge_repository();
+/** Legacy summaries are usable only when their original retained source can still be verified. */
+function repairLegacyKnowledgeEvidence() {
+	let repaired = 0;
+	for (const item of listKnowledgeItems({
+		recordClass: "memory",
+		statuses: ["candidate"],
+		limit: 1e3
+	})) {
+		if (item.originClass !== "untrusted" || item.verification !== "tentative" || typeof item.source.sourceRunId !== "string" || !Array.isArray(item.source.evidenceRefs)) continue;
+		const run = getUnderstandingSourceRun(item.source.sourceRunId);
+		const consent = run ? getActiveUnderstandingConsent(run.grantId) : void 0;
+		if (!consent || !consent.purposes.includes("work_assistance")) continue;
+		const sources = item.source.evidenceRefs.filter((ref) => typeof ref === "string").map((ref) => ref.startsWith("knowledge-source://") ? getKnowledgeSourceItem(ref.slice(19)) : void 0);
+		if (!sources.length || sources.some((source) => !source || source.deletedAt || Date.parse(source.updatedAt) > item.updatedAt)) continue;
+		const evidence = sources.map((source) => {
+			return {
+				id: createContextEvidence({
+					sourceType: "connector",
+					sourceInstanceId: source.sourceInstanceId,
+					sourceRef: `knowledge-source://${source.id}`,
+					sourceItemId: source.id,
+					contentHash: source.contentHash,
+					trustLevel: "untrusted",
+					observedAt: Date.parse(source.updatedAt),
+					processingPolicy: consent.processingPolicy
+				}).id,
+				contentHash: source.contentHash,
+				consentReceiptId: consent.id
+			};
+		});
+		writeKnowledgeItem({
+			...item,
+			claimMode: "reported",
+			verification: "supported",
+			status: item.confidence >= .7 ? "active" : "candidate",
+			evidence,
+			replaceExisting: true,
+			source: {
+				...item.source,
+				consentReceiptId: consent.id,
+				sourceInstanceId: sources[0].sourceInstanceId
+			}
+		});
+		repaired += 1;
+	}
+	return repaired;
+}
+//#endregion
+export { repairLegacyKnowledgeEvidence };

package/dist/src/knowledge-memory/repository.d.ts

@@ -1,6 +1,14 @@
 import { type UserModelScope } from '../user-model/domain.js';
 import type { KnowledgeItem, KnowledgeKind, KnowledgeOriginClass, KnowledgeRecordClass, KnowledgeContentSource, KnowledgeReadPolicy, KnowledgeStatus, KnowledgeReviewAction, KnowledgeStatusActor, KnowledgeStatusEvent, KnowledgeVisibilityContext } from './domain.js';
 export interface WriteKnowledgeInput {
+    claimMode?: KnowledgeItem['claimMode'];
+    verification?: KnowledgeItem['verification'];
+    sensitivity?: KnowledgeItem['sensitivity'];
+    evidence?: Array<{
+        id: string;
+        contentHash?: string;
+        consentReceiptId?: string;
+    }>;
     principalId?: string;
     kind: KnowledgeKind;
     scope: UserModelScope;