@xopcai/xopc 0.0.248 → 0.0.250

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

@@ -0,0 +1,50 @@
+import type { AssertionStatus } from '../domain.js';
+import type { CaptureEvidence, UserModelInterpretation } from './semantic.js';
+export interface UserModelCapturePolicy {
+    write: 'deny' | 'confirm' | 'allow';
+    sensitiveWrite: 'deny' | 'confirm' | 'allow';
+    processing: 'local_only' | 'remote_allowed';
+}
+export interface CaptureScopeContext {
+    sessionId: string;
+    agentId: string;
+    workspaceId: string;
+    projectId?: string;
+}
+export interface UserModelCaptureResult {
+    proposed: number;
+    created: number;
+    deduplicated: number;
+    rejected: number;
+    createdAssertions: Array<{
+        id: string;
+        content: string;
+        kind: string;
+        status: AssertionStatus;
+    }>;
+    createdGoals: Array<{
+        id: string;
+        title: string;
+        status: 'proposed' | 'active';
+    }>;
+    createdRules: Array<{
+        id: string;
+        statement: string;
+        status: 'active' | 'disabled';
+    }>;
+    outputs: Array<{
+        candidateKey: string;
+        assertionId?: string;
+        outcome: 'created' | 'deduplicated' | 'superseded' | 'conflicted' | 'rejected';
+    }>;
+}
+export declare function emptyUserModelCaptureResult(): UserModelCaptureResult;
+export declare function executeUserModelInterpretation(input: {
+    interpretation: UserModelInterpretation;
+    evidence: CaptureEvidence[];
+    extractionRunId: string;
+    extractorId: string;
+    scopeContext: CaptureScopeContext;
+    policy: UserModelCapturePolicy;
+    turnId?: string;
+}): UserModelCaptureResult;

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

@@ -0,0 +1,230 @@
+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 { createHash } from "node:crypto";
+//#region src/user-model/capture/executor.ts
+function emptyUserModelCaptureResult() {
+	return {
+		proposed: 0,
+		created: 0,
+		deduplicated: 0,
+		rejected: 0,
+		createdAssertions: [],
+		createdGoals: [],
+		createdRules: [],
+		outputs: []
+	};
+}
+function scopeAllowed(type, id, context) {
+	if (type === "global") return id === void 0;
+	return id === {
+		agent: context.agentId,
+		workspace: context.workspaceId,
+		project: context.projectId,
+		session: context.sessionId
+	}[type];
+}
+function candidateKey(predicate, scopeType, scopeId) {
+	return `${scopeType}:${scopeId ?? ""}:${predicate}`;
+}
+function executeUserModelInterpretation(input) {
+	const result = emptyUserModelCaptureResult();
+	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."
+			});
+			result.outputs.push({
+				candidateKey: target.id,
+				assertionId: target.id,
+				outcome: "rejected"
+			});
+			result.rejected += 1;
+		}
+		return result;
+	}
+	if (input.interpretation.intent === "confirm" && input.policy.write !== "deny") for (const target of targets) {
+		const confirmed = setAssertionStatus(target.id, "active", {
+			actor: "user",
+			reason: "Explicit user confirmation."
+		});
+		result.createdAssertions.push({
+			id: confirmed.id,
+			content: confirmed.statement,
+			kind: confirmed.kind,
+			status: confirmed.status
+		});
+		result.outputs.push({
+			candidateKey: confirmed.id,
+			assertionId: confirmed.id,
+			outcome: "deduplicated"
+		});
+		result.deduplicated += 1;
+	}
+	if (input.interpretation.intent === "correct" && targets.length && input.interpretation.candidates.length === 0) {
+		for (const target of targets) setAssertionStatus(target.id, "needs_review", {
+			actor: "user",
+			reason: "Correction requested without a grounded replacement."
+		});
+		return result;
+	}
+	const goals = input.interpretation.goals ?? [];
+	const collaborationRules = input.interpretation.collaborationRules ?? [];
+	if (!input.interpretation.candidates.length && !goals.length && !collaborationRules.length) return result;
+	const evidenceByRef = new Map(input.evidence.map((entry) => [entry.ref, entry]));
+	const evidenceIds = /* @__PURE__ */ new Map();
+	for (const ref of new Set([
+		...input.interpretation.candidates.flatMap((item) => item.evidenceRefs),
+		...goals.flatMap((item) => item.evidenceRefs),
+		...collaborationRules.flatMap((item) => item.evidenceRefs)
+	])) {
+		const item = evidenceByRef.get(ref);
+		if (!item || item.role !== "user") continue;
+		const evidence = createContextEvidence({
+			sourceType: "conversation",
+			sourceRef: `session:${input.scopeContext.sessionId}:entry:${ref}`,
+			sourceRunId: input.extractionRunId,
+			sessionId: input.scopeContext.sessionId,
+			...input.turnId ? { turnId: input.turnId } : {},
+			messageId: ref,
+			contentHash: createHash("sha256").update(item.text).digest("hex"),
+			retentionPolicy: "derived_only",
+			processingPolicy: input.policy.processing,
+			extractorId: input.extractorId,
+			extractorVersion: "user-model-v1",
+			trustLevel: "owner",
+			observedAt: item.createdAt
+		});
+		evidenceIds.set(ref, evidence.id);
+	}
+	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)) {
+			result.rejected += 1;
+			result.outputs.push({
+				candidateKey: key,
+				outcome: "rejected"
+			});
+			continue;
+		}
+		const requiresConfirmation = !explicitCommand && (input.policy.write === "confirm" || sensitive && input.policy.sensitiveWrite === "confirm");
+		const refs = source.evidenceRefs.flatMap((ref) => evidenceIds.get(ref) ?? []);
+		const applied = reconcileAssertion({
+			...source,
+			authority: requiresConfirmation && source.authority === "user_explicit" ? "user_observed" : source.authority,
+			createdBy: source.authority === "user_explicit" ? "user" : "runtime",
+			...refs[0] ? {
+				evidenceId: refs[0],
+				evidenceConfidence: source.confidence
+			} : {}
+		});
+		for (const evidenceId of refs.slice(1)) linkAssertionEvidence(applied.assertion.id, evidenceId, "supports", source.confidence);
+		result.createdAssertions.push({
+			id: applied.assertion.id,
+			content: applied.assertion.statement,
+			kind: applied.assertion.kind,
+			status: applied.assertion.status
+		});
+		result.outputs.push({
+			candidateKey: key,
+			assertionId: applied.assertion.id,
+			outcome: applied.action
+		});
+		if (applied.action === "deduplicated") result.deduplicated += 1;
+		else result.created += 1;
+	}
+	for (const source of goals) {
+		result.proposed += 1;
+		const key = candidateKey(`goal:${source.title.toLocaleLowerCase()}`, source.scope.type, source.scope.id);
+		if (input.policy.write === "deny" || !scopeAllowed(source.scope.type, source.scope.id, input.scopeContext)) {
+			result.rejected += 1;
+			result.outputs.push({
+				candidateKey: key,
+				outcome: "rejected"
+			});
+			continue;
+		}
+		if (listUserGoals().find((goal) => goal.scope.type === source.scope.type && goal.scope.id === source.scope.id && goal.title.toLocaleLowerCase() === source.title.toLocaleLowerCase() && goal.status !== "achieved" && goal.status !== "abandoned")) {
+			result.deduplicated += 1;
+			result.outputs.push({
+				candidateKey: key,
+				outcome: "deduplicated"
+			});
+			continue;
+		}
+		const active = explicitCommand || input.policy.write === "allow";
+		const goal = createUserGoal({
+			title: source.title,
+			desiredOutcome: source.desiredOutcome,
+			scope: source.scope,
+			...source.declaredImportance === void 0 ? {} : { declaredImportance: source.declaredImportance },
+			...source.targetAt === void 0 ? {} : { targetAt: source.targetAt },
+			status: active ? "active" : "proposed",
+			authority: active ? "user_explicit" : "user_observed",
+			confidence: active ? 1 : .8,
+			createdBy: "runtime"
+		});
+		result.created += 1;
+		result.createdGoals.push({
+			id: goal.id,
+			title: goal.title,
+			status: goal.status
+		});
+		result.outputs.push({
+			candidateKey: key,
+			outcome: "created"
+		});
+	}
+	for (const source of collaborationRules) {
+		result.proposed += 1;
+		const key = candidateKey(`rule:${source.category}:${source.statement.toLocaleLowerCase()}`, source.scope.type, source.scope.id);
+		if (input.policy.write === "deny" || !scopeAllowed(source.scope.type, source.scope.id, input.scopeContext) || source.scope.type === "agent") {
+			result.rejected += 1;
+			result.outputs.push({
+				candidateKey: key,
+				outcome: "rejected"
+			});
+			continue;
+		}
+		if (listCollaborationRules().find((rule) => rule.scope.type === source.scope.type && rule.scope.id === source.scope.id && rule.statement.toLocaleLowerCase() === source.statement.toLocaleLowerCase() && rule.status !== "archived")) {
+			result.deduplicated += 1;
+			result.outputs.push({
+				candidateKey: key,
+				outcome: "deduplicated"
+			});
+			continue;
+		}
+		const active = explicitCommand || input.policy.write === "allow";
+		const rule = createCollaborationRule({
+			category: source.category,
+			priority: source.priority,
+			scope: source.scope,
+			conditions: {
+				...source.conditions,
+				enforcementLevel: "prompt",
+				...active ? {} : { reviewRequired: true }
+			},
+			statement: source.statement,
+			status: active ? "active" : "disabled"
+		});
+		result.created += 1;
+		result.createdRules.push({
+			id: rule.id,
+			statement: rule.statement,
+			status: rule.status
+		});
+		result.outputs.push({
+			candidateKey: key,
+			outcome: "created"
+		});
+	}
+	return result;
+}
+//#endregion
+export { emptyUserModelCaptureResult, executeUserModelInterpretation };

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

@@ -0,0 +1,2 @@
+export * from './executor.js';
+export * from './semantic.js';

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

@@ -0,0 +1,3 @@
+import { emptyUserModelCaptureResult, executeUserModelInterpretation } from "./executor.js";
+import { USER_MODEL_CAPTURE_INTENTS, parseUserModelInterpretation } from "./semantic.js";
+export { USER_MODEL_CAPTURE_INTENTS, emptyUserModelCaptureResult, executeUserModelInterpretation, parseUserModelInterpretation };

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

@@ -0,0 +1,39 @@
+import type { AssertionCandidate } from '../domain.js';
+export declare const USER_MODEL_CAPTURE_INTENTS: readonly ["remember", "query", "confirm", "correct", "forget", "user_assertion", "task", "none"];
+export type UserModelCaptureIntent = typeof USER_MODEL_CAPTURE_INTENTS[number];
+export interface CaptureEvidence {
+    ref: string;
+    role: 'user' | 'assistant';
+    text: string;
+    createdAt: number;
+}
+export interface ParsedAssertionCandidate extends AssertionCandidate {
+    evidenceRefs: string[];
+    temporalResolution: 'exact' | 'relative_resolved' | 'unresolved';
+    originalTimePhrase?: string;
+}
+export interface ParsedGoalCandidate {
+    title: string;
+    desiredOutcome: string;
+    scope: AssertionCandidate['scope'];
+    declaredImportance?: number;
+    targetAt?: number;
+    evidenceRefs: string[];
+}
+export interface ParsedCollaborationRuleCandidate {
+    category: 'communication' | 'execution' | 'boundary' | 'routine' | 'proactive';
+    priority: number;
+    scope: AssertionCandidate['scope'];
+    conditions: Record<string, unknown>;
+    statement: string;
+    evidenceRefs: string[];
+}
+export interface UserModelInterpretation {
+    intent: UserModelCaptureIntent;
+    candidates: ParsedAssertionCandidate[];
+    goals?: ParsedGoalCandidate[];
+    collaborationRules?: ParsedCollaborationRuleCandidate[];
+    targetAssertionIds: string[];
+    abstentionReason?: string;
+}
+export declare function parseUserModelInterpretation(raw: string, evidence: CaptureEvidence[], allowedTargetIds?: string[]): UserModelInterpretation | null;

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

@@ -0,0 +1,263 @@
+import { z } from "zod";
+//#region src/user-model/capture/semantic.ts
+const USER_MODEL_CAPTURE_INTENTS = [
+	"remember",
+	"query",
+	"confirm",
+	"correct",
+	"forget",
+	"user_assertion",
+	"task",
+	"none"
+];
+const ScopeSchema = z.object({
+	type: z.enum([
+		"global",
+		"agent",
+		"workspace",
+		"project",
+		"session"
+	]),
+	id: z.string().min(1).optional()
+}).strict().superRefine((scope, ctx) => {
+	if (scope.type === "global" && scope.id) ctx.addIssue({
+		code: "custom",
+		message: "Global scope has no id."
+	});
+	if (scope.type !== "global" && !scope.id) ctx.addIssue({
+		code: "custom",
+		message: `${scope.type} scope needs an id.`
+	});
+});
+const CandidateSchema = z.object({
+	subject: z.object({
+		type: z.enum([
+			"user",
+			"person",
+			"goal",
+			"project",
+			"topic"
+		]),
+		id: z.string().min(1).max(160)
+	}).strict(),
+	predicate: z.string().regex(/^[a-z][a-z0-9_.-]{2,119}$/),
+	cardinality: z.enum(["single", "multiple"]),
+	scope: ScopeSchema,
+	kind: z.enum([
+		"identity",
+		"preference",
+		"value",
+		"routine",
+		"capability",
+		"relationship",
+		"current_state",
+		"derived_insight"
+	]),
+	value: z.unknown(),
+	normalizedValue: z.string().min(1).max(600),
+	statement: z.string().min(4).max(600),
+	authority: z.enum([
+		"user_explicit",
+		"user_observed",
+		"system_inferred",
+		"external_untrusted"
+	]),
+	confidence: z.number().min(0).max(1),
+	declaredImportance: z.number().min(0).max(1).optional(),
+	inferredImportance: z.number().min(0).max(1),
+	consequence: z.enum([
+		"low",
+		"medium",
+		"high",
+		"critical"
+	]),
+	actionability: z.number().min(0).max(1),
+	volatility: z.enum([
+		"stable",
+		"slow",
+		"dynamic",
+		"event"
+	]),
+	sensitivity: z.enum([
+		"normal",
+		"personal",
+		"secret",
+		"regulated"
+	]),
+	disclosurePolicy: z.enum([
+		"silent",
+		"referenceable",
+		"ask_before_reference"
+	]),
+	applicability: z.record(z.string(), z.unknown()).default({}),
+	validFrom: z.string().datetime({ offset: true }).optional(),
+	validTo: z.string().datetime({ offset: true }).optional(),
+	reviewAt: z.string().datetime({ offset: true }).optional(),
+	temporalResolution: z.enum([
+		"exact",
+		"relative_resolved",
+		"unresolved"
+	]),
+	originalTimePhrase: z.string().max(200).optional(),
+	correctionOfAssertionId: z.string().min(1).optional(),
+	evidence: z.array(z.object({
+		ref: z.string().min(1),
+		quote: z.string().min(1)
+	}).strict()).min(1).max(8),
+	selfContained: z.boolean(),
+	unresolvedReferences: z.array(z.string()).max(8)
+}).strict();
+const GroundingSchema = z.object({
+	evidence: z.array(z.object({
+		ref: z.string().min(1),
+		quote: z.string().min(1)
+	}).strict()).min(1).max(8),
+	selfContained: z.boolean(),
+	unresolvedReferences: z.array(z.string()).max(8)
+});
+const GoalSchema = z.object({
+	title: z.string().min(1).max(200),
+	desiredOutcome: z.string().min(1).max(600),
+	scope: ScopeSchema,
+	declaredImportance: z.number().min(0).max(1).optional(),
+	targetAt: z.string().datetime({ offset: true }).optional()
+}).merge(GroundingSchema).strict();
+const CollaborationRuleSchema = z.object({
+	category: z.enum([
+		"communication",
+		"execution",
+		"boundary",
+		"routine",
+		"proactive"
+	]),
+	priority: z.number().int().min(0).max(100),
+	scope: ScopeSchema,
+	conditions: z.record(z.string(), z.unknown()).default({}),
+	statement: z.string().min(4).max(600)
+}).merge(GroundingSchema).strict();
+const InterpretationSchema = z.object({
+	intent: z.enum(USER_MODEL_CAPTURE_INTENTS),
+	candidates: z.array(CandidateSchema).max(8),
+	goals: z.array(GoalSchema).max(4).default([]),
+	collaborationRules: z.array(CollaborationRuleSchema).max(4).default([]),
+	targetAssertionIds: z.array(z.string().min(1)).max(8),
+	abstentionReason: z.string().max(500).optional()
+}).strict();
+function extractJson(raw) {
+	const fenced = /```(?:json)?\s*([\s\S]*?)```/i.exec(raw)?.[1];
+	const start = raw.indexOf("{");
+	const end = raw.lastIndexOf("}");
+	return JSON.parse(fenced ?? (start >= 0 && end > start ? raw.slice(start, end + 1) : raw));
+}
+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;
+	return authority === "user_explicit" ? "user_observed" : authority;
+}
+function parseTime(value) {
+	return value === void 0 ? void 0 : Date.parse(value);
+}
+function groundedEvidenceRefs(item, evidenceByRef) {
+	if (!item.selfContained || item.unresolvedReferences.length) return void 0;
+	return item.evidence.every((claim) => {
+		const source = evidenceByRef.get(claim.ref);
+		return source?.role === "user" && comparable(source.text).includes(comparable(claim.quote));
+	}) ? [...new Set(item.evidence.map((claim) => claim.ref))] : void 0;
+}
+function parseUserModelInterpretation(raw, evidence, allowedTargetIds = []) {
+	let parsed;
+	try {
+		const result = InterpretationSchema.safeParse(extractJson(raw));
+		if (!result.success) return null;
+		parsed = result.data;
+	} catch {
+		return null;
+	}
+	const evidenceByRef = new Map(evidence.map((item) => [item.ref, item]));
+	const candidateIntents = new Set([
+		"remember",
+		"correct",
+		"confirm",
+		"user_assertion"
+	]);
+	const candidates = [];
+	if (candidateIntents.has(parsed.intent)) for (const item of parsed.candidates) {
+		const evidenceRefs = groundedEvidenceRefs(item, evidenceByRef);
+		if (!evidenceRefs) continue;
+		const observedAt = Math.max(...item.evidence.map((claim) => evidenceByRef.get(claim.ref).createdAt));
+		candidates.push({
+			subject: item.subject,
+			predicate: item.predicate,
+			cardinality: item.cardinality,
+			scope: item.scope,
+			kind: item.kind,
+			value: item.value,
+			normalizedValue: item.normalizedValue,
+			statement: item.statement,
+			authority: effectiveAuthority(parsed.intent, item.authority),
+			confidence: item.confidence,
+			...item.declaredImportance === void 0 ? {} : { declaredImportance: item.declaredImportance },
+			inferredImportance: item.inferredImportance,
+			consequence: item.consequence,
+			actionability: item.actionability,
+			volatility: item.volatility,
+			sensitivity: item.sensitivity,
+			disclosurePolicy: item.disclosurePolicy,
+			applicability: item.applicability,
+			...item.temporalResolution === "unresolved" ? {} : {
+				...item.validFrom ? { validFrom: parseTime(item.validFrom) } : {},
+				...item.validTo ? { validTo: parseTime(item.validTo) } : {},
+				...item.reviewAt ? { reviewAt: parseTime(item.reviewAt) } : {}
+			},
+			temporalResolution: item.temporalResolution,
+			...item.originalTimePhrase ? { originalTimePhrase: item.originalTimePhrase } : {},
+			...item.correctionOfAssertionId && allowedTargetIds.includes(item.correctionOfAssertionId) ? { correctionOfAssertionId: item.correctionOfAssertionId } : {},
+			observedAt,
+			createdBy: "runtime",
+			evidenceRefs
+		});
+	}
+	const structuredIntents = new Set([
+		"remember",
+		"confirm",
+		"correct",
+		"user_assertion"
+	]);
+	const goals = structuredIntents.has(parsed.intent) ? parsed.goals.flatMap((item) => {
+		const evidenceRefs = groundedEvidenceRefs(item, evidenceByRef);
+		if (!evidenceRefs) return [];
+		return [{
+			title: item.title,
+			desiredOutcome: item.desiredOutcome,
+			scope: item.scope,
+			...item.declaredImportance === void 0 ? {} : { declaredImportance: item.declaredImportance },
+			...item.targetAt === void 0 ? {} : { targetAt: parseTime(item.targetAt) },
+			evidenceRefs
+		}];
+	}) : [];
+	const collaborationRules = structuredIntents.has(parsed.intent) ? parsed.collaborationRules.flatMap((item) => {
+		const evidenceRefs = groundedEvidenceRefs(item, evidenceByRef);
+		if (!evidenceRefs || item.scope.type === "agent") return [];
+		return [{
+			category: item.category,
+			priority: item.priority,
+			scope: item.scope,
+			conditions: item.conditions,
+			statement: item.statement,
+			evidenceRefs
+		}];
+	}) : [];
+	const allowed = new Set(allowedTargetIds);
+	return {
+		intent: parsed.intent,
+		candidates,
+		goals,
+		collaborationRules,
+		targetAssertionIds: [...new Set(parsed.targetAssertionIds.filter((id) => allowed.has(id)))],
+		...parsed.abstentionReason ? { abstentionReason: parsed.abstentionReason } : {}
+	};
+}
+//#endregion
+export { USER_MODEL_CAPTURE_INTENTS, parseUserModelInterpretation };

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

@@ -0,0 +1,93 @@
+export declare const USER_MODEL_PRINCIPAL_ID = "local-owner";
+export type UserModelScopeType = 'global' | 'agent' | 'workspace' | 'project' | 'session';
+export type AssertionSubjectType = 'user' | 'person' | 'goal' | 'project' | 'topic';
+export type AssertionCardinality = 'single' | 'multiple';
+export type AssertionKind = 'identity' | 'preference' | 'value' | 'routine' | 'capability' | 'relationship' | 'current_state' | 'derived_insight';
+export type AssertionAuthority = 'user_explicit' | 'user_observed' | 'system_inferred' | 'external_untrusted';
+export type AssertionStatus = 'candidate' | 'active' | 'needs_review' | 'conflicted' | 'stale' | 'archived' | 'rejected';
+export type AssertionConsequence = 'low' | 'medium' | 'high' | 'critical';
+export type AssertionVolatility = 'stable' | 'slow' | 'dynamic' | 'event';
+export type AssertionCreator = 'user' | 'runtime' | 'connector' | 'maintenance' | 'migration';
+export type AssertionSensitivity = 'normal' | 'personal' | 'secret' | 'regulated';
+export type AssertionDisclosurePolicy = 'silent' | 'referenceable' | 'ask_before_reference';
+export interface UserModelScope {
+    type: UserModelScopeType;
+    id?: string;
+}
+export interface AssertionSubject {
+    type: AssertionSubjectType;
+    id: string;
+}
+export interface AssertionSlot {
+    id: string;
+    principalId: string;
+    subject: AssertionSubject;
+    predicate: string;
+    cardinality: AssertionCardinality;
+    scope: UserModelScope;
+    createdAt: number;
+}
+export interface UserAssertion {
+    id: string;
+    slotId: string;
+    kind: AssertionKind;
+    value: unknown;
+    normalizedValue: string;
+    statement: string;
+    authority: AssertionAuthority;
+    status: AssertionStatus;
+    confidence: number;
+    declaredImportance?: number;
+    inferredImportance: number;
+    consequence: AssertionConsequence;
+    actionability: number;
+    volatility: AssertionVolatility;
+    sensitivity: AssertionSensitivity;
+    disclosurePolicy: AssertionDisclosurePolicy;
+    applicability: Record<string, unknown>;
+    validFrom?: number;
+    validTo?: number;
+    observedAt: number;
+    recordedAt: number;
+    reviewAt?: number;
+    supersedesAssertionId?: string;
+    createdBy: AssertionCreator;
+    createdAt: number;
+}
+export interface AssertionCandidate {
+    principalId?: string;
+    subject: AssertionSubject;
+    predicate: string;
+    cardinality: AssertionCardinality;
+    scope: UserModelScope;
+    kind: AssertionKind;
+    value: unknown;
+    normalizedValue: string;
+    statement: string;
+    authority: AssertionAuthority;
+    confidence: number;
+    declaredImportance?: number;
+    inferredImportance: number;
+    consequence: AssertionConsequence;
+    actionability: number;
+    volatility: AssertionVolatility;
+    sensitivity: AssertionSensitivity;
+    disclosurePolicy: AssertionDisclosurePolicy;
+    applicability?: Record<string, unknown>;
+    validFrom?: number;
+    validTo?: number;
+    observedAt: number;
+    reviewAt?: number;
+    createdBy: AssertionCreator;
+    evidenceId?: string;
+    evidenceConfidence?: number;
+    correctionOfAssertionId?: string;
+}
+export type ReconciliationAction = 'created' | 'deduplicated' | 'superseded' | 'conflicted';
+export interface ReconciliationResult {
+    action: ReconciliationAction;
+    assertion: UserAssertion;
+    previousAssertion?: UserAssertion;
+}
+export declare function validateScope(scope: UserModelScope): void;
+export declare function validateCandidate(candidate: AssertionCandidate): void;