@xopcai/xopc 0.0.176 → 0.0.177

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

@@ -0,0 +1,162 @@
+import { getSqliteDatabase, runSqliteWriteTransaction } from "../../storage/sqlite/transaction.js";
+import { createHash, randomUUID } from "node:crypto";
+//#region src/proactive/scenarios/repository.ts
+const text = (row, key) => String(row[key]);
+function scenarioFromRow(row) {
+	const condition = row.condition_json ? JSON.parse(String(row.condition_json)) : void 0;
+	return {
+		key: text(row, "scenario_key"),
+		version: Number(row.version),
+		title: text(row, "title"),
+		description: text(row, "description"),
+		basePrompt: text(row, "base_prompt"),
+		baseTemplateVersion: Number(row.base_template_version),
+		eventTypes: JSON.parse(text(row, "event_types_json")),
+		...condition ? { condition } : {},
+		aggregation: text(row, "aggregation"),
+		debounceSeconds: Number(row.debounce_seconds),
+		maxWindowSeconds: Number(row.max_window_seconds)
+	};
+}
+function subscriptionFromRow(row) {
+	return {
+		id: text(row, "subscription_id"),
+		scenarioKey: text(row, "scenario_key"),
+		workspaceId: text(row, "workspace_id"),
+		scopeKind: text(row, "scope_kind"),
+		scopeId: text(row, "scope_id"),
+		enabled: Number(row.enabled) === 1,
+		...row.active_prompt_revision_id ? { activePromptRevisionId: text(row, "active_prompt_revision_id") } : {},
+		createdAt: text(row, "created_at"),
+		updatedAt: text(row, "updated_at")
+	};
+}
+function revisionFromRow(row) {
+	return {
+		id: text(row, "revision_id"),
+		subscriptionId: text(row, "subscription_id"),
+		revision: Number(row.revision),
+		status: text(row, "status"),
+		baseTemplateVersion: Number(row.base_template_version),
+		userInstructions: text(row, "user_instructions"),
+		contentHash: text(row, "content_hash"),
+		createdAt: text(row, "created_at"),
+		...row.published_at ? { publishedAt: text(row, "published_at") } : {}
+	};
+}
+function listScenarios() {
+	return getSqliteDatabase().prepare("SELECT * FROM proactive_scenarios ORDER BY scenario_key").all().map(scenarioFromRow);
+}
+function getScenario(key) {
+	const row = getSqliteDatabase().prepare("SELECT * FROM proactive_scenarios WHERE scenario_key = ?").get(key);
+	return row ? scenarioFromRow(row) : null;
+}
+function upsertSubscription(input, now = /* @__PURE__ */ new Date()) {
+	if (!getScenario(input.scenarioKey)) throw new Error("Scenario not found");
+	const nowIso = now.toISOString();
+	runSqliteWriteTransaction((db) => db.prepare(`INSERT INTO proactive_scenario_subscriptions (
+    subscription_id, scenario_key, workspace_id, scope_kind, scope_id, enabled, created_at, updated_at
+  ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+  ON CONFLICT(scenario_key, workspace_id, scope_kind, scope_id) DO UPDATE SET enabled = excluded.enabled, updated_at = excluded.updated_at`).run(randomUUID(), input.scenarioKey, input.workspaceId, input.scopeKind, input.scopeId, input.enabled ? 1 : 0, nowIso, nowIso));
+	return subscriptionFromRow(getSqliteDatabase().prepare(`SELECT * FROM proactive_scenario_subscriptions
+    WHERE scenario_key = ? AND workspace_id = ? AND scope_kind = ? AND scope_id = ?`).get(input.scenarioKey, input.workspaceId, input.scopeKind, input.scopeId));
+}
+function listSubscriptions(scenarioKey) {
+	return (scenarioKey ? getSqliteDatabase().prepare("SELECT * FROM proactive_scenario_subscriptions WHERE scenario_key = ? ORDER BY updated_at DESC").all(scenarioKey) : getSqliteDatabase().prepare("SELECT * FROM proactive_scenario_subscriptions ORDER BY updated_at DESC").all()).map(subscriptionFromRow);
+}
+function listEnabledRoutes() {
+	return listSubscriptions().filter((item) => item.enabled).flatMap((subscription) => {
+		const scenario = getScenario(subscription.scenarioKey);
+		if (!scenario) return [];
+		return [{
+			subscriptionId: subscription.id,
+			key: scenario.key,
+			version: scenario.version,
+			enabled: true,
+			eventTypes: scenario.eventTypes,
+			...scenario.condition ? { condition: scenario.condition } : {},
+			aggregation: scenario.aggregation,
+			debounceSeconds: scenario.debounceSeconds,
+			maxWindowSeconds: scenario.maxWindowSeconds,
+			scope: {
+				workspaceId: subscription.workspaceId,
+				...subscription.scopeKind === "project" ? { projectId: subscription.scopeId } : {}
+			}
+		}];
+	});
+}
+function createPromptDraft(subscriptionId, userInstructions, now = /* @__PURE__ */ new Date()) {
+	const instructions = userInstructions.trim();
+	if (instructions.length > 12e3) throw new Error("User instructions exceed 12000 characters");
+	return runSqliteWriteTransaction((db) => {
+		const subscription = db.prepare("SELECT * FROM proactive_scenario_subscriptions WHERE subscription_id = ?").get(subscriptionId);
+		if (!subscription) throw new Error("Subscription not found");
+		const scenario = db.prepare("SELECT * FROM proactive_scenarios WHERE scenario_key = ?").get(text(subscription, "scenario_key"));
+		const next = db.prepare("SELECT COALESCE(MAX(revision), 0) + 1 AS revision FROM proactive_prompt_revisions WHERE subscription_id = ?").get(subscriptionId);
+		const id = randomUUID();
+		const baseTemplateVersion = Number(scenario.base_template_version);
+		const hash = createHash("sha256").update(`${baseTemplateVersion}:${instructions}`).digest("hex");
+		db.prepare(`INSERT INTO proactive_prompt_revisions
+      (revision_id, subscription_id, revision, status, base_template_version, user_instructions, content_hash, created_at)
+      VALUES (?, ?, ?, 'draft', ?, ?, ?, ?)`).run(id, subscriptionId, next.revision, baseTemplateVersion, instructions, hash, now.toISOString());
+		return revisionFromRow(db.prepare("SELECT * FROM proactive_prompt_revisions WHERE revision_id = ?").get(id));
+	});
+}
+function getPromptRevision(id) {
+	const row = getSqliteDatabase().prepare("SELECT * FROM proactive_prompt_revisions WHERE revision_id = ?").get(id);
+	return row ? revisionFromRow(row) : null;
+}
+function getSubscription(id) {
+	const row = getSqliteDatabase().prepare("SELECT * FROM proactive_scenario_subscriptions WHERE subscription_id = ?").get(id);
+	return row ? subscriptionFromRow(row) : null;
+}
+function publishPromptRevision(id, now = /* @__PURE__ */ new Date()) {
+	return runSqliteWriteTransaction((db) => {
+		const draft = db.prepare("SELECT * FROM proactive_prompt_revisions WHERE revision_id = ?").get(id);
+		if (!draft || draft.status !== "draft") throw new Error("Prompt draft not found");
+		const nowIso = now.toISOString();
+		const subscriptionId = text(draft, "subscription_id");
+		db.prepare("UPDATE proactive_prompt_revisions SET status = 'retired' WHERE subscription_id = ? AND status = 'published'").run(subscriptionId);
+		db.prepare("UPDATE proactive_prompt_revisions SET status = 'published', published_at = ? WHERE revision_id = ?").run(nowIso, id);
+		db.prepare("UPDATE proactive_scenario_subscriptions SET active_prompt_revision_id = ?, updated_at = ? WHERE subscription_id = ?").run(id, nowIso, subscriptionId);
+		return revisionFromRow(db.prepare("SELECT * FROM proactive_prompt_revisions WHERE revision_id = ?").get(id));
+	});
+}
+function rollbackPromptRevision(id, now = /* @__PURE__ */ new Date()) {
+	return runSqliteWriteTransaction((db) => {
+		const target = db.prepare("SELECT * FROM proactive_prompt_revisions WHERE revision_id = ?").get(id);
+		if (!target || target.status === "draft") throw new Error("Published prompt revision not found");
+		const nowIso = now.toISOString();
+		const subscriptionId = text(target, "subscription_id");
+		db.prepare("UPDATE proactive_prompt_revisions SET status = 'retired' WHERE subscription_id = ? AND status = 'published'").run(subscriptionId);
+		db.prepare("UPDATE proactive_prompt_revisions SET status = 'published', published_at = ? WHERE revision_id = ?").run(nowIso, id);
+		db.prepare("UPDATE proactive_scenario_subscriptions SET active_prompt_revision_id = ?, updated_at = ? WHERE subscription_id = ?").run(id, nowIso, subscriptionId);
+		return revisionFromRow(db.prepare("SELECT * FROM proactive_prompt_revisions WHERE revision_id = ?").get(id));
+	});
+}
+function publishInstructionFeedback(input, now = /* @__PURE__ */ new Date()) {
+	const normalized = input.instruction.trim();
+	if (!normalized) throw new Error("instruction is required");
+	if (normalized.length > 2e3) throw new Error("instruction exceeds 2000 characters");
+	return runSqliteWriteTransaction((db) => {
+		const subscription = db.prepare("SELECT * FROM proactive_scenario_subscriptions WHERE subscription_id = ?").get(input.subscriptionId);
+		if (!subscription) throw new Error("Subscription not found");
+		const scenario = db.prepare("SELECT * FROM proactive_scenarios WHERE scenario_key = ?").get(text(subscription, "scenario_key"));
+		const instructions = [(subscription.active_prompt_revision_id ? db.prepare("SELECT user_instructions FROM proactive_prompt_revisions WHERE revision_id = ?").get(text(subscription, "active_prompt_revision_id")) : void 0)?.user_instructions?.trim() ?? "", `User feedback (${now.toISOString()}): ${normalized}`].filter(Boolean).join("\n").slice(-12e3);
+		const next = db.prepare("SELECT COALESCE(MAX(revision), 0) + 1 AS revision FROM proactive_prompt_revisions WHERE subscription_id = ?").get(input.subscriptionId);
+		const revisionId = randomUUID();
+		const baseTemplateVersion = Number(scenario.base_template_version);
+		const hash = createHash("sha256").update(`${baseTemplateVersion}:${instructions}`).digest("hex");
+		const nowIso = now.toISOString();
+		db.prepare("UPDATE proactive_prompt_revisions SET status = 'retired' WHERE subscription_id = ? AND status = 'published'").run(input.subscriptionId);
+		db.prepare(`INSERT INTO proactive_prompt_revisions
+      (revision_id, subscription_id, revision, status, base_template_version, user_instructions, content_hash, created_at, published_at)
+      VALUES (?, ?, ?, 'published', ?, ?, ?, ?, ?)`).run(revisionId, input.subscriptionId, next.revision, baseTemplateVersion, instructions, hash, nowIso, nowIso);
+		db.prepare("UPDATE proactive_scenario_subscriptions SET active_prompt_revision_id = ?, updated_at = ? WHERE subscription_id = ?").run(revisionId, nowIso, input.subscriptionId);
+		db.prepare(`INSERT INTO proactive_instruction_feedback
+      (instruction_id, inbox_item_id, prompt_revision_id, instruction, created_at) VALUES (?, ?, ?, ?, ?)`).run(randomUUID(), input.inboxItemId, revisionId, normalized, nowIso);
+		return revisionFromRow(db.prepare("SELECT * FROM proactive_prompt_revisions WHERE revision_id = ?").get(revisionId));
+	});
+}
+//#endregion
+export { createPromptDraft, getPromptRevision, getScenario, getSubscription, listEnabledRoutes, listScenarios, listSubscriptions, publishInstructionFeedback, publishPromptRevision, rollbackPromptRevision, upsertSubscription };

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

@@ -0,0 +1,15 @@
+import { createPromptDraft, listEnabledRoutes, listScenarios, listSubscriptions, publishPromptRevision, rollbackPromptRevision, upsertSubscription } from './repository.js';
+export declare class ProactiveScenarioService {
+    list: typeof listScenarios;
+    subscriptions: typeof listSubscriptions;
+    routes: typeof listEnabledRoutes;
+    subscribe: typeof upsertSubscription;
+    createDraft: typeof createPromptDraft;
+    publish: typeof publishPromptRevision;
+    rollback: typeof rollbackPromptRevision;
+    preview(input: {
+        scenarioKey: string;
+        revisionId?: string;
+        runtimeContext?: string;
+    }): import("./prompt-composer.js").ComposedPrompt;
+}

package/dist/src/proactive/scenarios/service.js

@@ -0,0 +1,26 @@
+import { createPromptDraft, getPromptRevision, getScenario, getSubscription, listEnabledRoutes, listScenarios, listSubscriptions, publishPromptRevision, rollbackPromptRevision, upsertSubscription } from "./repository.js";
+import { composeScenarioPrompt } from "./prompt-composer.js";
+//#region src/proactive/scenarios/service.ts
+var ProactiveScenarioService = class {
+	list = listScenarios;
+	subscriptions = listSubscriptions;
+	routes = listEnabledRoutes;
+	subscribe = upsertSubscription;
+	createDraft = createPromptDraft;
+	publish = publishPromptRevision;
+	rollback = rollbackPromptRevision;
+	preview(input) {
+		const scenario = getScenario(input.scenarioKey);
+		if (!scenario) throw new Error("Scenario not found");
+		const revision = input.revisionId ? getPromptRevision(input.revisionId) : void 0;
+		if (input.revisionId && !revision) throw new Error("Prompt revision not found");
+		if (revision && getSubscription(revision.subscriptionId)?.scenarioKey !== scenario.key) throw new Error("Prompt revision does not belong to this scenario");
+		return composeScenarioPrompt({
+			scenario,
+			...revision ? { revision } : {},
+			runtimeContext: input.runtimeContext ?? "[runtime context redacted]"
+		});
+	}
+};
+//#endregion
+export { ProactiveScenarioService };

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

@@ -0,0 +1,36 @@
+import type { EventCondition, ScenarioRoute } from '../routing/types.js';
+export interface ScenarioDefinition {
+    key: string;
+    version: number;
+    title: string;
+    description: string;
+    basePrompt: string;
+    baseTemplateVersion: number;
+    eventTypes: string[];
+    condition?: EventCondition;
+    aggregation: ScenarioRoute['aggregation'];
+    debounceSeconds: number;
+    maxWindowSeconds: number;
+}
+export interface ScenarioSubscription {
+    id: string;
+    scenarioKey: string;
+    workspaceId: string;
+    scopeKind: 'workspace' | 'project';
+    scopeId: string;
+    enabled: boolean;
+    activePromptRevisionId?: string;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface PromptRevision {
+    id: string;
+    subscriptionId: string;
+    revision: number;
+    status: 'draft' | 'published' | 'retired';
+    baseTemplateVersion: number;
+    userInstructions: string;
+    contentHash: string;
+    createdAt: string;
+    publishedAt?: string;
+}

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

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

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

@@ -0,0 +1,18 @@
+import { listEvents } from './events/repository.js';
+import type { PublishEventInput, PublishedEvent } from './events/types.js';
+import { listBatches, markReadyBatches } from './routing/batch-repository.js';
+import type { ScenarioRoute } from './routing/types.js';
+export declare class ProactiveEventService {
+    private readonly routes;
+    constructor(routes?: () => readonly ScenarioRoute[]);
+    publish(input: PublishEventInput, now?: Date): PublishedEvent;
+    listEvents: typeof listEvents;
+    listBatches: typeof listBatches;
+    markReadyBatches: typeof markReadyBatches;
+    health(): {
+        events: number;
+        collecting: number;
+        ready: number;
+        oldestReadyAt: string | null;
+    };
+}

package/dist/src/proactive/service.js

@@ -0,0 +1,61 @@
+import { getSqliteDatabase } from "../storage/sqlite/transaction.js";
+import { normalizeEventEnvelope } from "./events/envelope.js";
+import { matchScenario } from "./routing/matcher.js";
+import { getEventByDedupeKey, insertEvent, isEventRouted, listEvents, markEventRouted } from "./events/repository.js";
+import { addEventToBatch, listBatches, markReadyBatches } from "./routing/batch-repository.js";
+//#region src/proactive/service.ts
+var ProactiveEventService = class {
+	constructor(routes = () => []) {
+		this.routes = routes;
+	}
+	publish(input, now = /* @__PURE__ */ new Date()) {
+		let event = normalizeEventEnvelope(input, now);
+		const inserted = insertEvent(event);
+		if (!inserted) {
+			const existing = getEventByDedupeKey(event.dedupeKey);
+			if (!existing) throw new Error(`Proactive event dedupe lookup failed: ${event.dedupeKey}`);
+			event = existing;
+			if (isEventRouted(event.id)) return {
+				event,
+				inserted: false,
+				batchIds: []
+			};
+		}
+		const batchIds = this.routes().flatMap((scenario) => {
+			const key = matchScenario(event, scenario);
+			if (!key) return [];
+			return [addEventToBatch({
+				event,
+				scenario,
+				aggregationKey: key,
+				now
+			}).id];
+		});
+		markEventRouted(event.id, now.toISOString());
+		return {
+			event,
+			inserted,
+			batchIds
+		};
+	}
+	listEvents = listEvents;
+	listBatches = listBatches;
+	markReadyBatches = markReadyBatches;
+	health() {
+		const db = getSqliteDatabase();
+		const events = db.prepare("SELECT COUNT(*) AS count FROM proactive_events").get();
+		const batches = db.prepare(`SELECT
+      SUM(CASE WHEN status = 'collecting' THEN 1 ELSE 0 END) AS collecting,
+      SUM(CASE WHEN status = 'ready' THEN 1 ELSE 0 END) AS ready,
+      MIN(CASE WHEN status = 'ready' THEN ready_at END) AS oldest_ready_at
+      FROM proactive_signal_batches`).get();
+		return {
+			events: events.count,
+			collecting: batches.collecting ?? 0,
+			ready: batches.ready ?? 0,
+			oldestReadyAt: batches.oldest_ready_at
+		};
+	}
+};
+//#endregion
+export { ProactiveEventService };

package/dist/src/projects/project-service.d.ts

@@ -1,3 +1,4 @@
+import type { ProactiveSignalPublisher } from '../proactive/events/publisher.js';
 import { ProjectStore } from './project-store.js';
 import type { CreateProjectInput, Project, ProjectListQuery, ProjectListResult, ProjectWithDetails, SidebarProjectListQuery, UpdateProjectInput } from './types.js';
 import { type WorkspaceProjectMatch } from './workspace-project.js';
@@ -9,7 +10,8 @@ export type ProjectSuggestion = {
 };
 export declare class ProjectService {
     private readonly store;
-    constructor(store?: ProjectStore);
+    private readonly signals?;
+    constructor(store?: ProjectStore, signals?: ProactiveSignalPublisher);
     private listAllProjects;
     create(input: CreateProjectInput): Project;
     get(id: string): Project | null;

package/dist/src/projects/project-service.js

@@ -1,3 +1,4 @@
+import { runSqliteWriteTransaction } from "../storage/sqlite/transaction.js";
 import { getSessionMetadata } from "../storage/sqlite/session-repository.js";
 import "../storage/sqlite/index.js";
 import { changedFieldsFromPatch, emitActivity, systemActivityActor, systemActivitySource } from "../activity/emitter.js";
@@ -5,10 +6,12 @@ import { ProjectStore } from "./project-store.js";
 import { bindGoalToProject, listProjectGoalIds, unbindGoalFromProject } from "./goal-bind.js";
 import { bindSessionToProject, listProjectSessionKeys, unbindSessionFromProject } from "./session-bind.js";
 import { ProjectWorkspaceConflictError, ProjectWorkspaceMissingError, canonicalWorkspacePath, ensureWorkspaceDirectory, inferProjectNameFromWorkspaceRoot, isPathSameOrInsideWorkspace, isSafeAutoCreateWorkspaceRoot, resolveWorkspaceProjectRoot, workspaceDirectoryExists } from "./workspace-project.js";
+import { createHash } from "node:crypto";
 //#region src/projects/project-service.ts
 var ProjectService = class {
-	constructor(store = new ProjectStore()) {
+	constructor(store = new ProjectStore(), signals) {
 		this.store = store;
+		this.signals = signals;
 	}
 	listAllProjects() {
 		const items = [];
@@ -144,38 +147,65 @@ var ProjectService = class {
 			else throw new ProjectWorkspaceMissingError(workspaceRoot);
 			patch.workspaceRoot = workspaceRoot;
 		}
-		const before = this.store.get(id);
-		const project = this.store.update(id, patch);
-		const changes = changedFieldsFromPatch(patch, ["createWorkspaceRoot"]);
-		const type = before?.status !== project.status ? "project.status_changed" : before?.workspaceRoot !== project.workspaceRoot ? "project.workspace_changed" : "project.updated";
-		emitActivity({
-			type,
-			primaryObject: {
-				kind: "project",
-				id: project.id,
-				title: project.name
-			},
-			actor: systemActivityActor(),
-			source: systemActivitySource(),
-			payload: {
-				changes,
-				...type === "project.status_changed" ? {
-					from: before?.status,
-					to: project.status
-				} : {},
-				...type === "project.workspace_changed" ? {
-					from: before?.workspaceRoot,
-					to: project.workspaceRoot
-				} : {}
-			},
-			scopes: [{
-				scopeKind: "project",
-				scopeId: project.id,
-				reason: "object_owner"
-			}],
-			nowMs: project.updatedAt
+		return runSqliteWriteTransaction(() => {
+			const before = this.store.get(id);
+			const project = this.store.update(id, patch);
+			const changes = changedFieldsFromPatch(patch, ["createWorkspaceRoot"]);
+			const type = before?.status !== project.status ? "project.status_changed" : before?.workspaceRoot !== project.workspaceRoot ? "project.workspace_changed" : "project.updated";
+			emitActivity({
+				type,
+				primaryObject: {
+					kind: "project",
+					id: project.id,
+					title: project.name
+				},
+				actor: systemActivityActor(),
+				source: systemActivitySource(),
+				payload: {
+					changes,
+					...type === "project.status_changed" ? {
+						from: before?.status,
+						to: project.status
+					} : {},
+					...type === "project.workspace_changed" ? {
+						from: before?.workspaceRoot,
+						to: project.workspaceRoot
+					} : {}
+				},
+				scopes: [{
+					scopeKind: "project",
+					scopeId: project.id,
+					reason: "object_owner"
+				}],
+				nowMs: project.updatedAt
+			});
+			this.signals?.publish({
+				type: "project.updated.v1",
+				schemaVersion: 1,
+				source: {
+					kind: "projects",
+					id: "local"
+				},
+				subject: {
+					kind: "project",
+					id: project.id
+				},
+				actor: { kind: "system" },
+				scope: {
+					workspaceId: "default",
+					projectId: project.id
+				},
+				occurredAt: new Date(project.updatedAt).toISOString(),
+				dedupeKey: `project:${project.id}:${project.updatedAt}:${createHash("sha256").update(JSON.stringify(patch)).digest("hex")}`,
+				sensitivity: "personal",
+				payload: {
+					before,
+					after: project,
+					changes
+				}
+			});
+			return project;
 		});
-		return project;
 	}
 	pin(id) {
 		return this.update(id, { pinnedAt: Date.now() });

package/dist/src/storage/sqlite/migrations/068_proactive_event_spine.sql

@@ -0,0 +1,71 @@
+DROP TABLE IF EXISTS focus_insights;
+DROP TABLE IF EXISTS focus_activities;
+DROP TABLE IF EXISTS focus_monitors;
+DROP TABLE IF EXISTS focus_projects;
+DROP TABLE IF EXISTS focuses;
+DROP TABLE IF EXISTS focus_candidate_projects;
+DROP TABLE IF EXISTS focus_candidates;
+
+CREATE TABLE proactive_events (
+  event_id TEXT PRIMARY KEY,
+  type TEXT NOT NULL,
+  schema_version INTEGER NOT NULL CHECK (schema_version > 0),
+  source_kind TEXT NOT NULL,
+  source_id TEXT NOT NULL,
+  device_id TEXT,
+  subject_kind TEXT NOT NULL,
+  subject_id TEXT NOT NULL,
+  actor_kind TEXT NOT NULL CHECK (actor_kind IN ('user', 'agent', 'system', 'integration')),
+  actor_id TEXT,
+  workspace_id TEXT NOT NULL,
+  project_id TEXT,
+  agent_id TEXT,
+  occurred_at TEXT NOT NULL,
+  observed_at TEXT NOT NULL,
+  correlation_id TEXT NOT NULL,
+  causation_id TEXT,
+  dedupe_key TEXT NOT NULL UNIQUE,
+  sensitivity TEXT NOT NULL CHECK (sensitivity IN ('public', 'personal', 'confidential', 'restricted')),
+  payload_json TEXT NOT NULL,
+  routed_at TEXT
+);
+
+CREATE TABLE proactive_signal_batches (
+  batch_id TEXT PRIMARY KEY,
+  scenario_key TEXT NOT NULL,
+  scenario_version INTEGER NOT NULL CHECK (scenario_version > 0),
+  aggregation_key TEXT NOT NULL,
+  window_started_at TEXT NOT NULL,
+  window_ends_at TEXT NOT NULL,
+  ready_at TEXT NOT NULL,
+  status TEXT NOT NULL CHECK (status IN (
+    'collecting', 'ready', 'processing', 'processed', 'ignored',
+    'failed_retryable', 'failed_permanent', 'expired'
+  )),
+  event_count INTEGER NOT NULL DEFAULT 0 CHECK (event_count >= 0),
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL
+);
+
+CREATE TABLE proactive_batch_events (
+  batch_id TEXT NOT NULL,
+  event_id TEXT NOT NULL,
+  added_at TEXT NOT NULL,
+  PRIMARY KEY (batch_id, event_id),
+  FOREIGN KEY (batch_id) REFERENCES proactive_signal_batches(batch_id) ON DELETE CASCADE,
+  FOREIGN KEY (event_id) REFERENCES proactive_events(event_id) ON DELETE CASCADE
+);
+
+CREATE INDEX idx_proactive_events_type_observed
+  ON proactive_events(type, observed_at DESC);
+CREATE INDEX idx_proactive_events_subject
+  ON proactive_events(subject_kind, subject_id, occurred_at DESC);
+CREATE INDEX idx_proactive_events_project
+  ON proactive_events(project_id, occurred_at DESC) WHERE project_id IS NOT NULL;
+CREATE INDEX idx_proactive_events_correlation
+  ON proactive_events(correlation_id);
+CREATE INDEX idx_proactive_batches_ready
+  ON proactive_signal_batches(status, ready_at);
+CREATE UNIQUE INDEX idx_proactive_collecting_batch
+  ON proactive_signal_batches(scenario_key, aggregation_key)
+  WHERE status = 'collecting';

package/dist/src/storage/sqlite/migrations/069_proactive_scenario_control.sql

@@ -0,0 +1,69 @@
+CREATE TABLE proactive_scenarios (
+  scenario_key TEXT PRIMARY KEY,
+  version INTEGER NOT NULL CHECK (version > 0),
+  title TEXT NOT NULL,
+  description TEXT NOT NULL,
+  base_prompt TEXT NOT NULL,
+  base_template_version INTEGER NOT NULL CHECK (base_template_version > 0),
+  event_types_json TEXT NOT NULL,
+  condition_json TEXT,
+  aggregation TEXT NOT NULL CHECK (aggregation IN ('subject', 'project', 'workspace')),
+  debounce_seconds INTEGER NOT NULL CHECK (debounce_seconds >= 0),
+  max_window_seconds INTEGER NOT NULL CHECK (max_window_seconds > 0),
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL
+);
+
+CREATE TABLE proactive_scenario_subscriptions (
+  subscription_id TEXT PRIMARY KEY,
+  scenario_key TEXT NOT NULL,
+  workspace_id TEXT NOT NULL,
+  scope_kind TEXT NOT NULL CHECK (scope_kind IN ('workspace', 'project')),
+  scope_id TEXT NOT NULL,
+  enabled INTEGER NOT NULL DEFAULT 0 CHECK (enabled IN (0, 1)),
+  active_prompt_revision_id TEXT,
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL,
+  UNIQUE (scenario_key, workspace_id, scope_kind, scope_id),
+  FOREIGN KEY (scenario_key) REFERENCES proactive_scenarios(scenario_key) ON DELETE CASCADE
+);
+
+CREATE TABLE proactive_prompt_revisions (
+  revision_id TEXT PRIMARY KEY,
+  subscription_id TEXT NOT NULL,
+  revision INTEGER NOT NULL CHECK (revision > 0),
+  status TEXT NOT NULL CHECK (status IN ('draft', 'published', 'retired')),
+  base_template_version INTEGER NOT NULL CHECK (base_template_version > 0),
+  user_instructions TEXT NOT NULL,
+  content_hash TEXT NOT NULL,
+  created_at TEXT NOT NULL,
+  published_at TEXT,
+  UNIQUE (subscription_id, revision),
+  FOREIGN KEY (subscription_id) REFERENCES proactive_scenario_subscriptions(subscription_id) ON DELETE CASCADE
+);
+
+CREATE INDEX idx_proactive_subscriptions_enabled
+  ON proactive_scenario_subscriptions(enabled, workspace_id, scenario_key);
+CREATE INDEX idx_proactive_prompt_revisions_subscription
+  ON proactive_prompt_revisions(subscription_id, status, revision DESC);
+
+ALTER TABLE proactive_signal_batches ADD COLUMN subscription_id TEXT NOT NULL DEFAULT '';
+DROP INDEX idx_proactive_collecting_batch;
+CREATE UNIQUE INDEX idx_proactive_collecting_batch
+  ON proactive_signal_batches(subscription_id, scenario_key, aggregation_key)
+  WHERE status = 'collecting';
+
+INSERT INTO proactive_scenarios VALUES
+  ('project_delivery_risk', 1, 'Project delivery risk', 'Detect credible risks to a project commitment.',
+   'Identify material changes that create supported schedule, scope, dependency, capacity, or ownership risk. Ignore routine activity and unsupported absence-of-activity claims.',
+   1, '["project.updated.v1","work_item.status_changed.v1","work_item.updated.v1"]', NULL,
+   'project', 300, 1800, datetime('now'), datetime('now')),
+  ('blocked_work', 1, 'Blocked work', 'Find work that needs a decision, dependency, or owner intervention.',
+   'Confirm that work is truly blocked, identify the blocking object and downstream impact, then propose the smallest supported intervention.',
+   1, '["work_item.status_changed.v1","work_item.updated.v1"]',
+   '{"op":"any","conditions":[{"op":"eq","field":"payload.after.status","value":"blocked"},{"op":"changed","field":"payload.dependencyIds"}]}',
+   'project', 180, 900, datetime('now'), datetime('now')),
+  ('automation_failure_impact', 1, 'Automation failure impact', 'Explain whether a terminal automation failure affects user outcomes.',
+   'Classify the failure, distinguish completed from incomplete work, connect it to a user outcome, and request only supported recovery decisions. Do not repeat raw stack traces.',
+   1, '["automation.run_failed.v1"]', NULL,
+   'subject', 60, 300, datetime('now'), datetime('now'));

package/dist/src/storage/sqlite/migrations/070_proactive_execution.sql

@@ -0,0 +1,55 @@
+CREATE TABLE proactive_context_snapshots (
+  snapshot_id TEXT PRIMARY KEY,
+  batch_id TEXT NOT NULL,
+  content_json TEXT NOT NULL,
+  evidence_ids_json TEXT NOT NULL,
+  created_at TEXT NOT NULL,
+  FOREIGN KEY (batch_id) REFERENCES proactive_signal_batches(batch_id) ON DELETE CASCADE
+);
+
+CREATE TABLE proactive_runs (
+  run_id TEXT PRIMARY KEY,
+  batch_id TEXT NOT NULL UNIQUE,
+  subscription_id TEXT NOT NULL,
+  scenario_key TEXT NOT NULL,
+  scenario_version INTEGER NOT NULL,
+  prompt_revision_id TEXT,
+  context_snapshot_id TEXT,
+  status TEXT NOT NULL CHECK (status IN ('running', 'completed', 'discarded', 'retryable', 'failed')),
+  attempt INTEGER NOT NULL DEFAULT 1 CHECK (attempt > 0),
+  lease_owner TEXT,
+  lease_expires_at TEXT,
+  model_ref TEXT,
+  raw_output TEXT,
+  error_message TEXT,
+  next_attempt_at TEXT,
+  started_at TEXT NOT NULL,
+  completed_at TEXT,
+  updated_at TEXT NOT NULL,
+  FOREIGN KEY (batch_id) REFERENCES proactive_signal_batches(batch_id) ON DELETE CASCADE,
+  FOREIGN KEY (subscription_id) REFERENCES proactive_scenario_subscriptions(subscription_id) ON DELETE CASCADE,
+  FOREIGN KEY (prompt_revision_id) REFERENCES proactive_prompt_revisions(revision_id),
+  FOREIGN KEY (context_snapshot_id) REFERENCES proactive_context_snapshots(snapshot_id)
+);
+
+CREATE TABLE proactive_insights (
+  insight_id TEXT PRIMARY KEY,
+  run_id TEXT NOT NULL UNIQUE,
+  subscription_id TEXT NOT NULL,
+  scenario_key TEXT NOT NULL,
+  title TEXT NOT NULL,
+  summary TEXT NOT NULL,
+  why_now TEXT NOT NULL,
+  impact TEXT NOT NULL,
+  recommendation TEXT NOT NULL,
+  urgency TEXT NOT NULL CHECK (urgency IN ('low', 'medium', 'high', 'critical')),
+  confidence REAL NOT NULL CHECK (confidence >= 0 AND confidence <= 1),
+  value_score REAL NOT NULL CHECK (value_score >= 0 AND value_score <= 1),
+  evidence_ids_json TEXT NOT NULL,
+  created_at TEXT NOT NULL,
+  FOREIGN KEY (run_id) REFERENCES proactive_runs(run_id) ON DELETE CASCADE,
+  FOREIGN KEY (subscription_id) REFERENCES proactive_scenario_subscriptions(subscription_id) ON DELETE CASCADE
+);
+
+CREATE INDEX idx_proactive_runs_status_lease ON proactive_runs(status, next_attempt_at, lease_expires_at, updated_at);
+CREATE INDEX idx_proactive_insights_created ON proactive_insights(created_at DESC);