@xopcai/xopc 0.0.268 → 0.0.270

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

@@ -1,8 +1,8 @@
 import { getSqliteDatabase } from "../../storage/sqlite/transaction.js";
-import { getKnowledgeSourceItem } from "../../storage/sqlite/knowledge-repository.js";
-import { getConnectorSyncPolicyForConnection } from "../../storage/sqlite/connector-sync-policy-repository.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
@@ -28,15 +28,12 @@ function emptyContext() {
 	};
 }
 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 = getConnectorSyncPolicyForConnection(connectionId);
-	const scenarioAllowed = !policy?.allowedScenarioKeys.length || policy.allowedScenarioKeys.includes(scenarioKey);
-	return policy?.scanEnabled && policy.proactiveEnabled && scenarioAllowed ? item : null;
+	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 (payload.meetingStartsAt !== item.occurredAt || payload.contentHash && payload.contentHash !== item.contentHash) return null;
+	}
+	return item;
 }
 var EventBatchContextProvider = class {
 	id = "event_batch";
@@ -62,11 +59,13 @@ var ConnectedSourceContextProvider = class {
 	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) continue;
+			if (!item || seen.has(item.id)) continue;
+			seen.add(item.id);
 			const evidenceId = `source-item:${item.id}`;
 			const common = {
 				evidenceId,
@@ -334,6 +333,43 @@ var DiscussionContextProvider = class {
 		};
 	}
 };
+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(),
@@ -343,7 +379,8 @@ var ContextProviderRegistry = class {
 		new MeetingWorkspaceContextProvider(),
 		new ProjectStateContextProvider(),
 		new AutomationStateContextProvider(),
-		new DiscussionContextProvider()
+		new DiscussionContextProvider(),
+		new MailFollowUpContextProvider()
 	]) {
 		this.providers = providers;
 	}
@@ -366,4 +403,4 @@ var ContextProviderRegistry = class {
 	}
 };
 //#endregion
-export { AutomationStateContextProvider, ConnectedSourceContextProvider, ContextProviderRegistry, DiscussionContextProvider, EventBatchContextProvider, InternalObjectContextProvider, MeetingWorkspaceContextProvider, ProjectStateContextProvider, UserModelContextProvider };
+export { AutomationStateContextProvider, ConnectedSourceContextProvider, ContextProviderRegistry, DiscussionContextProvider, EventBatchContextProvider, InternalObjectContextProvider, MailFollowUpContextProvider, MeetingWorkspaceContextProvider, ProjectStateContextProvider, UserModelContextProvider };

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

@@ -5,3 +5,10 @@ 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,3 +1,4 @@
+import { ProactiveArtifactSchema } from "../../../packages/gateway-contract/src/proactive.js";
 import { stripCodeFences } from "../../providers/model-response.js";
 //#region src/proactive/execution/insight.ts
 const URGENCY = new Set([
@@ -57,7 +58,7 @@ function parseInsightCandidate(raw, allowedEvidenceIds) {
 	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" || row.confidence < 0 || row.confidence > 1) throw new Error("Insight confidence 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");
@@ -65,6 +66,7 @@ function parseInsightCandidate(raw, allowedEvidenceIds) {
 	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),
@@ -91,7 +93,38 @@ function isValuableInsight(candidate, policy = {
 	minConfidence: .65,
 	minScore: .6
 }) {
-	return candidate.confidence >= policy.minConfidence && candidate.urgency !== "low" && scoreInsight(candidate) >= policy.minScore;
+	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, parseInsightCandidate, scoreInsight };
+export { isValuableInsight, parseAnalysisResult, parseInsightCandidate, scoreInsight };

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

@@ -7,6 +7,7 @@ export interface ClaimedRun {
     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[];
@@ -18,6 +19,7 @@ export declare function finishRun(input: {
     valueScore?: number;
     cooldownSeconds?: number;
     rawOutput: string;
+    outcomeReason?: string;
     modelRef?: string;
 }, now?: Date): ProactiveInsight | null;
 export declare function failRun(run: ClaimedRun, error: unknown, retryable: boolean, now?: Date): void;

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

@@ -1,10 +1,16 @@
 import { getSqliteDatabase, runSqliteWriteTransaction } from "../../storage/sqlite/transaction.js";
+import { effectiveProactivePolicy } from "../policy/service.js";
 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) {
 	return runSqliteWriteTransaction((db) => {
 		const nowIso = now.toISOString();
+		for (const row of db.prepare("SELECT run_id, batch_id, subscription_id FROM proactive_runs WHERE status IN ('retryable', 'running')").all()) if (!effectiveProactivePolicy(str(row, "subscription_id"), now).enabled) {
+			db.prepare("UPDATE proactive_runs SET status = 'discarded', outcome_reason = 'disabled', updated_at = ? WHERE run_id = ?").run(nowIso, str(row, "run_id"));
+			db.prepare("UPDATE proactive_signal_batches SET status = 'ignored', updated_at = ? WHERE batch_id = ?").run(nowIso, str(row, "batch_id"));
+		}
+		for (const row of db.prepare("SELECT batch_id, subscription_id FROM proactive_signal_batches WHERE status = 'ready'").all()) if (!effectiveProactivePolicy(str(row, "subscription_id"), now).enabled) db.prepare("UPDATE proactive_signal_batches SET status = 'ignored' WHERE batch_id = ?").run(str(row, "batch_id"));
 		const dayStart = new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate())).toISOString();
 		db.prepare(`UPDATE proactive_signal_batches SET status = 'ignored', updated_at = ? WHERE status = 'ready'
       AND subscription_id IN (SELECT subscription_id FROM proactive_scenario_subscriptions WHERE enabled = 0)`).run(nowIso);
@@ -38,9 +44,14 @@ function claimNextRun(owner, now = /* @__PURE__ */ new Date(), leaseSeconds = 12
       WHERE b.status = 'ready' ORDER BY b.ready_at LIMIT 1`).get();
 		if (!batch) return null;
 		const id = randomUUID();
+		const policy = effectiveProactivePolicy(str(batch, "subscription_id"), now);
 		db.prepare(`INSERT INTO proactive_runs (run_id, batch_id, subscription_id, scenario_key, scenario_version,
-      prompt_revision_id, status, attempt, lease_owner, lease_expires_at, started_at, updated_at)
-      VALUES (?, ?, ?, ?, ?, ?, 'running', 1, ?, ?, ?, ?)`).run(id, str(batch, "batch_id"), str(batch, "subscription_id"), str(batch, "scenario_key"), Number(batch.scenario_version), batch.active_prompt_revision_id ? String(batch.active_prompt_revision_id) : null, owner, new Date(now.getTime() + leaseSeconds * 1e3).toISOString(), nowIso, nowIso);
+      prompt_revision_id, status, attempt, lease_owner, lease_expires_at, started_at, updated_at, policy_revision, subscription_revision, policy_snapshot_json)
+      VALUES (?, ?, ?, ?, ?, ?, 'running', 1, ?, ?, ?, ?, ?, ?, ?)`).run(id, str(batch, "batch_id"), str(batch, "subscription_id"), str(batch, "scenario_key"), Number(batch.scenario_version), batch.active_prompt_revision_id ? String(batch.active_prompt_revision_id) : null, owner, new Date(now.getTime() + leaseSeconds * 1e3).toISOString(), nowIso, nowIso, policy.preferences.revision, policy.settings.revision, JSON.stringify({
+			level: policy.level,
+			delivery: policy.settings.delivery,
+			scanIntervalMinutes: policy.scanIntervalMinutes
+		}));
 		db.prepare("UPDATE proactive_signal_batches SET status = 'processing', updated_at = ? WHERE batch_id = ?").run(nowIso, str(batch, "batch_id"));
 		return runFromRow(db.prepare("SELECT * FROM proactive_runs WHERE run_id = ?").get(id));
 	});
@@ -53,6 +64,7 @@ function runFromRow(row) {
 		scenarioKey: str(row, "scenario_key"),
 		scenarioVersion: Number(row.scenario_version),
 		attempt: Number(row.attempt),
+		subscriptionRevision: Number(row.subscription_revision),
 		...row.prompt_revision_id ? { promptRevisionId: str(row, "prompt_revision_id") } : {}
 	};
 }
@@ -77,21 +89,51 @@ function attachSnapshot(runId, snapshotId) {
 function finishRun(input, now = /* @__PURE__ */ new Date()) {
 	return runSqliteWriteTransaction((db) => {
 		const nowIso = now.toISOString();
+		const current = db.prepare("SELECT status, attempt FROM proactive_runs WHERE run_id = ?").get(input.run.id);
+		if (!current || current.status !== "running" || current.attempt !== input.run.attempt) return null;
+		const currentPolicy = effectiveProactivePolicy(input.run.subscriptionId, now);
+		if (!currentPolicy.enabled) input = {
+			...input,
+			candidate: void 0,
+			outcomeReason: "disabled"
+		};
+		else if (input.run.subscriptionRevision !== void 0 && input.run.subscriptionRevision !== currentPolicy.settings.revision) input = {
+			...input,
+			candidate: void 0,
+			outcomeReason: "policy_changed"
+		};
 		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 snapshot = db.prepare(`SELECT c.content_json FROM proactive_runs r JOIN proactive_context_snapshots c
+      ON c.snapshot_id = r.context_snapshot_id WHERE r.run_id = ?`).get(input.run.id);
+		const sourceVersions = snapshot ? JSON.parse(snapshot.content_json) : {};
+		const fingerprint = input.candidate ? createHash("sha256").update([
+			...subjectScope,
+			JSON.stringify(input.candidate.artifact ?? null),
+			JSON.stringify(sourceVersions.connected_source ?? sourceVersions.project_state ?? sourceVersions.follow_up ?? null),
+			...[
+				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() - (input.cooldownSeconds ?? 10080 * 60) * 1e3)).toISOString()) : void 0;
 		const valuable = Boolean(input.candidate) && !duplicate;
+		const reason = duplicate ? "duplicate" : input.outcomeReason;
+		const completed = valuable || [
+			"unchanged",
+			"routine",
+			"insufficient_evidence",
+			"duplicate",
+			"below_threshold"
+		].includes(reason ?? "");
+		db.prepare("UPDATE proactive_runs SET outcome_reason = ? WHERE run_id = ?").run(reason ?? null, input.run.id);
 		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);
+      lease_expires_at = NULL, completed_at = ?, updated_at = ? WHERE run_id = ?`).run(completed ? "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 || duplicate) return null;
 		const insight = {
@@ -107,6 +149,7 @@ function finishRun(input, now = /* @__PURE__ */ new Date()) {
       why_now, impact, recommendation, work_done, decision_json, proposed_action_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.proposedAction ? JSON.stringify(insight.proposedAction) : null, insight.urgency, insight.confidence, insight.valueScore, JSON.stringify(insight.evidenceIds), fingerprint, insight.createdAt);
+		if (insight.artifact) db.prepare("UPDATE proactive_insights SET artifact_json = ? WHERE insight_id = ?").run(JSON.stringify(insight.artifact), insight.id);
 		return insight;
 	});
 }
@@ -115,7 +158,7 @@ function failRun(run, error, retryable, now = /* @__PURE__ */ new Date()) {
 		const finalRetryable = retryable && run.attempt < 3;
 		const nowIso = now.toISOString();
 		const nextAttemptAt = finalRetryable ? new Date(now.getTime() + 15e3 * run.attempt).toISOString() : null;
-		db.prepare(`UPDATE proactive_runs SET status = ?, error_message = ?, lease_owner = NULL, lease_expires_at = NULL, next_attempt_at = ?, updated_at = ? WHERE run_id = ?`).run(finalRetryable ? "retryable" : "failed", String(error instanceof Error ? error.message : error).slice(0, 2e3), nextAttemptAt, nowIso, run.id);
+		if (!db.prepare(`UPDATE proactive_runs SET status = ?, error_message = ?, lease_owner = NULL, lease_expires_at = NULL, next_attempt_at = ?, updated_at = ? WHERE run_id = ? AND status = 'running' AND attempt = ?`).run(finalRetryable ? "retryable" : "failed", String(error instanceof Error ? error.message : error).slice(0, 2e3), nextAttemptAt, nowIso, run.id, run.attempt).changes) return;
 		db.prepare(`UPDATE proactive_signal_batches SET status = ?, updated_at = ? WHERE batch_id = ?`).run(finalRetryable ? "failed_retryable" : "failed_permanent", nowIso, run.batchId);
 	});
 }
@@ -131,6 +174,7 @@ function listInsights(limit = 50) {
 		impact: str(row, "impact"),
 		recommendation: str(row, "recommendation"),
 		workDone: str(row, "work_done"),
+		...row.artifact_json ? { artifact: JSON.parse(str(row, "artifact_json")) } : {},
 		...row.decision_json ? { decision: JSON.parse(str(row, "decision_json")) } : {},
 		...row.proposed_action_json ? { proposedAction: JSON.parse(str(row, "proposed_action_json")) } : {},
 		urgency: str(row, "urgency"),

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

@@ -1,3 +1,4 @@
+import type { ProactiveArtifact } from '@xopcai/gateway-contract';
 export interface ContextSnapshot {
     id: string;
     batchId: string;
@@ -6,6 +7,7 @@ export interface ContextSnapshot {
     createdAt: string;
 }
 export interface InsightCandidate {
+    artifact?: ProactiveArtifact;
     title: string;
     summary: string;
     whyNow: string;
@@ -55,6 +57,11 @@ export interface ProactiveAgentExecutor {
     }): Promise<{
         text: string;
         modelRef?: string;
+        usage?: {
+            inputTokens: number;
+            outputTokens: number;
+            estimatedCostUsd?: number;
+        };
     }>;
 }
 export interface ContextProvider {

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

@@ -1,12 +1,16 @@
 import { createLogger } from "../../utils/logger/index.js";
 import { init_logger } from "../../utils/logger.js";
+import { getSqliteDatabase } from "../../storage/sqlite/transaction.js";
+import { authorizedConnectedSource } from "./authorization.js";
+import { effectiveProactivePolicy } from "../policy/service.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";
+import { isValuableInsight, parseAnalysisResult, scoreInsight } from "./insight.js";
 import { randomUUID } from "node:crypto";
+import { isDeepStrictEqual } from "node:util";
 //#region src/proactive/execution/worker.ts
 init_logger();
 const log = createLogger("ProactiveWorker");
@@ -42,6 +46,14 @@ var ProactiveWorker = class {
 			try {
 				const scenario = getScenario(run.scenarioKey, run.scenarioVersion);
 				if (!scenario) throw new Error("Pinned scenario version is unavailable");
+				if (!effectiveProactivePolicy(run.subscriptionId).enabled) {
+					finishRun({
+						run,
+						rawOutput: "",
+						outcomeReason: "disabled"
+					});
+					return;
+				}
 				const revision = run.promptRevisionId ? getPromptRevision(run.promptRevisionId) ?? void 0 : void 0;
 				const eventIds = eventIdsForBatch(run.batchId);
 				const context = await this.contexts.collect(scenario, {
@@ -49,6 +61,14 @@ var ProactiveWorker = class {
 					eventIds,
 					subscriptionId: run.subscriptionId
 				});
+				if (context.evidenceIds.length === 0) {
+					finishRun({
+						run,
+						rawOutput: "",
+						outcomeReason: "source_unavailable"
+					});
+					return;
+				}
 				const snapshot = saveSnapshot(run.batchId, context.snapshotContent ?? context.content, context.evidenceIds);
 				attachSnapshot(run.id, snapshot.id);
 				const prompt = composeScenarioPrompt({
@@ -61,9 +81,24 @@ var ProactiveWorker = class {
 					userPrompt: prompt.text,
 					authorizedContext: context.content
 				});
-				const candidate = parseInsightCandidate(output.text, new Set(context.evidenceIds));
-				const valueScore = scoreInsight(candidate);
-				const valuable = isValuableInsight(candidate, scenario.valuePolicy);
+				if (output.usage) getSqliteDatabase().prepare("UPDATE proactive_runs SET input_tokens = ?, output_tokens = ?, estimated_cost_usd = ? WHERE run_id = ? AND attempt = ?").run(output.usage.inputTokens, output.usage.outputTokens, output.usage.estimatedCostUsd ?? null, run.id, run.attempt);
+				const latestContext = await this.contexts.collect(scenario, {
+					batchId: run.batchId,
+					eventIds,
+					subscriptionId: run.subscriptionId
+				});
+				const revoked = context.evidenceIds.some((id) => !latestContext.evidenceIds.includes(id));
+				const changed = !isDeepStrictEqual(context.snapshotContent ?? context.content, latestContext.snapshotContent ?? latestContext.content);
+				const unavailable = context.evidenceIds.some((id) => id.startsWith("source-item:") && !authorizedConnectedSource(id.slice(12), effectiveProactivePolicy(run.subscriptionId).workspaceId, run.scenarioKey));
+				const result = revoked || changed ? {
+					result: "no_insight",
+					reason: unavailable ? "source_unavailable" : "source_changed"
+				} : parseAnalysisResult(output.text, new Set(latestContext.evidenceIds));
+				const candidate = result.result === "insight" ? result.candidate : void 0;
+				if (run.scenarioKey === "communication_follow_up" && (candidate?.decision || candidate?.proposedAction)) throw new Error("Communication preparation must return a draft or update; actions require the conversation confirmation flow");
+				const valueScore = candidate ? scoreInsight(candidate) : 0;
+				const enabled = effectiveProactivePolicy(run.subscriptionId).enabled;
+				const valuable = enabled && candidate && isValuableInsight(candidate, scenario.valuePolicy);
 				const insight = finishRun({
 					run,
 					...valuable ? {
@@ -71,16 +106,17 @@ var ProactiveWorker = class {
 						valueScore
 					} : {},
 					cooldownSeconds: scenario.valuePolicy.cooldownSeconds,
-					rawOutput: output.text,
+					outcomeReason: !enabled ? "disabled" : result.result === "no_insight" ? result.reason : valuable ? "insight" : "below_threshold",
+					rawOutput: revoked ? "" : output.text,
 					modelRef: output.modelRef
 				});
-				const disposition = insight ? "created" : valuable ? "duplicate_suppressed" : "value_gate_discarded";
+				const disposition = insight ? "created" : valuable ? "duplicate_suppressed" : result.result === "no_insight" ? result.reason : "value_gate_discarded";
 				log.info({
 					runId: run.id,
 					scenarioKey: run.scenarioKey,
 					disposition,
 					insightId: insight?.id
-				}, insight ? "Proactive insight created" : "Proactive output discarded");
+				}, insight ? "Proactive insight created" : "Proactive check completed without a card");
 			} catch (error) {
 				failRun(run, error, !(error instanceof Error && /Pinned scenario/.test(error.message)));
 				log.warn({

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

@@ -0,0 +1,69 @@
+export declare function startDelegation(workspace: string, value: unknown): {
+    effectiveLevel: "off" | "active" | "quiet" | "balanced";
+    schedule: Record<string, import("node:sqlite").SQLOutputValue>;
+    revision: number;
+    level: "off" | "active" | "quiet" | "balanced";
+    delivery: "digest" | "inbox" | "important";
+    completedAt: string;
+    scanIntervalMinutes: number;
+    userInstructions: string;
+    id: string;
+    scenarioKey: string;
+    workspaceId: string;
+    scopeKind: "workspace" | "project";
+    scopeId: string;
+    enabled: boolean;
+    activePromptRevisionId?: string;
+    createdAt: string;
+    updatedAt: string;
+};
+/** Queue work in the existing worker; HTTP and conversation requests do not own model runs. */
+export declare function checkDelegation(workspace: string, id: string): {
+    status: "queued";
+};
+export declare function delegationOverview(workspace: string): {
+    followUps: {
+        id: string;
+        subscriptionId: string;
+        instructions: string;
+        dueAt: string;
+        status: "completed" | "paused" | "watching";
+        revision: number;
+        lastCheckedAt: string;
+        sessionKey: string;
+        sourceAvailable: boolean;
+        enabled: boolean;
+        subject: string;
+        latestMessageAt: string;
+        latestDirection: string;
+        lastSyncedAt: string;
+        syncFailed: boolean;
+    }[];
+    needsDecision: import("@xopcai/gateway-contract/src/proactive.js").ProactiveCard[];
+    prepared: import("@xopcai/gateway-contract/src/proactive.js").ProactiveCard[];
+    updates: import("@xopcai/gateway-contract/src/proactive.js").ProactiveCard[];
+    delegations: {
+        effectiveEnabled: boolean;
+        project: Record<string, import("node:sqlite").SQLOutputValue>;
+        latestRun: Record<string, import("node:sqlite").SQLOutputValue>;
+        pending: boolean;
+        effectiveLevel: "off" | "active" | "quiet" | "balanced";
+        schedule: Record<string, import("node:sqlite").SQLOutputValue>;
+        revision: number;
+        level: "off" | "active" | "quiet" | "balanced";
+        delivery: "digest" | "inbox" | "important";
+        completedAt: string;
+        scanIntervalMinutes: number;
+        userInstructions: string;
+        id: string;
+        scenarioKey: string;
+        workspaceId: string;
+        scopeKind: "workspace" | "project";
+        scopeId: string;
+        enabled: boolean;
+        activePromptRevisionId?: string;
+        createdAt: string;
+        updatedAt: string;
+    }[];
+};
+export declare function completeDeliveredProjects(now?: Date): void;

package/dist/src/proactive/experience.js

@@ -0,0 +1,90 @@
+import { getSqliteDatabase, runSqliteWriteTransaction } from "../storage/sqlite/transaction.js";
+import { ProactiveConflict, effectiveProactivePolicy } from "./policy/service.js";
+import { controlledSubscriptions, createControlledSubscription, requireSubscription, updateControlledSubscription } from "./scenarios/control.js";
+import { ProactiveScenarioService } from "./scenarios/service.js";
+import { ProactiveEventService } from "./service.js";
+import { listMailFollowUps } from "./follow-ups.js";
+import { getCard } from "./inbox/cards.js";
+import { scanDueProjects } from "./temporal/schedule.js";
+import { z } from "zod";
+//#region src/proactive/experience.ts
+const DelegateSchema = z.object({
+	scenarioKey: z.enum([
+		"project_delivery_risk",
+		"meeting_preparation",
+		"discussion_follow_up"
+	]),
+	projectId: z.string().min(1).optional(),
+	instructions: z.string().trim().min(1).max(12e3)
+}).strict();
+function startDelegation(workspace, value) {
+	const input = DelegateSchema.parse(value);
+	if (input.scenarioKey === "project_delivery_risk" && !input.projectId) throw new Error("Choose a project");
+	if (input.scenarioKey !== "project_delivery_risk" && input.projectId) throw new Error("This service uses workspace sources");
+	const subscription = createControlledSubscription(workspace, {
+		scenarioKey: input.scenarioKey,
+		scopeKind: input.projectId ? "project" : "workspace",
+		scopeId: input.projectId ?? workspace,
+		userInstructions: input.instructions
+	});
+	if (input.projectId && effectiveProactivePolicy(subscription.id).enabled) checkDelegation(workspace, subscription.id);
+	return subscription;
+}
+/** Queue work in the existing worker; HTTP and conversation requests do not own model runs. */
+function checkDelegation(workspace, id) {
+	const sub = requireSubscription(id, workspace);
+	if (!effectiveProactivePolicy(id).enabled) throw new Error("Resume this service before checking");
+	if (sub.scopeKind !== "project") throw new Error("This service checks when connected sources change");
+	return runSqliteWriteTransaction((db) => {
+		if (db.prepare("SELECT 1 FROM proactive_signal_batches WHERE subscription_id = ? AND status IN ('collecting', 'ready', 'processing')").get(id)) return { status: "queued" };
+		const last = db.prepare("SELECT MAX(started_at) AS at FROM proactive_runs WHERE subscription_id = ?").get(id);
+		if (last.at && Date.parse(last.at) > Date.now() - 6e4) throw new ProactiveConflict("A check just finished; try again in a minute");
+		db.prepare(`INSERT INTO proactive_schedule_state(subscription_id, next_due_at) VALUES (?, ?)
+      ON CONFLICT(subscription_id) DO UPDATE SET next_due_at = excluded.next_due_at, last_fingerprint = NULL`).run(id, (/* @__PURE__ */ new Date()).toISOString());
+		scanDueProjects(new ProactiveEventService(() => new ProactiveScenarioService().routes()));
+		db.prepare("UPDATE proactive_signal_batches SET ready_at = ?, status = 'ready' WHERE subscription_id = ? AND status = 'collecting'").run((/* @__PURE__ */ new Date()).toISOString(), id);
+		return { status: "queued" };
+	});
+}
+function delegationOverview(workspace) {
+	const db = getSqliteDatabase();
+	const now = (/* @__PURE__ */ new Date()).toISOString();
+	const cards = db.prepare(`SELECT i.inbox_item_id FROM proactive_inbox_items i
+    JOIN proactive_insights x USING(insight_id) JOIN proactive_scenario_subscriptions s USING(subscription_id)
+    WHERE s.workspace_id = ? AND i.withdrawn_at IS NULL AND i.status IN ('unread', 'read')
+    AND (i.expires_at IS NULL OR i.expires_at > ?)
+    ORDER BY CASE WHEN x.action_status = 'approval_required' THEN 0 WHEN x.artifact_json IS NOT NULL THEN 1 ELSE 2 END,
+    x.value_score DESC, i.updated_at DESC LIMIT 100`).all(workspace, now).map((row) => getCard(row.inbox_item_id, workspace)).filter((card) => !["withdrawn", "expired"].includes(card.status));
+	return {
+		followUps: listMailFollowUps(workspace),
+		needsDecision: cards.filter((card) => card.decision && card.actionStatus !== "completed"),
+		prepared: cards.filter((card) => card.artifact && !card.decision),
+		updates: cards.filter((card) => !card.artifact && !card.decision),
+		delegations: controlledSubscriptions(workspace).map((sub) => ({
+			...sub,
+			effectiveEnabled: effectiveProactivePolicy(sub.id).enabled,
+			project: sub.scopeKind === "project" ? db.prepare("SELECT name, status FROM projects WHERE project_id = ?").get(sub.scopeId) ?? null : null,
+			latestRun: db.prepare(`SELECT status, outcome_reason AS reason, completed_at AS completedAt, started_at AS startedAt, error_message AS error
+        FROM proactive_runs WHERE subscription_id = ? ORDER BY started_at DESC LIMIT 1`).get(sub.id) ?? null,
+			pending: Boolean(db.prepare("SELECT 1 FROM proactive_signal_batches WHERE subscription_id = ? AND status IN ('collecting', 'ready', 'processing')").get(sub.id))
+		}))
+	};
+}
+function completeDeliveredProjects(now = /* @__PURE__ */ new Date()) {
+	const db = getSqliteDatabase();
+	const rows = db.prepare(`SELECT s.subscription_id, s.workspace_id FROM proactive_scenario_subscriptions s
+    JOIN projects p ON p.project_id = s.scope_id WHERE s.scope_kind = 'project' AND s.enabled = 1
+    AND p.status IN ('completed', 'cancelled', 'archived')`).all();
+	for (const row of rows) {
+		const current = controlledSubscriptions(row.workspace_id).find((sub) => sub.id === row.subscription_id);
+		updateControlledSubscription(row.workspace_id, row.subscription_id, {
+			expectedRevision: current.revision,
+			enabled: false,
+			completedAt: now.toISOString()
+		});
+		db.prepare(`UPDATE proactive_inbox_items SET status = 'resolved', resolution = 'project_ended', updated_at = ?
+      WHERE insight_id IN (SELECT insight_id FROM proactive_insights WHERE subscription_id = ?) AND status <> 'resolved'`).run(now.toISOString(), row.subscription_id);
+	}
+}
+//#endregion
+export { checkDelegation, completeDeliveredProjects, delegationOverview, startDelegation };