@xopcai/xopc 0.0.309 → 0.0.311

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

@@ -1,408 +0,0 @@
-import { getSqliteDatabase, init_transaction } from "../../storage/sqlite/transaction.js";
-import { getAssertionSlot, listUserAssertions } from "../../user-model/repository.js";
-import "../../user-model/index.js";
-import { authorizedConnectedSource } from "./authorization.js";
-import { authorizedMailThread, requireMailFollowUp } from "../follow-ups.js";
-import { getDiscussionCapture, getLatestDiscussionOrganization } from "../../discussions/repository.js";
-import { wrapExternalContent } from "../../gateway/security/external-content.js";
-//#region src/proactive/execution/context.ts
-init_transaction();
-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 = authorizedConnectedSource(event.subject_id, event.workspace_id, scenarioKey, event.agent_id);
-	if (item && event.type === "connected_source.calendar_window.v1") {
-		const payload = JSON.parse(event.payload_json);
-		if (!item.occurredAt || Date.parse(item.occurredAt) <= Date.now()) return null;
-		if (payload.meetingStartsAt !== item.occurredAt || payload.contentHash && payload.contentHash !== item.contentHash) return null;
-	}
-	return item;
-}
-var EventBatchContextProvider = class {
-	id = "event_batch";
-	async collect(input) {
-		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";
-	async collect(input) {
-		const items = [];
-		const snapshotItems = [];
-		const seen = /* @__PURE__ */ new Set();
-		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 || seen.has(item.id)) continue;
-			seen.add(item.id);
-			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";
-	async collect(input) {
-		const db = getSqliteDatabase();
-		const objects = [];
-		const evidenceIds = [];
-		for (const event of eventRows(input.eventIds)) {
-			if (event.subject_kind === "task") {
-				const task = db.prepare(`SELECT tasks.task_id, tasks.title, tasks.body,
-          tasks.phase, tasks.resolution, tasks.priority,
-          tasks.due_at, tasks.updated_at, tasks.delegate_agent_id,
-          (SELECT kind FROM task_waits
-            WHERE task_waits.task_id = tasks.task_id AND task_waits.status = 'active'
-            ORDER BY task_waits.created_at DESC LIMIT 1) AS wait_kind,
-          (SELECT reason FROM task_waits
-            WHERE task_waits.task_id = tasks.task_id AND task_waits.status = 'active'
-            ORDER BY task_waits.created_at DESC LIMIT 1) AS wait_reason
-          FROM tasks
-          WHERE tasks.task_id = ?`).get(event.subject_id);
-				if (task) {
-					const evidenceId = `task:${event.subject_id}`;
-					objects.push({
-						evidenceId,
-						kind: "task",
-						...task
-					});
-					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 UserModelContextProvider = class {
-	id = "user_model";
-	async collect(input) {
-		const scope = eventRows(input.eventIds).at(-1);
-		if (!scope) return emptyContext();
-		const records = listUserAssertions({
-			statuses: ["active"],
-			limit: 500
-		}).filter((record) => {
-			const now = Date.now();
-			const assertionScope = getAssertionSlot(record.slotId)?.scope;
-			const scopeMatches = assertionScope?.type === "global" || assertionScope?.type === "workspace" && assertionScope.id === scope.workspace_id || assertionScope?.type === "project" && assertionScope.id === scope.project_id || assertionScope?.type === "agent" && assertionScope.id === scope.agent_id;
-			return record.disclosurePolicy === "referenceable" && record.sensitivity !== "secret" && record.sensitivity !== "regulated" && scopeMatches && (!record.validFrom || record.validFrom <= now) && (!record.validTo || record.validTo >= now) && (record.authority === "user_explicit" || record.confidence >= .7);
-		}).slice(0, 20);
-		return {
-			content: { records: records.map((record) => ({
-				evidenceId: `assertion:${record.id}`,
-				kind: record.kind,
-				content: boundedText(record.statement, 1e3),
-				confidence: record.confidence,
-				recordedAt: record.recordedAt
-			})) },
-			evidenceIds: records.map((record) => `assertion:${record.id}`)
-		};
-	}
-};
-var MeetingWorkspaceContextProvider = class {
-	id = "meeting_workspace";
-	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 taskMatches = terms.map(() => `LOWER(COALESCE(tasks.title, '') || ' '
-      || COALESCE(tasks.body, '')) LIKE ?`).join(" OR ");
-		const tasks = db.prepare(`SELECT tasks.task_id, tasks.title, tasks.body,
-      tasks.phase, tasks.resolution, tasks.priority, tasks.due_at,
-      tasks.updated_at, tasks.project_id
-      FROM tasks
-      WHERE tasks.phase <> 'closed'
-      AND COALESCE(tasks.delegate_agent_id, ?) = ? AND (${taskMatches})
-      ORDER BY tasks.updated_at DESC LIMIT 10`).all(scope.agent_id ?? "main", 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 taskEvidenceIds = tasks.map((task) => `task:${String(task.task_id)}`);
-		const noteEvidenceIds = notes.map((note) => `note:${String(note.note_id)}`);
-		return {
-			content: {
-				activeTasks: tasks.map((task, index) => ({
-					evidenceId: taskEvidenceIds[index],
-					...task
-				})),
-				recentNotes: notes.map((note, index) => ({
-					evidenceId: noteEvidenceIds[index],
-					...note,
-					snippet: boundedText(note.snippet, 1500)
-				}))
-			},
-			evidenceIds: [...taskEvidenceIds, ...noteEvidenceIds]
-		};
-	}
-};
-var ProjectStateContextProvider = class {
-	id = "project_state";
-	async collect(input) {
-		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 emptyContext();
-		const tasks = getSqliteDatabase().prepare(`SELECT task.task_id, task.title, task.body,
-      task.phase, task.resolution, task.priority, task.due_at, task.updated_at,
-      (SELECT wait.kind FROM task_waits wait
-        WHERE wait.task_id = task.task_id AND wait.status = 'active'
-        ORDER BY wait.created_at DESC LIMIT 1) AS wait_kind,
-      (SELECT wait.reason FROM task_waits wait
-        WHERE wait.task_id = task.task_id AND wait.status = 'active'
-        ORDER BY wait.created_at DESC LIMIT 1) AS wait_reason,
-      (SELECT json_group_array(json_object(
-        'taskId', dependency.depends_on_task_id,
-        'title', upstream.title,
-        'phase', upstream.phase,
-        'resolution', upstream.resolution
-      )) FROM task_dependencies dependency
-        JOIN tasks upstream ON upstream.task_id = dependency.depends_on_task_id
-        WHERE dependency.task_id = task.task_id) AS dependencies_json
-      FROM tasks task
-      WHERE task.project_id = ? AND task.phase <> 'closed'
-      ORDER BY CASE WHEN EXISTS (
-        SELECT 1 FROM task_waits wait WHERE wait.task_id = task.task_id AND wait.status = 'active'
-      ) THEN 0 ELSE 1 END,
-        task.updated_at DESC LIMIT 100`).all(String(project.project_id));
-		const projectEvidenceId = `project:${String(project.project_id)}`;
-		const taskEvidenceIds = tasks.map((task) => `task:${String(task.task_id)}`);
-		return {
-			content: {
-				project: {
-					evidenceId: projectEvidenceId,
-					...project
-				},
-				activeTasks: tasks.map((task, index) => {
-					const { dependencies_json: dependenciesJson, ...fields } = task;
-					return {
-						evidenceId: taskEvidenceIds[index],
-						...fields,
-						dependencies: dependenciesJson ? JSON.parse(String(dependenciesJson)) : []
-					};
-				})
-			},
-			evidenceIds: [projectEvidenceId, ...taskEvidenceIds]
-		};
-	}
-};
-var AutomationStateContextProvider = class {
-	id = "automation_state";
-	async collect(input) {
-		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 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 recentRuns = getSqliteDatabase().prepare(`SELECT run_id, status, summary, error, duration_ms, started_at, ended_at
-      FROM automation_runs WHERE automation_id = ? AND run_id <> ?
-      ORDER BY started_at DESC LIMIT 5`).all(String(run.automation_id), String(run.run_id));
-		const runEvidenceId = `automation-run:${String(run.run_id)}`;
-		return {
-			content: {
-				automation,
-				failedRun: {
-					evidenceId: runEvidenceId,
-					...run
-				},
-				recentRuns
-			},
-			evidenceIds: [runEvidenceId]
-		};
-	}
-};
-var DiscussionContextProvider = class {
-	id = "discussion";
-	async collect(input) {
-		const event = eventRows(input.eventIds).findLast((row) => row.subject_kind === "discussion");
-		if (!event) return emptyContext();
-		const discussion = getDiscussionCapture(event.subject_id);
-		if (!discussion || discussion.status !== "completed") return emptyContext();
-		const organization = getLatestDiscussionOrganization(discussion.id);
-		const discussionEvidenceId = `discussion:${discussion.id}`;
-		const noteEvidenceId = `note:${discussion.noteId}`;
-		return {
-			content: { discussion: {
-				evidenceId: discussionEvidenceId,
-				id: discussion.id,
-				noteId: discussion.noteId,
-				noteEvidenceId,
-				projectId: discussion.projectId,
-				title: discussion.generatedTitle,
-				transcript: boundedText(discussion.canonicalTranscript, 6e3),
-				organization: organization?.organization,
-				completedAt: discussion.completedAt
-			} },
-			snapshotContent: { discussion: {
-				evidenceId: discussionEvidenceId,
-				id: discussion.id,
-				noteId: discussion.noteId,
-				noteEvidenceId,
-				projectId: discussion.projectId,
-				transcriptSha256: discussion.canonicalTranscriptSha256,
-				organizationRevision: organization?.revision,
-				organization: organization?.organization,
-				completedAt: discussion.completedAt
-			} },
-			evidenceIds: [discussionEvidenceId, noteEvidenceId]
-		};
-	}
-};
-var MailFollowUpContextProvider = class {
-	id = "follow_up";
-	async collect(input) {
-		const event = eventRows(input.eventIds).findLast((row) => row.subject_kind === "mail_follow_up");
-		if (!event) return emptyContext();
-		const follow = requireMailFollowUp(event.workspace_id, event.subject_id);
-		const thread = authorizedMailThread(follow);
-		if (!thread || follow.status !== "watching") return emptyContext();
-		const common = {
-			followUpId: follow.id,
-			revision: follow.revision,
-			fingerprint: thread.fingerprint,
-			dueAt: follow.due_at,
-			deadlinePassed: Date.parse(follow.due_at) <= Date.now()
-		};
-		return {
-			content: {
-				...common,
-				instructions: follow.instructions,
-				items: thread.items.map((item) => ({
-					evidenceId: `source-item:${item.id}`,
-					occurredAt: item.occurredAt,
-					content: wrapExternalContent(item.normalizedText?.slice(0, 4e3) ?? "", { source: "email" })
-				}))
-			},
-			snapshotContent: {
-				...common,
-				items: thread.items.map((item) => ({
-					sourceItemId: item.id,
-					contentHash: item.contentHash,
-					occurredAt: item.occurredAt
-				}))
-			},
-			evidenceIds: thread.items.map((item) => `source-item:${item.id}`)
-		};
-	}
-};
-var ContextProviderRegistry = class {
-	constructor(providers = [
-		new EventBatchContextProvider(),
-		new ConnectedSourceContextProvider(),
-		new InternalObjectContextProvider(),
-		new UserModelContextProvider(),
-		new MeetingWorkspaceContextProvider(),
-		new ProjectStateContextProvider(),
-		new AutomationStateContextProvider(),
-		new DiscussionContextProvider(),
-		new MailFollowUpContextProvider()
-	]) {
-		this.providers = providers;
-	}
-	async collect(scenario, input) {
-		const providers = new Map(this.providers.map((provider) => [provider.id, provider]));
-		const selected = scenario.contextProviderIds.map((id) => {
-			const provider = providers.get(id);
-			if (!provider) throw new Error(`Unknown context provider: ${id}`);
-			return provider;
-		});
-		const entries = await Promise.all(selected.map(async (provider) => [provider.id, await provider.collect({
-			...input,
-			scenarioKey: scenario.key
-		})]));
-		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, ConnectedSourceContextProvider, ContextProviderRegistry, DiscussionContextProvider, EventBatchContextProvider, InternalObjectContextProvider, MailFollowUpContextProvider, MeetingWorkspaceContextProvider, ProjectStateContextProvider, UserModelContextProvider };

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

@@ -1,14 +0,0 @@
-import type { InsightCandidate } from './types.js';
-export declare function parseInsightCandidate(raw: string, allowedEvidenceIds: Set<string>): InsightCandidate;
-export declare function scoreInsight(candidate: InsightCandidate): number;
-export declare function isValuableInsight(candidate: InsightCandidate, policy?: {
-    minConfidence: number;
-    minScore: number;
-}): boolean;
-export declare function parseAnalysisResult(raw: string, allowedEvidenceIds: Set<string>): {
-    result: 'no_insight';
-    reason: string;
-} | {
-    result: 'insight';
-    candidate: InsightCandidate;
-};

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

@@ -1,132 +0,0 @@
-import { ProactiveArtifactSchema } from "../../../packages/gateway-contract/src/proactive.js";
-import { init_src } from "../../../packages/gateway-contract/src/index.js";
-import { stripCodeFences } from "../../providers/model-response.js";
-//#region src/proactive/execution/insight.ts
-init_src();
-const URGENCY = new Set([
-	"low",
-	"medium",
-	"high",
-	"critical"
-]);
-const boundedText = (value, field, max) => {
-	if (typeof value !== "string" || !value.trim()) throw new Error(`Insight ${field} is required`);
-	return value.trim().slice(0, max);
-};
-function parseDecision(value) {
-	if (value == null) return void 0;
-	if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error("Insight decision is invalid");
-	const row = value;
-	if (!Array.isArray(row.options) || row.options.length < 2 || row.options.length > 3) throw new Error("Insight decision options are invalid");
-	const options = row.options.map((option) => {
-		if (!option || typeof option !== "object" || Array.isArray(option)) throw new Error("Insight decision option is invalid");
-		const item = option;
-		return {
-			id: boundedText(item.id, "decision option id", 80),
-			label: boundedText(item.label, "decision option label", 120),
-			consequence: boundedText(item.consequence, "decision option consequence", 400)
-		};
-	});
-	if (new Set(options.map((option) => option.id)).size !== options.length) throw new Error("Insight decision option ids must be unique");
-	return {
-		question: boundedText(row.question, "decision question", 400),
-		options
-	};
-}
-function parseProposedAction(value) {
-	if (value == null) return void 0;
-	if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error("Insight proposedAction is invalid");
-	const row = value;
-	if (row.id !== "create_project_task" || row.risk !== "low") throw new Error("Insight proposedAction is not supported");
-	if (!row.input || typeof row.input !== "object" || Array.isArray(row.input)) throw new Error("Insight proposedAction input is invalid");
-	const input = row.input;
-	return {
-		id: "create_project_task",
-		risk: "low",
-		rationale: boundedText(row.rationale, "proposedAction rationale", 600),
-		input: {
-			title: boundedText(input.title, "proposedAction title", 160),
-			objective: boundedText(input.objective, "proposedAction objective", 1200)
-		}
-	};
-}
-function parseInsightCandidate(raw, allowedEvidenceIds) {
-	let value;
-	try {
-		value = JSON.parse(stripCodeFences(raw));
-	} catch {
-		throw new Error("Model output is not valid JSON");
-	}
-	if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error("Insight must be a JSON object");
-	const row = value;
-	if (!URGENCY.has(String(row.urgency))) throw new Error("Insight urgency is invalid");
-	if (typeof row.confidence !== "number" || !Number.isFinite(row.confidence) || row.confidence < 0 || row.confidence > 1) throw new Error("Insight confidence is invalid");
-	if (!Array.isArray(row.evidenceIds) || row.evidenceIds.length === 0 || row.evidenceIds.length > 20) throw new Error("Insight evidenceIds are invalid");
-	const evidenceIds = [...new Set(row.evidenceIds.map(String))];
-	if (evidenceIds.some((id) => !allowedEvidenceIds.has(id))) throw new Error("Insight cites unknown evidence");
-	const decision = parseDecision(row.decision);
-	const proposedAction = parseProposedAction(row.proposedAction);
-	if (proposedAction && (!decision || decision.options.length !== 2 || decision.options[0]?.id !== "approve" || decision.options[1]?.id !== "reject")) throw new Error("Insight proposedAction requires approve and reject decision options");
-	return {
-		...row.artifact != null ? { artifact: ProactiveArtifactSchema.parse(row.artifact) } : {},
-		title: boundedText(row.title, "title", 160),
-		summary: boundedText(row.summary, "summary", 1200),
-		whyNow: boundedText(row.whyNow, "whyNow", 800),
-		impact: boundedText(row.impact, "impact", 800),
-		recommendation: boundedText(row.recommendation, "recommendation", 800),
-		workDone: boundedText(row.workDone, "workDone", 800),
-		...decision ? { decision } : {},
-		...proposedAction ? { proposedAction } : {},
-		urgency: String(row.urgency),
-		confidence: row.confidence,
-		evidenceIds
-	};
-}
-function scoreInsight(candidate) {
-	const urgencyWeight = {
-		low: .15,
-		medium: .45,
-		high: .75,
-		critical: 1
-	}[candidate.urgency];
-	return Math.round((candidate.confidence * .7 + urgencyWeight * .3) * 1e3) / 1e3;
-}
-function isValuableInsight(candidate, policy = {
-	minConfidence: .65,
-	minScore: .6
-}) {
-	return candidate.confidence >= policy.minConfidence && (candidate.urgency !== "low" || Boolean(candidate.artifact)) && scoreInsight(candidate) >= policy.minScore;
-}
-function parseAnalysisResult(raw, allowedEvidenceIds) {
-	let value;
-	try {
-		value = JSON.parse(stripCodeFences(raw));
-	} catch {
-		throw new Error("Model output is not valid JSON");
-	}
-	if (value && typeof value === "object" && !Array.isArray(value)) {
-		const row = value;
-		if (row.result === "no_insight") {
-			if (![
-				"unchanged",
-				"routine",
-				"insufficient_evidence",
-				"duplicate"
-			].includes(String(row.reason)) || Object.keys(row).some((key) => key !== "result" && key !== "reason")) throw new Error("Invalid no_insight result");
-			return {
-				result: "no_insight",
-				reason: String(row.reason)
-			};
-		}
-		if (row.result === "insight") return {
-			result: "insight",
-			candidate: parseInsightCandidate(JSON.stringify(row.candidate), allowedEvidenceIds)
-		};
-	}
-	return {
-		result: "insight",
-		candidate: parseInsightCandidate(raw, allowedEvidenceIds)
-	};
-}
-//#endregion
-export { isValuableInsight, parseAnalysisResult, parseInsightCandidate, scoreInsight };

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

@@ -1,28 +0,0 @@
-import type { ContextSnapshot, InsightCandidate, ProactiveInsight } from './types.js';
-export interface ClaimedRun {
-    id: string;
-    batchId: string;
-    subscriptionId: string;
-    scenarioKey: string;
-    scenarioVersion: number;
-    promptRevisionId?: string;
-    attempt: number;
-    subscriptionRevision?: number;
-}
-export declare function claimNextRun(owner: string, now?: Date, leaseSeconds?: number): ClaimedRun | null;
-export declare function eventIdsForBatch(batchId: string): string[];
-export declare function saveSnapshot(batchId: string, content: Record<string, unknown>, evidenceIds: string[], now?: Date): ContextSnapshot;
-export declare function attachSnapshot(runId: string, snapshotId: string): void;
-export declare function finishRun(input: {
-    run: ClaimedRun;
-    candidate?: InsightCandidate;
-    valueScore?: number;
-    cooldownSeconds?: number;
-    rawOutput: string;
-    outcomeReason?: string;
-    modelRef?: string;
-}, now?: Date): ProactiveInsight | null;
-/** Stale evidence waits without spending model attempts; never retain work indefinitely. */
-export declare function deferRunForSource(run: ClaimedRun, now?: Date): void;
-export declare function failRun(run: ClaimedRun, error: unknown, retryable: boolean, now?: Date): void;
-export declare function listInsights(limit?: number): ProactiveInsight[];