@xopcai/xopc 0.0.268 → 0.0.269

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

@@ -0,0 +1,88 @@
+import { getSqliteDatabase, runSqliteWriteTransaction } from "../../storage/sqlite/transaction.js";
+import { ProactiveConflict, effectiveProactivePolicy } from "../policy/service.js";
+import { requireSubscription } from "../scenarios/control.js";
+import { getCard } from "../inbox/cards.js";
+import { randomUUID } from "node:crypto";
+import { z } from "zod";
+//#region src/proactive/actions/workflow.ts
+const StartSchema = z.object({
+	expectedRevision: z.number().int().positive(),
+	retry: z.boolean().default(false)
+}).strict();
+async function prepareCardWorkflow(workspace, cardId, value, agentId, workflows) {
+	const input = StartSchema.parse(value);
+	const card = getCard(cardId, workspace);
+	const policy = effectiveProactivePolicy(card.subscriptionId);
+	const sub = requireSubscription(card.subscriptionId, workspace);
+	if (!policy.enabled || card.status === "withdrawn" || card.status === "expired") throw new Error("Card is no longer actionable");
+	if (card.revision !== input.expectedRevision) throw new ProactiveConflict("Card changed; refresh before acting");
+	const definitionId = policy.settings.preparationWorkflowId;
+	if (!definitionId) throw new Error("Choose a preparation workflow in the subscription settings first");
+	const claim = runSqliteWriteTransaction((db) => {
+		const previous = db.prepare("SELECT * FROM proactive_workflow_links WHERE inbox_item_id = ?").get(cardId);
+		if (previous?.lease_until && previous.lease_until > Date.now()) throw new ProactiveConflict("Workflow request is already running");
+		if (previous?.run_id && !input.retry) return {
+			existing: true,
+			...previous
+		};
+		if (previous && previous.definition_id !== definitionId) throw new Error("Workflow selection changed; open the existing run to recover it");
+		const attemptKey = previous?.status === "starting" || previous?.status === "failed" && !previous.run_id ? previous.attempt_key : `proactive-prepare:${cardId}:${randomUUID()}`;
+		db.prepare(`INSERT INTO proactive_workflow_links(inbox_item_id, definition_id, agent_id, attempt_key, status, lease_until)
+      VALUES (?, ?, ?, ?, 'starting', ?) ON CONFLICT(inbox_item_id) DO UPDATE SET status = 'starting', attempt_key = excluded.attempt_key, lease_until = excluded.lease_until, error = NULL`).run(cardId, definitionId, agentId, attemptKey, Date.now() + 12e4);
+		return {
+			existing: false,
+			run_id: previous?.run_id ?? null,
+			agent_id: previous?.agent_id ?? agentId,
+			attempt_key: attemptKey
+		};
+	});
+	if (claim.existing) return workflowForCard(cardId, workspace, workflows);
+	try {
+		if (input.retry && claim.run_id) {
+			const previous = await workflows.createRunStore(claim.agent_id).readRunView(claim.run_id);
+			if (previous && ![
+				"failed",
+				"cancelled",
+				"interrupted"
+			].includes(previous.run.status)) throw new Error("Only failed or interrupted workflows can be retried");
+		}
+		if (["withdrawn", "expired"].includes(getCard(cardId, workspace).status) || !effectiveProactivePolicy(card.subscriptionId).enabled) throw new Error("Card permissions changed");
+		const result = await workflows.startWorkflowRun({
+			agentId: claim.agent_id,
+			definitionId,
+			preparationOnly: true,
+			writebackPolicy: { targets: [] },
+			...sub.scopeKind === "project" ? { projectId: sub.scopeId } : {},
+			goal: `Prepare a reviewable checklist for this user-selected card. Do not send messages or publish results.\n${card.title}\n${card.summary}\n${card.recommendation}`,
+			input: {
+				cardId,
+				evidence: card.evidence,
+				purpose: "preparation_checklist"
+			},
+			source: { kind: "webui" },
+			concurrency: 1,
+			tokenBudget: 5e3,
+			idempotencyKey: claim.attempt_key,
+			...input.retry && claim.run_id ? { retryOfRunId: claim.run_id } : {}
+		});
+		if (result.ok === false) throw new Error(result.message);
+		getSqliteDatabase().prepare("UPDATE proactive_workflow_links SET status = 'started', run_id = ?, session_key = ?, lease_until = NULL WHERE inbox_item_id = ? AND attempt_key = ?").run(result.runId, result.sessionKey, cardId, claim.attempt_key);
+		return workflowForCard(cardId, workspace, workflows);
+	} catch (error) {
+		getSqliteDatabase().prepare("UPDATE proactive_workflow_links SET status = 'failed', lease_until = NULL, error = ? WHERE inbox_item_id = ? AND attempt_key = ?").run(error instanceof Error ? error.message.slice(0, 500) : "Workflow failed", cardId, claim.attempt_key);
+		throw error;
+	}
+}
+async function workflowForCard(cardId, workspace, workflows) {
+	if (getCard(cardId, workspace).status === "withdrawn") return null;
+	const row = getSqliteDatabase().prepare("SELECT run_id AS runId, agent_id AS agentId, session_key AS sessionKey, status, error FROM proactive_workflow_links WHERE inbox_item_id = ?").get(cardId);
+	if (!row) return null;
+	if (!row.runId) return row;
+	const view = await workflows.createRunStore(row.agentId).readRunView(row.runId);
+	return {
+		...row,
+		status: view?.run.status ?? row.status
+	};
+}
+//#endregion
+export { prepareCardWorkflow, workflowForCard };

package/dist/src/proactive/execution/agent-executor.d.ts

@@ -12,5 +12,10 @@ export declare class ReadonlyProactiveAgentExecutor implements ProactiveAgentExe
     }): Promise<{
         text: string;
         modelRef: string;
+        usage: {
+            inputTokens: number;
+            outputTokens: number;
+            estimatedCostUsd?: number;
+        };
     }>;
 }

package/dist/src/proactive/execution/agent-executor.js

@@ -56,6 +56,7 @@ var ReadonlyProactiveAgentExecutor = class {
 		this.config = config;
 	}
 	async execute(input) {
+		input.signal?.throwIfAborted();
 		const model = resolveModel(getDefaultModelSync(this.config()));
 		let toolCalls = 0;
 		const agent = new Agent({
@@ -91,8 +92,28 @@ var ReadonlyProactiveAgentExecutor = class {
 			const text = assistantText(agent.state.messages);
 			if (!text) throw new Error("Proactive agent returned empty output");
 			if (toolCalls === 0) throw new Error("Proactive agent did not inspect authorized evidence");
+			const usage = {
+				inputTokens: 0,
+				outputTokens: 0,
+				estimatedCostUsd: 0
+			};
+			for (const message of agent.state.messages) {
+				if (message.role !== "assistant") continue;
+				const reported = message.usage;
+				if (reported) {
+					usage.inputTokens += reported.input ?? 0;
+					usage.outputTokens += reported.output ?? 0;
+					usage.estimatedCostUsd += reported.cost?.total ?? 0;
+				}
+			}
+			const priced = Object.values(model.cost).some((value) => value > 0);
 			return {
 				text,
+				usage: {
+					inputTokens: usage.inputTokens,
+					outputTokens: usage.outputTokens,
+					...priced ? { estimatedCostUsd: usage.estimatedCostUsd } : {}
+				},
 				modelRef: `${model.provider}/${model.id}`
 			};
 		} finally {

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

@@ -0,0 +1,3 @@
+/** Recheck connector consent for stored cards and actions, not just model input. */
+export declare function insightSourcesAuthorized(insightId: string): boolean;
+export declare function authorizedConnectedSource(itemId: string, workspaceId: string, scenarioKey: string, agentId?: string | null): import("../../knowledge/types.js").KnowledgeSourceItem;

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

@@ -0,0 +1,23 @@
+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";
+//#region src/proactive/execution/authorization.ts
+/** Recheck connector consent for stored cards and actions, not just model input. */
+function insightSourcesAuthorized(insightId) {
+	return getSqliteDatabase().prepare(`SELECT e.subject_id, e.workspace_id, x.scenario_key
+    FROM proactive_insights x JOIN proactive_runs r USING(run_id)
+    JOIN proactive_batch_events be ON be.batch_id = r.batch_id JOIN proactive_events e USING(event_id)
+    WHERE x.insight_id = ? AND e.type LIKE 'connected_source.%'`).all(insightId).every((row) => Boolean(authorizedConnectedSource(row.subject_id, row.workspace_id, row.scenario_key)));
+}
+function authorizedConnectedSource(itemId, workspaceId, scenarioKey, agentId) {
+	const item = getKnowledgeSourceItem(itemId);
+	if (!item || item.deletedAt || item.metadata.workspaceId !== workspaceId || item.sensitivity === "secret" || item.sensitivity === "regulated") return null;
+	if (agentId && item.metadata.agentId && item.metadata.agentId !== agentId) return null;
+	const connectionId = item.metadata.connectionId;
+	if (typeof connectionId !== "string") return null;
+	if (!getSqliteDatabase().prepare("SELECT 1 FROM connector_connections WHERE id = ? AND status = 'active'").get(connectionId)) return null;
+	const policy = getConnectorSyncPolicyForConnection(connectionId);
+	return policy?.scanEnabled && policy.proactiveEnabled && (!policy.allowedScenarioKeys.length || policy.allowedScenarioKeys.includes(scenarioKey)) ? item : null;
+}
+//#endregion
+export { authorizedConnectedSource, insightSourcesAuthorized };

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

@@ -1,9 +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 { getDiscussionCapture, getLatestDiscussionOrganization } from "../../discussions/repository.js";
+import { authorizedConnectedSource } from "./authorization.js";
 import { wrapExternalContent } from "../../gateway/security/external-content.js";
 //#region src/proactive/execution/context.ts
 const MAX_EVENT_COUNT = 50;
@@ -28,15 +27,7 @@ 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;
+	return authorizedConnectedSource(event.subject_id, event.workspace_id, scenarioKey, event.agent_id);
 }
 var EventBatchContextProvider = class {
 	id = "event_batch";

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

@@ -57,7 +57,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");
@@ -93,5 +93,36 @@ function isValuableInsight(candidate, policy = {
 }) {
 	return candidate.confidence >= policy.minConfidence && candidate.urgency !== "low" && 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,6 +89,19 @@ 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
@@ -90,8 +115,17 @@ function finishRun(input, now = /* @__PURE__ */ new Date()) {
 		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 = {
@@ -115,7 +149,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);
 	});
 }

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

@@ -55,6 +55,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,11 +1,13 @@
 import { createLogger } from "../../utils/logger/index.js";
 import { init_logger } from "../../utils/logger.js";
+import { getSqliteDatabase } from "../../storage/sqlite/transaction.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";
 //#region src/proactive/execution/worker.ts
 init_logger();
@@ -42,6 +44,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 +59,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 +79,21 @@ 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 result = revoked ? {
+					result: "no_insight",
+					reason: "source_unavailable"
+				} : parseAnalysisResult(output.text, new Set(latestContext.evidenceIds));
+				const candidate = result.result === "insight" ? result.candidate : void 0;
+				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 +101,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/inbox/cards.d.ts

@@ -0,0 +1,21 @@
+import { type ProactiveCard } from '@xopcai/gateway-contract';
+export declare function requireCardScope(id: string, workspaceId: string): void;
+export declare function getCard(id: string, workspaceId: string): ProactiveCard;
+export declare function listCards(workspaceId: string, input?: {
+    status?: string;
+    before?: string;
+    limit?: number;
+}): {
+    cards: ProactiveCard[];
+    nextCursor: string;
+};
+export declare function cardChanges(workspaceId: string, cursor?: number): {
+    items: {
+        id: string;
+        deleted: boolean;
+        card?: ProactiveCard;
+    }[];
+    nextCursor: number;
+    hasMore: boolean;
+};
+export declare function performCardAction(id: string, workspaceId: string, value: unknown): ProactiveCard;