@xopcai/xopc 0.0.323 → 0.0.324

package/dist/src/home-intelligence/host.js

@@ -0,0 +1,257 @@
+import { createLogger } from "../utils/logger/index.js";
+import { init_logger } from "../utils/logger.js";
+import { homePatternKey } from "./strategy.js";
+import { HomeAdvicePolicy } from "./policy.js";
+import { HomeIntelligenceRepository } from "./repository.js";
+import { HomeOpportunityApplicationService } from "./application-service.js";
+import { buildHomeOpportunityNotification } from "./notification.js";
+import { createHash } from "node:crypto";
+//#region src/home-intelligence/host.ts
+init_logger();
+const log = createLogger("HomeIntelligence");
+const POLL_INTERVAL_MS = 5e3;
+const REFRESH_INTERVAL_MS = 30 * 6e4;
+const GENERATION_LEASE_MS = 5 * 6e4;
+const DAILY_MODEL_GENERATION_BUDGET = 12;
+function generationFingerprint(snapshotHash, capabilities) {
+	return createHash("sha256").update(JSON.stringify({
+		snapshotHash,
+		agentId: capabilities.agentId,
+		connectors: [...capabilities.connectors].sort(),
+		skills: [...capabilities.skills].sort()
+	})).digest("hex");
+}
+var HomeIntelligenceHost = class {
+	repository;
+	opportunities;
+	now;
+	timer;
+	running = false;
+	stopped = false;
+	nextScheduledRefresh = 0;
+	abortController = new AbortController();
+	localeHint;
+	constructor(db, deps) {
+		this.deps = deps;
+		this.repository = new HomeIntelligenceRepository(db);
+		this.opportunities = new HomeOpportunityApplicationService(db, deps.principal, () => deps.capabilities().agentId);
+		this.now = deps.now ?? Date.now;
+		this.localeHint = deps.locale();
+	}
+	start() {
+		if (this.timer) return;
+		this.stopped = false;
+		this.nextScheduledRefresh = this.now();
+		this.timer = setInterval(() => void this.tick(), POLL_INTERVAL_MS);
+		this.timer.unref?.();
+		this.tick();
+	}
+	stop() {
+		this.stopped = true;
+		this.abortController.abort();
+		this.abortController = new AbortController();
+		if (this.timer) clearInterval(this.timer);
+		this.timer = void 0;
+	}
+	getAdvisor() {
+		if (this.deps.enabled?.() === false) return { state: "disabled" };
+		return this.repository.getAdvisor(this.deps.principal, this.now());
+	}
+	getMetrics(since = Math.max(0, this.now() - 720 * 60 * 6e4)) {
+		return this.repository.getMetrics(this.deps.principal, since, this.now());
+	}
+	getHistory() {
+		if (this.deps.enabled?.() === false) return [];
+		return this.repository.listHistory(this.deps.principal);
+	}
+	requestRefresh(reason, idempotencyKey, locale) {
+		if (this.deps.enabled?.() === false) return "disabled";
+		const now = this.now();
+		if (locale) this.localeHint = locale.toLowerCase().startsWith("zh") ? "zh" : "en";
+		const bucket = Math.floor(now / (reason === "manual_refresh" ? 1 : 5 * 6e4));
+		const request = this.repository.enqueue(this.deps.principal, {
+			idempotencyKey: idempotencyKey ?? `${reason}:${bucket}`,
+			reasons: [reason],
+			requestedAt: now
+		});
+		this.tick();
+		return request.generationId;
+	}
+	sourceChanged(input) {
+		if (this.deps.enabled?.() === false) return;
+		const now = this.now();
+		const invalidated = this.repository.invalidateOpportunitiesByEvidenceSources(this.deps.principal, new Set([
+			"calendar",
+			"mail",
+			"communication"
+		]), now);
+		this.requestRefresh("connector_changed", `connector:${input.sourceInstanceId}:${input.revision}`);
+		if (invalidated > 0) this.deps.publish("home.advisor.updated", {
+			state: "source_changed",
+			sourceInstanceId: input.sourceInstanceId,
+			invalidated
+		});
+	}
+	act(opportunityId, input) {
+		const request = {
+			opportunityId,
+			expectedRevision: input.expectedRevision,
+			idempotencyKey: input.idempotencyKey,
+			now: this.now()
+		};
+		if (input.mode !== "discuss") {
+			const opportunity = this.repository.getOpportunity(this.deps.principal, opportunityId, request.now);
+			if (!opportunity) return this.opportunities.start(request);
+			const resolution = this.resolveCapabilityRequirements(opportunity.capabilities, Boolean(opportunity.degradedActionPrompt));
+			if (input.mode === "start" && resolution.preflight.state === "needs_setup") return {
+				outcome: "needs_setup",
+				preflight: resolution.preflight
+			};
+			const degraded = input.mode === "degraded_start" && resolution.preflight.state === "needs_setup" && Boolean(resolution.preflight.degradedAction);
+			const result = this.opportunities.start(request, { degraded });
+			this.deps.dispatchTaskRuns?.();
+			this.deps.publish("home.advisor.updated", {
+				state: "acted",
+				opportunityId,
+				mode: input.mode
+			});
+			return result;
+		}
+		const result = this.opportunities.discuss(request);
+		if (result.outcome === "task") this.deps.dispatchTaskRuns?.();
+		this.deps.publish("home.advisor.updated", {
+			state: "acted",
+			opportunityId,
+			mode: input.mode
+		});
+		return result;
+	}
+	feedback(opportunityId, input) {
+		this.opportunities.feedback(opportunityId, {
+			idempotencyKey: input.idempotencyKey,
+			expectedRevision: input.expectedRevision,
+			kind: input.kind,
+			createdAt: this.now(),
+			reasonCode: input.reasonCode,
+			note: input.note,
+			snoozedUntil: input.snoozedUntil
+		});
+		this.deps.publish("home.advisor.updated", {
+			state: "feedback",
+			opportunityId,
+			kind: input.kind
+		});
+	}
+	undoFeedback(opportunityId, idempotencyKey) {
+		this.repository.undoFeedback(this.deps.principal, opportunityId, idempotencyKey, this.now());
+		this.deps.publish("home.advisor.updated", {
+			state: "feedback_undone",
+			opportunityId
+		});
+	}
+	async tick() {
+		if (this.running || this.stopped || this.deps.enabled?.() === false) return;
+		this.running = true;
+		try {
+			const now = this.now();
+			this.repository.maintain(now);
+			if (now >= this.nextScheduledRefresh) {
+				this.nextScheduledRefresh = now + REFRESH_INTERVAL_MS;
+				this.requestRefresh("scheduled_refresh", `scheduled_refresh:${Math.floor(now / REFRESH_INTERVAL_MS)}`);
+			}
+			const claim = this.repository.claimNext(this.deps.principal, `gateway:${process.pid}`, now, GENERATION_LEASE_MS);
+			if (!claim) return;
+			await this.process(claim);
+		} finally {
+			this.running = false;
+		}
+	}
+	async process(claim) {
+		const startedAt = this.now();
+		let currentFingerprint;
+		try {
+			const successfulPatterns = this.repository.getSuccessfulPatterns(this.deps.principal);
+			const snapshot = this.deps.snapshot.build({
+				now: startedAt,
+				locale: this.localeHint,
+				successfulPatterns
+			});
+			const capabilities = this.deps.capabilities();
+			currentFingerprint = generationFingerprint(snapshot.hash, capabilities);
+			const previousHash = this.repository.getLatestSnapshotHash(this.deps.principal);
+			let generation;
+			const startOfDay = new Date(startedAt);
+			startOfDay.setHours(0, 0, 0, 0);
+			const modelGenerationAttempts = this.repository.countModelGenerationAttemptsSince(this.deps.principal, startOfDay.getTime(), claim.generationId);
+			const manualRefresh = claim.reasons.includes("manual_refresh");
+			const result = modelGenerationAttempts >= DAILY_MODEL_GENERATION_BUDGET && !manualRefresh ? {
+				state: "quiet",
+				reason: "budget_exhausted"
+			} : previousHash === currentFingerprint && !manualRefresh ? {
+				state: "quiet",
+				reason: "no_change"
+			} : await (async () => {
+				generation = await this.deps.generator.generate(snapshot, capabilities, this.abortController.signal);
+				return new HomeAdvicePolicy((requirements, options) => this.resolveCapabilityRequirements(requirements, Boolean(options?.degradedActionAvailable)), this.repository.listSuppressionKeys(this.deps.principal), new Map(successfulPatterns.map((item) => [homePatternKey(item.projectId, item.outcome), item.successCount])), this.repository.getPersonalization(this.deps.principal, this.now())).apply(snapshot, generation.result, this.now());
+			})();
+			const completedAt = this.now();
+			const completion = this.repository.complete(claim, {
+				result,
+				snapshotHash: currentFingerprint,
+				evidenceIds: snapshot.evidence.map((item) => item.id),
+				modelRef: generation?.modelRef,
+				inputTokens: generation?.usage.inputTokens,
+				outputTokens: generation?.usage.outputTokens,
+				estimatedCostUsd: generation?.usage.estimatedCostUsd,
+				outcomeReason: result.state === "quiet" ? result.reason : result.state,
+				completedAt
+			});
+			this.deps.publish("home.advisor.updated", {
+				state: result.state,
+				completedAt
+			});
+			if (result.state === "ready") {
+				const notification = buildHomeOpportunityNotification(result.opportunities[0], claim.reasons, result.placement ?? "primary");
+				if (notification) this.deps.notifyOpportunity(notification);
+			}
+			if (completion.dirty) this.requestRefresh("conversation_changed", `dirty:${claim.generationId}:${completedAt}`);
+		} catch (error) {
+			if (this.stopped) {
+				this.repository.fail(claim, this.now(), "cancelled", this.now());
+				return;
+			}
+			const message = error instanceof Error ? error.message : String(error);
+			if (/no api key|no default model|credentials|unknown model|local model/i.test(message)) {
+				const completedAt = this.now();
+				const completion = this.repository.complete(claim, {
+					result: {
+						state: "quiet",
+						reason: "model_unavailable"
+					},
+					snapshotHash: currentFingerprint ?? this.repository.getLatestSnapshotHash(this.deps.principal) ?? "unavailable",
+					evidenceIds: [],
+					outcomeReason: "model_unavailable",
+					completedAt
+				});
+				this.deps.publish("home.advisor.updated", {
+					state: "quiet",
+					reason: "model_unavailable"
+				});
+				if (completion.dirty) this.requestRefresh("conversation_changed", `dirty:${claim.generationId}:${completedAt}`);
+				return;
+			}
+			const retryAt = this.now() + (claim.attempt <= 1 ? 6e4 : 5 * 6e4);
+			this.repository.fail(claim, this.now(), "generation_failed", retryAt);
+			log.warn({
+				err: error,
+				generationId: claim.generationId,
+				attempt: claim.attempt
+			}, `Home advice generation failed: ${message}`);
+		}
+	}
+	resolveCapabilityRequirements(requirements, degradedActionAvailable) {
+		return this.deps.resolveCapabilities(requirements, { degradedActionAvailable });
+	}
+};
+//#endregion
+export { HomeIntelligenceHost };

package/dist/src/home-intelligence/notification.d.ts

@@ -0,0 +1,8 @@
+import type { HomeOpportunity } from '@xopcai/gateway-contract';
+import type { HomeGenerationReason } from './repository.js';
+export interface HomeOpportunityNotification {
+    notificationKey: string;
+    opportunityId: string;
+    title: string;
+}
+export declare function buildHomeOpportunityNotification(opportunity: HomeOpportunity, reasons: readonly HomeGenerationReason[], placement: 'primary' | 'compact'): HomeOpportunityNotification | undefined;

package/dist/src/home-intelligence/notification.js

@@ -0,0 +1,20 @@
+import { createHash } from "node:crypto";
+//#region src/home-intelligence/notification.ts
+function buildHomeOpportunityNotification(opportunity, reasons, placement) {
+	const backgroundRefresh = reasons.includes("connector_changed") || reasons.includes("scheduled_refresh");
+	const foregroundRefresh = reasons.includes("home_opened") || reasons.includes("manual_refresh");
+	const hasCrossSourceEvidence = opportunity.evidence.some((item) => item.sourceType === "calendar" || item.sourceType === "mail" || item.sourceType === "communication");
+	if (!backgroundRefresh || foregroundRefresh || placement !== "primary" || opportunity.confidence !== "high" || opportunity.urgency !== "now" || !opportunity.actions.canStart || !hasCrossSourceEvidence) return void 0;
+	const evidenceRevision = opportunity.evidence.map((item) => `${item.sourceType}:${item.sourceRef}:${item.revision}`).sort().join("\n");
+	return {
+		notificationKey: createHash("sha256").update([
+			opportunity.kind,
+			opportunity.projectId ?? "global",
+			evidenceRevision
+		].join("\n")).digest("hex"),
+		opportunityId: opportunity.id,
+		title: opportunity.title
+	};
+}
+//#endregion
+export { buildHomeOpportunityNotification };

package/dist/src/home-intelligence/policy.d.ts

@@ -0,0 +1,16 @@
+import type { HomeModelResult } from './generator.js';
+import type { HomeCapabilityRequirement, HomeCapabilityResolution } from './capability-preflight.js';
+import type { HomeGeneratedResult } from './types.js';
+import type { HomeContextSnapshot } from './snapshot.js';
+import { type HomeAdvicePersonalization } from './strategy.js';
+export declare class HomeAdvicePolicy {
+    private readonly resolveCapabilities;
+    private readonly suppressedKeys;
+    private readonly successfulCounts;
+    private readonly personalization;
+    constructor(resolveCapabilities: (requirements: readonly HomeCapabilityRequirement[], options?: {
+        degradedActionAvailable?: boolean;
+    }) => HomeCapabilityResolution, suppressedKeys?: ReadonlySet<string>, successfulCounts?: ReadonlyMap<string, number>, personalization?: HomeAdvicePersonalization);
+    apply(snapshot: HomeContextSnapshot, model: HomeModelResult, now: number): HomeGeneratedResult;
+    private continuation;
+}

package/dist/src/home-intelligence/policy.js

@@ -0,0 +1,152 @@
+import { homePatternKey } from "./strategy.js";
+import { randomUUID } from "node:crypto";
+//#region src/home-intelligence/policy.ts
+const CONFIDENCE_SCORE = {
+	high: 30,
+	medium: 20,
+	low: 0
+};
+const URGENCY_SCORE = {
+	now: 12,
+	today: 8,
+	this_week: 4
+};
+const RISK_PENALTY = {
+	analysis: 0,
+	external_read: 1,
+	file_write: 4,
+	external_write: 10
+};
+function expiryFor(urgency, now) {
+	if (urgency === "now") return now + 360 * 6e4;
+	if (urgency === "today") return now + 1440 * 6e4;
+	return now + 4320 * 6e4;
+}
+function normalized(value) {
+	return (value ?? "").toLocaleLowerCase().replace(/[\p{P}\p{S}\s]+/gu, "");
+}
+function hasRequiredScenarioEvidence(kind, evidence) {
+	if (kind === "meeting_prep") return evidence.some((item) => item.sourceType === "calendar");
+	if (kind === "commitment_follow_up") return evidence.some((item) => item.sourceType === "mail" || item.sourceType === "communication");
+	return true;
+}
+var HomeAdvicePolicy = class {
+	constructor(resolveCapabilities, suppressedKeys = /* @__PURE__ */ new Set(), successfulCounts = /* @__PURE__ */ new Map(), personalization = { highConfidenceKinds: /* @__PURE__ */ new Set() }) {
+		this.resolveCapabilities = resolveCapabilities;
+		this.suppressedKeys = suppressedKeys;
+		this.successfulCounts = successfulCounts;
+		this.personalization = personalization;
+	}
+	apply(snapshot, model, now) {
+		const evidenceById = new Map(snapshot.evidence.map((item) => [item.id, item]));
+		if (model.state === "quiet") return model;
+		if (model.state === "clarification") {
+			const evidenceIds = [...new Set(model.evidenceIds)].filter((id) => (evidenceById.get(id)?.freshUntil ?? 0) > now);
+			const options = [...new Map(model.options.map((option) => [option.id, option])).values()];
+			if (evidenceIds.length < 2 || options.length < 2) return {
+				state: "quiet",
+				reason: "insufficient_value"
+			};
+			return {
+				state: "clarification",
+				question: {
+					id: randomUUID(),
+					revision: 1,
+					question: model.question,
+					options,
+					evidenceIds
+				},
+				generatedAt: now,
+				expiresAt: now + 1440 * 6e4
+			};
+		}
+		const projectIds = new Set(snapshot.projects.map((project) => project.id));
+		const scored = model.candidates.flatMap((candidate) => {
+			if (candidate.confidence === "low" || candidate.projectId && !projectIds.has(candidate.projectId)) return [];
+			if (candidate.confidence !== "high" && this.personalization.highConfidenceKinds.has(candidate.kind)) return [];
+			if (this.suppressedKeys.has(`${candidate.kind}:${candidate.projectId ?? "global"}`)) return [];
+			if (snapshot.tasks.some((task) => task.projectId === candidate.projectId && (normalized(task.title) === normalized(candidate.title) || task.objective && normalized(task.objective) === normalized(candidate.outcome)))) return [];
+			const evidence = [...new Set(candidate.evidenceIds)].map((id) => evidenceById.get(id)).filter((item) => Boolean(item && item.freshUntil > now));
+			if (!evidence.length || !hasRequiredScenarioEvidence(candidate.kind, evidence)) return [];
+			const capabilities = this.resolveCapabilities(candidate.requiredCapabilities, { degradedActionAvailable: Boolean(candidate.degradedActionPrompt) }).capabilities;
+			const missingRequired = capabilities.some((item) => item.required && item.readiness !== "ready");
+			const canStart = !missingRequired && candidate.risk !== "external_write";
+			const degradedStartAvailable = missingRequired && Boolean(candidate.degradedActionPrompt) && candidate.risk !== "external_write";
+			return [{
+				opportunity: {
+					id: randomUUID(),
+					revision: 1,
+					kind: candidate.kind,
+					projectId: candidate.projectId,
+					title: candidate.title,
+					outcome: candidate.outcome,
+					rationale: candidate.rationale,
+					evidence,
+					confidence: candidate.confidence,
+					urgency: candidate.urgency,
+					estimatedMinutes: candidate.estimatedMinutes,
+					risk: candidate.risk,
+					proposedSteps: candidate.proposedSteps,
+					capabilities,
+					verification: candidate.verification,
+					actionPrompt: candidate.actionPrompt,
+					degradedActionPrompt: candidate.degradedActionPrompt,
+					...this.continuation(candidate, snapshot.locale),
+					actions: {
+						canStart,
+						canDiscuss: true,
+						degradedStartAvailable
+					},
+					generatedAt: now,
+					expiresAt: expiryFor(candidate.urgency, now)
+				},
+				score: CONFIDENCE_SCORE[candidate.confidence] + URGENCY_SCORE[candidate.urgency] - RISK_PENALTY[candidate.risk] - (missingRequired ? 12 : 0) + Math.min(evidence.length, 3)
+			}];
+		});
+		const seen = /* @__PURE__ */ new Set();
+		const ranked = scored.sort((left, right) => right.score - left.score || left.opportunity.title.localeCompare(right.opportunity.title)).filter(({ opportunity }) => {
+			const key = `${opportunity.kind}:${opportunity.projectId ?? "global"}:${normalized(opportunity.outcome)}`;
+			if (seen.has(key)) return false;
+			seen.add(key);
+			return true;
+		}).slice(0, 3);
+		if (!ranked.length) return {
+			state: "quiet",
+			reason: "insufficient_value"
+		};
+		const primary = ranked[0];
+		return {
+			state: "ready",
+			opportunities: ranked.map((item) => item.opportunity),
+			placement: primary.score >= 38 && primary.opportunity.actions.canStart ? "primary" : "compact"
+		};
+	}
+	continuation(candidate, locale) {
+		if (candidate.kind !== "automation_candidate") return {};
+		const successCount = this.successfulCounts.get(homePatternKey(candidate.projectId, candidate.outcome)) ?? 0;
+		if (successCount >= 2) {
+			const outcome = candidate.outcome.slice(0, 140);
+			const approach = candidate.actionPrompt.slice(0, 140);
+			const prompt = locale === "zh" ? `把这项已经稳定成功的工作设计成可复核的 Automation 草稿：${outcome}\n执行方式：${approach}\n请先确认触发条件、频率、范围和外部动作边界，不要直接发布。` : `Design a reviewable Automation draft for this repeatedly successful work: ${outcome}\nExecution approach: ${approach}\nFirst confirm the trigger, schedule, scope, and external-action boundaries. Do not publish it automatically.`;
+			const params = new URLSearchParams({
+				draft: prompt,
+				autogenerate: "1"
+			});
+			if (candidate.projectId) params.set("projectId", candidate.projectId);
+			return { continuation: {
+				kind: "automation",
+				reason: "repeated_success",
+				href: `/automations?${params.toString()}`,
+				successCount
+			} };
+		}
+		if (successCount === 1) return { continuation: {
+			kind: "scene",
+			reason: "prior_success",
+			href: "/scenes"
+		} };
+		return {};
+	}
+};
+//#endregion
+export { HomeAdvicePolicy };

package/dist/src/home-intelligence/repository.d.ts

@@ -0,0 +1,81 @@
+import type { DatabaseSync } from 'node:sqlite';
+import { type HomeAdvisor, type HomeAdviceMetrics, type HomeOpportunity, type HomeOpportunityHistoryItem } from '@xopcai/gateway-contract';
+import type { HomeGeneratedResult } from './types.js';
+import { type HomeAdvicePersonalization, type HomeSuccessfulPattern } from './strategy.js';
+export interface HomePrincipal {
+    ownerId: string;
+    workspaceId: string;
+}
+export type HomeGenerationReason = 'home_opened' | 'manual_refresh' | 'project_changed' | 'task_changed' | 'conversation_changed' | 'connector_changed' | 'scheduled_refresh';
+export interface HomeGenerationClaim extends HomePrincipal {
+    generationId: string;
+    leaseOwner: string;
+    leaseEpoch: number;
+    attempt: number;
+    reasons: HomeGenerationReason[];
+}
+export interface HomeGenerationCompletion {
+    result: HomeGeneratedResult;
+    snapshotHash: string;
+    evidenceIds: string[];
+    modelRef?: string;
+    inputTokens?: number;
+    outputTokens?: number;
+    estimatedCostUsd?: number;
+    outcomeReason?: string;
+    completedAt: number;
+}
+export type HomeFeedbackKind = 'started' | 'discussed' | 'already_done' | 'irrelevant' | 'too_early' | 'source_incorrect' | 'less_like_this' | 'snoozed';
+export interface HomeOpportunityFeedbackInput {
+    feedbackId?: string;
+    idempotencyKey: string;
+    kind: HomeFeedbackKind;
+    expectedRevision: number;
+    createdAt: number;
+    reasonCode?: string;
+    note?: string;
+    scope?: Record<string, unknown>;
+    snoozedUntil?: number;
+    resolution?: {
+        kind: 'session' | 'task' | 'scene';
+        ref: string;
+    };
+}
+export declare class HomeIntelligenceRepository {
+    private readonly db;
+    constructor(db: DatabaseSync);
+    enqueue(principal: HomePrincipal, input: {
+        idempotencyKey: string;
+        reasons: HomeGenerationReason[];
+        requestedAt: number;
+    }): {
+        generationId: string;
+        created: boolean;
+    };
+    claimNext(principal: HomePrincipal, workerId: string, now: number, leaseMs?: number): HomeGenerationClaim | undefined;
+    complete(claim: HomeGenerationClaim, completion: HomeGenerationCompletion): {
+        dirty: boolean;
+    };
+    fail(claim: HomeGenerationClaim, now: number, errorCode: string, retryAt?: number): void;
+    getLatestSnapshotHash(principal: HomePrincipal): string | undefined;
+    countModelGenerationAttemptsSince(principal: HomePrincipal, since: number, currentGenerationId: string): number;
+    listSuppressionKeys(principal: HomePrincipal): Set<string>;
+    getSuccessfulPatterns(principal: HomePrincipal): HomeSuccessfulPattern[];
+    getPersonalization(principal: HomePrincipal, now: number): HomeAdvicePersonalization;
+    getMetrics(principal: HomePrincipal, since: number, until: number): HomeAdviceMetrics;
+    invalidateOpportunitiesByEvidenceSources(principal: HomePrincipal, sourceTypes: ReadonlySet<HomeOpportunity['evidence'][number]['sourceType']>, now: number): number;
+    getAdvisor(principal: HomePrincipal, now: number): HomeAdvisor;
+    getOpportunity(principal: HomePrincipal, opportunityId: string, now: number): HomeOpportunity | undefined;
+    getOpportunitySnapshot(principal: HomePrincipal, opportunityId: string): HomeOpportunity | undefined;
+    listHistory(principal: HomePrincipal): HomeOpportunityHistoryItem[];
+    isFeedbackRecorded(opportunityId: string, idempotencyKey: string): boolean;
+    recordFeedback(principal: HomePrincipal, opportunityId: string, input: HomeOpportunityFeedbackInput): HomeOpportunity | undefined;
+    undoFeedback(principal: HomePrincipal, opportunityId: string, idempotencyKey: string, now: number): HomeOpportunity;
+    maintain(now: number): {
+        expired: number;
+        awakened: number;
+    };
+    private requireClaim;
+    private feedbackTransition;
+    private opportunityDedupeKey;
+}