@xopcai/xopc 0.0.247 → 0.0.249

package/dist/src/user-context/sources/activity-clustering.d.ts

@@ -1,5 +1,11 @@
-import type { UnderstandingSourceItem, UserFocus } from './types.js';
-export type ActivityTopic = Pick<UserFocus, 'canonicalKey' | 'title' | 'summary' | 'horizon' | 'confidence' | 'evidenceRefs'> & {
+import type { UnderstandingSourceItem } from './types.js';
+export interface ActivityTopic {
+    canonicalKey: string;
+    title: string;
+    summary: string;
+    horizon: 'current' | 'ongoing' | 'long_term';
+    confidence: number;
+    evidenceRefs: string[];
     sourceIds: string[];
-};
+}
 export declare function clusterActivityTopics(items: UnderstandingSourceItem[], now?: number): ActivityTopic[];

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

@@ -1,4 +1,4 @@
-import { createUnderstandingSourceRun, deleteUserFocus, getUnderstandingSourceGrant, getUnderstandingSourceRun, getUserFocus, listUnderstandingSourceGrants, listUnderstandingSourceRuns, listUserFocusEvidence, listUserFocuses, revokeUnderstandingSourceGrant, updateUnderstandingSourceGrantCheckpoint, updateUnderstandingSourceGrantPolicies, updateUnderstandingSourceRun, updateUserFocus, upsertUnderstandingSourceGrant, upsertUserFocus } from "./repository.js";
+import { createUnderstandingSourceRun, getUnderstandingSourceGrant, getUnderstandingSourceRun, listUnderstandingSourceGrants, listUnderstandingSourceRuns, revokeUnderstandingSourceGrant, updateUnderstandingSourceGrantCheckpoint, updateUnderstandingSourceGrantPolicies, updateUnderstandingSourceRun, upsertUnderstandingSourceGrant } from "./repository.js";
 import { clusterUnderstandingSignals, tokenizeUnderstandingSignal } from "./signal-clustering.js";
 import { listUnderstandingSourceDefinitions } from "./catalog.js";
-export { clusterUnderstandingSignals, createUnderstandingSourceRun, deleteUserFocus, getUnderstandingSourceGrant, getUnderstandingSourceRun, getUserFocus, listUnderstandingSourceDefinitions, listUnderstandingSourceGrants, listUnderstandingSourceRuns, listUserFocusEvidence, listUserFocuses, revokeUnderstandingSourceGrant, tokenizeUnderstandingSignal, updateUnderstandingSourceGrantCheckpoint, updateUnderstandingSourceGrantPolicies, updateUnderstandingSourceRun, updateUserFocus, upsertUnderstandingSourceGrant, upsertUserFocus };
+export { clusterUnderstandingSignals, createUnderstandingSourceRun, getUnderstandingSourceGrant, getUnderstandingSourceRun, listUnderstandingSourceDefinitions, listUnderstandingSourceGrants, listUnderstandingSourceRuns, revokeUnderstandingSourceGrant, tokenizeUnderstandingSignal, updateUnderstandingSourceGrantCheckpoint, updateUnderstandingSourceGrantPolicies, updateUnderstandingSourceRun, upsertUnderstandingSourceGrant };

package/dist/src/user-context/sources/repository.d.ts

@@ -1,18 +1,4 @@
-import { type ContextEvidence, type UserContextScope } from '../domain.js';
-import type { UnderstandingSourceGrant, UnderstandingSourceRun, UserFocus } from './types.js';
-type UserFocusInput = Omit<UserFocus, 'id' | 'versionId' | 'principalId' | 'scope' | 'explicitness' | 'sensitivity' | 'disclosurePolicy' | 'validFrom' | 'validTo' | 'reviewAt' | 'createdAt' | 'updatedAt'> & {
-    principalId?: string;
-    scope?: UserContextScope;
-    explicitness?: UserFocus['explicitness'];
-    sensitivity?: UserFocus['sensitivity'];
-    disclosurePolicy?: UserFocus['disclosurePolicy'];
-    validFrom?: number;
-    validTo?: number;
-    reviewAt?: number;
-    changeReason?: string;
-    nowMs?: number;
-};
-export declare function listUserFocusEvidence(focusId: string): ContextEvidence[];
+import type { UnderstandingSourceGrant, UnderstandingSourceRun } from './types.js';
 export declare function listUnderstandingSourceGrants(options?: {
     includeRevoked?: boolean;
 }): UnderstandingSourceGrant[];
@@ -53,9 +39,3 @@ export declare function updateUnderstandingSourceRun(id: string, patch: {
     completed?: boolean;
     nowMs?: number;
 }): UnderstandingSourceRun | null;
-export declare function upsertUserFocus(input: UserFocusInput): UserFocus;
-export declare function listUserFocuses(statuses?: UserFocus['status'][], limit?: number): UserFocus[];
-export declare function getUserFocus(id: string): UserFocus | undefined;
-export declare function updateUserFocus(id: string, patch: Partial<Pick<UserFocus, 'title' | 'summary' | 'status' | 'validFrom' | 'validTo' | 'reviewAt'>>, nowMs?: number): UserFocus | null;
-export declare function deleteUserFocus(id: string): boolean;
-export {};

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

@@ -1,7 +1,5 @@
 import { getSqliteDatabase, runSqliteWriteTransaction } from "../../storage/sqlite/transaction.js";
-import { USER_CONTEXT_PRINCIPAL_ID } from "../domain.js";
 import { notifyUserContextChange } from "../changes.js";
-import { focusLifecycle } from "../focus-lifecycle.js";
 import { randomUUID } from "node:crypto";
 //#region src/user-context/sources/repository.ts
 function record(value) {
@@ -11,14 +9,6 @@ function record(value) {
 		return {};
 	}
 }
-function strings(value) {
-	try {
-		const parsed = JSON.parse(value);
-		return Array.isArray(parsed) ? parsed.filter((item) => typeof item === "string") : [];
-	} catch {
-		return [];
-	}
-}
 function grantFromRow(row) {
 	return {
 		id: row.grant_id,
@@ -53,85 +43,6 @@ function runFromRow(row) {
 		...row.completed_at == null ? {} : { completedAt: row.completed_at }
 	};
 }
-function focusFromRow(row) {
-	return {
-		id: row.focus_id,
-		versionId: row.current_version_id,
-		principalId: row.principal_id,
-		canonicalKey: row.canonical_key,
-		title: row.title,
-		summary: row.summary,
-		horizon: row.horizon,
-		status: row.status,
-		confidence: row.confidence,
-		scope: {
-			type: row.scope_type,
-			...row.scope_id ? { id: row.scope_id } : {}
-		},
-		explicitness: row.explicitness,
-		sensitivity: row.sensitivity,
-		disclosurePolicy: row.disclosure_policy,
-		...row.valid_from == null ? {} : { validFrom: row.valid_from },
-		...row.valid_to == null ? {} : { validTo: row.valid_to },
-		...row.review_at == null ? {} : { reviewAt: row.review_at },
-		evidenceRefs: strings(row.evidence_refs_json),
-		...row.source_run_id ? { sourceRunId: row.source_run_id } : {},
-		createdAt: row.created_at,
-		updatedAt: row.updated_at
-	};
-}
-function focusSnapshot(row) {
-	return {
-		horizon: row.horizon,
-		status: row.status,
-		confidence: row.confidence,
-		scopeType: row.scope_type,
-		scopeId: row.scope_id,
-		explicitness: row.explicitness,
-		sensitivity: row.sensitivity,
-		disclosurePolicy: row.disclosure_policy,
-		validFrom: row.valid_from,
-		validTo: row.valid_to,
-		reviewAt: row.review_at,
-		evidenceRefs: strings(row.evidence_refs_json)
-	};
-}
-function sameFocusVersion(left, right) {
-	return Boolean(left && left.title === right.title && left.summary === right.summary && JSON.stringify(focusSnapshot(left)) === JSON.stringify(focusSnapshot(right)));
-}
-function linkFocusEvidence(versionId, evidenceRefs, confidence) {
-	if (!evidenceRefs.length) return;
-	const placeholders = evidenceRefs.map(() => "?").join(", ");
-	getSqliteDatabase().prepare(`INSERT OR IGNORE INTO user_focus_evidence_links (
-    version_id, evidence_id, relation, confidence
-  ) SELECT ?, evidence_id, 'supports', ? FROM context_evidence WHERE source_ref IN (${placeholders})`).run(versionId, confidence, ...evidenceRefs);
-}
-function listUserFocusEvidence(focusId) {
-	return getSqliteDatabase().prepare(`SELECT DISTINCT e.* FROM context_evidence e
-    JOIN user_focus_evidence_links l ON l.evidence_id = e.evidence_id
-    JOIN user_focus_versions v ON v.version_id = l.version_id
-    WHERE v.focus_id = ? ORDER BY e.observed_at DESC`).all(focusId).map((row) => ({
-		id: row.evidence_id,
-		sourceType: row.source_type,
-		...row.source_instance_id ? { sourceInstanceId: row.source_instance_id } : {},
-		sourceRef: row.source_ref,
-		...row.source_run_id ? { sourceRunId: row.source_run_id } : {},
-		...row.source_item_id ? { sourceItemId: row.source_item_id } : {},
-		...row.session_id ? { sessionId: row.session_id } : {},
-		...row.turn_id ? { turnId: row.turn_id } : {},
-		...row.message_id ? { messageId: row.message_id } : {},
-		...row.content_hash ? { contentHash: row.content_hash } : {},
-		...row.retention_policy ? { retentionPolicy: row.retention_policy } : {},
-		...row.processing_policy ? { processingPolicy: row.processing_policy } : {},
-		...row.extractor_id ? { extractorId: row.extractor_id } : {},
-		...row.extractor_version ? { extractorVersion: row.extractor_version } : {},
-		...row.redacted_excerpt ? { redactedExcerpt: row.redacted_excerpt } : {},
-		trustLevel: row.trust_level,
-		observedAt: row.observed_at,
-		ingestedAt: row.ingested_at ?? row.created_at,
-		createdAt: row.created_at
-	}));
-}
 function listUnderstandingSourceGrants(options = {}) {
 	return getSqliteDatabase().prepare(`SELECT * FROM understanding_source_grants ${options.includeRevoked ? "" : "WHERE status = 'active'"} ORDER BY updated_at DESC`).all().map(grantFromRow);
 }
@@ -213,98 +124,5 @@ function updateUnderstandingSourceRun(id, patch) {
   `).run(patch.status ?? current.status, patch.cursorAfter ?? current.cursorAfter ?? null, patch.itemsSeen ?? current.itemsSeen, JSON.stringify(patch.metadata ?? current.metadata), patch.errorMessage ?? current.errorMessage ?? null, completedAt, id));
 	return getUnderstandingSourceRun(id);
 }
-function upsertUserFocus(input) {
-	const id = randomUUID();
-	const now = input.nowMs ?? Date.now();
-	const scope = input.scope ?? { type: "global" };
-	const explicitness = input.explicitness ?? "inferred";
-	const sensitivity = input.sensitivity ?? "normal";
-	const disclosurePolicy = input.disclosurePolicy ?? "referenceable";
-	const existingRow = getSqliteDatabase().prepare("SELECT * FROM user_focuses WHERE canonical_key = ?").get(input.canonicalKey);
-	if (existingRow?.explicitness === "explicit" && explicitness !== "explicit") return focusFromRow(existingRow);
-	if (existingRow) notifyUserContextChange({
-		kind: "focus",
-		id: existingRow.focus_id
-	});
-	let currentVersionId = existingRow?.current_version_id;
-	runSqliteWriteTransaction((db) => {
-		db.prepare(`
-    INSERT INTO user_focuses (
-      focus_id, principal_id, canonical_key, title, summary, horizon, status, confidence,
-      scope_type, scope_id, explicitness, sensitivity, disclosure_policy,
-      valid_from, valid_to, review_at, evidence_refs_json, source_run_id, created_at, updated_at
-    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-    ON CONFLICT(canonical_key) DO UPDATE SET title = excluded.title, summary = excluded.summary,
-      horizon = excluded.horizon,
-      status = CASE
-        WHEN user_focuses.status IN ('active', 'paused', 'completed', 'rejected') AND excluded.status = 'candidate'
-          THEN user_focuses.status
-        ELSE excluded.status
-      END,
-      confidence = excluded.confidence,
-      scope_type = excluded.scope_type, scope_id = excluded.scope_id,
-      explicitness = excluded.explicitness, sensitivity = excluded.sensitivity,
-      disclosure_policy = excluded.disclosure_policy, valid_from = excluded.valid_from,
-      valid_to = excluded.valid_to, review_at = excluded.review_at,
-      evidence_refs_json = excluded.evidence_refs_json,
-      source_run_id = excluded.source_run_id, updated_at = excluded.updated_at
-  `).run(id, input.principalId ?? "local-owner", input.canonicalKey, input.title, input.summary, input.horizon, input.status, input.confidence, scope.type, scope.id ?? null, explicitness, sensitivity, disclosurePolicy, input.validFrom ?? null, input.validTo ?? null, input.reviewAt ?? null, JSON.stringify(input.evidenceRefs), input.sourceRunId ?? null, now, now);
-		const nextRow = db.prepare("SELECT * FROM user_focuses WHERE canonical_key = ?").get(input.canonicalKey);
-		if (!sameFocusVersion(existingRow, nextRow)) {
-			currentVersionId = randomUUID();
-			db.prepare(`INSERT INTO user_focus_versions (
-        version_id, focus_id, title, summary, snapshot_json, created_by, change_reason, created_at
-      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(currentVersionId, nextRow.focus_id, nextRow.title, nextRow.summary, JSON.stringify(focusSnapshot(nextRow)), explicitness === "explicit" ? "user" : input.sourceRunId ? "connector" : "runtime", input.changeReason ?? (existingRow ? "Focus updated" : "Focus created"), now);
-			db.prepare("UPDATE user_focuses SET current_version_id = ? WHERE focus_id = ?").run(currentVersionId, nextRow.focus_id);
-		}
-	});
-	if (currentVersionId) linkFocusEvidence(currentVersionId, input.evidenceRefs, input.confidence);
-	return focusFromRow(getSqliteDatabase().prepare("SELECT * FROM user_focuses WHERE canonical_key = ?").get(input.canonicalKey));
-}
-function listUserFocuses(statuses, limit) {
-	const maxRows = limit === void 0 ? -1 : Math.max(1, Math.min(200, Math.floor(limit)));
-	if (!statuses?.length) return getSqliteDatabase().prepare("SELECT * FROM user_focuses ORDER BY updated_at DESC LIMIT ?").all(maxRows).map(focusFromRow);
-	const placeholders = statuses.map(() => "?").join(", ");
-	return getSqliteDatabase().prepare(`SELECT * FROM user_focuses WHERE status IN (${placeholders}) ORDER BY updated_at DESC LIMIT ?`).all(...statuses, maxRows).map(focusFromRow);
-}
-function getUserFocus(id) {
-	const row = getSqliteDatabase().prepare("SELECT * FROM user_focuses WHERE focus_id = ? AND principal_id = ?").get(id, USER_CONTEXT_PRINCIPAL_ID);
-	return row ? focusFromRow(row) : void 0;
-}
-function updateUserFocus(id, patch, nowMs = Date.now()) {
-	notifyUserContextChange({
-		kind: "focus",
-		id
-	});
-	const currentRow = getSqliteDatabase().prepare("SELECT * FROM user_focuses WHERE focus_id = ?").get(id);
-	if (!currentRow) return null;
-	const current = focusFromRow(currentRow);
-	const renewedLifecycle = patch.status === "active" && (current.status !== "active" || current.reviewAt !== void 0 && current.reviewAt <= nowMs || current.validTo !== void 0 && current.validTo <= nowMs) ? focusLifecycle(current.horizon, nowMs) : {};
-	const nextValidFrom = patch.validFrom ?? renewedLifecycle.validFrom ?? current.validFrom;
-	const nextValidTo = patch.validTo ?? renewedLifecycle.validTo ?? current.validTo;
-	const nextReviewAt = patch.reviewAt ?? renewedLifecycle.reviewAt ?? current.reviewAt;
-	if ((patch.title ?? current.title) === current.title && (patch.summary ?? current.summary) === current.summary && (patch.status ?? current.status) === current.status && nextValidFrom === current.validFrom && nextValidTo === current.validTo && nextReviewAt === current.reviewAt) return current;
-	const versionId = randomUUID();
-	runSqliteWriteTransaction((db) => {
-		db.prepare(`UPDATE user_focuses
-      SET title = ?, summary = ?, status = ?, valid_from = ?, valid_to = ?, review_at = ?, updated_at = ?
-      WHERE focus_id = ?`).run(patch.title ?? current.title, patch.summary ?? current.summary, patch.status ?? current.status, nextValidFrom ?? null, nextValidTo ?? null, nextReviewAt ?? null, nowMs, id);
-		const nextRow = db.prepare("SELECT * FROM user_focuses WHERE focus_id = ?").get(id);
-		db.prepare(`INSERT INTO user_focus_versions (
-      version_id, focus_id, title, summary, snapshot_json, created_by, change_reason, created_at
-    ) VALUES (?, ?, ?, ?, ?, ?, 'Focus updated', ?)`).run(versionId, id, nextRow.title, nextRow.summary, JSON.stringify(focusSnapshot(nextRow)), current.explicitness === "explicit" ? "user" : "runtime", nowMs);
-		db.prepare("UPDATE user_focuses SET current_version_id = ? WHERE focus_id = ?").run(versionId, id);
-	});
-	linkFocusEvidence(versionId, current.evidenceRefs, current.confidence);
-	const row = getSqliteDatabase().prepare("SELECT * FROM user_focuses WHERE focus_id = ?").get(id);
-	return row ? focusFromRow(row) : null;
-}
-function deleteUserFocus(id) {
-	notifyUserContextChange({
-		kind: "focus",
-		id
-	});
-	return Number(getSqliteDatabase().prepare("DELETE FROM user_focuses WHERE focus_id = ?").run(id).changes) > 0;
-}
 //#endregion
-export { createUnderstandingSourceRun, deleteUserFocus, getUnderstandingSourceGrant, getUnderstandingSourceRun, getUserFocus, listUnderstandingSourceGrants, listUnderstandingSourceRuns, listUserFocusEvidence, listUserFocuses, revokeUnderstandingSourceGrant, updateUnderstandingSourceGrantCheckpoint, updateUnderstandingSourceGrantPolicies, updateUnderstandingSourceRun, updateUserFocus, upsertUnderstandingSourceGrant, upsertUserFocus };
+export { createUnderstandingSourceRun, getUnderstandingSourceGrant, getUnderstandingSourceRun, listUnderstandingSourceGrants, listUnderstandingSourceRuns, revokeUnderstandingSourceGrant, updateUnderstandingSourceGrantCheckpoint, updateUnderstandingSourceGrantPolicies, updateUnderstandingSourceRun, upsertUnderstandingSourceGrant };

package/dist/src/user-context/sources/types.d.ts

@@ -1,4 +1,3 @@
-import type { UserContextScope, UserUnderstanding } from '../domain.js';
 export type UnderstandingSourcePlatform = 'darwin' | 'win32' | 'linux' | 'all';
 export type UnderstandingSourceCategory = 'files' | 'recent_documents' | 'calendar' | 'tasks' | 'notes' | 'mail' | 'messages' | 'code_activity';
 export type UnderstandingSourceAccessMode = 'once' | 'continuous';
@@ -74,25 +73,3 @@ export interface UnderstandingSourceRun {
     startedAt: number;
     completedAt?: number;
 }
-export interface UserFocus {
-    id: string;
-    versionId: string;
-    principalId: string;
-    canonicalKey: string;
-    title: string;
-    summary: string;
-    horizon: 'current' | 'ongoing' | 'long_term';
-    status: 'candidate' | 'active' | 'paused' | 'completed' | 'rejected';
-    confidence: number;
-    scope: UserContextScope;
-    explicitness: UserUnderstanding['explicitness'];
-    sensitivity: UserUnderstanding['sensitivity'];
-    disclosurePolicy: UserUnderstanding['disclosurePolicy'];
-    validFrom?: number;
-    validTo?: number;
-    reviewAt?: number;
-    evidenceRefs: string[];
-    sourceRunId?: string;
-    createdAt: number;
-    updatedAt: number;
-}

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

@@ -0,0 +1,40 @@
+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;
+    }>;
+    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,134 @@
+import { createContextEvidence } from "../../storage/sqlite/context-evidence-repository.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: [],
+		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;
+	}
+	if (!input.interpretation.candidates.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))) {
+		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);
+	}
+	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 = !(input.interpretation.intent === "remember" || input.interpretation.intent === "correct") && (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;
+	}
+	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,21 @@
+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 UserModelInterpretation {
+    intent: UserModelCaptureIntent;
+    candidates: ParsedAssertionCandidate[];
+    targetAssertionIds: string[];
+    abstentionReason?: string;
+}
+export declare function parseUserModelInterpretation(raw: string, evidence: CaptureEvidence[], allowedTargetIds?: string[]): UserModelInterpretation | null;