@xopcai/xopc 0.0.307 → 0.0.308

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

@@ -10,26 +10,6 @@ function isValidTimeZone(value) {
 		return false;
 	}
 }
-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 resolveKnowledgeReadPolicy(config) {
 	return {
 		scopes: config.readScopes,
@@ -82,7 +62,7 @@ var init_config = __esmMin((() => {
 	MaintenanceTimeSchema = z.string().regex(/^([01]\d|2[0-3]):[0-5]\d$/, "Expected time in HH:mm format");
 	UserModelConfigSchema = z.object({
 		enabled: z.boolean().default(true),
-		writePolicy: WritePolicySchema.default("confirm"),
+		writePolicy: z.enum(["deny", "allow"]).default("allow"),
 		sensitiveWritePolicy: WritePolicySchema.default("confirm"),
 		processingPolicy: z.enum(["local_only", "remote_allowed"]).default("remote_allowed"),
 		extraction: z.object({
@@ -124,7 +104,7 @@ var init_config = __esmMin((() => {
 		})
 	}).strict().default({
 		enabled: true,
-		writePolicy: "confirm",
+		writePolicy: "allow",
 		sensitiveWritePolicy: "confirm",
 		processingPolicy: "remote_allowed",
 		extraction: {
@@ -143,9 +123,9 @@ var init_config = __esmMin((() => {
 			staleRetentionDays: 30
 		}
 	});
-	KnowledgeMemoryConfigSchema = z.preprocess(normalizeKnowledgeMemoryConfigInput, z.object({
+	KnowledgeMemoryConfigSchema = z.object({
 		enabled: z.boolean().default(true),
-		writePolicy: WritePolicySchema.default("confirm"),
+		writePolicy: z.enum(["deny", "allow"]).default("allow"),
 		readScopes: z.array(z.enum([
 			"global",
 			"agent",
@@ -182,9 +162,9 @@ var init_config = __esmMin((() => {
 		allowExternalWrites: z.boolean().default(false),
 		allowedProviderIds: z.array(z.string().min(1)).optional(),
 		autoWriteKinds: z.array(z.string().min(1)).optional()
-	}).strict()).default({
+	}).strict().default({
 		enabled: true,
-		writePolicy: "confirm",
+		writePolicy: "allow",
 		readScopes: [
 			"global",
 			"agent",
@@ -227,4 +207,4 @@ var init_config = __esmMin((() => {
 }));
 //#endregion
 init_config();
-export { ContextCompactionPolicySchema, ContextPlanningConfigSchema, DEFAULT_CONTEXT_COMPACTION_POLICY, KnowledgeMemoryConfigSchema, UserContextConfigSchema, UserModelConfigSchema, init_config, normalizeKnowledgeMemoryConfigInput, resolveKnowledgeReadPolicy };
+export { ContextCompactionPolicySchema, ContextPlanningConfigSchema, DEFAULT_CONTEXT_COMPACTION_POLICY, KnowledgeMemoryConfigSchema, UserContextConfigSchema, UserModelConfigSchema, init_config, resolveKnowledgeReadPolicy };

package/dist/src/user-context/memory-suppression.d.ts

@@ -0,0 +1,7 @@
+import type { DatabaseSync } from 'node:sqlite';
+export declare function memoryFingerprint(parts: unknown[]): string;
+export declare function isMemorySuppressed(db: DatabaseSync, fingerprints: string[]): boolean;
+export declare function suppressMemory(db: DatabaseSync, fingerprints: string[], now: number): void;
+export declare function restoreMemory(db: DatabaseSync, fingerprints: string[]): void;
+/** Remove cached decisions containing deleted content; retain only unrelated audit rows. */
+export declare function clearMemoryAudit(db: DatabaseSync, type: 'assertion' | 'knowledge', id: string): void;

package/dist/src/user-context/memory-suppression.js

@@ -0,0 +1,23 @@
+import { createHash } from "node:crypto";
+//#region src/user-context/memory-suppression.ts
+function memoryFingerprint(parts) {
+	const normalized = parts.map((part) => typeof part === "string" ? part.normalize("NFKC").toLowerCase().replace(/\s+/g, " ").trim() : part);
+	return createHash("sha256").update(JSON.stringify(normalized)).digest("hex");
+}
+function isMemorySuppressed(db, fingerprints) {
+	return fingerprints.some((key) => db.prepare("SELECT 1 FROM memory_suppressions WHERE fingerprint = ?").get(key));
+}
+function suppressMemory(db, fingerprints, now) {
+	const insert = db.prepare("INSERT OR IGNORE INTO memory_suppressions (fingerprint, created_at) VALUES (?, ?)");
+	for (const key of fingerprints) insert.run(key, now);
+}
+function restoreMemory(db, fingerprints) {
+	for (const key of fingerprints) db.prepare("DELETE FROM memory_suppressions WHERE fingerprint = ?").run(key);
+}
+/** Remove cached decisions containing deleted content; retain only unrelated audit rows. */
+function clearMemoryAudit(db, type, id) {
+	db.prepare("DELETE FROM memory_maintenance_decisions WHERE object_type = ? AND object_id = ?").run(type, id);
+	db.prepare("DELETE FROM execution_context_items WHERE object_type = ? AND object_id = ?").run(type, id);
+}
+//#endregion
+export { clearMemoryAudit, isMemorySuppressed, memoryFingerprint, restoreMemory, suppressMemory };

package/dist/src/user-context/relationship-continuity.js

@@ -62,7 +62,7 @@ function recordExplicitRelationshipFollowUp(input) {
 		createdBy: "user",
 		evidenceId: evidence.id,
 		evidenceConfidence: 1
-	}, now).assertion;
+	}, now, { restoreDeleted: true }).assertion ?? null;
 }
 //#endregion
 export { extractExplicitRelationshipFollowUp, recordExplicitRelationshipFollowUp };

package/dist/src/user-context/sources/refresh-service.d.ts

@@ -0,0 +1,48 @@
+import type { UnderstandingSourceGrant, UnderstandingSourceItem, UnderstandingSourceRun } from './types.js';
+export type RefreshProgress = {
+    status: UnderstandingSourceRun['status'];
+    phase: 'queued' | 'waiting_desktop' | 'reading' | 'analyzing' | 'completed';
+    added?: number;
+    updated?: number;
+    itemsSeen?: number;
+    error?: string;
+};
+export type RefreshSourceRun = UnderstandingSourceRun & {
+    adapterId: string;
+    displayName: string;
+};
+export type RefreshBatch = {
+    id: string;
+    status: 'running' | 'completed' | 'partial' | 'failed';
+    sources: RefreshSourceRun[];
+    createdAt: number;
+};
+export interface UnderstandingRefreshDeps {
+    enabled(): boolean;
+    start(grant: UnderstandingSourceGrant, runId: string): Promise<Record<string, unknown>>;
+    progress(run: UnderstandingSourceRun): RefreshProgress | undefined;
+    analyzeDesktop(grant: UnderstandingSourceGrant, items: UnderstandingSourceItem[], signal: AbortSignal): Promise<{
+        added?: number;
+        updated?: number;
+    }>;
+    emit?(type: string, payload: unknown): void;
+}
+/** Coordinates existing source executors; the source run remains the authority for progress. */
+export declare class UnderstandingRefreshService {
+    private readonly deps;
+    private readonly owner;
+    private readonly starting;
+    private readonly analyzing;
+    constructor(deps: UnderstandingRefreshDeps);
+    start(sourceIds?: string[]): RefreshBatch;
+    sources(): RefreshSourceRun[];
+    latest(): RefreshBatch | null;
+    get(id: string): RefreshBatch | null;
+    private update;
+    private reconcile;
+    private dispatch;
+    submitDesktop(runId: string, input: {
+        items: UnderstandingSourceItem[];
+        error?: string;
+    }): void;
+}

package/dist/src/user-context/sources/refresh-service.js

@@ -0,0 +1,221 @@
+import { createLogger } from "../../utils/logger/index.js";
+import { init_logger } from "../../utils/logger.js";
+import { getSqliteDatabase, init_transaction, runSqliteWriteTransaction } from "../../storage/sqlite/transaction.js";
+import { createUnderstandingSourceRun, getUnderstandingSourceGrant, getUnderstandingSourceRun, listUnderstandingSourceGrants, listUnderstandingSourceRuns, updateUnderstandingSourceRun } from "./repository.js";
+import { randomUUID } from "node:crypto";
+//#region src/user-context/sources/refresh-service.ts
+init_transaction();
+init_logger();
+const log = createLogger("UnderstandingRefresh");
+const ACTIVE = new Set(["queued", "running"]);
+const DESKTOP_WAIT_MS = 12e4;
+const ANALYSIS_TIMEOUT_MS = 18e4;
+/** Coordinates existing source executors; the source run remains the authority for progress. */
+var UnderstandingRefreshService = class {
+	owner = randomUUID();
+	starting = /* @__PURE__ */ new Set();
+	analyzing = /* @__PURE__ */ new Set();
+	constructor(deps) {
+		this.deps = deps;
+	}
+	start(sourceIds) {
+		if (!this.deps.enabled()) throw new Error("User understanding is disabled.");
+		const grants = listUnderstandingSourceGrants();
+		const selected = sourceIds === void 0 ? grants : [...new Set(sourceIds)].map((id) => {
+			const grant = grants.find((item) => item.id === id);
+			if (!grant) throw new Error("An authorized source was not found.");
+			return grant;
+		});
+		if (!selected.length || selected.length > 100) throw new Error("Select between 1 and 100 authorized sources.");
+		const id = randomUUID();
+		const createdAt = Date.now();
+		const runs = runSqliteWriteTransaction((db) => {
+			const runs = selected.map((grant) => {
+				return listUnderstandingSourceRuns(grant.id, 100).find((run) => run.metadata.refresh === true && ACTIVE.has(this.reconcile(run).status)) ?? createUnderstandingSourceRun({
+					grantId: grant.id,
+					kind: "incremental",
+					status: "queued",
+					metadata: {
+						refresh: true,
+						owner: this.owner,
+						phase: "queued",
+						adapterId: grant.adapterId,
+						displayName: grant.displayName,
+						processingPolicy: grant.processingPolicy
+					}
+				});
+			});
+			db.prepare("INSERT INTO understanding_refresh_batches (batch_id, source_run_ids_json, created_at) VALUES (?, ?, ?)").run(id, JSON.stringify(runs.map((run) => run.id)), createdAt);
+			return runs;
+		});
+		for (const run of runs) if (run.status === "queued" && !this.starting.has(run.id)) this.dispatch(run);
+		return this.get(id);
+	}
+	sources() {
+		return listUnderstandingSourceGrants().flatMap((grant) => {
+			const saved = listUnderstandingSourceRuns(grant.id, 100).find((run) => run.metadata.refresh === true);
+			if (!saved) return [];
+			return [{
+				...this.reconcile(saved),
+				adapterId: grant.adapterId,
+				displayName: grant.displayName
+			}];
+		});
+	}
+	latest() {
+		const row = getSqliteDatabase().prepare("SELECT batch_id FROM understanding_refresh_batches ORDER BY created_at DESC, rowid DESC LIMIT 1").get();
+		return row ? this.get(row.batch_id) : null;
+	}
+	get(id) {
+		const row = getSqliteDatabase().prepare("SELECT * FROM understanding_refresh_batches WHERE batch_id = ?").get(id);
+		if (!row) return null;
+		const sources = JSON.parse(row.source_run_ids_json).flatMap((runId) => {
+			const saved = getUnderstandingSourceRun(runId);
+			if (!saved) return [];
+			const run = this.reconcile(saved);
+			return [{
+				...run,
+				adapterId: String(run.metadata.adapterId),
+				displayName: String(run.metadata.displayName)
+			}];
+		});
+		const completed = sources.filter((run) => run.status === "completed").length;
+		return {
+			id,
+			status: sources.some((run) => ACTIVE.has(run.status)) ? "running" : completed === sources.length && completed > 0 ? "completed" : completed || sources.some((run) => run.status === "partial") ? "partial" : "failed",
+			sources,
+			createdAt: row.created_at
+		};
+	}
+	update(run, progress) {
+		const next = updateUnderstandingSourceRun(run.id, {
+			status: progress.status,
+			itemsSeen: progress.itemsSeen,
+			...progress.error ? { errorMessage: progress.error } : {},
+			completed: !ACTIVE.has(progress.status),
+			metadata: {
+				...run.metadata,
+				phase: progress.phase,
+				...progress.added === void 0 ? {} : { added: progress.added },
+				...progress.updated === void 0 ? {} : { updated: progress.updated }
+			}
+		});
+		this.deps.emit?.("understanding.refresh.updated", {
+			runId: run.id,
+			grantId: run.grantId
+		});
+		return next;
+	}
+	reconcile(run) {
+		if (!ACTIVE.has(run.status)) return run;
+		const grant = getUnderstandingSourceGrant(run.grantId);
+		if (!grant || grant.status !== "active" || grant.processingPolicy !== run.metadata.processingPolicy || !this.deps.enabled()) return this.update(run, {
+			status: "canceled",
+			phase: "completed",
+			error: "Source authorization changed. Retry after reviewing its settings."
+		});
+		const progress = this.deps.progress(run);
+		if (progress) {
+			if (progress.status !== run.status || progress.phase !== run.metadata.phase || progress.added !== run.metadata.added || progress.updated !== run.metadata.updated || progress.itemsSeen !== void 0 && progress.itemsSeen !== run.itemsSeen) return this.update(run, progress);
+			return run;
+		}
+		if (run.metadata.owner !== this.owner) return this.update(run, {
+			status: "failed",
+			phase: "completed",
+			error: "Update was interrupted. Please retry."
+		});
+		if (run.metadata.phase === "waiting_desktop" && Date.now() - run.startedAt > DESKTOP_WAIT_MS) return this.update(run, {
+			status: "failed",
+			phase: "completed",
+			error: "Desktop collection did not finish. Open the desktop app and retry."
+		});
+		return run;
+	}
+	async dispatch(run) {
+		this.starting.add(run.id);
+		try {
+			const grant = getUnderstandingSourceGrant(run.grantId);
+			this.update(run, {
+				status: "running",
+				phase: "reading"
+			});
+			const metadata = await this.deps.start(grant, run.id);
+			const latest = getUnderstandingSourceRun(run.id);
+			updateUnderstandingSourceRun(run.id, { metadata: {
+				...latest.metadata,
+				...metadata
+			} });
+			this.reconcile(getUnderstandingSourceRun(run.id));
+		} catch (err) {
+			log.warn({
+				err,
+				runId: run.id,
+				grantId: run.grantId
+			}, "Understanding refresh could not start");
+			this.update(getUnderstandingSourceRun(run.id), {
+				status: "failed",
+				phase: "completed",
+				error: err instanceof Error ? err.message : String(err)
+			});
+		} finally {
+			this.starting.delete(run.id);
+		}
+	}
+	submitDesktop(runId, input) {
+		const saved = getUnderstandingSourceRun(runId);
+		const run = saved ? this.reconcile(saved) : null;
+		if (!run || run.metadata.refresh !== true) throw new Error("Refresh run not found.");
+		if (this.analyzing.has(runId) || !ACTIVE.has(run.status)) return;
+		if (run.metadata.phase !== "waiting_desktop") throw new Error("This run is not waiting for desktop collection.");
+		const grant = getUnderstandingSourceGrant(run.grantId);
+		if (input.items.length > 1200 || input.items.some((item) => item.sourceId !== grant.adapterId)) throw new Error("Collected items must belong to the requested source.");
+		if (input.error) {
+			this.update(run, {
+				status: "failed",
+				phase: "completed",
+				error: input.error.slice(0, 500)
+			});
+			return;
+		}
+		if (!input.items.length) {
+			this.update(run, {
+				status: "completed",
+				phase: "completed",
+				added: 0,
+				updated: 0,
+				itemsSeen: 0
+			});
+			return;
+		}
+		this.analyzing.add(runId);
+		this.update(run, {
+			status: "running",
+			phase: "analyzing",
+			itemsSeen: input.items.length
+		});
+		const signal = AbortSignal.timeout(ANALYSIS_TIMEOUT_MS);
+		this.deps.analyzeDesktop(grant, input.items, signal).then((result) => {
+			signal.throwIfAborted();
+			const current = this.reconcile(getUnderstandingSourceRun(runId));
+			if (ACTIVE.has(current.status)) this.update(current, {
+				status: "completed",
+				phase: "completed",
+				...result
+			});
+		}).catch((err) => {
+			log.warn({
+				err,
+				runId,
+				grantId: grant.id
+			}, "Understanding refresh analysis failed");
+			const current = getUnderstandingSourceRun(runId);
+			if (ACTIVE.has(current.status)) this.update(current, {
+				status: "failed",
+				phase: "completed",
+				error: "Analysis failed. Please retry."
+			});
+		}).finally(() => this.analyzing.delete(runId));
+	}
+};
+//#endregion
+export { UnderstandingRefreshService };

package/dist/src/user-context/sources/repository.js

@@ -114,7 +114,7 @@ function getUnderstandingSourceRun(id) {
 	return row ? runFromRow(row) : null;
 }
 function listUnderstandingSourceRuns(grantId, limit = 20) {
-	return getSqliteDatabase().prepare("SELECT * FROM understanding_source_runs WHERE grant_id = ? ORDER BY started_at DESC LIMIT ?").all(grantId, Math.max(1, Math.min(100, limit))).map(runFromRow);
+	return getSqliteDatabase().prepare("SELECT * FROM understanding_source_runs WHERE grant_id = ? ORDER BY started_at DESC, rowid DESC LIMIT ?").all(grantId, Math.max(1, Math.min(100, limit))).map(runFromRow);
 }
 function updateUnderstandingSourceRun(id, patch) {
 	const current = getUnderstandingSourceRun(id);

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

@@ -8,30 +8,33 @@ function statements(values, limit) {
 }
 function addExplicitAssertions(values, input, now) {
 	let created = 0;
-	for (const statement of values) if (reconcileAssertion({
-		subject: {
-			type: "user",
-			id: "self"
-		},
-		predicate: input.predicate,
-		cardinality: "multiple",
-		scope: { type: "global" },
-		kind: input.kind,
-		value: statement,
-		normalizedValue: statement.toLocaleLowerCase(),
-		statement,
-		authority: "user_explicit",
-		confidence: 1,
-		declaredImportance: input.importance,
-		inferredImportance: input.importance,
-		consequence: "medium",
-		actionability: .8,
-		volatility: "slow",
-		sensitivity: input.kind === "relationship" ? "personal" : "normal",
-		disclosurePolicy: "referenceable",
-		observedAt: now,
-		createdBy: "user"
-	}, now).action !== "deduplicated") created += 1;
+	for (const statement of values) {
+		const result = reconcileAssertion({
+			subject: {
+				type: "user",
+				id: "self"
+			},
+			predicate: input.predicate,
+			cardinality: "multiple",
+			scope: { type: "global" },
+			kind: input.kind,
+			value: statement,
+			normalizedValue: statement.toLocaleLowerCase(),
+			statement,
+			authority: "user_explicit",
+			confidence: 1,
+			declaredImportance: input.importance,
+			inferredImportance: input.importance,
+			consequence: "medium",
+			actionability: .8,
+			volatility: "slow",
+			sensitivity: input.kind === "relationship" ? "personal" : "normal",
+			disclosurePolicy: "referenceable",
+			observedAt: now,
+			createdBy: "user"
+		}, now, { restoreDeleted: true });
+		if (result.assertion && result.action !== "deduplicated") created += 1;
+	}
 	return created;
 }
 function addRules(category, values) {

package/dist/src/user-model/capture/executor.d.ts

@@ -1,7 +1,7 @@
 import type { AssertionStatus } from '../domain.js';
 import type { CaptureEvidence, UserModelInterpretation } from './semantic.js';
 export interface UserModelCapturePolicy {
-    write: 'deny' | 'confirm' | 'allow';
+    write: 'deny' | 'allow';
     sensitiveWrite: 'deny' | 'confirm' | 'allow';
     processing: 'local_only' | 'remote_allowed';
 }

package/dist/src/user-model/capture/executor.js

@@ -1,7 +1,7 @@
 import { createCollaborationRule, listCollaborationRules } from "../../storage/sqlite/collaboration-rule-repository.js";
 import { createContextEvidence } from "../../storage/sqlite/context-evidence-repository.js";
 import { createUserGoal, listUserGoals } from "../goals.js";
-import { getUserAssertion, linkAssertionEvidence, reconcileAssertion, setAssertionStatus } from "../repository.js";
+import { deleteUserAssertion, getUserAssertion, linkAssertionEvidence, reconcileAssertion, setAssertionStatus } from "../repository.js";
 import { createHash } from "node:crypto";
 //#region src/user-model/capture/executor.ts
 function emptyUserModelCaptureResult() {
@@ -33,10 +33,7 @@ function executeUserModelInterpretation(input) {
 	const targets = input.interpretation.targetAssertionIds.flatMap((id) => getUserAssertion(id) ?? []);
 	if (input.interpretation.intent === "forget") {
 		for (const target of targets) {
-			setAssertionStatus(target.id, "rejected", {
-				actor: "user",
-				reason: "Explicit user forget request."
-			});
+			deleteUserAssertion(target.id);
 			result.outputs.push({
 				candidateKey: target.id,
 				assertionId: target.id,
@@ -100,12 +97,13 @@ function executeUserModelInterpretation(input) {
 		});
 		evidenceIds.set(ref, evidence.id);
 	}
+	const latestUserRef = input.evidence.filter((item) => item.role === "user").sort((a, b) => b.createdAt - a.createdAt)[0]?.ref;
 	const explicitCommand = input.interpretation.intent === "remember" || input.interpretation.intent === "correct";
 	for (const source of input.interpretation.candidates) {
 		result.proposed += 1;
 		const key = candidateKey(source.predicate, source.scope.type, source.scope.id);
-		const sensitive = source.sensitivity === "secret" || source.sensitivity === "regulated";
-		if (input.policy.write === "deny" || sensitive && input.policy.sensitiveWrite === "deny" || !scopeAllowed(source.scope.type, source.scope.id, input.scopeContext)) {
+		const sensitive = source.sensitivity !== "normal";
+		if (input.policy.write === "deny" || sensitive && (source.authority !== "user_explicit" || input.policy.sensitiveWrite === "deny") || !scopeAllowed(source.scope.type, source.scope.id, input.scopeContext)) {
 			result.rejected += 1;
 			result.outputs.push({
 				candidateKey: key,
@@ -113,7 +111,7 @@ function executeUserModelInterpretation(input) {
 			});
 			continue;
 		}
-		const requiresConfirmation = !explicitCommand && (input.policy.write === "confirm" || sensitive && input.policy.sensitiveWrite === "confirm");
+		const requiresConfirmation = !explicitCommand && sensitive && input.policy.sensitiveWrite === "confirm";
 		const refs = source.evidenceRefs.flatMap((ref) => evidenceIds.get(ref) ?? []);
 		const applied = reconcileAssertion({
 			...source,
@@ -123,7 +121,15 @@ function executeUserModelInterpretation(input) {
 				evidenceId: refs[0],
 				evidenceConfidence: source.confidence
 			} : {}
-		});
+		}, Date.now(), { restoreDeleted: explicitCommand && source.evidenceRefs.includes(latestUserRef) });
+		if (applied.action === "suppressed") {
+			result.rejected += 1;
+			result.outputs.push({
+				candidateKey: key,
+				outcome: "rejected"
+			});
+			continue;
+		}
 		for (const evidenceId of refs.slice(1)) linkAssertionEvidence(applied.assertion.id, evidenceId, "supports", source.confidence);
 		result.createdAssertions.push({
 			id: applied.assertion.id,
@@ -158,7 +164,7 @@ function executeUserModelInterpretation(input) {
 			});
 			continue;
 		}
-		const active = explicitCommand || input.policy.write === "allow";
+		const active = explicitCommand;
 		const goal = createUserGoal({
 			title: source.title,
 			desiredOutcome: source.desiredOutcome,
@@ -200,7 +206,7 @@ function executeUserModelInterpretation(input) {
 			});
 			continue;
 		}
-		const active = explicitCommand || input.policy.write === "allow";
+		const active = explicitCommand;
 		const rule = createCollaborationRule({
 			category: source.category,
 			priority: source.priority,

package/dist/src/user-model/capture/semantic.js

@@ -153,7 +153,7 @@ function comparable(value) {
 	return value.normalize("NFKC").toLocaleLowerCase().replace(/\s+/g, " ").trim();
 }
 function effectiveAuthority(intent, authority) {
-	if (intent === "remember" || intent === "correct" || intent === "confirm") return authority;
+	if (intent === "remember" || intent === "correct" || intent === "confirm" || intent === "user_assertion") return authority;
 	return authority === "user_explicit" ? "user_observed" : authority;
 }
 function parseTime(value) {

package/dist/src/user-model/domain.d.ts

@@ -84,10 +84,14 @@ export interface AssertionCandidate {
     correctionOfAssertionId?: string;
 }
 export type ReconciliationAction = 'created' | 'deduplicated' | 'superseded' | 'conflicted';
-export interface ReconciliationResult {
+export type ReconciliationResult = {
     action: ReconciliationAction;
     assertion: UserAssertion;
     previousAssertion?: UserAssertion;
-}
+} | {
+    action: 'suppressed';
+    assertion?: undefined;
+    previousAssertion?: undefined;
+};
 export declare function validateScope(scope: UserModelScope): void;
 export declare function validateCandidate(candidate: AssertionCandidate): void;

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

@@ -2,8 +2,8 @@ import { USER_MODEL_PRINCIPAL_ID, validateCandidate, validateScope } from "./dom
 import { calculateExecutionValue } from "./importance.js";
 import { createPriorityWindow, createUserGoal, listPriorityWindows, listUserGoals, setUserGoalStatus } from "./goals.js";
 import { defaultReviewAt, isAssertionValidAt, requiresBoundedValidity, resolveCurrentAssertion } from "./temporal.js";
-import { getActiveAssertionByPredicate, getActiveAssertionForSlot, getAssertionSlot, getUserAssertion, getUserTimezone, linkAssertionEvidence, listSlotAssertions, listUserAssertionSources, listUserAssertions, reconcileAssertion, setAssertionStatus } from "./repository.js";
+import { deleteUserAssertion, getActiveAssertionByPredicate, getActiveAssertionForSlot, getAssertionSlot, getUserAssertion, getUserTimezone, linkAssertionEvidence, listSlotAssertions, listUserAssertionSources, listUserAssertions, reconcileAssertion, setAssertionStatus } from "./repository.js";
 import { applyUserProfilePatch, getUserProfileSnapshot } from "./profile.js";
 import { bootstrapUserModel } from "./bootstrap.js";
-import { isWorkingAssumption } from "./usage-policy.js";
-export { USER_MODEL_PRINCIPAL_ID, applyUserProfilePatch, bootstrapUserModel, calculateExecutionValue, createPriorityWindow, createUserGoal, defaultReviewAt, getActiveAssertionByPredicate, getActiveAssertionForSlot, getAssertionSlot, getUserAssertion, getUserProfileSnapshot, getUserTimezone, isAssertionValidAt, isWorkingAssumption, linkAssertionEvidence, listPriorityWindows, listSlotAssertions, listUserAssertionSources, listUserAssertions, listUserGoals, reconcileAssertion, requiresBoundedValidity, resolveCurrentAssertion, setAssertionStatus, setUserGoalStatus, validateCandidate, validateScope };
+import { canUseAssertion, isWorkingAssumption } from "./usage-policy.js";
+export { USER_MODEL_PRINCIPAL_ID, applyUserProfilePatch, bootstrapUserModel, calculateExecutionValue, canUseAssertion, createPriorityWindow, createUserGoal, defaultReviewAt, deleteUserAssertion, getActiveAssertionByPredicate, getActiveAssertionForSlot, getAssertionSlot, getUserAssertion, getUserProfileSnapshot, getUserTimezone, isAssertionValidAt, isWorkingAssumption, linkAssertionEvidence, listPriorityWindows, listSlotAssertions, listUserAssertionSources, listUserAssertions, listUserGoals, reconcileAssertion, requiresBoundedValidity, resolveCurrentAssertion, setAssertionStatus, setUserGoalStatus, validateCandidate, validateScope };

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

@@ -90,7 +90,7 @@ function applyUserProfilePatch(input, now = Date.now()) {
 			observedAt: now,
 			createdBy: "user",
 			...current ? { correctionOfAssertionId: current.id } : {}
-		}, now);
+		}, now, { restoreDeleted: true });
 	}
 	return getUserProfileSnapshot();
 }

package/dist/src/user-model/repository.d.ts

@@ -6,7 +6,9 @@ export type UserAssertionSource = {
     category?: 'files' | 'recent_documents' | 'calendar' | 'tasks' | 'notes' | 'mail' | 'messages' | 'code_activity';
     observedAt: number;
 };
-export declare function reconcileAssertion(candidate: AssertionCandidate, now?: number): ReconciliationResult;
+export declare function reconcileAssertion(candidate: AssertionCandidate, now?: number, options?: {
+    restoreDeleted?: boolean;
+}): ReconciliationResult;
 export declare function getUserAssertion(id: string): UserAssertion | undefined;
 export declare function getAssertionSlot(id: string): AssertionSlot | undefined;
 export declare function listSlotAssertions(slotId: string): UserAssertion[];
@@ -29,3 +31,4 @@ export declare function setAssertionStatus(assertionId: string, status: Assertio
     reason: string;
     now?: number;
 }): UserAssertion;
+export declare function deleteUserAssertion(id: string, now?: number): boolean;