@xopcai/xopc 0.0.178 → 0.0.180

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

@@ -9,6 +9,8 @@ export type GoalRunStatus = 'running' | 'succeeded' | 'failed' | 'aborted';
 export type GoalRunVerdict = 'continue' | 'done' | 'blocked' | 'needs_input' | 'decompose';
 export interface Goal {
     id: string;
+    outcomeId: string;
+    outcomeContractVersion: number;
     title: string;
     description?: string;
     status: GoalStatus;
@@ -80,27 +82,8 @@ export interface GoalEvidence {
     summary?: string;
     uri?: string;
     data?: unknown;
-    requirementIds?: string[];
     createdAt: number;
 }
-export type GoalEvidenceRequirementStatus = 'pending' | 'ai_verified' | 'approved' | 'rejected';
-export type GoalEvidenceReviewSource = 'ai' | 'user' | 'system';
-/** A single, reviewable proof obligation from the goal contract. */
-export interface GoalEvidenceRequirement {
-    id: string;
-    goalId: string;
-    text: string;
-    status: GoalEvidenceRequirementStatus;
-    evidenceIds: string[];
-    reviewReason?: string;
-    reviewConfidence?: number;
-    reviewedBy?: GoalEvidenceReviewSource;
-    reviewedAt?: number;
-    requiresHumanApproval: boolean;
-    createdAt: number;
-    updatedAt: number;
-    sortOrder: number;
-}
 export type GoalContextAttachment = MediaRef;
 export interface GoalContextMessage {
     goalId: string;
@@ -109,56 +92,10 @@ export interface GoalContextMessage {
     createdAt: number;
     updatedAt: number;
 }
-/**
- * The user-confirmed definition of success for a persistent goal.
- * Checklist items hold the individual acceptance criteria; this contract
- * supplies the outcome, scope boundary, and expected evidence around them.
- */
-export interface GoalContract {
-    goalId: string;
-    version: number;
-    objective: string;
-    scopeBoundary?: string;
-    evidencePlan: string[];
-    outcomeMetric?: GoalOutcomeMetric;
-    createdAt: number;
-    updatedAt: number;
-}
-export type GoalOutcomeDirection = 'increase' | 'decrease';
-/** A measurable user-visible result used to verify that outputs changed the intended outcome. */
-export interface GoalOutcomeMetric {
-    name: string;
-    baselineValue: number;
-    targetValue: number;
-    currentValue?: number;
-    unit?: string;
-    direction: GoalOutcomeDirection;
-    sourceUrl?: string;
-    measuredAt?: number;
-}
-export interface GoalOutcomeMetricInput {
-    name: string;
-    baselineValue: number;
-    targetValue: number;
-    currentValue?: number;
-    unit?: string;
-    direction?: GoalOutcomeDirection;
-    sourceUrl?: string;
-    measuredAt?: number;
-}
-export interface GoalContractInput {
-    objective?: string;
-    scopeBoundary?: string;
-    evidencePlan?: string[];
-    criteria?: string[];
-    outcomeMetric?: GoalOutcomeMetricInput | null;
-}
 export interface GoalWithDetails extends Goal {
     checklist: GoalChecklistItem[];
     latestRun?: GoalRun;
     contextMessage?: GoalContextMessage;
-    contract?: GoalContract;
-    evidenceRequirements: GoalEvidenceRequirement[];
 }
 export interface GoalListQuery {
     status?: GoalStatus | GoalStatus[];
@@ -169,6 +106,8 @@ export interface GoalListQuery {
     offset?: number;
 }
 export interface CreateGoalInput {
+    outcomeId: string;
+    outcomeContractVersion: number;
     title: string;
     description?: string;
     agentId: string;
@@ -180,7 +119,6 @@ export interface CreateGoalInput {
     uiLocale?: GoalUiLocale;
     source?: GoalSource;
     projectId?: string;
-    contract?: GoalContractInput;
 }
 export interface GoalJudgeDecision {
     verdict: GoalRunVerdict;

package/dist/src/notes/agent-context.js

@@ -4,8 +4,8 @@ import { resolveImageModelConfigForTool } from "../agent/image/tool-model-config
 import { describeImagesWithFallback } from "../agent/image/understanding/runtime.js";
 import { transcribe } from "../voice/stt/transcribe-core.js";
 import { isSTTAvailable } from "../voice/stt/availability.js";
+import { mergeSttConfigFromAppConfig } from "../voice/stt/config.js";
 import "../voice/stt/index.js";
-import { mergeSttConfigFromAppConfig } from "../channels/attachments/voice-stt-webchat.js";
 import { extractDocumentText } from "../document-understanding/extract.js";
 import { extname } from "node:path";
 import { readFile } from "node:fs/promises";

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

@@ -49,6 +49,7 @@ export declare class NotesService {
         mimeType: string;
         duration?: number;
     }): Promise<NoteAttachment | null>;
+    removeAttachment(noteId: string, attachmentId: string): Promise<boolean>;
     getAttachmentPath(noteId: string, attachmentId: string): Promise<{
         filePath: string;
         mimeType: string;

package/dist/src/notes/service.js

@@ -4,8 +4,8 @@ import { buildNoteAttachmentRef } from "./attachment-ref.js";
 import { parseNoteMarkdown } from "./note-markdown.js";
 import { changedFieldsFromPatch, emitActivity, previewText, systemActivityActor, systemActivitySource } from "../activity/emitter.js";
 import { getDefaultModelSync, init_providers, resolveModel } from "../providers/index.js";
-import { publishAutomationProductEvent } from "../automations/product-events.js";
 import { completeWithResolvedCredentials } from "../providers/model-call.js";
+import { publishAutomationProductEvent } from "../automations/product-events.js";
 import { NotesStore } from "./store.js";
 import { partitionAttachmentsByReference } from "./note-attachment-sync.js";
 import { buildNoteAgentContextArtifact, getCachedNoteAgentContextArtifact } from "./agent-context.js";
@@ -484,6 +484,15 @@ var NotesService = class {
 		});
 		return attachment;
 	}
+	async removeAttachment(noteId, attachmentId) {
+		const note = await this.store.getNote(noteId);
+		if (!note) return false;
+		const attachment = note.attachments?.find((candidate) => candidate.id === attachmentId);
+		if (!attachment) return false;
+		await this.store.updateNote(noteId, { attachments: note.attachments?.filter((candidate) => candidate.id !== attachmentId) ?? [] });
+		await this.store.deleteAttachmentFile(noteId, attachment.relativePath);
+		return true;
+	}
 	async getAttachmentPath(noteId, attachmentId) {
 		const note = await this.store.getNote(noteId);
 		if (!note) return null;

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

@@ -173,6 +173,7 @@ export interface NotesListQuery {
     status?: NoteStatus;
     kind?: NoteKind;
     tag?: string;
+    projectId?: string;
     pinned?: boolean;
     search?: string;
     limit?: number;

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 };