@xopcai/xopc 0.0.248 → 0.0.250

package/dist/src/memory-maintenance/schedule.js

@@ -0,0 +1,51 @@
+//#region src/memory-maintenance/schedule.ts
+const MEMORY_MAINTENANCE_TOKEN = "__xopc_memory_maintenance__";
+const WEEKDAY = {
+	sun: 0,
+	mon: 1,
+	tue: 2,
+	wed: 3,
+	thu: 4,
+	fri: 5,
+	sat: 6
+};
+function cronAt(time, weekday) {
+	const [hour, minute] = time.split(":").map(Number);
+	return `${minute} ${hour} * * ${weekday ?? "*"}`;
+}
+function resolveMemoryMaintenanceSchedules(config) {
+	const maintenance = config.userContext.userModel.maintenance;
+	if (!config.userContext.enabled || !config.userContext.userModel.enabled || !maintenance.enabled) return [];
+	const timezone = maintenance.timezone ?? Intl.DateTimeFormat().resolvedOptions().timeZone ?? "UTC";
+	return [
+		{
+			jobType: "temporal_sweep",
+			automationId: "system-memory-temporal-sweep",
+			name: "Memory temporal sweep",
+			cron: `*/${maintenance.temporalSweepMinutes} * * * *`,
+			timezone
+		},
+		{
+			jobType: "daily_reconciliation",
+			automationId: "system-memory-daily-reconciliation",
+			name: "Memory daily reconciliation",
+			cron: cronAt(maintenance.dailyTime),
+			timezone
+		},
+		{
+			jobType: "weekly_knowledge",
+			automationId: "system-memory-weekly-knowledge",
+			name: "Memory weekly knowledge maintenance",
+			cron: cronAt(maintenance.weeklyTime, WEEKDAY[maintenance.weeklyDay]),
+			timezone
+		}
+	];
+}
+function maintenanceInstruction(jobType) {
+	return `${MEMORY_MAINTENANCE_TOKEN}:${jobType}`;
+}
+function parseMaintenanceInstruction(value) {
+	return new RegExp(`${MEMORY_MAINTENANCE_TOKEN}:(temporal_sweep|daily_reconciliation|weekly_knowledge)`).exec(value)?.[1];
+}
+//#endregion
+export { MEMORY_MAINTENANCE_TOKEN, maintenanceInstruction, parseMaintenanceInstruction, resolveMemoryMaintenanceSchedules };

package/dist/src/memory-maintenance/service.d.ts

@@ -0,0 +1,28 @@
+export type MemoryMaintenanceJob = 'temporal_sweep' | 'daily_reconciliation' | 'weekly_knowledge' | 'manual_repair';
+export interface MemoryMaintenanceMetrics {
+    scanned: number;
+    stale: number;
+    needsReview: number;
+    activated: number;
+    expiredPriorities: number;
+    archived: number;
+    repairedIndexes: number;
+}
+export interface MemoryMaintenanceResult {
+    runId: string;
+    jobType: MemoryMaintenanceJob;
+    status: 'running' | 'completed' | 'failed';
+    skipped: boolean;
+    metrics: MemoryMaintenanceMetrics;
+}
+export interface RunMemoryMaintenanceInput {
+    jobType: MemoryMaintenanceJob;
+    principalId?: string;
+    now?: number;
+    idempotencyKey?: string;
+    limit?: number;
+    staleRetentionDays?: number;
+    evidenceThreshold?: number;
+}
+export declare function runMemoryMaintenance(input: RunMemoryMaintenanceInput): MemoryMaintenanceResult;
+export declare function listMemoryMaintenanceRuns(limit?: number): Array<Record<string, unknown>>;

package/dist/src/memory-maintenance/service.js

@@ -0,0 +1,216 @@
+import { getSqliteDatabase, runSqliteWriteTransaction } from "../storage/sqlite/transaction.js";
+import "../user-model/domain.js";
+import { randomUUID } from "node:crypto";
+//#region src/memory-maintenance/service.ts
+const ALGORITHM_VERSION = "user-model-maintenance-v1";
+function emptyMetrics() {
+	return {
+		scanned: 0,
+		stale: 0,
+		needsReview: 0,
+		activated: 0,
+		expiredPriorities: 0,
+		archived: 0,
+		repairedIndexes: 0
+	};
+}
+function periodKey(job, now) {
+	const date = new Date(now);
+	if (job === "temporal_sweep") return date.toISOString().slice(0, 13);
+	if (job === "daily_reconciliation") return date.toISOString().slice(0, 10);
+	if (job === "weekly_knowledge") {
+		const monday = new Date(Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate()));
+		const day = monday.getUTCDay() || 7;
+		monday.setUTCDate(monday.getUTCDate() - day + 1);
+		return monday.toISOString().slice(0, 10);
+	}
+	return String(now);
+}
+function addDecision(db, runId, objectType, objectId, action, reason, before, after, now) {
+	db.prepare(`INSERT INTO memory_maintenance_decisions (
+    decision_id, run_id, object_type, object_id, action, reason, before_json, after_json, created_at
+  ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(randomUUID(), runId, objectType, objectId, action, reason, before === void 0 ? null : JSON.stringify(before), after === void 0 ? null : JSON.stringify(after), now);
+}
+function transitionAssertions(db, runId, now, limit, metrics) {
+	const expired = db.prepare(`SELECT assertion_id, status, valid_to FROM user_assertions
+    WHERE status = 'active' AND valid_to IS NOT NULL AND valid_to < ? LIMIT ?`).all(now, limit);
+	metrics.scanned += expired.length;
+	for (const row of expired) {
+		db.prepare("UPDATE user_assertions SET status = 'stale' WHERE assertion_id = ? AND status = 'active'").run(row.assertion_id);
+		db.prepare(`INSERT INTO user_assertion_status_events (
+      event_id, assertion_id, from_status, to_status, actor_type, reason, source_run_id, created_at
+    ) VALUES (?, ?, 'active', 'stale', 'maintenance', 'Validity interval ended.', ?, ?)`).run(randomUUID(), row.assertion_id, runId, now);
+		addDecision(db, runId, "assertion", row.assertion_id, "stale", "validity_ended", row, { status: "stale" }, now);
+		metrics.stale += 1;
+	}
+	const reviewDue = db.prepare(`SELECT assertion_id, status, review_at FROM user_assertions
+    WHERE status = 'active' AND review_at IS NOT NULL AND review_at <= ? LIMIT ?`).all(now, Math.max(0, limit - expired.length));
+	metrics.scanned += reviewDue.length;
+	for (const row of reviewDue) {
+		db.prepare("UPDATE user_assertions SET status = 'needs_review' WHERE assertion_id = ? AND status = 'active'").run(row.assertion_id);
+		db.prepare(`INSERT INTO user_assertion_status_events (
+      event_id, assertion_id, from_status, to_status, actor_type, reason, source_run_id, created_at
+    ) VALUES (?, ?, 'active', 'needs_review', 'maintenance', 'Scheduled review became due.', ?, ?)`).run(randomUUID(), row.assertion_id, runId, now);
+		addDecision(db, runId, "assertion", row.assertion_id, "needs_review", "review_due", row, { status: "needs_review" }, now);
+		metrics.needsReview += 1;
+	}
+}
+function transitionPriorities(db, runId, principalId, now, limit, metrics) {
+	const rows = db.prepare(`SELECT priority_id, status, valid_to FROM user_priority_windows
+    WHERE principal_id = ? AND status = 'active' AND valid_to < ? LIMIT ?`).all(principalId, now, limit);
+	metrics.scanned += rows.length;
+	for (const row of rows) {
+		db.prepare("UPDATE user_priority_windows SET status = 'expired', updated_at = ? WHERE priority_id = ?").run(now, row.priority_id);
+		addDecision(db, runId, "priority", row.priority_id, "expired", "priority_window_ended", row, { status: "expired" }, now);
+		metrics.expiredPriorities += 1;
+	}
+}
+function transitionKnowledge(db, runId, principalId, now, limit, metrics) {
+	const expired = db.prepare(`SELECT knowledge_id, status, expires_at FROM knowledge_items
+    WHERE principal_id = ? AND status = 'active' AND expires_at IS NOT NULL AND expires_at < ? LIMIT ?`).all(principalId, now, limit);
+	metrics.scanned += expired.length;
+	for (const row of expired) {
+		db.prepare("UPDATE knowledge_items SET status = 'stale', updated_at = ? WHERE knowledge_id = ?").run(now, row.knowledge_id);
+		addDecision(db, runId, "knowledge", row.knowledge_id, "stale", "retention_expired", row, { status: "stale" }, now);
+		metrics.stale += 1;
+	}
+	const reviewDue = db.prepare(`SELECT knowledge_id, status, review_at FROM knowledge_items
+    WHERE principal_id = ? AND status = 'active' AND review_at IS NOT NULL AND review_at <= ? LIMIT ?`).all(principalId, now, Math.max(0, limit - expired.length));
+	metrics.scanned += reviewDue.length;
+	for (const row of reviewDue) {
+		db.prepare("UPDATE knowledge_items SET status = 'needs_review', updated_at = ? WHERE knowledge_id = ?").run(now, row.knowledge_id);
+		addDecision(db, runId, "knowledge", row.knowledge_id, "needs_review", "review_due", row, { status: "needs_review" }, now);
+		metrics.needsReview += 1;
+	}
+}
+function reconcileEvidence(db, runId, principalId, now, limit, evidenceThreshold, metrics) {
+	const contradicted = db.prepare(`SELECT DISTINCT a.assertion_id, a.status
+    FROM user_assertions a
+    JOIN user_assertion_slots s ON s.slot_id = a.slot_id
+    JOIN user_assertion_evidence ae ON ae.assertion_id = a.assertion_id AND ae.relation = 'contradicts'
+    WHERE s.principal_id = ? AND a.status = 'active' LIMIT ?`).all(principalId, limit);
+	metrics.scanned += contradicted.length;
+	for (const row of contradicted) {
+		db.prepare("UPDATE user_assertions SET status = 'needs_review' WHERE assertion_id = ?").run(row.assertion_id);
+		db.prepare(`INSERT INTO user_assertion_status_events (
+      event_id, assertion_id, from_status, to_status, actor_type, reason, source_run_id, created_at
+    ) VALUES (?, ?, 'active', 'needs_review', 'maintenance', 'Contradictory evidence exists.', ?, ?)`).run(randomUUID(), row.assertion_id, runId, now);
+		addDecision(db, runId, "assertion", row.assertion_id, "needs_review", "contradictory_evidence", row, { status: "needs_review" }, now);
+		metrics.needsReview += 1;
+	}
+	const candidates = db.prepare(`SELECT a.assertion_id, a.status, COUNT(DISTINCT
+      e.source_type || ':' || COALESCE(e.source_instance_id, '') || ':' || e.source_ref
+    ) AS evidence_count
+    FROM user_assertions a
+    JOIN user_assertion_slots s ON s.slot_id = a.slot_id
+    JOIN user_assertion_evidence ae ON ae.assertion_id = a.assertion_id AND ae.relation = 'supports'
+    JOIN context_evidence e ON e.evidence_id = ae.evidence_id AND e.trust_level = 'owner'
+    WHERE s.principal_id = ? AND a.status = 'candidate'
+      AND a.authority IN ('user_observed', 'system_inferred')
+    GROUP BY a.assertion_id HAVING evidence_count >= ? LIMIT ?`).all(principalId, evidenceThreshold, limit);
+	metrics.scanned += candidates.length;
+	for (const row of candidates) {
+		db.prepare("UPDATE user_assertions SET status = 'active' WHERE assertion_id = ? AND status = 'candidate'").run(row.assertion_id);
+		db.prepare(`INSERT INTO user_assertion_status_events (
+      event_id, assertion_id, from_status, to_status, actor_type, reason, source_run_id, created_at
+    ) VALUES (?, ?, 'candidate', 'active', 'maintenance', 'Independent owner evidence threshold met.', ?, ?)`).run(randomUUID(), row.assertion_id, runId, now);
+		addDecision(db, runId, "assertion", row.assertion_id, "activated", "owner_evidence_threshold", row, { status: "active" }, now);
+		metrics.activated += 1;
+	}
+}
+function repairIndexes(db, runId, now, metrics) {
+	const assertionMissing = db.prepare(`SELECT COUNT(*) AS count FROM user_assertions a
+    LEFT JOIN user_assertions_fts f ON f.assertion_id = a.assertion_id
+    WHERE f.assertion_id IS NULL`).get();
+	const knowledgeMissing = db.prepare(`SELECT COUNT(*) AS count FROM knowledge_items k
+    LEFT JOIN knowledge_items_fts f ON f.knowledge_id = k.knowledge_id
+    WHERE f.knowledge_id IS NULL`).get();
+	if (assertionMissing.count) db.prepare(`INSERT INTO user_assertions_fts(statement, assertion_id, slot_id)
+      SELECT a.statement, a.assertion_id, a.slot_id FROM user_assertions a
+      LEFT JOIN user_assertions_fts f ON f.assertion_id = a.assertion_id WHERE f.assertion_id IS NULL`).run();
+	if (knowledgeMissing.count) db.prepare(`INSERT INTO knowledge_items_fts(content, knowledge_id)
+      SELECT k.content, k.knowledge_id FROM knowledge_items k
+      LEFT JOIN knowledge_items_fts f ON f.knowledge_id = k.knowledge_id WHERE f.knowledge_id IS NULL`).run();
+	metrics.repairedIndexes = assertionMissing.count + knowledgeMissing.count;
+	if (metrics.repairedIndexes) addDecision(db, runId, "index", "fts", "repair", "missing_index_rows", { missing: metrics.repairedIndexes }, { missing: 0 }, now);
+}
+function archiveOldKnowledge(db, runId, principalId, cutoff, now, limit, metrics) {
+	const rows = db.prepare(`SELECT knowledge_id, status, updated_at FROM knowledge_items
+    WHERE principal_id = ? AND status = 'stale' AND updated_at < ? LIMIT ?`).all(principalId, cutoff, limit);
+	metrics.scanned += rows.length;
+	for (const row of rows) {
+		db.prepare("UPDATE knowledge_items SET status = 'archived', updated_at = ? WHERE knowledge_id = ?").run(now, row.knowledge_id);
+		addDecision(db, runId, "knowledge", row.knowledge_id, "archived", "stale_retention_elapsed", row, { status: "archived" }, now);
+		metrics.archived += 1;
+	}
+}
+function runMemoryMaintenance(input) {
+	const now = input.now ?? Date.now();
+	const principalId = input.principalId ?? "local-owner";
+	const limit = Math.max(1, Math.min(1e4, input.limit ?? 1e3));
+	const evidenceThreshold = Math.max(2, Math.min(10, input.evidenceThreshold ?? 2));
+	const idempotencyKey = input.idempotencyKey ?? `${principalId}:${input.jobType}:${periodKey(input.jobType, now)}`;
+	const existing = getSqliteDatabase().prepare(`SELECT run_id, status, metrics_json
+    FROM memory_maintenance_runs WHERE idempotency_key = ?`).get(idempotencyKey);
+	if (existing && existing.status !== "failed") return {
+		runId: existing.run_id,
+		jobType: input.jobType,
+		status: existing.status,
+		skipped: true,
+		metrics: JSON.parse(existing.metrics_json)
+	};
+	const runId = existing?.run_id ?? randomUUID();
+	const metrics = emptyMetrics();
+	const snapshot = JSON.stringify({
+		limit,
+		staleRetentionDays: input.staleRetentionDays ?? 30,
+		evidenceThreshold
+	});
+	runSqliteWriteTransaction((db) => {
+		if (existing) db.prepare(`UPDATE memory_maintenance_runs SET status = 'running', config_snapshot_json = ?,
+        cursor_json = '{}', metrics_json = '{}', error_message = NULL, started_at = ?, finished_at = NULL
+        WHERE run_id = ?`).run(snapshot, now, runId);
+		else db.prepare(`INSERT INTO memory_maintenance_runs (
+        run_id, principal_id, job_type, idempotency_key, algorithm_version,
+        config_snapshot_json, status, started_at
+      ) VALUES (?, ?, ?, ?, ?, ?, 'running', ?)`).run(runId, principalId, input.jobType, idempotencyKey, ALGORITHM_VERSION, snapshot, now);
+	});
+	try {
+		runSqliteWriteTransaction((db) => {
+			transitionAssertions(db, runId, now, limit, metrics);
+			transitionPriorities(db, runId, principalId, now, limit, metrics);
+			transitionKnowledge(db, runId, principalId, now, limit, metrics);
+			if (input.jobType === "daily_reconciliation" || input.jobType === "manual_repair") {
+				reconcileEvidence(db, runId, principalId, now, limit, evidenceThreshold, metrics);
+				repairIndexes(db, runId, now, metrics);
+			}
+			if (input.jobType === "weekly_knowledge" || input.jobType === "manual_repair") archiveOldKnowledge(db, runId, principalId, now - (input.staleRetentionDays ?? 30) * 24 * 60 * 60 * 1e3, now, limit, metrics);
+			db.prepare(`UPDATE memory_maintenance_runs SET status = 'completed', metrics_json = ?, finished_at = ?
+        WHERE run_id = ?`).run(JSON.stringify(metrics), now, runId);
+		});
+		return {
+			runId,
+			jobType: input.jobType,
+			status: "completed",
+			skipped: false,
+			metrics
+		};
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		getSqliteDatabase().prepare(`UPDATE memory_maintenance_runs SET status = 'failed',
+      metrics_json = ?, error_message = ?, finished_at = ? WHERE run_id = ?`).run(JSON.stringify(metrics), message, now, runId);
+		throw error;
+	}
+}
+function listMemoryMaintenanceRuns(limit = 20) {
+	return getSqliteDatabase().prepare(`SELECT run_id AS runId, principal_id AS principalId,
+    job_type AS jobType, idempotency_key AS idempotencyKey, algorithm_version AS algorithmVersion,
+    status, metrics_json AS metricsJson, error_message AS errorMessage,
+    started_at AS startedAt, finished_at AS finishedAt
+    FROM memory_maintenance_runs ORDER BY started_at DESC LIMIT ?`).all(Math.max(1, Math.min(100, limit))).map(({ metricsJson, ...row }) => ({
+		...row,
+		metrics: typeof metricsJson === "string" ? JSON.parse(metricsJson) : {}
+	}));
+}
+//#endregion
+export { listMemoryMaintenanceRuns, runMemoryMaintenance };

package/dist/src/notes/service.d.ts

@@ -46,6 +46,7 @@ export declare class NotesService {
         offset: number;
         hasMore: boolean;
     }>;
+    listProjectSummaries(): import("./types.js").NoteProjectSummary[];
     addAttachment(noteId: string, file: {
         name: string;
         buffer: Buffer;

package/dist/src/notes/service.js

@@ -2,6 +2,7 @@ import { createLogger } from "../utils/logger/index.js";
 import { init_logger } from "../utils/logger.js";
 import { buildNoteAttachmentRef } from "./attachment-ref.js";
 import { parseNoteMarkdown } from "./note-markdown.js";
+import { listNoteProjectSummaries } from "../storage/sqlite/notes-repository.js";
 import { changedFieldsFromPatch, emitActivity, previewText, systemActivityActor, systemActivitySource } from "../activity/emitter.js";
 import { getDefaultModelSync, init_providers, resolveModel } from "../providers/index.js";
 import { completeWithResolvedCredentials } from "../providers/model-call.js";
@@ -280,6 +281,7 @@ var NotesService = class {
 		const contentTouched = patch.markdown !== void 0 || patch.title !== void 0;
 		if (contentTouched) await this.maybeSaveSnapshot(existing, trigger);
 		const normalizedPatch = { ...patch };
+		if (contentTouched) normalizedPatch.lastEditTrigger = trigger;
 		if (patch.markdown !== void 0) normalizedPatch.kind = patch.kind ?? inferKind(patch.markdown, Boolean(existing.attachments?.length), existing.attachments);
 		if (contentTouched || patch.attachments) {
 			normalizedPatch.remoteVersion = (existing.remoteVersion ?? 1) + 1;
@@ -483,6 +485,9 @@ var NotesService = class {
 	async listNotes(query = {}) {
 		return this.store.listNotes(query);
 	}
+	listProjectSummaries() {
+		return listNoteProjectSummaries();
+	}
 	async addAttachment(noteId, file, idempotencyKey) {
 		if (!idempotencyKey) return this.addAttachmentWithId(noteId, file, randomUUID());
 		const attachmentId = noteAttachmentId(noteId, idempotencyKey);
@@ -555,7 +560,8 @@ var NotesService = class {
 			markdown: snapshot.markdown,
 			tags: snapshot.tags,
 			kind: snapshot.kind,
-			status: snapshot.status
+			status: snapshot.status,
+			lastEditTrigger: "restore"
 		});
 	}
 	async moveToGroup(noteId, groupId) {

package/dist/src/notes/types.d.ts

@@ -113,6 +113,8 @@ export interface Note {
     status: NoteStatus;
     /** Canonical note body. Markdown is the only content truth. */
     markdown: string;
+    /** Provenance of the latest content edit, independent of snapshot throttling. */
+    lastEditTrigger?: SnapshotTrigger;
     attachments?: NoteAttachment[];
     createdAt: number;
     updatedAt: number;
@@ -149,6 +151,18 @@ export interface NoteIndexEntry {
     taskCount?: number;
     uncheckedTaskCount?: number;
     linkCount?: number;
+    projects?: Array<{
+        id: string;
+        name: string;
+    }>;
+    lastEditTrigger?: SnapshotTrigger;
+}
+export interface NoteProjectSummary {
+    id: string;
+    name: string;
+    description?: string;
+    noteCount: number;
+    updatedAt?: number;
 }
 export interface NotesIndexFile {
     version: number;
@@ -175,6 +189,8 @@ export interface NotesListQuery {
     kind?: NoteKind;
     tag?: string;
     projectId?: string;
+    unassigned?: boolean;
+    agentEdited?: boolean;
     pinned?: boolean;
     search?: string;
     limit?: number;

package/dist/src/notifications/planner.js

@@ -122,7 +122,11 @@ function automationPlan(payload) {
 function proactivePlan(payload) {
 	if (!payload || typeof payload !== "object") return null;
 	const item = payload;
-	if (typeof item.id !== "string" || typeof item.insight?.id !== "string" || typeof item.insight.title !== "string") return null;
+	if (typeof item.id !== "string" || typeof item.insightId !== "string" || typeof item.insight.title !== "string") return null;
+	const requiresDecision = item.insight.attentionKind === "decision";
+	const highUrgency = item.insight.urgency === "high" || item.insight.urgency === "critical";
+	if (item.insight.attentionKind === "receipt") return null;
+	if (!requiresDecision && !highUrgency) return null;
 	const title = item.insight.title.trim().slice(0, 120);
 	const summary = typeof item.insight.summary === "string" ? item.insight.summary.trim().slice(0, 180) : "";
 	return {
@@ -133,7 +137,7 @@ function proactivePlan(payload) {
 				kind: "insight",
 				inboxItemId: item.id
 			},
-			priority: item.insight.urgency === "high" || item.insight.urgency === "critical" ? "high" : "normal",
+			priority: requiresDecision || highUrgency ? "high" : "normal",
 			title: {
 				en: title,
 				zh: title
@@ -144,7 +148,7 @@ function proactivePlan(payload) {
 			} } : {},
 			payload: {
 				inboxItemId: item.id,
-				insightId: item.insight.id
+				insightId: item.insightId
 			}
 		}
 	};

package/dist/src/proactive/actions/service.d.ts

@@ -1,2 +1 @@
 export declare function executePendingProactiveActions(now?: Date): number;
-export declare function resolveProactiveActionDecision(inboxItemId: string, choice: string, now?: Date): void;

package/dist/src/proactive/actions/service.js

@@ -67,14 +67,5 @@ function executePendingProactiveActions(now = /* @__PURE__ */ new Date()) {
 		executed += 1;
 	}
 }
-function resolveProactiveActionDecision(inboxItemId, choice, now = /* @__PURE__ */ new Date()) {
-	const row = getSqliteDatabase().prepare(`SELECT x.insight_id, x.action_status
-    FROM proactive_inbox_items i JOIN proactive_insights x ON x.insight_id = i.insight_id
-    WHERE i.inbox_item_id = ?`).get(inboxItemId);
-	if (!row || row.action_status !== "approval_required") return;
-	getSqliteDatabase().prepare(`UPDATE proactive_insights SET action_status = ?, action_updated_at = ?
-    WHERE insight_id = ? AND action_status = 'approval_required'`).run(choice === "approve" ? "pending" : "rejected", now.toISOString(), row.insight_id);
-	if (choice === "approve") executePendingProactiveActions(now);
-}
 //#endregion
-export { executePendingProactiveActions, resolveProactiveActionDecision };
+export { executePendingProactiveActions };

package/dist/src/proactive/execution/context.d.ts

@@ -1,44 +1,42 @@
 import type { ContextProvider, ResolvedContext } from './types.js';
+import type { ScenarioDefinition } from '../scenarios/types.js';
 type ContextInput = Parameters<ContextProvider['collect']>[0];
 export declare class EventBatchContextProvider implements ContextProvider {
     readonly id = "event_batch";
-    supports(): boolean;
     collect(input: ContextInput): Promise<ResolvedContext>;
 }
 export declare class ConnectedSourceContextProvider implements ContextProvider {
     readonly id = "connected_source";
-    supports(): boolean;
     collect(input: ContextInput): Promise<ResolvedContext>;
 }
 export declare class InternalObjectContextProvider implements ContextProvider {
     readonly id = "internal_objects";
-    supports(): boolean;
     collect(input: ContextInput): Promise<ResolvedContext>;
 }
-export declare class UserUnderstandingContextProvider implements ContextProvider {
-    readonly id = "user_understanding";
-    supports(): boolean;
+export declare class UserModelContextProvider implements ContextProvider {
+    readonly id = "user_model";
     collect(input: ContextInput): Promise<ResolvedContext>;
 }
 export declare class MeetingWorkspaceContextProvider implements ContextProvider {
     readonly id = "meeting_workspace";
-    supports(scenarioKey: string): boolean;
     collect(input: ContextInput): Promise<ResolvedContext>;
 }
 export declare class ProjectStateContextProvider implements ContextProvider {
     readonly id = "project_state";
-    supports(scenarioKey: string): boolean;
     collect(input: ContextInput): Promise<ResolvedContext>;
 }
 export declare class AutomationStateContextProvider implements ContextProvider {
     readonly id = "automation_state";
-    supports(scenarioKey: string): boolean;
+    collect(input: ContextInput): Promise<ResolvedContext>;
+}
+export declare class DiscussionContextProvider implements ContextProvider {
+    readonly id = "discussion";
     collect(input: ContextInput): Promise<ResolvedContext>;
 }
 export declare class ContextProviderRegistry {
     private readonly providers;
     constructor(providers?: ContextProvider[]);
-    collect(scenarioKey: string, input: {
+    collect(scenario: ScenarioDefinition, input: {
         batchId: string;
         eventIds: string[];
         subscriptionId: string;