@xopcai/xopc 0.0.176 → 0.0.177

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

@@ -0,0 +1,104 @@
+import { init_sync_provider_auth, resolveProviderApiKeySync } from "../../auth/sync-provider-auth.js";
+import { getApiKeySync, getDefaultModelSync, init_providers, resolveModel } from "../../providers/index.js";
+import { createExtensionAwareStreamFn } from "../../providers/extension-stream-bridge.js";
+import { runAgentTurnWithTimeout } from "../../agent/orchestration/run-agent-turn-with-timeout.js";
+import { isAssistantTurnAborted, isAssistantTurnFailed } from "../../agent/orchestration/llm-turn-retry.js";
+import { Agent } from "@earendil-works/pi-agent-core";
+import { Type } from "@sinclair/typebox";
+//#region src/proactive/execution/agent-executor.ts
+init_sync_provider_auth();
+init_providers();
+const MAX_TOOL_CALLS = 6;
+const AGENT_TIMEOUT_MS = 9e4;
+function assistantText(messages) {
+	for (let index = messages.length - 1; index >= 0; index -= 1) {
+		const message = messages[index];
+		if (message.role !== "assistant") continue;
+		if (Array.isArray(message.content)) return message.content.flatMap((block) => block && typeof block === "object" && block.type === "text" ? [String(block.text ?? "")] : []).join("").trim();
+	}
+	return "";
+}
+function inspectionTool(context) {
+	return {
+		name: "inspect_authorized_context",
+		label: "Inspect authorized work context",
+		description: "Read one authorized evidence section. This tool cannot write or trigger any action.",
+		parameters: Type.Object({ section: Type.String({ description: "A top-level section name from the availableSections list." }) }),
+		async execute(_toolCallId, args) {
+			const values = args;
+			const section = typeof values.section === "string" ? values.section : "";
+			if (!Object.prototype.hasOwnProperty.call(context, section)) return {
+				content: [{
+					type: "text",
+					text: `Unknown section. Available: ${Object.keys(context).join(", ")}`
+				}],
+				details: { found: false }
+			};
+			return {
+				content: [{
+					type: "text",
+					text: JSON.stringify({
+						section,
+						evidence: context[section]
+					}, null, 2).slice(0, 6e4)
+				}],
+				details: {
+					found: true,
+					section
+				}
+			};
+		}
+	};
+}
+/** Runs an isolated, read-only agent over only the context authorized by the signal batch. */
+var ReadonlyProactiveAgentExecutor = class {
+	constructor(config) {
+		this.config = config;
+	}
+	async execute(input) {
+		const model = resolveModel(getDefaultModelSync(this.config()));
+		let toolCalls = 0;
+		const agent = new Agent({
+			initialState: {
+				systemPrompt: `${input.systemPrompt}\n\nYou are an autonomous background analysis agent. You MUST inspect relevant authorized context with the provided read-only tool before reaching a conclusion. You have no mutation, messaging, shell, network, or filesystem tools.`,
+				model,
+				thinkingLevel: "low",
+				tools: [inspectionTool(input.authorizedContext)],
+				messages: []
+			},
+			streamFn: createExtensionAwareStreamFn(),
+			getApiKey: (provider) => resolveProviderApiKeySync(provider) ?? getApiKeySync(provider) ?? "",
+			beforeToolCall: async () => {
+				if (toolCalls >= MAX_TOOL_CALLS) return {
+					block: true,
+					reason: `Maximum inspection calls reached (${MAX_TOOL_CALLS}).`
+				};
+			},
+			afterToolCall: async () => {
+				toolCalls += 1;
+			}
+		});
+		const abort = () => agent.abort();
+		input.signal?.addEventListener("abort", abort, { once: true });
+		try {
+			const sections = Object.keys(input.authorizedContext);
+			await runAgentTurnWithTimeout(agent, async () => {
+				await agent.prompt(`${input.userPrompt}\n\nAvailable authorized evidence sections: ${sections.join(", ") || "(none)"}.`);
+				await agent.waitForIdle();
+			}, AGENT_TIMEOUT_MS);
+			if (isAssistantTurnAborted(agent)) throw new Error("Proactive agent execution aborted");
+			if (isAssistantTurnFailed(agent)) throw new Error("Proactive agent execution failed");
+			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");
+			return {
+				text,
+				modelRef: `${model.provider}/${model.id}`
+			};
+		} finally {
+			input.signal?.removeEventListener("abort", abort);
+		}
+	}
+};
+//#endregion
+export { ReadonlyProactiveAgentExecutor };

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

@@ -0,0 +1,31 @@
+import type { ContextProvider } from './types.js';
+export declare class EventBatchContextProvider implements ContextProvider {
+    readonly id = "event_batch";
+    supports(): boolean;
+    collect(input: {
+        eventIds: string[];
+    }): Promise<Record<string, unknown>>;
+}
+export declare class ProjectStateContextProvider implements ContextProvider {
+    readonly id = "project_state";
+    supports(scenarioKey: string): boolean;
+    collect(input: {
+        eventIds: string[];
+    }): Promise<Record<string, unknown>>;
+}
+export declare class AutomationStateContextProvider implements ContextProvider {
+    readonly id = "automation_state";
+    supports(scenarioKey: string): boolean;
+    collect(input: {
+        eventIds: string[];
+    }): Promise<Record<string, unknown>>;
+}
+export declare class ContextProviderRegistry {
+    private readonly providers;
+    constructor(providers?: ContextProvider[]);
+    collect(scenarioKey: string, input: {
+        batchId: string;
+        eventIds: string[];
+        subscriptionId: string;
+    }): Promise<Record<string, unknown>>;
+}

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

@@ -0,0 +1,72 @@
+import { getSqliteDatabase } from "../../storage/sqlite/transaction.js";
+//#region src/proactive/execution/context.ts
+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
+			},
+			payload: JSON.parse(row.payload_json),
+			occurredAt: row.occurred_at
+		})) };
+	}
+};
+var ProjectStateContextProvider = class {
+	id = "project_state";
+	supports(scenarioKey) {
+		return scenarioKey === "project_delivery_risk" || scenarioKey === "blocked_work";
+	}
+	async collect(input) {
+		if (!input.eventIds.length) return {};
+		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,
+      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))
+		};
+	}
+};
+var AutomationStateContextProvider = class {
+	id = "automation_state";
+	supports(scenarioKey) {
+		return scenarioKey === "automation_failure_impact";
+	}
+	async collect(input) {
+		if (!input.eventIds.length) return {};
+		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 {};
+		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
+		};
+	}
+};
+var ContextProviderRegistry = class {
+	constructor(providers = [
+		new EventBatchContextProvider(),
+		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);
+	}
+};
+//#endregion
+export { AutomationStateContextProvider, ContextProviderRegistry, EventBatchContextProvider, ProjectStateContextProvider };

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

@@ -0,0 +1,4 @@
+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): boolean;

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

@@ -0,0 +1,74 @@
+import { stripCodeFences } from "../../agent/goals/judge.js";
+//#region src/proactive/execution/insight.ts
+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 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" || 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);
+	return {
+		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 } : {},
+		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) {
+	return candidate.confidence >= .65 && candidate.urgency !== "low" && scoreInsight(candidate) >= .6;
+}
+//#endregion
+export { isValuableInsight, parseInsightCandidate, scoreInsight };

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

@@ -0,0 +1,23 @@
+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;
+}
+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;
+    rawOutput: string;
+    modelRef?: string;
+}, now?: Date): ProactiveInsight | null;
+export declare function failRun(run: ClaimedRun, error: unknown, retryable: boolean, now?: Date): void;
+export declare function listInsights(limit?: number): ProactiveInsight[];

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

@@ -0,0 +1,122 @@
+import { getSqliteDatabase, runSqliteWriteTransaction } from "../../storage/sqlite/transaction.js";
+import { 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();
+		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);
+		db.prepare(`UPDATE proactive_signal_batches SET status = 'failed_permanent', updated_at = ?
+      WHERE status = 'processing' AND batch_id IN (
+        SELECT batch_id FROM proactive_runs WHERE status = 'running' AND lease_expires_at <= ? AND attempt >= 3
+      )`).run(nowIso, nowIso);
+		db.prepare(`UPDATE proactive_runs SET status = 'failed', error_message = 'Lease expired after maximum attempts',
+      lease_owner = NULL, lease_expires_at = NULL, updated_at = ?
+      WHERE status = 'running' AND lease_expires_at <= ? AND attempt >= 3`).run(nowIso, nowIso);
+		const retry = db.prepare(`SELECT * FROM proactive_runs WHERE status = 'retryable' AND next_attempt_at <= ? ORDER BY next_attempt_at LIMIT 1`).get(nowIso);
+		if (retry) {
+			db.prepare(`UPDATE proactive_runs SET status = 'running', attempt = attempt + 1, lease_owner = ?, lease_expires_at = ?, next_attempt_at = NULL, updated_at = ? WHERE run_id = ?`).run(owner, new Date(now.getTime() + leaseSeconds * 1e3).toISOString(), nowIso, str(retry, "run_id"));
+			db.prepare("UPDATE proactive_signal_batches SET status = 'processing', updated_at = ? WHERE batch_id = ?").run(nowIso, str(retry, "batch_id"));
+			return runFromRow(db.prepare("SELECT * FROM proactive_runs WHERE run_id = ?").get(str(retry, "run_id")));
+		}
+		const expired = db.prepare(`SELECT * FROM proactive_runs WHERE status = 'running' AND lease_expires_at <= ? AND attempt < 3 ORDER BY updated_at LIMIT 1`).get(nowIso);
+		if (expired) {
+			db.prepare(`UPDATE proactive_runs SET attempt = attempt + 1, lease_owner = ?, lease_expires_at = ?, updated_at = ? WHERE run_id = ?`).run(owner, new Date(now.getTime() + leaseSeconds * 1e3).toISOString(), nowIso, str(expired, "run_id"));
+			return runFromRow(db.prepare("SELECT * FROM proactive_runs WHERE run_id = ?").get(str(expired, "run_id")));
+		}
+		const batch = db.prepare(`SELECT b.*, s.active_prompt_revision_id FROM proactive_signal_batches b
+      JOIN proactive_scenario_subscriptions s ON s.subscription_id = b.subscription_id
+      WHERE b.status = 'ready' ORDER BY b.ready_at LIMIT 1`).get();
+		if (!batch) return null;
+		const id = randomUUID();
+		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);
+		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));
+	});
+}
+function runFromRow(row) {
+	return {
+		id: str(row, "run_id"),
+		batchId: str(row, "batch_id"),
+		subscriptionId: str(row, "subscription_id"),
+		scenarioKey: str(row, "scenario_key"),
+		scenarioVersion: Number(row.scenario_version),
+		attempt: Number(row.attempt),
+		...row.prompt_revision_id ? { promptRevisionId: str(row, "prompt_revision_id") } : {}
+	};
+}
+function eventIdsForBatch(batchId) {
+	return getSqliteDatabase().prepare("SELECT event_id FROM proactive_batch_events WHERE batch_id = ? ORDER BY added_at DESC LIMIT 100").all(batchId).map((row) => row.event_id);
+}
+function saveSnapshot(batchId, content, evidenceIds, now = /* @__PURE__ */ new Date()) {
+	const snapshot = {
+		id: randomUUID(),
+		batchId,
+		content,
+		evidenceIds,
+		createdAt: now.toISOString()
+	};
+	runSqliteWriteTransaction((db) => db.prepare(`INSERT INTO proactive_context_snapshots
+    (snapshot_id, batch_id, content_json, evidence_ids_json, created_at) VALUES (?, ?, ?, ?, ?)`).run(snapshot.id, batchId, JSON.stringify(content), JSON.stringify(evidenceIds), snapshot.createdAt));
+	return snapshot;
+}
+function attachSnapshot(runId, snapshotId) {
+	runSqliteWriteTransaction((db) => db.prepare("UPDATE proactive_runs SET context_snapshot_id = ?, updated_at = ? WHERE run_id = ?").run(snapshotId, (/* @__PURE__ */ new Date()).toISOString(), runId));
+}
+function finishRun(input, now = /* @__PURE__ */ new Date()) {
+	return runSqliteWriteTransaction((db) => {
+		const nowIso = now.toISOString();
+		const valuable = Boolean(input.candidate);
+		db.prepare(`UPDATE proactive_runs SET status = ?, raw_output = ?, model_ref = ?, lease_owner = NULL,
+      lease_expires_at = NULL, completed_at = ?, updated_at = ? WHERE run_id = ?`).run(valuable ? "completed" : "discarded", input.rawOutput.slice(0, 2e4), input.modelRef ?? null, nowIso, nowIso, input.run.id);
+		db.prepare(`UPDATE proactive_signal_batches SET status = ?, updated_at = ? WHERE batch_id = ?`).run(valuable ? "processed" : "ignored", nowIso, input.run.batchId);
+		if (!input.candidate) return null;
+		const insight = {
+			...input.candidate,
+			id: randomUUID(),
+			runId: input.run.id,
+			subscriptionId: input.run.subscriptionId,
+			scenarioKey: input.run.scenarioKey,
+			valueScore: input.valueScore ?? 0,
+			createdAt: nowIso
+		};
+		db.prepare(`INSERT INTO proactive_insights (insight_id, run_id, subscription_id, scenario_key, title, summary,
+      why_now, impact, recommendation, work_done, decision_json, urgency, confidence, value_score, evidence_ids_json, created_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(insight.id, insight.runId, insight.subscriptionId, insight.scenarioKey, insight.title, insight.summary, insight.whyNow, insight.impact, insight.recommendation, insight.workDone, insight.decision ? JSON.stringify(insight.decision) : null, insight.urgency, insight.confidence, insight.valueScore, JSON.stringify(insight.evidenceIds), insight.createdAt);
+		return insight;
+	});
+}
+function failRun(run, error, retryable, now = /* @__PURE__ */ new Date()) {
+	runSqliteWriteTransaction((db) => {
+		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);
+		db.prepare(`UPDATE proactive_signal_batches SET status = ?, updated_at = ? WHERE batch_id = ?`).run(finalRetryable ? "failed_retryable" : "failed_permanent", nowIso, run.batchId);
+	});
+}
+function listInsights(limit = 50) {
+	return getSqliteDatabase().prepare("SELECT * FROM proactive_insights ORDER BY created_at DESC LIMIT ?").all(Math.min(200, Math.max(1, limit))).map((row) => ({
+		id: str(row, "insight_id"),
+		runId: str(row, "run_id"),
+		subscriptionId: str(row, "subscription_id"),
+		scenarioKey: str(row, "scenario_key"),
+		title: str(row, "title"),
+		summary: str(row, "summary"),
+		whyNow: str(row, "why_now"),
+		impact: str(row, "impact"),
+		recommendation: str(row, "recommendation"),
+		workDone: str(row, "work_done"),
+		...row.decision_json ? { decision: JSON.parse(str(row, "decision_json")) } : {},
+		urgency: str(row, "urgency"),
+		confidence: Number(row.confidence),
+		valueScore: Number(row.value_score),
+		evidenceIds: JSON.parse(str(row, "evidence_ids_json")),
+		createdAt: str(row, "created_at")
+	}));
+}
+//#endregion
+export { attachSnapshot, claimNextRun, eventIdsForBatch, failRun, finishRun, listInsights, saveSnapshot };

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

@@ -0,0 +1,54 @@
+export interface ContextSnapshot {
+    id: string;
+    batchId: string;
+    content: Record<string, unknown>;
+    evidenceIds: string[];
+    createdAt: string;
+}
+export interface InsightCandidate {
+    title: string;
+    summary: string;
+    whyNow: string;
+    impact: string;
+    recommendation: string;
+    workDone: string;
+    decision?: {
+        question: string;
+        options: Array<{
+            id: string;
+            label: string;
+            consequence: string;
+        }>;
+    };
+    urgency: 'low' | 'medium' | 'high' | 'critical';
+    confidence: number;
+    evidenceIds: string[];
+}
+export interface ProactiveInsight extends InsightCandidate {
+    id: string;
+    runId: string;
+    subscriptionId: string;
+    scenarioKey: string;
+    valueScore: number;
+    createdAt: string;
+}
+export interface ProactiveAgentExecutor {
+    execute(input: {
+        systemPrompt: string;
+        userPrompt: string;
+        authorizedContext: Record<string, unknown>;
+        signal?: AbortSignal;
+    }): Promise<{
+        text: string;
+        modelRef?: string;
+    }>;
+}
+export interface ContextProvider {
+    id: string;
+    supports(scenarioKey: string): boolean;
+    collect(input: {
+        batchId: string;
+        eventIds: string[];
+        subscriptionId: string;
+    }): Promise<Record<string, unknown>>;
+}

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,15 @@
+import { ContextProviderRegistry } from './context.js';
+import type { ProactiveAgentExecutor } from './types.js';
+export declare class ProactiveWorker {
+    private readonly executor;
+    private readonly contexts;
+    private readonly intervalMs;
+    private readonly owner;
+    private timer?;
+    private running;
+    private stoppedWaiters;
+    constructor(executor: ProactiveAgentExecutor, contexts?: ContextProviderRegistry, intervalMs?: number);
+    start(): void;
+    stop(): Promise<void>;
+    tick(): Promise<void>;
+}

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

@@ -0,0 +1,96 @@
+import { createLogger } from "../../utils/logger/index.js";
+import { init_logger } from "../../utils/logger.js";
+import { markReadyBatches } from "../routing/batch-repository.js";
+import { getPromptRevision, getScenario } from "../scenarios/repository.js";
+import { composeScenarioPrompt } from "../scenarios/prompt-composer.js";
+import { ContextProviderRegistry } from "./context.js";
+import { attachSnapshot, claimNextRun, eventIdsForBatch, failRun, finishRun, saveSnapshot } from "./repository.js";
+import { isValuableInsight, parseInsightCandidate, scoreInsight } from "./insight.js";
+import { randomUUID } from "node:crypto";
+//#region src/proactive/execution/worker.ts
+init_logger();
+const log = createLogger("ProactiveWorker");
+var ProactiveWorker = class {
+	owner = randomUUID();
+	timer;
+	running = false;
+	stoppedWaiters = [];
+	constructor(executor, contexts = new ContextProviderRegistry(), intervalMs = 5e3) {
+		this.executor = executor;
+		this.contexts = contexts;
+		this.intervalMs = intervalMs;
+	}
+	start() {
+		if (this.timer) return;
+		this.timer = setInterval(() => void this.tick(), this.intervalMs);
+		this.timer.unref();
+		this.tick();
+	}
+	async stop() {
+		if (this.timer) clearInterval(this.timer);
+		this.timer = void 0;
+		if (!this.running) return;
+		await new Promise((resolve) => this.stoppedWaiters.push(resolve));
+	}
+	async tick() {
+		if (this.running) return;
+		this.running = true;
+		try {
+			markReadyBatches();
+			const run = claimNextRun(this.owner);
+			if (!run) return;
+			try {
+				const scenario = getScenario(run.scenarioKey);
+				if (!scenario || scenario.version !== run.scenarioVersion) throw new Error("Pinned scenario version is unavailable");
+				const revision = run.promptRevisionId ? getPromptRevision(run.promptRevisionId) ?? void 0 : void 0;
+				const eventIds = eventIdsForBatch(run.batchId);
+				const context = await this.contexts.collect(run.scenarioKey, {
+					batchId: run.batchId,
+					eventIds,
+					subscriptionId: run.subscriptionId
+				});
+				const snapshot = saveSnapshot(run.batchId, context, eventIds);
+				attachSnapshot(run.id, snapshot.id);
+				const prompt = composeScenarioPrompt({
+					scenario,
+					...revision ? { revision } : {},
+					runtimeContext: "Use the read-only inspection tool to examine the authorized evidence."
+				});
+				const output = await this.executor.execute({
+					systemPrompt: prompt.platformSafety,
+					userPrompt: prompt.text,
+					authorizedContext: context
+				});
+				const candidate = parseInsightCandidate(output.text, new Set(eventIds));
+				const valuable = isValuableInsight(candidate);
+				const insight = finishRun({
+					run,
+					...valuable ? {
+						candidate,
+						valueScore: scoreInsight(candidate)
+					} : {},
+					rawOutput: output.text,
+					modelRef: output.modelRef
+				});
+				log.info({
+					runId: run.id,
+					scenarioKey: run.scenarioKey,
+					valuable,
+					insightId: insight?.id
+				}, valuable ? "Proactive insight created" : "Proactive output discarded by value gate");
+			} catch (error) {
+				failRun(run, error, !(error instanceof Error && /Pinned scenario/.test(error.message)));
+				log.warn({
+					err: error,
+					runId: run.id,
+					scenarioKey: run.scenarioKey
+				}, "Proactive run failed");
+			}
+		} finally {
+			this.running = false;
+			for (const resolve of this.stoppedWaiters.splice(0)) resolve();
+		}
+	}
+};
+//#endregion
+export { ProactiveWorker };

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

@@ -0,0 +1,24 @@
+import type { InboxItem, InboxStatus } from './types.js';
+export declare function projectInsightsToInbox(now?: Date): number;
+export declare function wakeSnoozedItems(now?: Date): number;
+export declare function listInbox(input?: {
+    status?: InboxStatus;
+    limit?: number;
+}): InboxItem[];
+export declare function getInboxItem(id: string): InboxItem | null;
+export declare function transitionInboxItem(id: string, input: {
+    status: InboxStatus;
+    snoozedUntil?: string;
+    resolution?: string;
+}, now?: Date): InboxItem;
+export declare function recordDecision(id: string, choice: string, note?: string, now?: Date): InboxItem;
+export declare function recordFeedback(id: string, rating: 'useful' | 'not_useful', note?: string, now?: Date): void;
+export declare function getInboxSubscriptionId(id: string): string;
+export interface OutboxClaim {
+    id: string;
+    item: InboxItem;
+    attempt: number;
+}
+export declare function claimDelivery(now?: Date): OutboxClaim | null;
+export declare function finishDelivery(id: string, error?: unknown, attempt?: number, now?: Date): void;
+export declare function recoverExpiredDeliveries(now?: Date): number;