@xopcai/xopc 0.0.176 → 0.0.178

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;

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

@@ -0,0 +1,117 @@
+import { getSqliteDatabase, runSqliteWriteTransaction } from "../../storage/sqlite/transaction.js";
+import { randomUUID } from "node:crypto";
+//#region src/proactive/inbox/repository.ts
+const s = (row, key) => String(row[key]);
+function itemFromRow(row) {
+	return {
+		id: s(row, "inbox_item_id"),
+		insightId: s(row, "insight_id"),
+		status: s(row, "status"),
+		...row.snoozed_until ? { snoozedUntil: s(row, "snoozed_until") } : {},
+		...row.resolution ? { resolution: s(row, "resolution") } : {},
+		createdAt: s(row, "created_at"),
+		updatedAt: s(row, "updated_at"),
+		insight: {
+			scenarioKey: s(row, "scenario_key"),
+			title: s(row, "title"),
+			summary: s(row, "summary"),
+			whyNow: s(row, "why_now"),
+			impact: s(row, "impact"),
+			recommendation: s(row, "recommendation"),
+			workDone: s(row, "work_done"),
+			...row.decision_json ? { decision: JSON.parse(s(row, "decision_json")) } : {},
+			urgency: s(row, "urgency"),
+			confidence: Number(row.confidence),
+			valueScore: Number(row.value_score),
+			evidenceIds: JSON.parse(s(row, "evidence_ids_json"))
+		}
+	};
+}
+const SELECT_ITEM = `SELECT i.*, x.subscription_id, x.scenario_key, x.title, x.summary, x.why_now, x.impact, x.recommendation,
+  x.work_done, x.decision_json, x.urgency, x.confidence, x.value_score, x.evidence_ids_json FROM proactive_inbox_items i
+  JOIN proactive_insights x ON x.insight_id = i.insight_id`;
+function projectInsightsToInbox(now = /* @__PURE__ */ new Date()) {
+	return runSqliteWriteTransaction((db) => {
+		const missing = db.prepare(`SELECT insight_id FROM proactive_insights WHERE insight_id NOT IN
+      (SELECT insight_id FROM proactive_inbox_items) ORDER BY created_at`).all();
+		for (const row of missing) {
+			const id = randomUUID();
+			const nowIso = now.toISOString();
+			db.prepare(`INSERT INTO proactive_inbox_items (inbox_item_id, insight_id, status, created_at, updated_at)
+        VALUES (?, ?, 'unread', ?, ?)`).run(id, row.insight_id, nowIso, nowIso);
+			db.prepare(`INSERT INTO proactive_delivery_outbox (delivery_id, inbox_item_id, status, attempt, next_attempt_at, created_at, updated_at)
+        VALUES (?, ?, 'pending', 0, ?, ?, ?)`).run(randomUUID(), id, nowIso, nowIso, nowIso);
+		}
+		return missing.length;
+	});
+}
+function wakeSnoozedItems(now = /* @__PURE__ */ new Date()) {
+	return Number(runSqliteWriteTransaction((db) => db.prepare(`UPDATE proactive_inbox_items SET status = 'unread', snoozed_until = NULL, updated_at = ?
+    WHERE status = 'snoozed' AND snoozed_until <= ?`).run(now.toISOString(), now.toISOString()).changes));
+}
+function listInbox(input = {}) {
+	const limit = Math.min(200, Math.max(1, input.limit ?? 50));
+	return (input.status ? getSqliteDatabase().prepare(`${SELECT_ITEM} WHERE i.status = ? ORDER BY i.updated_at DESC LIMIT ?`).all(input.status, limit) : getSqliteDatabase().prepare(`${SELECT_ITEM} ORDER BY i.updated_at DESC LIMIT ?`).all(limit)).map(itemFromRow);
+}
+function getInboxItem(id) {
+	const row = getSqliteDatabase().prepare(`${SELECT_ITEM} WHERE i.inbox_item_id = ?`).get(id);
+	return row ? itemFromRow(row) : null;
+}
+function transitionInboxItem(id, input, now = /* @__PURE__ */ new Date()) {
+	if (input.status === "snoozed" && (!input.snoozedUntil || Date.parse(input.snoozedUntil) <= now.getTime())) throw new Error("snoozedUntil must be in the future");
+	if (input.status === "resolved" && !input.resolution?.trim()) throw new Error("resolution is required");
+	runSqliteWriteTransaction((db) => {
+		if (db.prepare(`UPDATE proactive_inbox_items SET status = ?, snoozed_until = ?, resolution = ?, updated_at = ? WHERE inbox_item_id = ?`).run(input.status, input.status === "snoozed" ? input.snoozedUntil : null, input.status === "resolved" ? input.resolution.trim() : null, now.toISOString(), id).changes !== 1) throw new Error("Inbox item not found");
+	});
+	return getInboxItem(id);
+}
+function recordDecision(id, choice, note = "", now = /* @__PURE__ */ new Date()) {
+	if (!choice.trim()) throw new Error("choice is required");
+	runSqliteWriteTransaction((db) => {
+		const row = db.prepare(`SELECT x.decision_json FROM proactive_inbox_items i
+      JOIN proactive_insights x ON x.insight_id = i.insight_id WHERE i.inbox_item_id = ?`).get(id);
+		if (!row) throw new Error("Inbox item not found");
+		if (!row.decision_json) throw new Error("Inbox item does not require a decision");
+		if (!JSON.parse(row.decision_json).options.some((option) => option.id === choice.trim())) throw new Error("choice is not a valid decision option");
+		db.prepare("INSERT INTO proactive_decisions (decision_id, inbox_item_id, choice, note, created_at) VALUES (?, ?, ?, ?, ?)").run(randomUUID(), id, choice.trim().slice(0, 200), note.trim().slice(0, 2e3), now.toISOString());
+		db.prepare("UPDATE proactive_inbox_items SET status = 'resolved', resolution = ?, updated_at = ? WHERE inbox_item_id = ?").run(choice.trim().slice(0, 200), now.toISOString(), id);
+	});
+	return getInboxItem(id);
+}
+function recordFeedback(id, rating, note = "", now = /* @__PURE__ */ new Date()) {
+	runSqliteWriteTransaction((db) => {
+		if (!db.prepare("SELECT 1 FROM proactive_inbox_items WHERE inbox_item_id = ?").get(id)) throw new Error("Inbox item not found");
+		db.prepare("INSERT INTO proactive_feedback (feedback_id, inbox_item_id, rating, note, created_at) VALUES (?, ?, ?, ?, ?)").run(randomUUID(), id, rating, note.trim().slice(0, 2e3), now.toISOString());
+	});
+}
+function getInboxSubscriptionId(id) {
+	const item = getSqliteDatabase().prepare(`${SELECT_ITEM} WHERE i.inbox_item_id = ?`).get(id);
+	if (!item) throw new Error("Inbox item not found");
+	return s(item, "subscription_id");
+}
+function claimDelivery(now = /* @__PURE__ */ new Date()) {
+	return runSqliteWriteTransaction((db) => {
+		const row = db.prepare(`SELECT delivery_id, inbox_item_id, attempt FROM proactive_delivery_outbox
+      WHERE status IN ('pending', 'retryable') AND next_attempt_at <= ? ORDER BY created_at LIMIT 1`).get(now.toISOString());
+		if (!row) return null;
+		db.prepare(`UPDATE proactive_delivery_outbox SET status = 'delivering', attempt = attempt + 1, lease_expires_at = ?, updated_at = ? WHERE delivery_id = ?`).run(new Date(now.getTime() + 6e4).toISOString(), now.toISOString(), s(row, "delivery_id"));
+		return {
+			id: s(row, "delivery_id"),
+			item: getInboxItem(s(row, "inbox_item_id")),
+			attempt: Number(row.attempt) + 1
+		};
+	});
+}
+function finishDelivery(id, error, attempt = 1, now = /* @__PURE__ */ new Date()) {
+	runSqliteWriteTransaction((db) => {
+		const retry = Boolean(error) && attempt < 5;
+		db.prepare(`UPDATE proactive_delivery_outbox SET status = ?, next_attempt_at = ?, lease_expires_at = NULL,
+      error_message = ?, delivered_at = ?, updated_at = ? WHERE delivery_id = ?`).run(error ? retry ? "retryable" : "failed" : "delivered", retry ? new Date(now.getTime() + attempt * 3e4).toISOString() : now.toISOString(), error ? String(error instanceof Error ? error.message : error).slice(0, 1e3) : null, error ? null : now.toISOString(), now.toISOString(), id);
+	});
+}
+function recoverExpiredDeliveries(now = /* @__PURE__ */ new Date()) {
+	return Number(runSqliteWriteTransaction((db) => db.prepare(`UPDATE proactive_delivery_outbox SET status = 'retryable', next_attempt_at = ?, lease_expires_at = NULL, updated_at = ?
+    WHERE status = 'delivering' AND lease_expires_at <= ?`).run(now.toISOString(), now.toISOString(), now.toISOString()).changes));
+}
+//#endregion
+export { claimDelivery, finishDelivery, getInboxItem, getInboxSubscriptionId, listInbox, projectInsightsToInbox, recordDecision, recordFeedback, recoverExpiredDeliveries, transitionInboxItem, wakeSnoozedItems };

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

@@ -0,0 +1,17 @@
+import { listInbox, projectInsightsToInbox, recordDecision, recordFeedback, wakeSnoozedItems } from './repository.js';
+import type { InboxStatus } from './types.js';
+export declare class ProactiveInboxService {
+    list: typeof listInbox;
+    project: typeof projectInsightsToInbox;
+    wakeSnoozed: typeof wakeSnoozedItems;
+    decide: typeof recordDecision;
+    feedback: typeof recordFeedback;
+    instruct(id: string, instruction: string): {
+        revisionId: string;
+    };
+    transition(id: string, input: {
+        status: InboxStatus;
+        snoozedUntil?: string;
+        resolution?: string;
+    }): import("./types.js").InboxItem;
+}