@xopcai/xopc 0.0.248 → 0.0.249

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

@@ -1,187 +0,0 @@
-import { finishContextConsolidationRun, recordContextConsolidationDecision, startContextConsolidationRun } from "../storage/sqlite/context-consolidation-repository.js";
-import { createUnderstanding, linkUnderstandingEvidence, listUnderstandingEvidence, listUnderstandings, setUnderstandingStatus } from "../storage/sqlite/user-context-repository.js";
-import "../storage/sqlite/index.js";
-//#region src/user-context/consolidation.ts
-const USER_CONTEXT_CONSOLIDATION_TOKEN = "__xopc_user_context_consolidation__";
-const USER_CONTEXT_CONSOLIDATION_AUTOMATION_ID = "system-user-context-consolidation";
-const GLOBAL_CANDIDATE_KINDS = new Set(["preference", "routine"]);
-function stricterSensitivity(items) {
-	const order = [
-		"normal",
-		"personal",
-		"secret",
-		"regulated"
-	];
-	return order[Math.max(...items.map((item) => order.indexOf(item.sensitivity)))] ?? "personal";
-}
-function stricterDisclosurePolicy(items) {
-	if (items.some((item) => item.disclosurePolicy === "silent")) return "silent";
-	if (items.some((item) => item.disclosurePolicy === "ask_before_reference")) return "ask_before_reference";
-	return "referenceable";
-}
-function createCrossProjectGlobalCandidates(minProjects) {
-	const all = listUnderstandings();
-	const existingGlobalKeys = new Set(all.filter((item) => item.scope.type === "global" && item.status !== "archived" && item.status !== "rejected").map((item) => item.canonicalKey));
-	const groups = /* @__PURE__ */ new Map();
-	for (const item of all) {
-		if (item.status !== "active" || item.scope.type !== "project" || !item.scope.id || !GLOBAL_CANDIDATE_KINDS.has(item.kind)) continue;
-		const normalizedStatement = item.statement.normalize("NFKC").toLocaleLowerCase().replace(/\s+/g, " ").trim();
-		const groupKey = `${item.canonicalKey}\u0000${normalizedStatement}`;
-		const group = groups.get(groupKey) ?? [];
-		group.push(item);
-		groups.set(groupKey, group);
-	}
-	let created = 0;
-	for (const items of groups.values()) {
-		const canonicalKey = items[0].canonicalKey;
-		const projectCount = new Set(items.map((item) => item.scope.id)).size;
-		if (projectCount < Math.max(2, minProjects) || existingGlobalKeys.has(canonicalKey)) continue;
-		const exemplar = [...items].sort((left, right) => right.confidence - left.confidence)[0];
-		const global = createUnderstanding({
-			kind: exemplar.kind,
-			canonicalKey,
-			status: "candidate",
-			scope: { type: "global" },
-			explicitness: "inferred",
-			durability: exemplar.durability,
-			sensitivity: stricterSensitivity(items),
-			disclosurePolicy: stricterDisclosurePolicy(items),
-			confidence: items.reduce((sum, item) => sum + item.confidence, 0) / items.length,
-			statement: exemplar.statement,
-			createdBy: "consolidation",
-			changeReason: `Repeated across ${projectCount} projects`
-		});
-		const linked = /* @__PURE__ */ new Set();
-		for (const item of items) for (const evidence of listUnderstandingEvidence(item.id, "supports")) {
-			if (linked.has(evidence.id)) continue;
-			linkUnderstandingEvidence(global.versionId, evidence.id, "supports", item.confidence);
-			linked.add(evidence.id);
-		}
-		existingGlobalKeys.add(canonicalKey);
-		created += 1;
-	}
-	return created;
-}
-function distinctEvidenceCount(understandingId, relation) {
-	return new Set(listUnderstandingEvidence(understandingId, relation).map((evidence) => `${evidence.sourceType}:${evidence.sourceInstanceId ?? ""}:${evidence.sourceRef}`)).size;
-}
-function resolveContextConsolidationConfig(config) {
-	const dreaming = config.userContext.dreaming;
-	return {
-		enabled: config.userContext.enabled && dreaming.mode === "review",
-		timezone: dreaming.timezone ?? Intl.DateTimeFormat().resolvedOptions().timeZone ?? "UTC",
-		time: dreaming.schedule.time,
-		minEvidenceSources: dreaming.minEvidenceSources,
-		limit: dreaming.limit
-	};
-}
-function compileContextConsolidationCron(time) {
-	const [hour, minute] = time.split(":").map(Number);
-	return `${minute} ${hour} * * *`;
-}
-async function runContextConsolidation(input) {
-	const resolved = resolveContextConsolidationConfig(input.config);
-	if (input.triggerKind === "schedule" && !resolved.enabled) throw new Error("User context consolidation is off");
-	const now = input.now ?? Date.now();
-	const run = startContextConsolidationRun(input.triggerKind, now);
-	const metrics = {
-		scanned: 0,
-		needsReview: 0,
-		stale: 0,
-		globalCandidates: 0
-	};
-	try {
-		const understandings = listUnderstandings(["candidate", "active"]).slice(0, resolved.limit);
-		for (const understanding of understandings) {
-			metrics.scanned += 1;
-			const evidenceCount = distinctEvidenceCount(understanding.id, "supports");
-			const contradictionCount = distinctEvidenceCount(understanding.id, "contradicts");
-			if (understanding.validTo != null && understanding.validTo <= now || understanding.expiresAt != null && understanding.expiresAt <= now) {
-				setUnderstandingStatus(understanding.id, "stale", {
-					actorType: "runtime",
-					source: "consolidation-expired"
-				});
-				recordContextConsolidationDecision({
-					runId: run.runId,
-					understandingId: understanding.id,
-					action: "stale",
-					reasonCode: "validity_expired",
-					evidenceCount,
-					now
-				});
-				metrics.stale += 1;
-				continue;
-			}
-			if (contradictionCount > 0) {
-				setUnderstandingStatus(understanding.id, "needs_review", {
-					actorType: "runtime",
-					source: "consolidation-contradiction"
-				});
-				recordContextConsolidationDecision({
-					runId: run.runId,
-					understandingId: understanding.id,
-					action: "needs_review",
-					reasonCode: "contradictory_evidence",
-					evidenceCount: contradictionCount,
-					now
-				});
-				metrics.needsReview += 1;
-				continue;
-			}
-			if (understanding.status === "active" && understanding.reviewAt != null && understanding.reviewAt <= now) {
-				setUnderstandingStatus(understanding.id, "needs_review", {
-					actorType: "runtime",
-					source: "consolidation-review-due"
-				});
-				recordContextConsolidationDecision({
-					runId: run.runId,
-					understandingId: understanding.id,
-					action: "needs_review",
-					reasonCode: "review_due",
-					evidenceCount,
-					now
-				});
-				metrics.needsReview += 1;
-				continue;
-			}
-			if (understanding.status === "candidate" && evidenceCount >= resolved.minEvidenceSources) {
-				setUnderstandingStatus(understanding.id, "needs_review", {
-					actorType: "runtime",
-					source: "consolidation-evidence-threshold"
-				});
-				recordContextConsolidationDecision({
-					runId: run.runId,
-					understandingId: understanding.id,
-					action: "needs_review",
-					reasonCode: "independent_evidence_threshold",
-					evidenceCount,
-					now
-				});
-				metrics.needsReview += 1;
-			}
-		}
-		metrics.globalCandidates = createCrossProjectGlobalCandidates(resolved.minEvidenceSources);
-		return {
-			run: finishContextConsolidationRun({
-				runId: run.runId,
-				ok: true,
-				reason: "completed",
-				metrics,
-				now
-			}) ?? run,
-			metrics
-		};
-	} catch (error) {
-		const reason = error instanceof Error ? error.message : String(error);
-		finishContextConsolidationRun({
-			runId: run.runId,
-			ok: false,
-			reason,
-			metrics,
-			now
-		});
-		throw error;
-	}
-}
-//#endregion
-export { USER_CONTEXT_CONSOLIDATION_AUTOMATION_ID, USER_CONTEXT_CONSOLIDATION_TOKEN, compileContextConsolidationCron, resolveContextConsolidationConfig, runContextConsolidation };

package/dist/src/user-context/context-objects.d.ts

@@ -1,17 +0,0 @@
-import type { ContextEvidence, UserContextScope } from './domain.js';
-export type ContextObjectView = 'current' | 'review' | 'history';
-export type ContextObjectOrigin = 'told_by_user' | 'observed' | 'inferred' | 'connected_source';
-export type ContextObject = {
-    objectType: 'profile' | 'rule' | 'focus' | 'understanding';
-    objectId: string;
-    status: string;
-    content: string;
-    scope: UserContextScope;
-    origin: ContextObjectOrigin;
-    confidence: number;
-    evidence: ContextEvidence[] | Array<{
-        sourceRef: string;
-    }>;
-    updatedAt: number;
-};
-export declare function listContextObjects(view: ContextObjectView): ContextObject[];

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

@@ -1,99 +0,0 @@
-import { getUserProfile, listCollaborationRules, listUnderstandingEvidence, listUnderstandings } from "../storage/sqlite/user-context-repository.js";
-import "../storage/sqlite/index.js";
-import { getUnderstandingSourceGrant, getUnderstandingSourceRun, listUserFocusEvidence, listUserFocuses } from "./sources/repository.js";
-//#region src/user-context/context-objects.ts
-function understandingOrigin(item, evidence) {
-	if (item.explicitness === "explicit") return "told_by_user";
-	if (evidence.some((entry) => entry.sourceType === "connector")) return "connected_source";
-	return item.explicitness === "observed" ? "observed" : "inferred";
-}
-function includesStatus(view, objectType, status) {
-	if (view === "current") return status === "active";
-	if (view === "review") return objectType === "understanding" ? [
-		"candidate",
-		"needs_review",
-		"stale"
-	].includes(status) : objectType === "focus" && status === "candidate";
-	return objectType === "understanding" ? ["archived", "rejected"].includes(status) : objectType === "focus" ? [
-		"paused",
-		"completed",
-		"rejected"
-	].includes(status) : objectType === "rule" && ["disabled", "archived"].includes(status);
-}
-function listContextObjects(view) {
-	const objects = [];
-	if (view === "current") {
-		const profile = getUserProfile();
-		const fields = [
-			["callName", profile.callName],
-			["role", profile.role],
-			["primaryGoal", profile.primaryGoal],
-			["pronouns", profile.pronouns],
-			["timezone", profile.timezone],
-			["locale", profile.locale]
-		];
-		for (const [field, value] of fields) {
-			if (!value) continue;
-			objects.push({
-				objectType: "profile",
-				objectId: field,
-				status: "active",
-				content: value,
-				scope: { type: "global" },
-				origin: "told_by_user",
-				confidence: 1,
-				evidence: [{ sourceRef: `user-profile://${field}` }],
-				updatedAt: profile.updatedAt
-			});
-		}
-	}
-	for (const rule of listCollaborationRules()) {
-		if (!includesStatus(view, "rule", rule.status)) continue;
-		objects.push({
-			objectType: "rule",
-			objectId: rule.id,
-			status: rule.status,
-			content: rule.statement,
-			scope: rule.scope,
-			origin: "told_by_user",
-			confidence: 1,
-			evidence: [{ sourceRef: `collaboration-rule://${rule.revisionId}` }],
-			updatedAt: rule.updatedAt
-		});
-	}
-	for (const focus of listUserFocuses()) {
-		if (!includesStatus(view, "focus", focus.status)) continue;
-		const sourceRun = focus.sourceRunId ? getUnderstandingSourceRun(focus.sourceRunId) : null;
-		const sourceGrant = sourceRun ? getUnderstandingSourceGrant(sourceRun.grantId) : null;
-		const linkedEvidence = listUserFocusEvidence(focus.id);
-		objects.push({
-			objectType: "focus",
-			objectId: focus.id,
-			status: focus.status,
-			content: `${focus.title}: ${focus.summary}`,
-			scope: focus.scope,
-			origin: focus.explicitness === "explicit" ? "told_by_user" : sourceGrant?.adapterId.startsWith("connector:") ? "connected_source" : focus.explicitness === "observed" ? "observed" : "inferred",
-			confidence: focus.confidence,
-			evidence: linkedEvidence.length ? linkedEvidence : focus.evidenceRefs.map((sourceRef) => ({ sourceRef })),
-			updatedAt: focus.updatedAt
-		});
-	}
-	for (const understanding of listUnderstandings()) {
-		if (!includesStatus(view, "understanding", understanding.status)) continue;
-		const evidence = listUnderstandingEvidence(understanding.id);
-		objects.push({
-			objectType: "understanding",
-			objectId: understanding.id,
-			status: understanding.status,
-			content: understanding.statement,
-			scope: understanding.scope,
-			origin: understandingOrigin(understanding, evidence),
-			confidence: understanding.confidence,
-			evidence,
-			updatedAt: understanding.updatedAt
-		});
-	}
-	return objects.sort((left, right) => right.updatedAt - left.updatedAt);
-}
-//#endregion
-export { listContextObjects };

package/dist/src/user-context/evaluation/harness.d.ts

@@ -1,13 +0,0 @@
-export type RetrievalEvaluationCase = {
-    id: string;
-    expectedIds: string[];
-    shouldAbstain?: boolean;
-    retrieve: () => string[];
-};
-export type RetrievalEvaluationMetrics = {
-    cases: number;
-    recallAtK: number;
-    precisionAtK: number;
-    abstentionAccuracy: number;
-};
-export declare function evaluateRetrievalCases(cases: RetrievalEvaluationCase[], k?: number): RetrievalEvaluationMetrics;

package/dist/src/user-context/evaluation/harness.js

@@ -1,31 +0,0 @@
-//#region src/user-context/evaluation/harness.ts
-function evaluateRetrievalCases(cases, k = 3) {
-	let expected = 0;
-	let recalled = 0;
-	let returned = 0;
-	let relevantReturned = 0;
-	let abstentionCases = 0;
-	let correctAbstentions = 0;
-	for (const item of cases) {
-		const results = [...new Set(item.retrieve())].slice(0, Math.max(1, k));
-		const expectedIds = new Set(item.expectedIds);
-		if (item.shouldAbstain) {
-			abstentionCases += 1;
-			if (results.length === 0) correctAbstentions += 1;
-			continue;
-		}
-		expected += expectedIds.size;
-		returned += results.length;
-		const matches = results.filter((id) => expectedIds.has(id)).length;
-		recalled += matches;
-		relevantReturned += matches;
-	}
-	return {
-		cases: cases.length,
-		recallAtK: expected ? recalled / expected : 1,
-		precisionAtK: returned ? relevantReturned / returned : 1,
-		abstentionAccuracy: abstentionCases ? correctAbstentions / abstentionCases : 1
-	};
-}
-//#endregion
-export { evaluateRetrievalCases };

package/dist/src/user-context/extraction/executor.d.ts

@@ -1,22 +0,0 @@
-import type { Config } from '../../config/schema.js';
-import type { MemoryManager } from '../../agent/memory/manager.js';
-import type { UnderstandingReviewResult } from '../../agent/memory/understanding/types.js';
-import { type ExtractorId } from './registry.js';
-import type { SemanticEvidence, SemanticUnderstandingInterpretation } from './semantic.js';
-export type UnderstandingEvidenceMessage = SemanticEvidence & {
-    createdAt: number;
-    message: unknown;
-};
-export declare function emptyUnderstandingReview(): UnderstandingReviewResult;
-export declare function executeUnderstandingInterpretation(params: {
-    interpretation: SemanticUnderstandingInterpretation;
-    evidence: UnderstandingEvidenceMessage[];
-    extractionRunId: string;
-    extractorId: ExtractorId;
-    sessionKey: string;
-    turnId?: string;
-    memoryManager: MemoryManager;
-    getConfig: () => Config | undefined;
-    reviewSource: 'turn' | 'background';
-    processingPolicy: 'local_only' | 'remote_allowed';
-}): Promise<UnderstandingReviewResult>;

package/dist/src/user-context/extraction/executor.js

@@ -1,142 +0,0 @@
-import { createContextEvidence, getTurnPersonalization, getUnderstanding, recordContextFeedback, rejectUnderstanding, setUnderstandingStatus } from "../../storage/sqlite/user-context-repository.js";
-import { getSessionMetadata } from "../../storage/sqlite/session-repository.js";
-import "../../storage/sqlite/index.js";
-import { extractionInputHash } from "./registry.js";
-//#region src/user-context/extraction/executor.ts
-function emptyUnderstandingReview() {
-	return {
-		proposed: 0,
-		created: 0,
-		deduplicated: 0,
-		rejected: 0,
-		createdRecords: [],
-		writeOutputs: []
-	};
-}
-function resolveWritePolicy(config) {
-	const memory = config?.userContext.memory;
-	if (!memory || memory.mode === "off" || memory.mode === "readOnly") return "deny";
-	return memory.writePolicy?.understanding ?? (memory.mode === "auto" ? "allow" : "confirm");
-}
-function recordTargetFeedback(turnId, targetIds, rating, reason) {
-	if (!turnId || targetIds.length === 0) return;
-	const personalization = getTurnPersonalization(turnId);
-	if (!personalization) return;
-	for (const objectId of targetIds) recordContextFeedback({
-		turnId,
-		runId: personalization.runId,
-		objectType: "understanding",
-		objectId,
-		rating,
-		reason
-	});
-}
-async function executeUnderstandingInterpretation(params) {
-	const { interpretation } = params;
-	const result = emptyUnderstandingReview();
-	const targets = interpretation.targetUnderstandingIds.flatMap((id) => {
-		const item = getUnderstanding(id);
-		return item ? [item] : [];
-	});
-	const targetIds = targets.map((item) => item.id);
-	const policy = resolveWritePolicy(params.getConfig());
-	if (interpretation.intent === "memory_forget") {
-		for (const target of targets) {
-			const rejected = rejectUnderstanding(target.id, "explicit user forget request", "user");
-			result.writeOutputs.push({
-				candidateKey: rejected.canonicalKey,
-				objectId: rejected.id,
-				versionId: rejected.versionId,
-				outcome: "rejected"
-			});
-		}
-		result.rejected += targets.length;
-		recordTargetFeedback(params.turnId, targetIds, "irrelevant", "explicit_user_forget_request");
-		return result;
-	}
-	if (interpretation.intent === "memory_confirm" && policy !== "deny") {
-		for (const target of targets) {
-			const confirmed = setUnderstandingStatus(target.id, "active", {
-				explicitness: "explicit",
-				confidence: 1,
-				actorType: "user",
-				source: "semantic-memory-confirmation"
-			});
-			result.createdRecords.push({
-				id: confirmed.id,
-				content: confirmed.statement,
-				kind: confirmed.kind,
-				status: confirmed.status
-			});
-			result.writeOutputs.push({
-				candidateKey: confirmed.canonicalKey,
-				objectId: confirmed.id,
-				versionId: confirmed.versionId,
-				outcome: "deduplicated"
-			});
-			result.deduplicated += 1;
-		}
-		recordTargetFeedback(params.turnId, targetIds, "helpful", "explicit_user_confirmation");
-	}
-	if (interpretation.intent === "memory_correct" && targets.length && interpretation.candidates.length === 0) {
-		for (const target of targets) setUnderstandingStatus(target.id, "needs_review", {
-			actorType: "user",
-			source: "semantic-memory-correction"
-		});
-		recordTargetFeedback(params.turnId, targetIds, "wrong", "explicit_user_correction_without_replacement");
-		return result;
-	}
-	if (interpretation.candidates.length === 0) return result;
-	if (policy === "deny") {
-		result.proposed = interpretation.candidates.length;
-		result.rejected = interpretation.candidates.length;
-		return result;
-	}
-	const evidenceByRef = new Map(params.evidence.map((entry) => [entry.ref, entry]));
-	const candidates = interpretation.candidates.map((candidate) => ({
-		...candidate,
-		explicitness: policy === "confirm" && candidate.explicitness === "explicit" ? "observed" : candidate.explicitness
-	}));
-	const evidenceIdsByRef = /* @__PURE__ */ new Map();
-	for (const ref of new Set(candidates.flatMap((candidate) => candidate.evidenceRefs))) {
-		const entry = evidenceByRef.get(ref);
-		if (!entry || entry.role !== "user") continue;
-		const evidence = createContextEvidence({
-			sourceType: "conversation",
-			sourceRef: `session:${params.sessionKey}:entry:${entry.ref}`,
-			sourceRunId: params.extractionRunId,
-			sessionId: params.sessionKey,
-			...params.turnId ? { turnId: params.turnId } : {},
-			messageId: entry.ref,
-			contentHash: extractionInputHash(JSON.stringify(entry.message)),
-			retentionPolicy: "derived_only",
-			processingPolicy: params.processingPolicy,
-			extractorId: params.extractorId,
-			extractorVersion: "1",
-			trustLevel: "owner",
-			observedAt: entry.createdAt
-		});
-		evidenceIdsByRef.set(ref, evidence.id);
-	}
-	const projectId = getSessionMetadata(params.sessionKey)?.projectId;
-	for (const candidate of candidates) {
-		const applied = await params.memoryManager.applyUnderstandingCandidates([candidate], {
-			sessionKey: params.sessionKey,
-			...projectId ? { projectId } : {},
-			evidenceIds: candidate.evidenceRefs.flatMap((ref) => evidenceIdsByRef.get(ref) ?? []),
-			reviewSource: params.reviewSource,
-			extractionRunId: params.extractionRunId,
-			...interpretation.intent === "memory_correct" ? { supersedesRecordIds: targetIds } : {}
-		});
-		result.proposed += applied.proposed;
-		result.created += applied.created;
-		result.deduplicated += applied.deduplicated;
-		result.rejected += applied.rejected;
-		result.createdRecords.push(...applied.createdRecords);
-		result.writeOutputs.push(...applied.writeOutputs ?? []);
-	}
-	if (interpretation.intent === "memory_correct" && result.created > 0) recordTargetFeedback(params.turnId, targetIds, "wrong", "explicit_user_correction_with_replacement");
-	return result;
-}
-//#endregion
-export { emptyUnderstandingReview, executeUnderstandingInterpretation };

package/dist/src/user-context/extraction/repair.d.ts

@@ -1,19 +0,0 @@
-export type ContextRepairFilter = {
-    runId?: string;
-    sourceRef?: string;
-    extractorId?: string;
-    extractorVersion?: string;
-    objectVersionId?: string;
-};
-export declare function repairExtractedContext(filter: ContextRepairFilter): {
-    runIds: string[];
-    repaired: Array<{
-        objectType: 'focus' | 'understanding';
-        objectId: string;
-    }>;
-    retained: Array<{
-        objectType: 'focus' | 'understanding';
-        objectId: string;
-        reason: string;
-    }>;
-};

package/dist/src/user-context/extraction/repair.js

@@ -1,71 +0,0 @@
-import { hasIndependentExtractionOutput, listContextExtractionOutputs, listContextExtractionRuns } from "../../storage/sqlite/context-extraction-repository.js";
-import { getUnderstanding, setUnderstandingStatus } from "../../storage/sqlite/user-context-repository.js";
-import "../../storage/sqlite/index.js";
-import { listUserFocuses, updateUserFocus } from "../sources/repository.js";
-//#region src/user-context/extraction/repair.ts
-function repairExtractedContext(filter) {
-	const runs = listContextExtractionRuns({
-		...filter.sourceRef ? { sourceRef: filter.sourceRef } : {},
-		...filter.extractorId ? { extractorId: filter.extractorId } : {},
-		...filter.extractorVersion ? { extractorVersion: filter.extractorVersion } : {},
-		limit: 500
-	}).filter((run) => !filter.runId || run.id === filter.runId);
-	const repaired = [];
-	const retained = [];
-	const seen = /* @__PURE__ */ new Set();
-	const targetRunIds = runs.map((run) => run.id);
-	for (const run of runs) for (const output of listContextExtractionOutputs(run.id)) {
-		if (output.objectType !== "focus" && output.objectType !== "understanding" || !output.objectId) continue;
-		if (filter.objectVersionId && output.versionId !== filter.objectVersionId) continue;
-		const key = `${output.objectType}:${output.objectId}`;
-		if (seen.has(key)) continue;
-		seen.add(key);
-		if (hasIndependentExtractionOutput(targetRunIds, output.objectType, output.objectId)) {
-			retained.push({
-				objectType: output.objectType,
-				objectId: output.objectId,
-				reason: "independent_extraction"
-			});
-			continue;
-		}
-		if (output.objectType === "understanding") {
-			const understanding = getUnderstanding(output.objectId);
-			if (!understanding) continue;
-			if (understanding.explicitness === "explicit") {
-				retained.push({
-					objectType: "understanding",
-					objectId: output.objectId,
-					reason: "user_explicit"
-				});
-				continue;
-			}
-			setUnderstandingStatus(output.objectId, "archived", {
-				actorType: "runtime",
-				source: "context-extraction-repair"
-			});
-		} else {
-			const focus = listUserFocuses().find((item) => item.id === output.objectId);
-			if (!focus) continue;
-			if (focus.explicitness === "explicit") {
-				retained.push({
-					objectType: "focus",
-					objectId: output.objectId,
-					reason: "user_explicit"
-				});
-				continue;
-			}
-			updateUserFocus(output.objectId, { status: "paused" });
-		}
-		repaired.push({
-			objectType: output.objectType,
-			objectId: output.objectId
-		});
-	}
-	return {
-		runIds: runs.map((run) => run.id),
-		repaired,
-		retained
-	};
-}
-//#endregion
-export { repairExtractedContext };

package/dist/src/user-context/extraction/semantic.d.ts

@@ -1,18 +0,0 @@
-import type { UnderstandingCandidate } from '../../agent/memory/understanding/types.js';
-export declare const UNDERSTANDING_INTENTS: readonly ["memory_create", "memory_query", "memory_confirm", "memory_correct", "memory_forget", "user_assertion", "task_request", "none"];
-export type UnderstandingIntent = typeof UNDERSTANDING_INTENTS[number];
-export type SemanticEvidence = {
-    ref: string;
-    role: 'user' | 'assistant';
-    text: string;
-};
-export type SemanticUnderstandingCandidate = UnderstandingCandidate & {
-    evidenceRefs: string[];
-};
-export type SemanticUnderstandingInterpretation = {
-    intent: UnderstandingIntent;
-    candidates: SemanticUnderstandingCandidate[];
-    targetUnderstandingIds: string[];
-    abstentionReason?: string;
-};
-export declare function parseSemanticUnderstanding(raw: string, evidence: SemanticEvidence[], allowedTargetIds?: string[]): SemanticUnderstandingInterpretation | null;