@xopcai/xopc 0.0.307 → 0.0.308

package/dist/src/user-model/repository.js

@@ -1,5 +1,6 @@
 import { getSqliteDatabase, init_transaction, runSqliteWriteTransaction } from "../storage/sqlite/transaction.js";
 import { USER_MODEL_PRINCIPAL_ID, validateCandidate, validateScope } from "./domain.js";
+import { clearMemoryAudit, isMemorySuppressed, memoryFingerprint, restoreMemory, suppressMemory } from "../user-context/memory-suppression.js";
 import { defaultReviewAt, requiresBoundedValidity } from "./temporal.js";
 import { basename } from "node:path";
 import { randomUUID } from "node:crypto";
@@ -136,9 +137,13 @@ function authorityRank(authority) {
 		user_explicit: 3
 	}[authority];
 }
-function reconcileAssertion(candidate, now = Date.now()) {
+function reconcileAssertion(candidate, now = Date.now(), options = {}) {
 	validateCandidate(candidate);
 	return runSqliteWriteTransaction((db) => {
+		if (candidate.authority !== "user_explicit" && candidate.sensitivity !== "normal") return { action: "suppressed" };
+		const keys = assertionFingerprints(candidate);
+		if (options.restoreDeleted && candidate.authority === "user_explicit") restoreMemory(db, keys);
+		if (isMemorySuppressed(db, keys)) return { action: "suppressed" };
 		const slot = findOrCreateSlot(db, candidate, now);
 		const existing = listReconcilableAssertions(db, slot.id);
 		if (candidate.correctionOfAssertionId) {
@@ -146,14 +151,21 @@ function reconcileAssertion(candidate, now = Date.now()) {
 			const target = existing.find((item) => item.id === candidate.correctionOfAssertionId);
 			if (!target) throw new Error("Correction target does not belong to the resolved assertion slot.");
 			if (target.normalizedValue === candidate.normalizedValue.trim()) {
+				db.prepare("UPDATE user_assertions SET statement = ?, authority = 'user_explicit', confidence = 1, status = 'active', observed_at = ?, review_at = ? WHERE assertion_id = ?").run(candidate.statement.trim(), candidate.observedAt, defaultReviewAt(candidate.volatility, candidate.observedAt) ?? null, target.id);
+				db.prepare("UPDATE user_assertions_fts SET statement = ? WHERE assertion_id = ?").run(candidate.statement.trim(), target.id);
 				attachEvidence(db, target.id, candidate, now);
 				return {
 					action: "deduplicated",
-					assertion: target
+					assertion: getUserAssertion(target.id)
 				};
 			}
+			if (slot.cardinality === "multiple") suppressMemory(db, assertionFingerprints({
+				...target,
+				...slot
+			}), now);
 			const assertion = insertAssertion(db, slot.id, candidate, "active", now, target.id);
-			closeValidity(db, target, candidate.validFrom ?? candidate.observedAt, now);
+			closeValidity(db, target, candidate.observedAt, now);
+			updateStatus(db, target, "archived", "Replaced by user correction.", now);
 			return {
 				action: "superseded",
 				assertion,
@@ -163,10 +175,12 @@ function reconcileAssertion(candidate, now = Date.now()) {
 		const overlapping = sortByAuthorityAndRecorded(existing.filter((item) => intervalsOverlap(item, candidate)));
 		const duplicate = overlapping.find((item) => item.normalizedValue === candidate.normalizedValue.trim());
 		if (duplicate) {
+			refreshSupportingObservation(db, duplicate, candidate, now);
+			if (candidate.authority === "user_explicit" && (duplicate.authority !== "user_explicit" || candidate.observedAt > duplicate.observedAt)) db.prepare("UPDATE user_assertions SET authority = 'user_explicit', confidence = ?, status = ?, observed_at = ?, review_at = ? WHERE assertion_id = ?").run(candidate.confidence, initialStatus(candidate), candidate.observedAt, candidate.reviewAt ?? defaultReviewAt(candidate.volatility, candidate.observedAt) ?? null, duplicate.id);
 			attachEvidence(db, duplicate.id, candidate, now);
 			return {
 				action: "deduplicated",
-				assertion: duplicate
+				assertion: getUserAssertion(duplicate.id)
 			};
 		}
 		const status = initialStatus(candidate);
@@ -345,13 +359,89 @@ function linkAssertionEvidence(assertionId, evidenceId, relation, confidence, no
 function setAssertionStatus(assertionId, status, input) {
 	const current = getUserAssertion(assertionId);
 	if (!current) throw new Error(`User assertion not found: ${assertionId}`);
-	if (current.status === status) return current;
+	if (current.status === status && !(status === "active" && input.actor === "user" && current.authority !== "user_explicit")) return current;
 	const now = input.now ?? Date.now();
 	runSqliteWriteTransaction((db) => {
 		db.prepare("UPDATE user_assertions SET status = ? WHERE assertion_id = ?").run(status, assertionId);
+		if ((status === "rejected" || status === "archived") && input.actor === "user") {
+			const slot = getAssertionSlot(current.slotId);
+			suppressMemory(db, assertionFingerprints({
+				...current,
+				...slot
+			}), now);
+		}
+		if (status === "active" && input.actor === "user") db.prepare("UPDATE user_assertions SET authority = 'user_explicit', confidence = 1 WHERE assertion_id = ?").run(assertionId);
 		recordStatusEvent(db, assertionId, current.status, status, input.actor, input.reason, now);
 	});
 	return getUserAssertion(assertionId);
 }
+function assertionFingerprints(candidate) {
+	const scope = [
+		candidate.principalId ?? "local-owner",
+		candidate.scope.type,
+		candidate.scope.id ?? ""
+	];
+	return [memoryFingerprint([
+		"assertion-slot",
+		...scope,
+		candidate.subject.type,
+		candidate.subject.id,
+		candidate.predicate,
+		candidate.cardinality === "single" ? "" : candidate.normalizedValue
+	]), memoryFingerprint([
+		"assertion-content",
+		...scope,
+		candidate.statement
+	])];
+}
+function deleteUserAssertion(id, now = Date.now()) {
+	return runSqliteWriteTransaction((db) => {
+		const current = getUserAssertion(id);
+		if (!current) return false;
+		const slot = getAssertionSlot(current.slotId);
+		const rows = db.prepare(`WITH RECURSIVE versions(id) AS (
+      SELECT ? UNION SELECT a.assertion_id FROM user_assertions a JOIN versions v
+      ON a.supersedes_assertion_id = v.id OR a.assertion_id = (
+        SELECT supersedes_assertion_id FROM user_assertions WHERE assertion_id = v.id)
+    ) SELECT * FROM user_assertions WHERE assertion_id IN (SELECT id FROM versions)
+      OR (? = 'single' AND slot_id = ?)`).all(id, slot.cardinality, slot.id);
+		const evidenceIds = new Set(rows.flatMap((row) => db.prepare("SELECT evidence_id FROM user_assertion_evidence WHERE assertion_id = ?").all(row.assertion_id).map((evidence) => evidence.evidence_id)));
+		for (const row of rows) {
+			const assertion = assertionFromRow(row);
+			suppressMemory(db, assertionFingerprints({
+				...assertion,
+				...slot,
+				principalId: slot.principalId
+			}), now);
+			clearMemoryAudit(db, "assertion", assertion.id);
+			db.prepare("DELETE FROM user_assertions_fts WHERE assertion_id = ?").run(assertion.id);
+			db.prepare(`UPDATE work_discovery_runs SET result_json = json_set(result_json, '$.profileCandidates',
+        json((SELECT COALESCE(json_group_array(json(value)), '[]')
+          FROM json_each(result_json, '$.profileCandidates')
+          WHERE COALESCE(json_extract(value, '$.assertionId'), '') != ?)))
+        WHERE EXISTS (SELECT 1 FROM json_each(result_json, '$.profileCandidates')
+          WHERE json_extract(value, '$.assertionId') = ?)`).run(assertion.id, assertion.id);
+		}
+		for (const row of rows) db.prepare("DELETE FROM user_assertions WHERE assertion_id = ?").run(row.assertion_id);
+		for (const evidenceId of evidenceIds) db.prepare(`UPDATE context_evidence SET redacted_excerpt = NULL WHERE evidence_id = ?
+        AND NOT EXISTS (SELECT 1 FROM user_assertion_evidence WHERE evidence_id = ?)`).run(evidenceId, evidenceId);
+		db.prepare(`DELETE FROM user_assertion_slots WHERE slot_id = ?
+      AND NOT EXISTS (SELECT 1 FROM user_assertions WHERE slot_id = ?)`).run(slot.id, slot.id);
+		return true;
+	});
+}
+function refreshSupportingObservation(db, current, candidate, now) {
+	if (!candidate.evidenceId || current.authority === "user_explicit" || ![
+		"active",
+		"candidate",
+		"stale"
+	].includes(current.status)) return;
+	const evidence = db.prepare(`SELECT observed_at FROM context_evidence WHERE evidence_id = ?
+    AND trust_level = 'owner' AND source_type IN ('conversation', 'user', 'connector')`).get(candidate.evidenceId);
+	if (!evidence || evidence.observed_at <= current.observedAt || evidence.observed_at > now || candidate.confidence < .7) return;
+	const reviewAt = defaultReviewAt(current.volatility, evidence.observed_at);
+	db.prepare(`UPDATE user_assertions SET observed_at = ?, review_at = ? WHERE assertion_id = ?`).run(evidence.observed_at, reviewAt ?? null, current.id);
+	if (current.status === "stale" && (current.validTo === void 0 || current.validTo >= now)) updateStatus(db, current, "candidate", "Fresh source evidence supports this understanding.", now);
+}
 //#endregion
-export { getActiveAssertionByPredicate, getActiveAssertionForSlot, getAssertionSlot, getUserAssertion, getUserTimezone, linkAssertionEvidence, listSlotAssertions, listUserAssertionSources, listUserAssertions, reconcileAssertion, setAssertionStatus };
+export { deleteUserAssertion, getActiveAssertionByPredicate, getActiveAssertionForSlot, getAssertionSlot, getUserAssertion, getUserTimezone, linkAssertionEvidence, listSlotAssertions, listUserAssertionSources, listUserAssertions, reconcileAssertion, setAssertionStatus };

package/dist/src/user-model/usage-policy.d.ts

@@ -1,2 +1,4 @@
 import type { UserAssertion } from './domain.js';
+/** Automatic personalization never grants execution authority. */
 export declare function isWorkingAssumption(assertion: UserAssertion): boolean;
+export declare function canUseAssertion(assertion: UserAssertion, asOf?: number): boolean;

package/dist/src/user-model/usage-policy.js

@@ -1,6 +1,10 @@
 //#region src/user-model/usage-policy.ts
+/** Automatic personalization never grants execution authority. */
 function isWorkingAssumption(assertion) {
-	return assertion.status === "candidate" && (assertion.authority === "user_observed" || assertion.authority === "system_inferred") && assertion.confidence >= .7 && assertion.consequence !== "critical" && assertion.sensitivity === "normal" && assertion.disclosurePolicy !== "ask_before_reference";
+	return (assertion.status === "candidate" || assertion.status === "active") && (assertion.authority === "user_observed" || assertion.authority === "system_inferred") && assertion.confidence >= .7 && (assertion.consequence === "low" || assertion.consequence === "medium") && assertion.sensitivity === "normal" && assertion.disclosurePolicy !== "ask_before_reference";
+}
+function canUseAssertion(assertion, asOf = Date.now()) {
+	return (assertion.validFrom === void 0 || assertion.validFrom <= asOf) && (assertion.validTo === void 0 || assertion.validTo >= asOf) && (assertion.reviewAt === void 0 || assertion.reviewAt > asOf) && assertion.sensitivity !== "secret" && assertion.sensitivity !== "regulated" && assertion.disclosurePolicy !== "ask_before_reference" && (assertion.status === "active" && assertion.authority === "user_explicit" || isWorkingAssumption(assertion));
 }
 //#endregion
-export { isWorkingAssumption };
+export { canUseAssertion, isWorkingAssumption };

package/dist/src/work-discovery/project-understanding.js

@@ -31,7 +31,8 @@ function saveProjectUnderstandingOverview(input) {
 			provider: "project-understanding",
 			evidenceRefs: input.evidenceRefs ?? []
 		},
-		replaceExisting: true
+		replaceExisting: true,
+		restoreDeleted: input.correctedByUser
 	}).item;
 }
 //#endregion

package/dist/src/work-discovery/service.d.ts

@@ -62,7 +62,14 @@ export declare class WorkDiscoveryService {
         reused?: undefined;
     }>;
     revokeDirectorySource(id: string): import("./types.js").WorkDiscoveryDirectorySource;
-    importUnderstandingSources(rawItems: unknown[], processingPolicy: ModelProcessingPolicy, signal?: AbortSignal, runId?: string, rawCheckpoints?: Record<string, unknown>): Promise<{
+    importUnderstandingSources(rawItems: unknown[], processingPolicy: ModelProcessingPolicy, signal?: AbortSignal, runId?: string, rawCheckpoints?: Record<string, unknown>, refresh?: {
+        grantId: string;
+    }): Promise<{
+        profileCandidates: any[];
+        workThreads: import("./types.js").WorkUnderstandingThread[];
+        knowledgeCandidates: import("../knowledge-memory/domain.js").KnowledgeItem[];
+        sourceStatuses: import("./analyzer.js").UnderstandingSourceAnalysisStatus[];
+    } | {
         profileCandidates: any[];
         workThreads: any[];
         knowledgeCandidates: any[];
@@ -70,21 +77,6 @@ export declare class WorkDiscoveryService {
             sourceId: string;
             status: "completed";
         }[];
-    } | {
-        profileCandidates: {
-            status: "pending" | "rejected";
-            assertionId: string;
-            id: string;
-            category: "role" | "responsibility" | "preference" | "routine" | "communication" | "boundary" | "relationship";
-            factKey: string;
-            statement: string;
-            confidence: "high" | "medium" | "low";
-            evidence: string[];
-            evidenceRefs?: string[];
-        }[];
-        workThreads: import("./types.js").WorkUnderstandingThread[];
-        knowledgeCandidates: import("../knowledge-memory/domain.js").KnowledgeItem[];
-        sourceStatuses: import("./analyzer.js").UnderstandingSourceAnalysisStatus[];
     }>;
     rescanDirectorySource(input: {
         id: string;
@@ -103,14 +95,6 @@ export declare class WorkDiscoveryService {
     private publish;
     private execute;
     private persistProfileCandidates;
-    updateProfileCandidates(input: {
-        runId: string;
-        decisions: Array<{
-            id: string;
-            status: 'accepted' | 'edited' | 'rejected';
-            statement?: string;
-        }>;
-    }): WorkDiscoveryRun | null;
     cancelRun(id: string): WorkDiscoveryRun | null;
     retryRun(id: string): WorkDiscoveryRun | null;
     submitRecognitionFeedback(input: {