@xopcai/xopc 0.0.247 → 0.0.249

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

@@ -0,0 +1,197 @@
+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 InterpretationSchema = z.object({
+	intent: z.enum(USER_MODEL_CAPTURE_INTENTS),
+	candidates: z.array(CandidateSchema).max(8),
+	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 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) {
+		if (!item.selfContained || item.unresolvedReferences.length) continue;
+		if (!item.evidence.every((claim) => {
+			const source = evidenceByRef.get(claim.ref);
+			return source?.role === "user" && comparable(source.text).includes(comparable(claim.quote));
+		})) 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: [...new Set(item.evidence.map((claim) => claim.ref))]
+		});
+	}
+	const allowed = new Set(allowedTargetIds);
+	return {
+		intent: parsed.intent,
+		candidates,
+		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;

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

@@ -0,0 +1,33 @@
+//#region src/user-model/domain.ts
+const USER_MODEL_PRINCIPAL_ID = "local-owner";
+function validateScope(scope) {
+	const id = scope.id?.trim();
+	if (scope.type === "global") {
+		if (id) throw new Error("Global user-model scope must not have an id.");
+		return;
+	}
+	if (!id) throw new Error(`${scope.type} user-model scope requires an id.`);
+}
+function validateCandidate(candidate) {
+	validateScope(candidate.scope);
+	if (!candidate.subject.id.trim()) throw new Error("Assertion subject id is required.");
+	if (!candidate.predicate.trim()) throw new Error("Assertion predicate is required.");
+	if (!candidate.normalizedValue.trim()) throw new Error("Assertion normalized value is required.");
+	if (!candidate.statement.trim()) throw new Error("Assertion statement is required.");
+	if (!Number.isFinite(candidate.observedAt)) throw new Error("Assertion observedAt must be finite.");
+	for (const [field, value] of [
+		["validFrom", candidate.validFrom],
+		["validTo", candidate.validTo],
+		["reviewAt", candidate.reviewAt]
+	]) if (value !== void 0 && !Number.isFinite(value)) throw new Error(`${field} must be finite.`);
+	for (const [field, value] of [
+		["confidence", candidate.confidence],
+		["inferredImportance", candidate.inferredImportance],
+		["actionability", candidate.actionability],
+		["declaredImportance", candidate.declaredImportance],
+		["evidenceConfidence", candidate.evidenceConfidence]
+	]) if (value !== void 0 && (!Number.isFinite(value) || value < 0 || value > 1)) throw new Error(`${field} must be between 0 and 1.`);
+	if (candidate.validFrom !== void 0 && candidate.validTo !== void 0 && candidate.validTo < candidate.validFrom) throw new Error("Assertion validTo must be greater than or equal to validFrom.");
+}
+//#endregion
+export { USER_MODEL_PRINCIPAL_ID, validateCandidate, validateScope };

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

@@ -0,0 +1,58 @@
+import { type AssertionAuthority, type UserModelScope } from './domain.js';
+export type UserGoalStatus = 'proposed' | 'active' | 'paused' | 'achieved' | 'abandoned';
+export interface UserGoal {
+    id: string;
+    principalId: string;
+    status: UserGoalStatus;
+    scope: UserModelScope;
+    title: string;
+    desiredOutcome: string;
+    declaredImportance?: number;
+    confidence: number;
+    authority: AssertionAuthority;
+    targetAt?: number;
+    validFrom?: number;
+    validTo?: number;
+    reviewAt?: number;
+    createdAt: number;
+    updatedAt: number;
+}
+export interface UserPriorityWindow {
+    id: string;
+    principalId: string;
+    targetType: 'goal' | 'project' | 'task' | 'assertion' | 'topic';
+    targetId: string;
+    rank: 'primary' | 'secondary' | 'background';
+    declaredImportance?: number;
+    urgency: number;
+    scope: UserModelScope;
+    validFrom: number;
+    validTo: number;
+    reviewAt: number;
+    status: 'active' | 'paused' | 'completed' | 'expired';
+    createdAt: number;
+    updatedAt: number;
+}
+export declare function listUserGoals(principalId?: string): UserGoal[];
+export declare function createUserGoal(input: {
+    title: string;
+    desiredOutcome: string;
+    scope: UserModelScope;
+    declaredImportance?: number;
+    targetAt?: number;
+    now?: number;
+}): UserGoal;
+export declare function setUserGoalStatus(id: string, status: UserGoalStatus, now?: number): UserGoal | undefined;
+export declare function listPriorityWindows(principalId?: string): UserPriorityWindow[];
+export declare function createPriorityWindow(input: {
+    targetType: UserPriorityWindow['targetType'];
+    targetId: string;
+    rank: UserPriorityWindow['rank'];
+    urgency: number;
+    scope: UserModelScope;
+    validFrom: number;
+    validTo: number;
+    reviewAt?: number;
+    declaredImportance?: number;
+    now?: number;
+}): UserPriorityWindow;

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

@@ -0,0 +1,89 @@
+import { getSqliteDatabase, runSqliteWriteTransaction } from "../storage/sqlite/transaction.js";
+import { USER_MODEL_PRINCIPAL_ID, validateScope } from "./domain.js";
+import { randomUUID } from "node:crypto";
+//#region src/user-model/goals.ts
+function optionalNumber(value) {
+	return value === null ? void 0 : value;
+}
+function listUserGoals(principalId = USER_MODEL_PRINCIPAL_ID) {
+	return getSqliteDatabase().prepare(`SELECT g.*, r.title, r.desired_outcome
+    FROM user_goals g JOIN user_goal_revisions r ON r.revision_id = g.current_revision_id
+    WHERE g.principal_id = ? ORDER BY g.updated_at DESC`).all(principalId).map((row) => ({
+		id: row.goal_id,
+		principalId: row.principal_id,
+		status: row.status,
+		scope: {
+			type: row.scope_type,
+			...row.scope_id ? { id: row.scope_id } : {}
+		},
+		title: row.title,
+		desiredOutcome: row.desired_outcome,
+		...optionalNumber(row.declared_importance) === void 0 ? {} : { declaredImportance: row.declared_importance },
+		confidence: row.confidence,
+		authority: row.authority,
+		...optionalNumber(row.target_at) === void 0 ? {} : { targetAt: row.target_at },
+		...optionalNumber(row.valid_from) === void 0 ? {} : { validFrom: row.valid_from },
+		...optionalNumber(row.valid_to) === void 0 ? {} : { validTo: row.valid_to },
+		...optionalNumber(row.review_at) === void 0 ? {} : { reviewAt: row.review_at },
+		createdAt: row.created_at,
+		updatedAt: row.updated_at
+	}));
+}
+function createUserGoal(input) {
+	validateScope(input.scope);
+	if (!input.title.trim() || !input.desiredOutcome.trim()) throw new Error("Goal title and desired outcome are required.");
+	if (input.declaredImportance !== void 0 && (input.declaredImportance < 0 || input.declaredImportance > 1)) throw new Error("Goal declared importance must be between 0 and 1.");
+	const now = input.now ?? Date.now();
+	const goalId = randomUUID();
+	const revisionId = randomUUID();
+	runSqliteWriteTransaction((db) => {
+		db.prepare(`INSERT INTO user_goals (
+      goal_id, principal_id, status, scope_type, scope_id, declared_importance,
+      confidence, authority, target_at, current_revision_id, created_at, updated_at
+    ) VALUES (?, ?, 'active', ?, ?, ?, 1, 'user_explicit', ?, ?, ?, ?)`).run(goalId, USER_MODEL_PRINCIPAL_ID, input.scope.type, input.scope.id ?? null, input.declaredImportance ?? null, input.targetAt ?? null, revisionId, now, now);
+		db.prepare(`INSERT INTO user_goal_revisions (
+      revision_id, goal_id, title, desired_outcome, created_by, change_reason, created_at
+    ) VALUES (?, ?, ?, ?, 'user', 'Goal created by user.', ?)`).run(revisionId, goalId, input.title.trim(), input.desiredOutcome.trim(), now);
+	});
+	return listUserGoals().find((goal) => goal.id === goalId);
+}
+function setUserGoalStatus(id, status, now = Date.now()) {
+	return getSqliteDatabase().prepare(`UPDATE user_goals SET status = ?, updated_at = ? WHERE goal_id = ?`).run(status, now, id).changes ? listUserGoals().find((goal) => goal.id === id) : void 0;
+}
+function listPriorityWindows(principalId = USER_MODEL_PRINCIPAL_ID) {
+	return getSqliteDatabase().prepare(`SELECT * FROM user_priority_windows
+    WHERE principal_id = ? ORDER BY valid_from DESC`).all(principalId).map((row) => ({
+		id: row.priority_id,
+		principalId: row.principal_id,
+		targetType: row.target_type,
+		targetId: row.target_id,
+		rank: row.rank,
+		...row.declared_importance === null ? {} : { declaredImportance: row.declared_importance },
+		urgency: row.urgency,
+		scope: {
+			type: row.scope_type,
+			...row.scope_id ? { id: row.scope_id } : {}
+		},
+		validFrom: row.valid_from,
+		validTo: row.valid_to,
+		reviewAt: row.review_at,
+		status: row.status,
+		createdAt: row.created_at,
+		updatedAt: row.updated_at
+	}));
+}
+function createPriorityWindow(input) {
+	validateScope(input.scope);
+	if (!input.targetId.trim()) throw new Error("Priority target id is required.");
+	if (input.validTo < input.validFrom) throw new Error("Priority validTo must be after validFrom.");
+	for (const value of [input.urgency, input.declaredImportance]) if (value !== void 0 && (value < 0 || value > 1)) throw new Error("Priority scores must be between 0 and 1.");
+	const now = input.now ?? Date.now();
+	const id = randomUUID();
+	getSqliteDatabase().prepare(`INSERT INTO user_priority_windows (
+    priority_id, principal_id, target_type, target_id, rank, declared_importance,
+    urgency, scope_type, scope_id, valid_from, valid_to, review_at, status, created_at, updated_at
+  ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'active', ?, ?)`).run(id, USER_MODEL_PRINCIPAL_ID, input.targetType, input.targetId.trim(), input.rank, input.declaredImportance ?? null, input.urgency, input.scope.type, input.scope.id ?? null, input.validFrom, input.validTo, input.reviewAt ?? input.validTo, now, now);
+	return listPriorityWindows().find((item) => item.id === id);
+}
+//#endregion
+export { createPriorityWindow, createUserGoal, listPriorityWindows, listUserGoals, setUserGoalStatus };

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

@@ -0,0 +1,11 @@
+import type { AssertionConsequence } from './domain.js';
+export interface ExecutionValueInput {
+    declaredImportance?: number;
+    inferredImportance: number;
+    consequence: AssertionConsequence;
+    actionability: number;
+    taskRelevance: number;
+    urgency: number;
+}
+/** Ranks eligible context. Confidence is deliberately absent: it is an admission signal. */
+export declare function calculateExecutionValue(input: ExecutionValueInput): number;

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

@@ -0,0 +1,17 @@
+//#region src/user-model/importance.ts
+const CONSEQUENCE_SCORE = {
+	low: .15,
+	medium: .45,
+	high: .75,
+	critical: 1
+};
+function clamp(value) {
+	return Math.min(1, Math.max(0, value));
+}
+/** Ranks eligible context. Confidence is deliberately absent: it is an admission signal. */
+function calculateExecutionValue(input) {
+	const importance = input.declaredImportance ?? input.inferredImportance;
+	return clamp(.28 * clamp(input.taskRelevance) + .22 * clamp(importance) + .2 * CONSEQUENCE_SCORE[input.consequence] + .18 * clamp(input.actionability) + .12 * clamp(input.urgency));
+}
+//#endregion
+export { calculateExecutionValue };

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

@@ -0,0 +1,5 @@
+export * from './domain.js';
+export * from './importance.js';
+export * from './goals.js';
+export * from './repository.js';
+export * from './temporal.js';

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

@@ -0,0 +1,6 @@
+import { USER_MODEL_PRINCIPAL_ID, validateCandidate, validateScope } from "./domain.js";
+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, listUserAssertions, reconcileAssertion, setAssertionStatus } from "./repository.js";
+export { USER_MODEL_PRINCIPAL_ID, calculateExecutionValue, createPriorityWindow, createUserGoal, defaultReviewAt, getActiveAssertionByPredicate, getActiveAssertionForSlot, getAssertionSlot, getUserAssertion, getUserTimezone, isAssertionValidAt, linkAssertionEvidence, listPriorityWindows, listSlotAssertions, listUserAssertions, listUserGoals, reconcileAssertion, requiresBoundedValidity, resolveCurrentAssertion, setAssertionStatus, setUserGoalStatus, validateCandidate, validateScope };

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

@@ -0,0 +1,23 @@
+import { type AssertionCandidate, type AssertionSlot, type AssertionStatus, type ReconciliationResult, type UserAssertion } from './domain.js';
+export declare function reconcileAssertion(candidate: AssertionCandidate, now?: number): ReconciliationResult;
+export declare function getUserAssertion(id: string): UserAssertion | undefined;
+export declare function getAssertionSlot(id: string): AssertionSlot | undefined;
+export declare function listSlotAssertions(slotId: string): UserAssertion[];
+export declare function listUserAssertions(input?: {
+    principalId?: string;
+    statuses?: AssertionStatus[];
+    limit?: number;
+}): UserAssertion[];
+export declare function getActiveAssertionByPredicate(predicate: string): UserAssertion | undefined;
+export declare function getActiveAssertionForSlot(input: {
+    subject: AssertionSlot['subject'];
+    predicate: string;
+    scope: AssertionSlot['scope'];
+}): UserAssertion | undefined;
+export declare function getUserTimezone(): string | undefined;
+export declare function linkAssertionEvidence(assertionId: string, evidenceId: string, relation: 'supports' | 'contradicts' | 'supersedes', confidence: number, now?: number): void;
+export declare function setAssertionStatus(assertionId: string, status: AssertionStatus, input: {
+    actor: 'user' | 'runtime' | 'maintenance' | 'migration';
+    reason: string;
+    now?: number;
+}): UserAssertion;