@xopcai/xopc 0.0.178 → 0.0.179

package/dist/src/proactive/events/product-event-bridge.d.ts

@@ -0,0 +1,7 @@
+import type { AutomationEvent } from '../../automations/domain/types.js';
+import type { PublishEventInput } from './types.js';
+export declare function mapProductEventToProactive(input: {
+    event: AutomationEvent;
+    workspaceId: string;
+    defaultAgentId: string;
+}): PublishEventInput | null;

package/dist/src/proactive/events/product-event-bridge.js

@@ -0,0 +1,84 @@
+//#region src/proactive/events/product-event-bridge.ts
+const SUPPORTED_EVENT_TYPES = new Set([
+	"goal.created",
+	"goal.status_changed",
+	"note.created",
+	"note.updated",
+	"workflow.run.completed",
+	"session.transcript.updated",
+	"discussion.completed"
+]);
+function stringValue(payload, key) {
+	const value = payload[key];
+	return typeof value === "string" && value.trim() ? value : void 0;
+}
+function subjectFor(event) {
+	const payload = event.payload ?? {};
+	if (event.type.startsWith("goal.")) {
+		const id = stringValue(payload, "goalId");
+		return id ? {
+			kind: "goal",
+			id
+		} : null;
+	}
+	if (event.type.startsWith("note.")) {
+		const id = stringValue(payload, "noteId");
+		return id ? {
+			kind: "note",
+			id
+		} : null;
+	}
+	if (event.type === "workflow.run.completed") {
+		const id = stringValue(payload, "runId");
+		return id ? {
+			kind: "workflow_run",
+			id
+		} : null;
+	}
+	if (event.type === "session.transcript.updated") {
+		const id = stringValue(payload, "sessionKey");
+		return id ? {
+			kind: "session",
+			id
+		} : null;
+	}
+	if (event.type === "discussion.completed") {
+		const id = stringValue(payload, "discussionId");
+		return id ? {
+			kind: "discussion",
+			id
+		} : null;
+	}
+	return null;
+}
+function mapProductEventToProactive(input) {
+	if (!SUPPORTED_EVENT_TYPES.has(input.event.type)) return null;
+	const subject = subjectFor(input.event);
+	if (!subject) return null;
+	const payload = input.event.payload ?? {};
+	const occurredAtMs = Number.isFinite(input.event.occurredAtMs) ? input.event.occurredAtMs : Date.now();
+	const versionId = stringValue(payload, "messageId") ?? stringValue(payload, "runId") ?? String(occurredAtMs);
+	const agentId = stringValue(payload, "agentId") ?? input.defaultAgentId;
+	const projectId = stringValue(payload, "projectId");
+	return {
+		type: `${input.event.type}.v1`,
+		schemaVersion: 1,
+		source: {
+			kind: "internal",
+			id: input.event.source ?? "xopc"
+		},
+		subject,
+		actor: { kind: "system" },
+		scope: {
+			workspaceId: input.workspaceId,
+			agentId,
+			...projectId ? { projectId } : {}
+		},
+		occurredAt: new Date(occurredAtMs).toISOString(),
+		dedupeKey: `product-event:${input.event.type}:${subject.id}:${versionId}`,
+		sensitivity: "personal",
+		payload
+	};
+}
+//#endregion
+export { mapProductEventToProactive };

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

@@ -1,24 +1,39 @@
-import type { ContextProvider } from './types.js';
+import type { ContextProvider, ResolvedContext } from './types.js';
+type ContextInput = Parameters<ContextProvider['collect']>[0];
 export declare class EventBatchContextProvider implements ContextProvider {
     readonly id = "event_batch";
     supports(): boolean;
-    collect(input: {
-        eventIds: string[];
-    }): Promise<Record<string, unknown>>;
+    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;
+    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: {
-        eventIds: string[];
-    }): Promise<Record<string, unknown>>;
+    collect(input: ContextInput): Promise<ResolvedContext>;
 }
 export declare class AutomationStateContextProvider implements ContextProvider {
     readonly id = "automation_state";
     supports(scenarioKey: string): boolean;
-    collect(input: {
-        eventIds: string[];
-    }): Promise<Record<string, unknown>>;
+    collect(input: ContextInput): Promise<ResolvedContext>;
 }
 export declare class ContextProviderRegistry {
     private readonly providers;
@@ -27,5 +42,6 @@ export declare class ContextProviderRegistry {
         batchId: string;
         eventIds: string[];
         subscriptionId: string;
-    }): Promise<Record<string, unknown>>;
+    }): Promise<ResolvedContext>;
 }
+export {};

package/dist/src/proactive/execution/context.js

@@ -1,23 +1,226 @@
 import { getSqliteDatabase } from "../../storage/sqlite/transaction.js";
+import { listMemoryRecords } from "../../storage/sqlite/memory-records-repository.js";
+import { getKnowledgeSourceItem } from "../../storage/sqlite/knowledge-repository.js";
+import { getConnectorSyncPolicy } from "../../storage/sqlite/connector-sync-policy-repository.js";
+import { wrapExternalContent } from "../../gateway/security/external-content.js";
 //#region src/proactive/execution/context.ts
+const MAX_EVENT_COUNT = 50;
+function boundedText(value, limit) {
+	if (typeof value !== "string") return void 0;
+	const normalized = value.trim();
+	if (!normalized) return void 0;
+	return normalized.length > limit ? `${normalized.slice(0, limit)}…` : normalized;
+}
+function eventRows(eventIds) {
+	const ids = [...new Set(eventIds)].slice(0, MAX_EVENT_COUNT);
+	if (ids.length === 0) return [];
+	return getSqliteDatabase().prepare(`SELECT event_id, type, subject_kind, subject_id, payload_json,
+      workspace_id, project_id, agent_id, occurred_at FROM proactive_events
+      WHERE event_id IN (${ids.map(() => "?").join(",")}) ORDER BY occurred_at`).all(...ids);
+}
+function emptyContext() {
+	return {
+		content: {},
+		snapshotContent: {},
+		evidenceIds: []
+	};
+}
+function authorizedConnectedSourceItem(event, scenarioKey) {
+	const item = getKnowledgeSourceItem(event.subject_id);
+	const connectionId = typeof item?.metadata.connectionId === "string" ? item.metadata.connectionId : void 0;
+	if (!item || item.deletedAt || !connectionId) return null;
+	if (item.sensitivity === "secret" || item.sensitivity === "regulated") return null;
+	if (item.metadata.workspaceId !== event.workspace_id) return null;
+	if (event.agent_id && item.metadata.agentId && item.metadata.agentId !== event.agent_id) return null;
+	const policy = getConnectorSyncPolicy(connectionId);
+	const scenarioAllowed = !policy?.allowedScenarioKeys.length || policy.allowedScenarioKeys.includes(scenarioKey);
+	return policy?.scanEnabled && policy.proactiveEnabled && scenarioAllowed ? item : null;
+}
 var EventBatchContextProvider = class {
 	id = "event_batch";
 	supports() {
 		return true;
 	}
 	async collect(input) {
-		if (input.eventIds.length === 0) return { events: [] };
-		return { events: getSqliteDatabase().prepare(`SELECT event_id, type, subject_kind, subject_id, payload_json, occurred_at
-      FROM proactive_events WHERE event_id IN (${input.eventIds.map(() => "?").join(",")}) ORDER BY occurred_at`).all(...input.eventIds).map((row) => ({
-			evidenceId: row.event_id,
-			type: row.type,
-			subject: {
-				kind: row.subject_kind,
-				id: row.subject_id
+		const rows = eventRows(input.eventIds).filter((row) => !row.type.startsWith("connected_source.") || Boolean(authorizedConnectedSourceItem(row, input.scenarioKey)));
+		return {
+			content: { events: rows.map((row) => ({
+				evidenceId: row.event_id,
+				type: row.type,
+				subject: {
+					kind: row.subject_kind,
+					id: row.subject_id
+				},
+				payload: JSON.parse(row.payload_json),
+				occurredAt: row.occurred_at
+			})) },
+			evidenceIds: rows.map((row) => row.event_id)
+		};
+	}
+};
+var ConnectedSourceContextProvider = class {
+	id = "connected_source";
+	supports() {
+		return true;
+	}
+	async collect(input) {
+		const items = [];
+		const snapshotItems = [];
+		const evidenceIds = [];
+		for (const event of eventRows(input.eventIds)) {
+			if (!event.type.startsWith("connected_source.") || event.type.includes("_deleted.")) continue;
+			const item = authorizedConnectedSourceItem(event, input.scenarioKey);
+			if (!item) continue;
+			const evidenceId = `source-item:${item.id}`;
+			const common = {
+				evidenceId,
+				sourceItemId: item.id,
+				sourceInstanceId: item.sourceInstanceId,
+				collectionScope: item.collectionScope,
+				itemType: item.itemType,
+				occurredAt: item.occurredAt,
+				sourceUpdatedAt: item.sourceUpdatedAt
+			};
+			const content = boundedText(item.normalizedText, 6e3);
+			items.push({
+				...common,
+				...content ? { content: wrapExternalContent(content, { source: item.itemType === "email" || item.itemType === "message" ? "email" : "api" }) } : {}
+			});
+			snapshotItems.push({
+				...common,
+				contentHash: item.contentHash,
+				sensitivity: item.sensitivity
+			});
+			evidenceIds.push(evidenceId);
+			if (items.length >= 20) break;
+		}
+		return {
+			content: { items },
+			snapshotContent: { items: snapshotItems },
+			evidenceIds
+		};
+	}
+};
+var InternalObjectContextProvider = class {
+	id = "internal_objects";
+	supports() {
+		return true;
+	}
+	async collect(input) {
+		const db = getSqliteDatabase();
+		const objects = [];
+		const evidenceIds = [];
+		for (const event of eventRows(input.eventIds)) {
+			if (event.subject_kind === "goal") {
+				const goal = db.prepare(`SELECT goal_id, title, description, status, agent_id, priority,
+          deadline_at, updated_at, next_action, blocked_reason FROM goals WHERE goal_id = ?`).get(event.subject_id);
+				if (goal) {
+					const evidenceId = `goal:${event.subject_id}`;
+					objects.push({
+						evidenceId,
+						kind: "goal",
+						...goal
+					});
+					evidenceIds.push(evidenceId);
+				}
+			} else if (event.subject_kind === "note") {
+				const note = db.prepare(`SELECT note_id, title, kind, status, snippet, pinned, tags_json,
+          task_done, task_due_at, unchecked_task_count, updated_at FROM notes WHERE note_id = ?`).get(event.subject_id);
+				if (note) {
+					const evidenceId = `note:${event.subject_id}`;
+					objects.push({
+						...note,
+						evidenceId,
+						kind: "note",
+						snippet: boundedText(note.snippet, 1500)
+					});
+					evidenceIds.push(evidenceId);
+				}
+			}
+			if (objects.length >= 20) break;
+		}
+		return {
+			content: { objects },
+			evidenceIds
+		};
+	}
+};
+var UserUnderstandingContextProvider = class {
+	id = "user_understanding";
+	supports() {
+		return true;
+	}
+	async collect(input) {
+		const scope = eventRows(input.eventIds).at(-1);
+		if (!scope) return emptyContext();
+		const records = listMemoryRecords({
+			workspaceId: scope.workspace_id,
+			...scope.project_id ? { visibleToProjectId: scope.project_id } : { unscopedProjectOnly: true },
+			status: "active",
+			limit: 20
+		}).filter((record) => {
+			const now = Date.now();
+			return record.disclosurePolicy === "referenceable" && record.sensitivity !== "secret" && record.sensitivity !== "regulated" && !record.tags?.includes("playbook:disabled") && (!record.validFrom || Date.parse(record.validFrom) <= now) && (!record.validTo || Date.parse(record.validTo) >= now) && (!record.expiresAt || Date.parse(record.expiresAt) >= now) && (!record.reviewAfter || Date.parse(record.reviewAfter) >= now) && !record.conflictGroupId && (record.explicitness === "explicit" || record.importance >= .7);
+		});
+		return {
+			content: { records: records.map((record) => ({
+				evidenceId: `memory:${record.id}`,
+				kind: record.kind,
+				content: boundedText(record.content, 1e3),
+				confidence: record.confidence,
+				importance: record.importance,
+				updatedAt: record.updatedAt
+			})) },
+			evidenceIds: records.map((record) => `memory:${record.id}`)
+		};
+	}
+};
+var MeetingWorkspaceContextProvider = class {
+	id = "meeting_workspace";
+	supports(scenarioKey) {
+		return scenarioKey === "meeting_preparation";
+	}
+	async collect(input) {
+		const scope = eventRows(input.eventIds).at(-1);
+		if (!scope) return emptyContext();
+		const calendarItem = authorizedConnectedSourceItem(scope, input.scenarioKey);
+		if (!calendarItem?.normalizedText) return emptyContext();
+		let title = "";
+		try {
+			const parsed = JSON.parse(calendarItem.normalizedText);
+			title = typeof parsed.title === "string" ? parsed.title : "";
+		} catch {
+			return emptyContext();
+		}
+		const terms = [...new Set(title.toLocaleLowerCase().match(/[\p{L}\p{N}]{2,}/gu) ?? [])].slice(0, 6);
+		if (terms.length === 0) return emptyContext();
+		const db = getSqliteDatabase();
+		const goalMatches = terms.map(() => `LOWER(COALESCE(title, '') || ' ' || COALESCE(description, '')
+      || ' ' || COALESCE(next_action, '')) LIKE ?`).join(" OR ");
+		const goals = db.prepare(`SELECT goal_id, title, description, status, priority, deadline_at,
+      next_action, blocked_reason, project_id, updated_at FROM goals
+      WHERE status NOT IN ('done', 'archived') AND agent_id = ? AND (${goalMatches})
+      ORDER BY updated_at DESC LIMIT 10`).all(scope.agent_id ?? "main", ...terms.map((term) => `%${term}%`));
+		const noteMatches = terms.map(() => `LOWER(COALESCE(title, '') || ' ' || COALESCE(snippet, '')) LIKE ?`).join(" OR ");
+		const notes = db.prepare(`SELECT note_id, title, kind, status, snippet, tags_json, task_due_at,
+      unchecked_task_count, updated_at FROM notes WHERE status NOT IN ('archived', 'trashed')
+      AND (${noteMatches}) ORDER BY updated_at DESC LIMIT 10`).all(...terms.map((term) => `%${term}%`));
+		const goalEvidenceIds = goals.map((goal) => `goal:${String(goal.goal_id)}`);
+		const noteEvidenceIds = notes.map((note) => `note:${String(note.note_id)}`);
+		return {
+			content: {
+				activeGoals: goals.map((goal, index) => ({
+					evidenceId: goalEvidenceIds[index],
+					...goal
+				})),
+				recentNotes: notes.map((note, index) => ({
+					evidenceId: noteEvidenceIds[index],
+					...note,
+					snippet: boundedText(note.snippet, 1500)
+				}))
 			},
-			payload: JSON.parse(row.payload_json),
-			occurredAt: row.occurred_at
-		})) };
+			evidenceIds: [...goalEvidenceIds, ...noteEvidenceIds]
+		};
 	}
 };
 var ProjectStateContextProvider = class {
@@ -26,15 +229,27 @@ var ProjectStateContextProvider = class {
 		return scenarioKey === "project_delivery_risk" || scenarioKey === "blocked_work";
 	}
 	async collect(input) {
-		if (!input.eventIds.length) return {};
+		if (!input.eventIds.length) return emptyContext();
 		const project = getSqliteDatabase().prepare(`SELECT p.* FROM proactive_events e JOIN projects p ON p.project_id = e.project_id
       WHERE e.event_id IN (${input.eventIds.map(() => "?").join(",")}) AND e.project_id IS NOT NULL ORDER BY e.occurred_at DESC LIMIT 1`).get(...input.eventIds);
-		if (!project) return {};
-		return {
-			project,
-			workItems: getSqliteDatabase().prepare(`SELECT id, title, status, priority, owner_agent_id, next_action,
+		if (!project) return emptyContext();
+		const workItems = getSqliteDatabase().prepare(`SELECT id, title, status, priority, owner_agent_id, next_action,
       blocked_reason, due_at, updated_at FROM work_items WHERE project_id = ? AND archived_at IS NULL
-      ORDER BY CASE status WHEN 'blocked' THEN 0 ELSE 1 END, updated_at DESC LIMIT 100`).all(String(project.project_id))
+      ORDER BY CASE status WHEN 'blocked' THEN 0 ELSE 1 END, updated_at DESC LIMIT 100`).all(String(project.project_id));
+		const projectEvidenceId = `project:${String(project.project_id)}`;
+		const workItemEvidenceIds = workItems.map((item) => `work-item:${String(item.id)}`);
+		return {
+			content: {
+				project: {
+					evidenceId: projectEvidenceId,
+					...project
+				},
+				workItems: workItems.map((item, index) => ({
+					evidenceId: workItemEvidenceIds[index],
+					...item
+				}))
+			},
+			evidenceIds: [projectEvidenceId, ...workItemEvidenceIds]
 		};
 	}
 };
@@ -44,29 +259,48 @@ var AutomationStateContextProvider = class {
 		return scenarioKey === "automation_failure_impact";
 	}
 	async collect(input) {
-		if (!input.eventIds.length) return {};
+		if (!input.eventIds.length) return emptyContext();
 		const run = getSqliteDatabase().prepare(`SELECT r.* FROM proactive_events e JOIN automation_runs r ON r.run_id = e.subject_id
       WHERE e.event_id IN (${input.eventIds.map(() => "?").join(",")}) ORDER BY e.occurred_at DESC LIMIT 1`).get(...input.eventIds);
-		if (!run) return {};
+		if (!run) return emptyContext();
+		const automation = getSqliteDatabase().prepare(`SELECT automation_id, name, description, enabled, reliability_json, state_json, project_id
+      FROM automations WHERE automation_id = ?`).get(String(run.automation_id));
+		const runEvidenceId = `automation-run:${String(run.run_id)}`;
 		return {
-			automation: getSqliteDatabase().prepare(`SELECT automation_id, name, description, enabled, reliability_json, state_json, project_id
-      FROM automations WHERE automation_id = ?`).get(String(run.automation_id)),
-			failedRun: run
+			content: {
+				automation,
+				failedRun: {
+					evidenceId: runEvidenceId,
+					...run
+				}
+			},
+			evidenceIds: [runEvidenceId]
 		};
 	}
 };
 var ContextProviderRegistry = class {
 	constructor(providers = [
 		new EventBatchContextProvider(),
+		new ConnectedSourceContextProvider(),
+		new InternalObjectContextProvider(),
+		new UserUnderstandingContextProvider(),
+		new MeetingWorkspaceContextProvider(),
 		new ProjectStateContextProvider(),
 		new AutomationStateContextProvider()
 	]) {
 		this.providers = providers;
 	}
 	async collect(scenarioKey, input) {
-		const entries = await Promise.all(this.providers.filter((provider) => provider.supports(scenarioKey)).map(async (provider) => [provider.id, await provider.collect(input)]));
-		return Object.fromEntries(entries);
+		const entries = await Promise.all(this.providers.filter((provider) => provider.supports(scenarioKey)).map(async (provider) => [provider.id, await provider.collect({
+			...input,
+			scenarioKey
+		})]));
+		return {
+			content: Object.fromEntries(entries.map(([id, result]) => [id, result.content])),
+			snapshotContent: Object.fromEntries(entries.map(([id, result]) => [id, result.snapshotContent ?? result.content])),
+			evidenceIds: [...new Set(entries.flatMap(([, result]) => result.evidenceIds))]
+		};
 	}
 };
 //#endregion
-export { AutomationStateContextProvider, ContextProviderRegistry, EventBatchContextProvider, ProjectStateContextProvider };
+export { AutomationStateContextProvider, ConnectedSourceContextProvider, ContextProviderRegistry, EventBatchContextProvider, InternalObjectContextProvider, MeetingWorkspaceContextProvider, ProjectStateContextProvider, UserUnderstandingContextProvider };

package/dist/src/proactive/execution/repository.js

@@ -1,5 +1,5 @@
 import { getSqliteDatabase, runSqliteWriteTransaction } from "../../storage/sqlite/transaction.js";
-import { randomUUID } from "node:crypto";
+import { createHash, randomUUID } from "node:crypto";
 //#region src/proactive/execution/repository.ts
 const str = (row, key) => String(row[key]);
 function claimNextRun(owner, now = /* @__PURE__ */ new Date(), leaseSeconds = 120) {
@@ -69,11 +69,23 @@ function attachSnapshot(runId, snapshotId) {
 function finishRun(input, now = /* @__PURE__ */ new Date()) {
 	return runSqliteWriteTransaction((db) => {
 		const nowIso = now.toISOString();
-		const valuable = Boolean(input.candidate);
+		const subjectScope = db.prepare(`SELECT DISTINCT e.subject_kind, e.subject_id
+      FROM proactive_batch_events be
+      JOIN proactive_events e ON e.event_id = be.event_id
+      WHERE be.batch_id = ?
+      ORDER BY e.subject_kind, e.subject_id`).all(input.run.batchId).map((row) => `${str(row, "subject_kind")}:${str(row, "subject_id")}`);
+		const fingerprint = input.candidate ? createHash("sha256").update([...subjectScope, ...[
+			input.candidate.title,
+			input.candidate.summary,
+			input.candidate.recommendation
+		].map((value) => value.trim().toLowerCase().replace(/\s+/g, " "))].join("\n")).digest("hex") : void 0;
+		const duplicate = fingerprint ? db.prepare(`SELECT 1 FROM proactive_insights
+      WHERE subscription_id = ? AND scenario_key = ? AND content_fingerprint = ? AND created_at >= ? LIMIT 1`).get(input.run.subscriptionId, input.run.scenarioKey, fingerprint, (/* @__PURE__ */ new Date(now.getTime() - 10080 * 6e4)).toISOString()) : void 0;
+		const valuable = Boolean(input.candidate) && !duplicate;
 		db.prepare(`UPDATE proactive_runs SET status = ?, raw_output = ?, model_ref = ?, lease_owner = NULL,
       lease_expires_at = NULL, completed_at = ?, updated_at = ? WHERE run_id = ?`).run(valuable ? "completed" : "discarded", input.rawOutput.slice(0, 2e4), input.modelRef ?? null, nowIso, nowIso, input.run.id);
 		db.prepare(`UPDATE proactive_signal_batches SET status = ?, updated_at = ? WHERE batch_id = ?`).run(valuable ? "processed" : "ignored", nowIso, input.run.batchId);
-		if (!input.candidate) return null;
+		if (!input.candidate || duplicate) return null;
 		const insight = {
 			...input.candidate,
 			id: randomUUID(),
@@ -84,8 +96,9 @@ function finishRun(input, now = /* @__PURE__ */ new Date()) {
 			createdAt: nowIso
 		};
 		db.prepare(`INSERT INTO proactive_insights (insight_id, run_id, subscription_id, scenario_key, title, summary,
-      why_now, impact, recommendation, work_done, decision_json, urgency, confidence, value_score, evidence_ids_json, created_at)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(insight.id, insight.runId, insight.subscriptionId, insight.scenarioKey, insight.title, insight.summary, insight.whyNow, insight.impact, insight.recommendation, insight.workDone, insight.decision ? JSON.stringify(insight.decision) : null, insight.urgency, insight.confidence, insight.valueScore, JSON.stringify(insight.evidenceIds), insight.createdAt);
+      why_now, impact, recommendation, work_done, decision_json, urgency, confidence, value_score,
+      evidence_ids_json, content_fingerprint, created_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(insight.id, insight.runId, insight.subscriptionId, insight.scenarioKey, insight.title, insight.summary, insight.whyNow, insight.impact, insight.recommendation, insight.workDone, insight.decision ? JSON.stringify(insight.decision) : null, insight.urgency, insight.confidence, insight.valueScore, JSON.stringify(insight.evidenceIds), fingerprint, insight.createdAt);
 		return insight;
 	});
 }

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

@@ -47,8 +47,14 @@ export interface ContextProvider {
     id: string;
     supports(scenarioKey: string): boolean;
     collect(input: {
+        scenarioKey: string;
         batchId: string;
         eventIds: string[];
         subscriptionId: string;
-    }): Promise<Record<string, unknown>>;
+    }): Promise<ResolvedContext>;
+}
+export interface ResolvedContext {
+    content: Record<string, unknown>;
+    snapshotContent?: Record<string, unknown>;
+    evidenceIds: string[];
 }

package/dist/src/proactive/execution/worker.js

@@ -1,8 +1,8 @@
 import { createLogger } from "../../utils/logger/index.js";
 import { init_logger } from "../../utils/logger.js";
-import { markReadyBatches } from "../routing/batch-repository.js";
 import { getPromptRevision, getScenario } from "../scenarios/repository.js";
 import { composeScenarioPrompt } from "../scenarios/prompt-composer.js";
+import { markReadyBatches } from "../routing/batch-repository.js";
 import { ContextProviderRegistry } from "./context.js";
 import { attachSnapshot, claimNextRun, eventIdsForBatch, failRun, finishRun, saveSnapshot } from "./repository.js";
 import { isValuableInsight, parseInsightCandidate, scoreInsight } from "./insight.js";
@@ -49,7 +49,7 @@ var ProactiveWorker = class {
 					eventIds,
 					subscriptionId: run.subscriptionId
 				});
-				const snapshot = saveSnapshot(run.batchId, context, eventIds);
+				const snapshot = saveSnapshot(run.batchId, context.snapshotContent ?? context.content, context.evidenceIds);
 				attachSnapshot(run.id, snapshot.id);
 				const prompt = composeScenarioPrompt({
 					scenario,
@@ -59,9 +59,9 @@ var ProactiveWorker = class {
 				const output = await this.executor.execute({
 					systemPrompt: prompt.platformSafety,
 					userPrompt: prompt.text,
-					authorizedContext: context
+					authorizedContext: context.content
 				});
-				const candidate = parseInsightCandidate(output.text, new Set(eventIds));
+				const candidate = parseInsightCandidate(output.text, new Set(context.evidenceIds));
 				const valuable = isValuableInsight(candidate);
 				const insight = finishRun({
 					run,
@@ -72,12 +72,13 @@ var ProactiveWorker = class {
 					rawOutput: output.text,
 					modelRef: output.modelRef
 				});
+				const disposition = insight ? "created" : valuable ? "duplicate_suppressed" : "value_gate_discarded";
 				log.info({
 					runId: run.id,
 					scenarioKey: run.scenarioKey,
-					valuable,
+					disposition,
 					insightId: insight?.id
-				}, valuable ? "Proactive insight created" : "Proactive output discarded by value gate");
+				}, insight ? "Proactive insight created" : "Proactive output discarded");
 			} catch (error) {
 				failRun(run, error, !(error instanceof Error && /Pinned scenario/.test(error.message)));
 				log.warn({

package/dist/src/proactive/inbox/repository.js

@@ -32,8 +32,14 @@ const SELECT_ITEM = `SELECT i.*, x.subscription_id, x.scenario_key, x.title, x.s
   JOIN proactive_insights x ON x.insight_id = i.insight_id`;
 function projectInsightsToInbox(now = /* @__PURE__ */ new Date()) {
 	return runSqliteWriteTransaction((db) => {
-		const missing = db.prepare(`SELECT insight_id FROM proactive_insights WHERE insight_id NOT IN
-      (SELECT insight_id FROM proactive_inbox_items) ORDER BY created_at`).all();
+		const missing = db.prepare(`SELECT x.insight_id FROM proactive_insights x
+      JOIN proactive_runs r ON r.run_id = x.run_id
+      JOIN proactive_signal_batches b ON b.batch_id = r.batch_id
+      LEFT JOIN project_monitoring_policies p
+        ON b.aggregation_key = 'project:' || p.project_id
+      WHERE x.insight_id NOT IN (SELECT insight_id FROM proactive_inbox_items)
+        AND (p.project_id IS NULL OR (p.mode != 'observe' AND x.confidence >= p.confidence_threshold))
+      ORDER BY x.created_at`).all();
 		for (const row of missing) {
 			const id = randomUUID();
 			const nowIso = now.toISOString();

package/dist/src/proactive/index.d.ts

@@ -1,4 +1,5 @@
 export { normalizeEventEnvelope } from './events/envelope.js';
+export { mapProductEventToProactive } from './events/product-event-bridge.js';
 export type { EventEnvelope, PublishEventInput, PublishedEvent } from './events/types.js';
 export type { ProactiveSignalPublisher } from './events/publisher.js';
 export { matchesCondition, matchScenario } from './routing/matcher.js';
@@ -7,11 +8,12 @@ export type { SignalBatch } from './routing/batch-repository.js';
 export { ProactiveEventService } from './service.js';
 export { ProactiveScenarioService } from './scenarios/service.js';
 export type { PromptRevision, ScenarioDefinition, ScenarioSubscription } from './scenarios/types.js';
-export { AutomationStateContextProvider, ContextProviderRegistry, EventBatchContextProvider, ProjectStateContextProvider } from './execution/context.js';
+export { AutomationStateContextProvider, ConnectedSourceContextProvider, ContextProviderRegistry, EventBatchContextProvider, InternalObjectContextProvider, MeetingWorkspaceContextProvider, ProjectStateContextProvider, UserUnderstandingContextProvider, } from './execution/context.js';
 export { ReadonlyProactiveAgentExecutor } from './execution/agent-executor.js';
 export { listInsights } from './execution/repository.js';
 export { ProactiveWorker } from './execution/worker.js';
-export type { ContextProvider, ContextSnapshot, InsightCandidate, ProactiveAgentExecutor, ProactiveInsight } from './execution/types.js';
+export { ProactiveTemporalWorker, type TemporalTickResult } from './temporal/worker.js';
+export type { ContextProvider, ContextSnapshot, InsightCandidate, ProactiveAgentExecutor, ProactiveInsight, ResolvedContext, } from './execution/types.js';
 export { ProactiveInboxService } from './inbox/service.js';
 export { ProactiveInboxWorker } from './inbox/worker.js';
 export type { InboxDelivery, InboxDeliveryAdapter, InboxItem, InboxStatus } from './inbox/types.js';

package/dist/src/proactive/index.js

@@ -1,11 +1,13 @@
+import { ProactiveScenarioService } from "./scenarios/service.js";
 import { normalizeEventEnvelope } from "./events/envelope.js";
+import { mapProductEventToProactive } from "./events/product-event-bridge.js";
 import { matchScenario, matchesCondition } from "./routing/matcher.js";
 import { ProactiveEventService } from "./service.js";
-import { ProactiveScenarioService } from "./scenarios/service.js";
-import { AutomationStateContextProvider, ContextProviderRegistry, EventBatchContextProvider, ProjectStateContextProvider } from "./execution/context.js";
+import { AutomationStateContextProvider, ConnectedSourceContextProvider, ContextProviderRegistry, EventBatchContextProvider, InternalObjectContextProvider, MeetingWorkspaceContextProvider, ProjectStateContextProvider, UserUnderstandingContextProvider } from "./execution/context.js";
 import { ReadonlyProactiveAgentExecutor } from "./execution/agent-executor.js";
 import { listInsights } from "./execution/repository.js";
 import { ProactiveWorker } from "./execution/worker.js";
+import { ProactiveTemporalWorker } from "./temporal/worker.js";
 import { ProactiveInboxService } from "./inbox/service.js";
 import { ProactiveInboxWorker } from "./inbox/worker.js";
-export { AutomationStateContextProvider, ContextProviderRegistry, EventBatchContextProvider, ProactiveEventService, ProactiveInboxService, ProactiveInboxWorker, ProactiveScenarioService, ProactiveWorker, ProjectStateContextProvider, ReadonlyProactiveAgentExecutor, listInsights, matchScenario, matchesCondition, normalizeEventEnvelope };
+export { AutomationStateContextProvider, ConnectedSourceContextProvider, ContextProviderRegistry, EventBatchContextProvider, InternalObjectContextProvider, MeetingWorkspaceContextProvider, ProactiveEventService, ProactiveInboxService, ProactiveInboxWorker, ProactiveScenarioService, ProactiveTemporalWorker, ProactiveWorker, ProjectStateContextProvider, ReadonlyProactiveAgentExecutor, UserUnderstandingContextProvider, listInsights, mapProductEventToProactive, matchScenario, matchesCondition, normalizeEventEnvelope };

package/dist/src/proactive/temporal/worker.d.ts

@@ -0,0 +1,16 @@
+import { ProactiveEventService } from '../service.js';
+export type TemporalTickResult = {
+    scanned: number;
+    published: number;
+    skipped: number;
+};
+export declare class ProactiveTemporalWorker {
+    private readonly events;
+    private readonly intervalMs;
+    private timer;
+    private running;
+    constructor(events: ProactiveEventService, intervalMs?: number);
+    start(): void;
+    stop(): void;
+    tick(now?: Date): Promise<TemporalTickResult>;
+}