@xopcai/xopc 0.0.307 → 0.0.309

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,5 +1,6 @@
 import { getSqliteDatabase, init_transaction, runSqliteWriteTransaction } from "../storage/sqlite/transaction.js";
 import { USER_MODEL_PRINCIPAL_ID, validateCandidate, validateScope } from "./domain.js";
+import { clearMemoryAudit, isMemorySuppressed, memoryFingerprint, restoreMemory, suppressMemory } from "../user-context/memory-suppression.js";
 import { defaultReviewAt, requiresBoundedValidity } from "./temporal.js";
 import { basename } from "node:path";
 import { randomUUID } from "node:crypto";
@@ -136,9 +137,13 @@ function authorityRank(authority) {
 		user_explicit: 3
 	}[authority];
 }
-function reconcileAssertion(candidate, now = Date.now()) {
+function reconcileAssertion(candidate, now = Date.now(), options = {}) {
 	validateCandidate(candidate);
 	return runSqliteWriteTransaction((db) => {
+		if (candidate.authority !== "user_explicit" && candidate.sensitivity !== "normal") return { action: "suppressed" };
+		const keys = assertionFingerprints(candidate);
+		if (options.restoreDeleted && candidate.authority === "user_explicit") restoreMemory(db, keys);
+		if (isMemorySuppressed(db, keys)) return { action: "suppressed" };
 		const slot = findOrCreateSlot(db, candidate, now);
 		const existing = listReconcilableAssertions(db, slot.id);
 		if (candidate.correctionOfAssertionId) {
@@ -146,14 +151,21 @@ function reconcileAssertion(candidate, now = Date.now()) {
 			const target = existing.find((item) => item.id === candidate.correctionOfAssertionId);
 			if (!target) throw new Error("Correction target does not belong to the resolved assertion slot.");
 			if (target.normalizedValue === candidate.normalizedValue.trim()) {
+				db.prepare("UPDATE user_assertions SET statement = ?, authority = 'user_explicit', confidence = 1, status = 'active', observed_at = ?, review_at = ? WHERE assertion_id = ?").run(candidate.statement.trim(), candidate.observedAt, defaultReviewAt(candidate.volatility, candidate.observedAt) ?? null, target.id);
+				db.prepare("UPDATE user_assertions_fts SET statement = ? WHERE assertion_id = ?").run(candidate.statement.trim(), target.id);
 				attachEvidence(db, target.id, candidate, now);
 				return {
 					action: "deduplicated",
-					assertion: target
+					assertion: getUserAssertion(target.id)
 				};
 			}
+			if (slot.cardinality === "multiple") suppressMemory(db, assertionFingerprints({
+				...target,
+				...slot
+			}), now);
 			const assertion = insertAssertion(db, slot.id, candidate, "active", now, target.id);
-			closeValidity(db, target, candidate.validFrom ?? candidate.observedAt, now);
+			closeValidity(db, target, candidate.observedAt, now);
+			updateStatus(db, target, "archived", "Replaced by user correction.", now);
 			return {
 				action: "superseded",
 				assertion,
@@ -163,10 +175,12 @@ function reconcileAssertion(candidate, now = Date.now()) {
 		const overlapping = sortByAuthorityAndRecorded(existing.filter((item) => intervalsOverlap(item, candidate)));
 		const duplicate = overlapping.find((item) => item.normalizedValue === candidate.normalizedValue.trim());
 		if (duplicate) {
+			refreshSupportingObservation(db, duplicate, candidate, now);
+			if (candidate.authority === "user_explicit" && (duplicate.authority !== "user_explicit" || candidate.observedAt > duplicate.observedAt)) db.prepare("UPDATE user_assertions SET authority = 'user_explicit', confidence = ?, status = ?, observed_at = ?, review_at = ? WHERE assertion_id = ?").run(candidate.confidence, initialStatus(candidate), candidate.observedAt, candidate.reviewAt ?? defaultReviewAt(candidate.volatility, candidate.observedAt) ?? null, duplicate.id);
 			attachEvidence(db, duplicate.id, candidate, now);
 			return {
 				action: "deduplicated",
-				assertion: duplicate
+				assertion: getUserAssertion(duplicate.id)
 			};
 		}
 		const status = initialStatus(candidate);
@@ -345,13 +359,89 @@ function linkAssertionEvidence(assertionId, evidenceId, relation, confidence, no
 function setAssertionStatus(assertionId, status, input) {
 	const current = getUserAssertion(assertionId);
 	if (!current) throw new Error(`User assertion not found: ${assertionId}`);
-	if (current.status === status) return current;
+	if (current.status === status && !(status === "active" && input.actor === "user" && current.authority !== "user_explicit")) return current;
 	const now = input.now ?? Date.now();
 	runSqliteWriteTransaction((db) => {
 		db.prepare("UPDATE user_assertions SET status = ? WHERE assertion_id = ?").run(status, assertionId);
+		if ((status === "rejected" || status === "archived") && input.actor === "user") {
+			const slot = getAssertionSlot(current.slotId);
+			suppressMemory(db, assertionFingerprints({
+				...current,
+				...slot
+			}), now);
+		}
+		if (status === "active" && input.actor === "user") db.prepare("UPDATE user_assertions SET authority = 'user_explicit', confidence = 1 WHERE assertion_id = ?").run(assertionId);
 		recordStatusEvent(db, assertionId, current.status, status, input.actor, input.reason, now);
 	});
 	return getUserAssertion(assertionId);
 }
+function assertionFingerprints(candidate) {
+	const scope = [
+		candidate.principalId ?? "local-owner",
+		candidate.scope.type,
+		candidate.scope.id ?? ""
+	];
+	return [memoryFingerprint([
+		"assertion-slot",
+		...scope,
+		candidate.subject.type,
+		candidate.subject.id,
+		candidate.predicate,
+		candidate.cardinality === "single" ? "" : candidate.normalizedValue
+	]), memoryFingerprint([
+		"assertion-content",
+		...scope,
+		candidate.statement
+	])];
+}
+function deleteUserAssertion(id, now = Date.now()) {
+	return runSqliteWriteTransaction((db) => {
+		const current = getUserAssertion(id);
+		if (!current) return false;
+		const slot = getAssertionSlot(current.slotId);
+		const rows = db.prepare(`WITH RECURSIVE versions(id) AS (
+      SELECT ? UNION SELECT a.assertion_id FROM user_assertions a JOIN versions v
+      ON a.supersedes_assertion_id = v.id OR a.assertion_id = (
+        SELECT supersedes_assertion_id FROM user_assertions WHERE assertion_id = v.id)
+    ) SELECT * FROM user_assertions WHERE assertion_id IN (SELECT id FROM versions)
+      OR (? = 'single' AND slot_id = ?)`).all(id, slot.cardinality, slot.id);
+		const evidenceIds = new Set(rows.flatMap((row) => db.prepare("SELECT evidence_id FROM user_assertion_evidence WHERE assertion_id = ?").all(row.assertion_id).map((evidence) => evidence.evidence_id)));
+		for (const row of rows) {
+			const assertion = assertionFromRow(row);
+			suppressMemory(db, assertionFingerprints({
+				...assertion,
+				...slot,
+				principalId: slot.principalId
+			}), now);
+			clearMemoryAudit(db, "assertion", assertion.id);
+			db.prepare("DELETE FROM user_assertions_fts WHERE assertion_id = ?").run(assertion.id);
+			db.prepare(`UPDATE work_discovery_runs SET result_json = json_set(result_json, '$.profileCandidates',
+        json((SELECT COALESCE(json_group_array(json(value)), '[]')
+          FROM json_each(result_json, '$.profileCandidates')
+          WHERE COALESCE(json_extract(value, '$.assertionId'), '') != ?)))
+        WHERE EXISTS (SELECT 1 FROM json_each(result_json, '$.profileCandidates')
+          WHERE json_extract(value, '$.assertionId') = ?)`).run(assertion.id, assertion.id);
+		}
+		for (const row of rows) db.prepare("DELETE FROM user_assertions WHERE assertion_id = ?").run(row.assertion_id);
+		for (const evidenceId of evidenceIds) db.prepare(`UPDATE context_evidence SET redacted_excerpt = NULL WHERE evidence_id = ?
+        AND NOT EXISTS (SELECT 1 FROM user_assertion_evidence WHERE evidence_id = ?)`).run(evidenceId, evidenceId);
+		db.prepare(`DELETE FROM user_assertion_slots WHERE slot_id = ?
+      AND NOT EXISTS (SELECT 1 FROM user_assertions WHERE slot_id = ?)`).run(slot.id, slot.id);
+		return true;
+	});
+}
+function refreshSupportingObservation(db, current, candidate, now) {
+	if (!candidate.evidenceId || current.authority === "user_explicit" || ![
+		"active",
+		"candidate",
+		"stale"
+	].includes(current.status)) return;
+	const evidence = db.prepare(`SELECT observed_at FROM context_evidence WHERE evidence_id = ?
+    AND trust_level = 'owner' AND source_type IN ('conversation', 'user', 'connector')`).get(candidate.evidenceId);
+	if (!evidence || evidence.observed_at <= current.observedAt || evidence.observed_at > now || candidate.confidence < .7) return;
+	const reviewAt = defaultReviewAt(current.volatility, evidence.observed_at);
+	db.prepare(`UPDATE user_assertions SET observed_at = ?, review_at = ? WHERE assertion_id = ?`).run(evidence.observed_at, reviewAt ?? null, current.id);
+	if (current.status === "stale" && (current.validTo === void 0 || current.validTo >= now)) updateStatus(db, current, "candidate", "Fresh source evidence supports this understanding.", now);
+}
 //#endregion
-export { getActiveAssertionByPredicate, getActiveAssertionForSlot, getAssertionSlot, getUserAssertion, getUserTimezone, linkAssertionEvidence, listSlotAssertions, listUserAssertionSources, listUserAssertions, reconcileAssertion, setAssertionStatus };
+export { deleteUserAssertion, getActiveAssertionByPredicate, getActiveAssertionForSlot, getAssertionSlot, getUserAssertion, getUserTimezone, linkAssertionEvidence, listSlotAssertions, listUserAssertionSources, listUserAssertions, reconcileAssertion, setAssertionStatus };

package/dist/src/user-model/usage-policy.d.ts

@@ -1,2 +1,4 @@
 import type { UserAssertion } from './domain.js';
+/** Automatic personalization never grants execution authority. */
 export declare function isWorkingAssumption(assertion: UserAssertion): boolean;
+export declare function canUseAssertion(assertion: UserAssertion, asOf?: number): boolean;

package/dist/src/user-model/usage-policy.js

@@ -1,6 +1,10 @@
 //#region src/user-model/usage-policy.ts
+/** Automatic personalization never grants execution authority. */
 function isWorkingAssumption(assertion) {
-	return assertion.status === "candidate" && (assertion.authority === "user_observed" || assertion.authority === "system_inferred") && assertion.confidence >= .7 && assertion.consequence !== "critical" && assertion.sensitivity === "normal" && assertion.disclosurePolicy !== "ask_before_reference";
+	return (assertion.status === "candidate" || assertion.status === "active") && (assertion.authority === "user_observed" || assertion.authority === "system_inferred") && assertion.confidence >= .7 && (assertion.consequence === "low" || assertion.consequence === "medium") && assertion.sensitivity === "normal" && assertion.disclosurePolicy !== "ask_before_reference";
+}
+function canUseAssertion(assertion, asOf = Date.now()) {
+	return (assertion.validFrom === void 0 || assertion.validFrom <= asOf) && (assertion.validTo === void 0 || assertion.validTo >= asOf) && (assertion.reviewAt === void 0 || assertion.reviewAt > asOf) && assertion.sensitivity !== "secret" && assertion.sensitivity !== "regulated" && assertion.disclosurePolicy !== "ask_before_reference" && (assertion.status === "active" && assertion.authority === "user_explicit" || isWorkingAssumption(assertion));
 }
 //#endregion
-export { isWorkingAssumption };
+export { canUseAssertion, isWorkingAssumption };

package/dist/src/work-discovery/project-understanding.js

@@ -31,7 +31,8 @@ function saveProjectUnderstandingOverview(input) {
 			provider: "project-understanding",
 			evidenceRefs: input.evidenceRefs ?? []
 		},
-		replaceExisting: true
+		replaceExisting: true,
+		restoreDeleted: input.correctedByUser
 	}).item;
 }
 //#endregion

package/dist/src/work-discovery/service.d.ts

@@ -62,7 +62,14 @@ export declare class WorkDiscoveryService {
         reused?: undefined;
     }>;
     revokeDirectorySource(id: string): import("./types.js").WorkDiscoveryDirectorySource;
-    importUnderstandingSources(rawItems: unknown[], processingPolicy: ModelProcessingPolicy, signal?: AbortSignal, runId?: string, rawCheckpoints?: Record<string, unknown>): Promise<{
+    importUnderstandingSources(rawItems: unknown[], processingPolicy: ModelProcessingPolicy, signal?: AbortSignal, runId?: string, rawCheckpoints?: Record<string, unknown>, refresh?: {
+        grantId: string;
+    }): Promise<{
+        profileCandidates: any[];
+        workThreads: import("./types.js").WorkUnderstandingThread[];
+        knowledgeCandidates: import("../knowledge-memory/domain.js").KnowledgeItem[];
+        sourceStatuses: import("./analyzer.js").UnderstandingSourceAnalysisStatus[];
+    } | {
         profileCandidates: any[];
         workThreads: any[];
         knowledgeCandidates: any[];
@@ -70,21 +77,6 @@ export declare class WorkDiscoveryService {
             sourceId: string;
             status: "completed";
         }[];
-    } | {
-        profileCandidates: {
-            status: "pending" | "rejected";
-            assertionId: string;
-            id: string;
-            category: "role" | "responsibility" | "preference" | "routine" | "communication" | "boundary" | "relationship";
-            factKey: string;
-            statement: string;
-            confidence: "high" | "medium" | "low";
-            evidence: string[];
-            evidenceRefs?: string[];
-        }[];
-        workThreads: import("./types.js").WorkUnderstandingThread[];
-        knowledgeCandidates: import("../knowledge-memory/domain.js").KnowledgeItem[];
-        sourceStatuses: import("./analyzer.js").UnderstandingSourceAnalysisStatus[];
     }>;
     rescanDirectorySource(input: {
         id: string;
@@ -103,14 +95,6 @@ export declare class WorkDiscoveryService {
     private publish;
     private execute;
     private persistProfileCandidates;
-    updateProfileCandidates(input: {
-        runId: string;
-        decisions: Array<{
-            id: string;
-            status: 'accepted' | 'edited' | 'rejected';
-            statement?: string;
-        }>;
-    }): WorkDiscoveryRun | null;
     cancelRun(id: string): WorkDiscoveryRun | null;
     retryRun(id: string): WorkDiscoveryRun | null;
     submitRecognitionFeedback(input: {