@xopcai/xopc 0.0.307 → 0.0.308

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

@@ -1,2 +1,2 @@
-import { KnowledgeReviewConflictError, classifyKnowledgeContentSource, getKnowledgeItem, knowledgeItemAllowed, listKnowledgeItems, listKnowledgeStatusEvents, reviewKnowledgeItem, searchKnowledgeItems, transitionKnowledgeStatus, writeKnowledgeItem } from "./repository.js";
-export { KnowledgeReviewConflictError, classifyKnowledgeContentSource, getKnowledgeItem, knowledgeItemAllowed, listKnowledgeItems, listKnowledgeStatusEvents, reviewKnowledgeItem, searchKnowledgeItems, transitionKnowledgeStatus, writeKnowledgeItem };
+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 };

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

@@ -21,6 +21,7 @@ export interface WriteKnowledgeInput {
     derivedFromRecalledContext?: boolean;
     source?: Record<string, unknown>;
     replaceExisting?: boolean;
+    restoreDeleted?: boolean;
     now?: number;
 }
 export declare class KnowledgeReviewConflictError extends Error {
@@ -29,6 +30,10 @@ export declare class KnowledgeReviewConflictError extends Error {
 export declare function writeKnowledgeItem(input: WriteKnowledgeInput): {
     item: KnowledgeItem;
     created: boolean;
+} | {
+    item?: undefined;
+    created: false;
+    suppressed: true;
 };
 export declare function getKnowledgeItem(id: string): KnowledgeItem | undefined;
 export declare function listKnowledgeItems(input?: {
@@ -70,3 +75,5 @@ export declare function searchKnowledgeItems(input: {
 }): KnowledgeItem[];
 export declare function classifyKnowledgeContentSource(item: KnowledgeItem): KnowledgeContentSource;
 export declare function knowledgeItemAllowed(item: KnowledgeItem, policy: KnowledgeReadPolicy): boolean;
+export declare function deleteKnowledgeItem(id: string, now?: number): boolean;
+export declare function isKnowledgeCurrent(item: KnowledgeItem, asOf?: number): boolean;

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

@@ -1,6 +1,7 @@
 import { getSqliteDatabase, init_transaction, runSqliteWriteTransaction } from "../storage/sqlite/transaction.js";
 import { validateScope } from "../user-model/domain.js";
 import { buildFts5SearchQuery, init_fts } from "../storage/sqlite/fts.js";
+import { clearMemoryAudit, isMemorySuppressed, memoryFingerprint, restoreMemory, suppressMemory } from "../user-context/memory-suppression.js";
 import { randomUUID } from "node:crypto";
 //#region src/knowledge-memory/repository.ts
 init_fts();
@@ -60,7 +61,14 @@ function writeKnowledgeItem(input) {
 	if (input.validFrom !== void 0 && input.validTo !== void 0 && input.validTo < input.validFrom) throw new Error("Knowledge validTo must be greater than or equal to validFrom.");
 	const principalId = input.principalId ?? "local-owner";
 	const now = input.now ?? Date.now();
+	const admittedStatus = input.status ?? (input.originClass === "owner" || input.originClass !== "untrusted" && input.confidence >= .7 && !input.derivedFromRecalledContext ? "active" : "candidate");
 	return runSqliteWriteTransaction((db) => {
+		const keys = knowledgeFingerprints(input);
+		if (input.restoreDeleted && input.originClass === "owner") restoreMemory(db, keys);
+		if (isMemorySuppressed(db, keys)) return {
+			created: false,
+			suppressed: true
+		};
 		const existingStatuses = input.replaceExisting ? [
 			"candidate",
 			"active",
@@ -76,12 +84,12 @@ function writeKnowledgeItem(input) {
 		const existing = db.prepare(`SELECT * FROM knowledge_items WHERE principal_id = ?
       AND canonical_key = ? AND scope_type = ? AND COALESCE(scope_id, '') = COALESCE(?, '')
       AND status IN (${existingStatuses.map(() => "?").join(", ")})`).get(principalId, input.canonicalKey.trim(), input.scope.type, input.scope.id ?? null, ...existingStatuses);
-		if (existing && !input.replaceExisting) return {
+		if (existing && (!input.replaceExisting || existing.origin_class === "owner" && input.originClass !== "owner")) return {
 			item: fromRow(existing),
 			created: false
 		};
 		if (existing) {
-			const nextStatus = input.status ?? (input.originClass === "owner" ? "active" : "candidate");
+			const nextStatus = admittedStatus;
 			db.prepare(`UPDATE knowledge_items SET kind = ?, content = ?, record_class = ?, status = ?, confidence = ?,
         importance = ?, valid_from = ?, valid_to = ?, expires_at = ?, review_at = ?,
         origin_class = ?, source_agent_id = ?, source_conversation_id = ?, source_turn_id = ?,
@@ -102,7 +110,7 @@ function writeKnowledgeItem(input) {
 			};
 		}
 		const id = randomUUID();
-		const status = input.status ?? (input.originClass === "owner" ? "active" : "candidate");
+		const status = admittedStatus;
 		db.prepare(`INSERT INTO knowledge_items (
       knowledge_id, principal_id, kind, scope_type, scope_id, content, canonical_key, record_class,
       status, confidence, importance, valid_from, valid_to, expires_at, review_at,
@@ -154,12 +162,14 @@ function transitionKnowledgeStatus(input) {
 		const current = db.prepare("SELECT * FROM knowledge_items WHERE knowledge_id = ?").get(input.id);
 		if (!current) return void 0;
 		if (input.expectedStatus && current.status !== input.expectedStatus) throw new KnowledgeReviewConflictError(`Knowledge status changed from ${input.expectedStatus} to ${current.status}.`);
-		db.prepare(`UPDATE knowledge_items SET status = ?, content = COALESCE(?, content), updated_at = ?
-      WHERE knowledge_id = ?`).run(input.status, content ?? null, now, input.id);
+		db.prepare(`UPDATE knowledge_items SET status = ?, content = COALESCE(?, content),
+      origin_class = CASE WHEN ? THEN 'owner' ELSE origin_class END, updated_at = ?
+      WHERE knowledge_id = ?`).run(input.status, content ?? null, input.actor === "user" && input.status === "active" ? 1 : 0, now, input.id);
 		if (content !== void 0) {
 			db.prepare("DELETE FROM knowledge_items_fts WHERE knowledge_id = ?").run(input.id);
 			db.prepare("INSERT INTO knowledge_items_fts(content, knowledge_id) VALUES (?, ?)").run(content, input.id);
 		}
+		if (input.actor === "user" && (input.status === "rejected" || input.status === "archived")) suppressMemory(db, knowledgeFingerprints(fromRow(current)), now);
 		insertStatusEvent(db, {
 			knowledgeId: input.id,
 			fromStatus: current.status,
@@ -184,7 +194,8 @@ const REVIEW_TRANSITIONS = {
 		from: [
 			"candidate",
 			"needs_review",
-			"stale"
+			"stale",
+			"active"
 		],
 		to: "active",
 		requiresContent: true
@@ -292,11 +303,12 @@ function searchKnowledgeItems(input) {
       AND (k.valid_from IS NULL OR k.valid_from <= ?)
       AND (k.valid_to IS NULL OR k.valid_to >= ?)
       AND (k.expires_at IS NULL OR k.expires_at >= ?)
+      AND (k.review_at IS NULL OR k.review_at > ?)
       ${input.recordClass ? "AND k.record_class = ?" : ""}
       ${input.trustedOnly ? "AND k.origin_class != 'untrusted'" : ""}
       AND ${contentSource}
       AND ${visible.sql}
-    ORDER BY rank ASC, k.importance DESC, k.updated_at DESC LIMIT ?`).all(fts, principalId, asOf, asOf, asOf, ...input.recordClass ? [input.recordClass] : [], ...visible.values, limit).map(fromRow);
+    ORDER BY rank ASC, k.importance DESC, k.updated_at DESC LIMIT ?`).all(fts, principalId, asOf, asOf, asOf, asOf, ...input.recordClass ? [input.recordClass] : [], ...visible.values, limit).map(fromRow);
 }
 function classifyKnowledgeContentSource(item) {
 	if (item.recordClass === "memory") return "memory";
@@ -305,5 +317,43 @@ function classifyKnowledgeContentSource(item) {
 function knowledgeItemAllowed(item, policy) {
 	return policy.scopes.includes(item.scope.type) && policy.contentSources.includes(classifyKnowledgeContentSource(item));
 }
+function knowledgeFingerprints(input) {
+	const principal = input.principalId ?? "local-owner";
+	return [memoryFingerprint([
+		"knowledge-key",
+		principal,
+		input.scope.type,
+		input.scope.id ?? "",
+		input.canonicalKey
+	]), memoryFingerprint([
+		"knowledge-content",
+		principal,
+		input.scope.type,
+		input.scope.id ?? "",
+		input.content
+	])];
+}
+function deleteKnowledgeItem(id, now = Date.now()) {
+	return runSqliteWriteTransaction((db) => {
+		const rows = db.prepare(`WITH RECURSIVE deleted(id) AS (
+      SELECT knowledge_id FROM knowledge_items WHERE knowledge_id = ?
+      UNION SELECT k.knowledge_id FROM knowledge_items k JOIN deleted d
+        ON json_extract(k.source_json, '$.episodeKnowledgeId') = d.id
+        OR k.knowledge_id = (SELECT json_extract(source_json, '$.episodeKnowledgeId')
+          FROM knowledge_items WHERE knowledge_id = d.id)
+    ) SELECT * FROM knowledge_items WHERE knowledge_id IN (SELECT id FROM deleted)`).all(id);
+		for (const row of rows) {
+			const item = fromRow(row);
+			suppressMemory(db, knowledgeFingerprints(item), now);
+			clearMemoryAudit(db, "knowledge", item.id);
+			db.prepare("DELETE FROM knowledge_items_fts WHERE knowledge_id = ?").run(item.id);
+			db.prepare("DELETE FROM knowledge_items WHERE knowledge_id = ?").run(item.id);
+		}
+		return rows.length > 0;
+	});
+}
+function isKnowledgeCurrent(item, asOf = Date.now()) {
+	return item.status === "active" && (item.validFrom === void 0 || item.validFrom <= asOf) && (item.validTo === void 0 || item.validTo >= asOf) && (item.expiresAt === void 0 || item.expiresAt >= asOf) && (item.reviewAt === void 0 || item.reviewAt > asOf);
+}
 //#endregion
-export { KnowledgeReviewConflictError, classifyKnowledgeContentSource, getKnowledgeItem, knowledgeItemAllowed, listKnowledgeItems, listKnowledgeStatusEvents, reviewKnowledgeItem, searchKnowledgeItems, transitionKnowledgeStatus, writeKnowledgeItem };
+export { KnowledgeReviewConflictError, classifyKnowledgeContentSource, deleteKnowledgeItem, getKnowledgeItem, isKnowledgeCurrent, knowledgeItemAllowed, listKnowledgeItems, listKnowledgeStatusEvents, reviewKnowledgeItem, searchKnowledgeItems, transitionKnowledgeStatus, writeKnowledgeItem };

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

@@ -3,7 +3,7 @@ import "../user-model/domain.js";
 import { randomUUID } from "node:crypto";
 //#region src/memory-maintenance/service.ts
 init_transaction();
-const ALGORITHM_VERSION = "user-model-maintenance-v1";
+const ALGORITHM_VERSION = "user-model-maintenance-v2";
 function emptyMetrics() {
 	return {
 		scanned: 0,
@@ -32,29 +32,22 @@ function addDecision(db, runId, objectType, objectId, action, reason, before, af
     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);
+function transitionAssertions(db, runId, principalId, now, limit, metrics) {
+	const rows = db.prepare(`SELECT a.assertion_id, a.status FROM user_assertions a
+    JOIN user_assertion_slots s ON s.slot_id = a.slot_id
+    WHERE s.principal_id = ? AND a.status IN ('active', 'candidate', 'needs_review')
+      AND ((a.valid_to IS NOT NULL AND a.valid_to < ?)
+        OR (a.review_at IS NOT NULL AND a.review_at <= ?))
+    ORDER BY COALESCE(a.valid_to, a.review_at), a.assertion_id LIMIT ?`).all(principalId, now, now, limit);
+	metrics.scanned += rows.length;
+	for (const row of rows) {
+		db.prepare("UPDATE user_assertions SET status = 'stale' 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', '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);
+    ) VALUES (?, ?, ?, 'stale', 'maintenance', 'No current supporting evidence at review time.', ?, ?)`).run(randomUUID(), row.assertion_id, row.status, runId, now);
+		addDecision(db, runId, "assertion", row.assertion_id, "stale", "validity_or_review_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
@@ -68,7 +61,7 @@ function transitionPriorities(db, runId, principalId, now, limit, metrics) {
 }
 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);
+    WHERE principal_id = ? AND status IN ('active', 'candidate') 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);
@@ -76,12 +69,12 @@ function transitionKnowledge(db, runId, principalId, now, limit, metrics) {
 		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));
+    WHERE principal_id = ? AND status IN ('active', 'candidate', 'needs_review') 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;
+		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", "review_due", row, { status: "stale" }, now);
+		metrics.stale += 1;
 	}
 }
 function reconcileEvidence(db, runId, principalId, now, limit, evidenceThreshold, metrics) {
@@ -89,7 +82,10 @@ function reconcileEvidence(db, runId, principalId, now, limit, evidenceThreshold
     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);
+    JOIN context_evidence e ON e.evidence_id = ae.evidence_id
+    WHERE s.principal_id = ? AND a.status = 'active'
+      AND e.trust_level = 'owner' AND e.source_type IN ('conversation', 'user')
+      AND e.observed_at > a.observed_at AND ae.confidence >= 0.7 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);
@@ -99,16 +95,31 @@ function reconcileEvidence(db, runId, principalId, now, limit, evidenceThreshold
 		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
+	const candidates = db.prepare(`SELECT a.assertion_id, a.status,
+      MIN(COUNT(DISTINCT COALESCE(e.content_hash, e.source_ref)),
+        COUNT(DISTINCT e.source_type || ':' || COALESCE(e.source_instance_id, '') || ':' ||
+          COALESCE(e.source_item_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);
+      AND a.confidence >= 0.7 AND ae.confidence >= 0.7
+      AND a.sensitivity = 'normal' AND a.consequence IN ('low', 'medium')
+      AND a.disclosure_policy != 'ask_before_reference'
+      AND e.source_type IN ('conversation', 'user', 'connector')
+      AND (a.valid_from IS NULL OR a.valid_from <= ?)
+      AND (a.valid_to IS NULL OR a.valid_to >= ?)
+      AND (a.review_at IS NULL OR a.review_at > ?)
+      AND NOT EXISTS (SELECT 1 FROM user_assertion_evidence bad
+        WHERE bad.assertion_id = a.assertion_id AND bad.relation = 'contradicts')
+      AND (s.cardinality = 'multiple' OR NOT EXISTS (
+        SELECT 1 FROM user_assertions other WHERE other.slot_id = a.slot_id
+          AND other.assertion_id != a.assertion_id AND other.status IN ('active', 'conflicted')
+          AND other.normalized_value != a.normalized_value
+          AND (other.valid_to IS NULL OR other.valid_to >= ?)))
+    GROUP BY a.assertion_id HAVING evidence_count >= ? ORDER BY a.recorded_at LIMIT ?`).all(principalId, now, now, now, now, 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);
@@ -119,6 +130,24 @@ function reconcileEvidence(db, runId, principalId, now, limit, evidenceThreshold
 		metrics.activated += 1;
 	}
 }
+function activateKnowledge(db, runId, principalId, now, limit, metrics) {
+	const rows = db.prepare(`SELECT knowledge_id FROM knowledge_items
+    WHERE principal_id = ? AND record_class = 'memory' AND status = 'candidate'
+      AND origin_class IN ('owner', 'agent', 'system') AND confidence >= 0.7
+      AND derived_from_recalled_context = 0
+      AND (valid_from IS NULL OR valid_from <= ?) AND (valid_to IS NULL OR valid_to >= ?)
+      AND (expires_at IS NULL OR expires_at >= ?) AND (review_at IS NULL OR review_at > ?)
+    ORDER BY created_at, knowledge_id LIMIT ?`).all(principalId, now, now, now, now, limit);
+	metrics.scanned += rows.length;
+	for (const row of rows) {
+		db.prepare("UPDATE knowledge_items SET status = 'active', updated_at = ? WHERE knowledge_id = ?").run(now, row.knowledge_id);
+		db.prepare(`INSERT INTO knowledge_item_status_events
+      (event_id, knowledge_id, from_status, to_status, actor_type, reason, created_at)
+      VALUES (?, ?, 'candidate', 'active', 'maintenance', 'Eligible scoped memory activated automatically.', ?)`).run(randomUUID(), row.knowledge_id, now);
+		addDecision(db, runId, "knowledge", row.knowledge_id, "activated", "eligible_scoped_memory", { status: "candidate" }, { 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
@@ -178,11 +207,12 @@ function runMemoryMaintenance(input) {
 	});
 	try {
 		runSqliteWriteTransaction((db) => {
-			transitionAssertions(db, runId, now, limit, metrics);
+			transitionAssertions(db, runId, principalId, 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);
+				activateKnowledge(db, runId, principalId, now, limit, 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);

package/dist/src/migrations/memory-config.d.ts

@@ -0,0 +1,2 @@
+import type { Migration } from './types.js';
+export declare const memoryConfigMigration: Migration;

package/dist/src/migrations/memory-config.js

@@ -0,0 +1,77 @@
+import { init_lock, isGatewayConfigLockedByAnotherProcessSync } from "../gateway/lock.js";
+import { existsSync, readFileSync } from "node:fs";
+//#region src/migrations/memory-config.ts
+init_lock();
+const id = "automatic-memory-config";
+function normalizeKnowledgeMemoryConfigInput(input) {
+	if (!input || typeof input !== "object" || Array.isArray(input)) return input;
+	const memory = input;
+	if (!Array.isArray(memory.sources)) return input;
+	const oldSources = memory.sources.filter((source) => typeof source === "string");
+	const visibilityScopes = new Set([
+		"session",
+		"workspace",
+		"project"
+	]);
+	const normalized = { ...memory };
+	if (!Array.isArray(normalized.readScopes)) normalized.readScopes = oldSources.filter((source) => visibilityScopes.has(source));
+	if (!Array.isArray(normalized.contentSources)) normalized.contentSources = [
+		...oldSources.some((source) => visibilityScopes.has(source)) ? ["memory"] : [],
+		...oldSources.includes("workspace") ? ["local_import"] : [],
+		...oldSources.includes("connector") ? ["connector"] : []
+	];
+	delete normalized.sources;
+	return normalized;
+}
+function convertedConfig(ctx) {
+	if (!existsSync(ctx.configPath)) return null;
+	const config = JSON.parse(readFileSync(ctx.configPath, "utf8"));
+	const userContext = config.userContext;
+	if (!userContext || typeof userContext !== "object" || Array.isArray(userContext)) return null;
+	const context = userContext;
+	let changed = false;
+	for (const key of ["userModel", "knowledgeMemory"]) {
+		const section = context[key];
+		if (!section || typeof section !== "object" || Array.isArray(section)) continue;
+		const memory = section;
+		if (memory.writePolicy === "confirm") {
+			memory.writePolicy = "allow";
+			changed = true;
+		}
+		if (key === "knowledgeMemory" && Array.isArray(memory.sources)) {
+			context[key] = normalizeKnowledgeMemoryConfigInput(memory);
+			changed = true;
+		}
+	}
+	if (!changed) return null;
+	return config;
+}
+function item(status) {
+	return {
+		id,
+		title: "Automatic memory configuration",
+		kind: "config",
+		safety: "auto",
+		status,
+		message: "Enable automatic ordinary memory and separate visibility scopes from content sources."
+	};
+}
+const memoryConfigMigration = {
+	id,
+	kind: "config",
+	safety: "auto",
+	detect: (ctx) => convertedConfig(ctx) ? item("planned") : null,
+	apply: (ctx) => {
+		if (isGatewayConfigLockedByAnotherProcessSync(ctx.configPath)) return {
+			...item("skipped"),
+			message: "Deferred knowledge memory config migration until the running gateway restarts."
+		};
+		const config = convertedConfig(ctx);
+		return config ? {
+			...item("applied"),
+			details: { config }
+		} : item("not_needed");
+	}
+};
+//#endregion
+export { memoryConfigMigration };

package/dist/src/migrations/runner.js

@@ -3,7 +3,7 @@ import { init_logger } from "../utils/logger.js";
 import { ConfigSchema, init_schema } from "../config/schema.js";
 import { listRegisteredMigrations } from "./registry.js";
 import { conversationRoutingConfigMigration } from "./conversation-routing-config.js";
-import { knowledgeMemoryReadPolicyConfigMigration } from "./knowledge-memory-read-policy-config.js";
+import { memoryConfigMigration } from "./memory-config.js";
 import { dirname, join } from "node:path";
 import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
 //#region src/migrations/runner.ts
@@ -12,7 +12,7 @@ init_logger();
 const log = createLogger("Migrations");
 const MIGRATION_LEDGER_FILENAME = "migrations.json";
 const CONFIG_BACKUP_COUNT = 10;
-const CORE_MIGRATIONS = [conversationRoutingConfigMigration, knowledgeMemoryReadPolicyConfigMigration];
+const CORE_MIGRATIONS = [conversationRoutingConfigMigration, memoryConfigMigration];
 function listAllMigrations() {
 	return [...CORE_MIGRATIONS, ...listRegisteredMigrations().map((entry) => entry.migration)];
 }

package/dist/src/notifications/planner.js

@@ -162,7 +162,7 @@ function workDiscoveryPlan(eventType, payload) {
 	const event = payload;
 	const completed = eventType === "work-discovery.completed";
 	if (typeof event.runId !== "string" || !event.runId || typeof event.conversationId !== "string" || !event.conversationId || event.status !== (completed ? "completed" : "failed")) return null;
-	const type = completed ? "work_discovery.review_ready" : "work_discovery.failed";
+	const type = completed ? "work_discovery.completed" : "work_discovery.failed";
 	return {
 		dedupeKey: `${type}:${event.runId}`,
 		notification: {
@@ -174,15 +174,15 @@ function workDiscoveryPlan(eventType, payload) {
 			},
 			priority: completed ? "normal" : "high",
 			title: completed ? {
-				en: "Understanding ready for review",
-				zh: "用户理解已可确认"
+				en: "Understanding updated",
+				zh: "用户理解已更新"
 			} : {
 				en: "Understanding needs attention",
 				zh: "用户理解需要处理"
 			},
 			body: completed ? {
-				en: "Review what xopc learned about your work.",
-				zh: "查看并确认 xopc 对你工作的理解。"
+				en: "See what xopc learned. You can edit or delete it anytime.",
+				zh: "理解已自动整理，可随时查看、修改或删除。"
 			} : {
 				en: "Open user understanding to review or retry.",
 				zh: "打开用户理解，查看详情或重试。"

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

@@ -19,7 +19,7 @@ export declare class NotificationService {
     persistGatewayEvent(type: string, payload: unknown): {
         schemaVersion: 1;
         id: string;
-        type: "work_discovery.failed" | "chat.completed" | "chat.failed" | "task.needs_input" | "task.blocked" | "task.failed" | "task.completed" | "automation.completed" | "automation.failed" | "proactive.insight" | "work_discovery.review_ready";
+        type: "work_discovery.completed" | "work_discovery.failed" | "chat.completed" | "chat.failed" | "task.needs_input" | "task.blocked" | "task.failed" | "task.completed" | "automation.completed" | "automation.failed" | "proactive.insight";
         priority: "normal" | "high";
         title: {
             en: string;
@@ -56,7 +56,7 @@ export declare class NotificationService {
     persistPlan(plan: NotificationPlan): {
         schemaVersion: 1;
         id: string;
-        type: "work_discovery.failed" | "chat.completed" | "chat.failed" | "task.needs_input" | "task.blocked" | "task.failed" | "task.completed" | "automation.completed" | "automation.failed" | "proactive.insight" | "work_discovery.review_ready";
+        type: "work_discovery.completed" | "work_discovery.failed" | "chat.completed" | "chat.failed" | "task.needs_input" | "task.blocked" | "task.failed" | "task.completed" | "automation.completed" | "automation.failed" | "proactive.insight";
         priority: "normal" | "high";
         title: {
             en: string;

package/dist/src/notifications/service.js

@@ -40,7 +40,7 @@ function preferenceAllows(type, preferences) {
 		case "automation.completed": return preferences.automationCompleted;
 		case "automation.failed": return preferences.automationFailed;
 		case "proactive.insight": return preferences.proactiveInsight;
-		case "work_discovery.review_ready":
+		case "work_discovery.completed":
 		case "work_discovery.failed": return true;
 	}
 }

package/dist/src/storage/sqlite/migrations/184_memory_suppressions.sql

@@ -0,0 +1,12 @@
+CREATE TABLE memory_suppressions (
+  fingerprint TEXT PRIMARY KEY,
+  created_at INTEGER NOT NULL
+);
+
+UPDATE notification_events SET
+  event_type = 'work_discovery.completed',
+  dedupe_key = replace(dedupe_key, 'work_discovery.review_ready:', 'work_discovery.completed:'),
+  title_en = 'Understanding updated', title_zh = '用户理解已更新',
+  body_en = 'See what xopc learned. You can edit or delete it anytime.',
+  body_zh = '理解已自动整理，可随时查看、修改或删除。'
+WHERE event_type = 'work_discovery.review_ready';

package/dist/src/storage/sqlite/migrations/185_understanding_refresh_batches.sql

@@ -0,0 +1,6 @@
+CREATE TABLE understanding_refresh_batches (
+  batch_id TEXT PRIMARY KEY,
+  source_run_ids_json TEXT NOT NULL,
+  created_at INTEGER NOT NULL
+);
+CREATE INDEX idx_understanding_refresh_batches_created ON understanding_refresh_batches(created_at DESC);

package/dist/src/storage/sqlite/migrations/runner.d.ts

@@ -3,7 +3,7 @@ import type { ApplyMigrationsOptions } from './types.js';
 /** Baseline schema version applied from schema.sql on first open. */
 export declare const XOPC_DB_BASELINE_SCHEMA_VERSION = 165;
 /** Latest schema version this release supports (increment when adding migrations). */
-export declare const XOPC_DB_SCHEMA_VERSION = 183;
+export declare const XOPC_DB_SCHEMA_VERSION = 185;
 export declare function resolveMigrationsDir(override?: string): string;
 /**
  * Apply sequential SQL migrations from (currentVersion + 1) through targetVersion.

package/dist/src/storage/sqlite/migrations/runner.js

@@ -63,7 +63,7 @@ function applySingleMigration(db, migration) {
 * Each step runs in its own transaction and updates schema_meta on success.
 */
 function applyPendingMigrations(db, options = {}) {
-	const targetVersion = options.targetVersion ?? 183;
+	const targetVersion = options.targetVersion ?? 185;
 	let currentVersion = readSchemaVersion(db);
 	if (currentVersion > targetVersion) throw new DatabaseSchemaTooNewError(currentVersion, targetVersion);
 	if (!options.migrationsDir && currentVersion < 165) throw new DatabaseSchemaTooOldError(currentVersion, 165);
@@ -118,7 +118,7 @@ function applyPendingMigrations(db, options = {}) {
 }
 /** Inspect schema version without mutating the database. */
 function inspectSchemaMigrationStatus(db, options = {}) {
-	const appVersion = options.targetVersion ?? 183;
+	const appVersion = options.targetVersion ?? 185;
 	const dbVersion = readSchemaVersion(db);
 	if (dbVersion > appVersion) return {
 		dbVersion,
@@ -157,7 +157,7 @@ var init_runner = __esmMin((() => {
 	init_errors();
 	log = createLogger("Sqlite:Migrations");
 	XOPC_DB_BASELINE_SCHEMA_VERSION = 165;
-	XOPC_DB_SCHEMA_VERSION = 183;
+	XOPC_DB_SCHEMA_VERSION = 185;
 	MODULE_DIR = dirname(fileURLToPath(import.meta.url));
 }));
 //#endregion

package/dist/src/storage/sqlite/schema.js

@@ -33,7 +33,7 @@ function ensureXopcDatabaseSchema(db, options = {}) {
 		currentVersion = 165;
 	}
 	applyPendingMigrations(db, {
-		targetVersion: 183,
+		targetVersion: 185,
 		databasePath: fresh ? void 0 : options.databasePath
 	});
 }

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

@@ -39,7 +39,6 @@ export declare const UserModelConfigSchema: z.ZodDefault<z.ZodObject<{
     enabled: z.ZodDefault<z.ZodBoolean>;
     writePolicy: z.ZodDefault<z.ZodEnum<{
         allow: "allow";
-        confirm: "confirm";
         deny: "deny";
     }>>;
     sensitiveWritePolicy: z.ZodDefault<z.ZodEnum<{
@@ -76,12 +75,10 @@ export declare const UserModelConfigSchema: z.ZodDefault<z.ZodObject<{
         staleRetentionDays: z.ZodDefault<z.ZodNumber>;
     }, z.core.$strict>>;
 }, z.core.$strict>>;
-export declare function normalizeKnowledgeMemoryConfigInput(input: unknown): unknown;
-export declare const KnowledgeMemoryConfigSchema: z.ZodDefault<z.ZodPreprocess<z.ZodObject<{
+export declare const KnowledgeMemoryConfigSchema: z.ZodDefault<z.ZodObject<{
     enabled: z.ZodDefault<z.ZodBoolean>;
     writePolicy: z.ZodDefault<z.ZodEnum<{
         allow: "allow";
-        confirm: "confirm";
         deny: "deny";
     }>>;
     readScopes: z.ZodDefault<z.ZodArray<z.ZodEnum<{
@@ -114,7 +111,7 @@ export declare const KnowledgeMemoryConfigSchema: z.ZodDefault<z.ZodPreprocess<z
     allowExternalWrites: z.ZodDefault<z.ZodBoolean>;
     allowedProviderIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
     autoWriteKinds: z.ZodOptional<z.ZodArray<z.ZodString>>;
-}, z.core.$strict>>>;
+}, z.core.$strict>>;
 export declare const ContextPlanningConfigSchema: z.ZodDefault<z.ZodObject<{
     enabled: z.ZodDefault<z.ZodBoolean>;
     maxAssertions: z.ZodDefault<z.ZodNumber>;
@@ -152,7 +149,6 @@ export declare const UserContextConfigSchema: z.ZodDefault<z.ZodObject<{
         enabled: z.ZodDefault<z.ZodBoolean>;
         writePolicy: z.ZodDefault<z.ZodEnum<{
             allow: "allow";
-            confirm: "confirm";
             deny: "deny";
         }>>;
         sensitiveWritePolicy: z.ZodDefault<z.ZodEnum<{
@@ -189,11 +185,10 @@ export declare const UserContextConfigSchema: z.ZodDefault<z.ZodObject<{
             staleRetentionDays: z.ZodDefault<z.ZodNumber>;
         }, z.core.$strict>>;
     }, z.core.$strict>>;
-    knowledgeMemory: z.ZodDefault<z.ZodPreprocess<z.ZodObject<{
+    knowledgeMemory: z.ZodDefault<z.ZodObject<{
         enabled: z.ZodDefault<z.ZodBoolean>;
         writePolicy: z.ZodDefault<z.ZodEnum<{
             allow: "allow";
-            confirm: "confirm";
             deny: "deny";
         }>>;
         readScopes: z.ZodDefault<z.ZodArray<z.ZodEnum<{
@@ -226,7 +221,7 @@ export declare const UserContextConfigSchema: z.ZodDefault<z.ZodObject<{
         allowExternalWrites: z.ZodDefault<z.ZodBoolean>;
         allowedProviderIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
         autoWriteKinds: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    }, z.core.$strict>>>;
+    }, z.core.$strict>>;
     contextPlanning: z.ZodDefault<z.ZodObject<{
         enabled: z.ZodDefault<z.ZodBoolean>;
         maxAssertions: z.ZodDefault<z.ZodNumber>;