@xopcai/xopc 0.0.176 → 0.0.178

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/providers/provider-auth-service.js

@@ -2,11 +2,13 @@ import { __esmMin } from "../../_virtual/_rolldown/runtime.js";
 import { init_paths, resolveModelsJsonPath } from "../config/paths.js";
 import { CredentialResolver, init_credentials } from "../auth/credentials.js";
 import { XopcModelCredentialStore, init_model_credential_store } from "../auth/model-credential-store.js";
+import { init_register_bundled_oauth_flows, registerBundledOAuthFlows } from "./register-bundled-oauth-flows.js";
 import { init_register_runtime_providers, registerRuntimeProviders } from "./register-runtime-providers.js";
 import { InMemoryModelsStore } from "@earendil-works/pi-ai";
 import { ModelRuntime } from "@earendil-works/pi-coding-agent";
 //#region src/providers/provider-auth-service.ts
 async function createAuthRuntime(credentials) {
+	registerBundledOAuthFlows();
 	const runtime = await ModelRuntime.create({
 		credentials,
 		modelsPath: resolveModelsJsonPath(),
@@ -32,6 +34,7 @@ var init_provider_auth_service = __esmMin((() => {
 	init_credentials();
 	init_model_credential_store();
 	init_paths();
+	init_register_bundled_oauth_flows();
 	init_register_runtime_providers();
 	ProviderAuthService = class {
 		credentials;

package/dist/src/providers/register-bundled-oauth-flows.d.ts

@@ -0,0 +1,2 @@
+/** Statically include pi-ai OAuth flows for single-file runtimes such as Electron. */
+export declare function registerBundledOAuthFlows(): void;

package/dist/src/providers/register-bundled-oauth-flows.js

@@ -0,0 +1,16 @@
+import { __esmMin } from "../../_virtual/_rolldown/runtime.js";
+import { registerBunOAuthFlows } from "@earendil-works/pi-ai/bun-oauth";
+//#region src/providers/register-bundled-oauth-flows.ts
+/** Statically include pi-ai OAuth flows for single-file runtimes such as Electron. */
+function registerBundledOAuthFlows() {
+	if (registered) return;
+	registerBunOAuthFlows();
+	registered = true;
+}
+var registered;
+var init_register_bundled_oauth_flows = __esmMin((() => {
+	registered = false;
+}));
+//#endregion
+init_register_bundled_oauth_flows();
+export { init_register_bundled_oauth_flows, registerBundledOAuthFlows };

package/dist/src/session/store.d.ts

@@ -26,6 +26,7 @@ export interface SessionCompactionHooks {
         compactedCount: number;
     }) => Promise<void> | void;
 }
+export type ModelFallbackPreparation = 'prompt' | 'resume' | 'unsafe';
 export declare class SessionStore {
     private options;
     private window;
@@ -78,6 +79,7 @@ export declare class SessionStore {
     private buildSessionDetail;
     loadTranscriptRows(key: string): Promise<TranscriptStoredRow[]>;
     loadTranscriptHistoryRows(key: string): Promise<TranscriptStoredRow[]>;
+    prepareModelFallback(key: string, rowsBeforeAttempt: readonly TranscriptStoredRow[]): Promise<ModelFallbackPreparation>;
     getMetadata(key: string): Promise<SessionMetadata | null>;
     resolveKeyBySessionId(sessionId: string): Promise<string | null>;
     updateMetadata(key: string, updates: Partial<SessionMetadata>): Promise<void>;

package/dist/src/session/store.js

@@ -21,6 +21,16 @@ init_paths_state();
 init_logger();
 const log = createLogger("SessionStore");
 const INDEX_VERSION = "1.0";
+function isTranscriptMessageRole(row, role) {
+	return !!row && typeof row === "object" && "role" in row && row.role === role;
+}
+function isErrorAssistantRow(row) {
+	return isTranscriptMessageRole(row, "assistant") && row.stopReason === "error";
+}
+function transcriptPrefixMatches(expected, current) {
+	if (current.length < expected.length) return false;
+	return expected.every((row, index) => JSON.stringify(row) === JSON.stringify(current[index]));
+}
 var SessionStore = class {
 	window;
 	compactor;
@@ -186,6 +196,26 @@ var SessionStore = class {
 		requireXopcDatabase();
 		return loadTranscriptHistoryRowsForSession(key);
 	}
+	async prepareModelFallback(key, rowsBeforeAttempt) {
+		return this.runStoreMutation(async () => {
+			requireXopcDatabase();
+			const currentRows = loadTranscriptRowsForSession(key);
+			if (!transcriptPrefixMatches(rowsBeforeAttempt, currentRows)) return "unsafe";
+			let preparedRows = currentRows;
+			let removedError = false;
+			if (isErrorAssistantRow(preparedRows.at(-1))) {
+				preparedRows = preparedRows.slice(0, -1);
+				removedError = true;
+			}
+			const appendedRows = preparedRows.slice(rowsBeforeAttempt.length);
+			if (appendedRows.length === 1 && isTranscriptMessageRole(appendedRows[0], "user") || removedError && appendedRows.length === 0 && isTranscriptMessageRole(preparedRows.at(-1), "user")) {
+				if (removedError) replaceTranscriptRows(key, preparedRows);
+				return "resume";
+			}
+			if (!removedError && appendedRows.length === 0) return "prompt";
+			return "unsafe";
+		});
+	}
 	async getMetadata(key) {
 		requireXopcDatabase();
 		return getSessionMetadata(key);

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);

package/dist/src/storage/sqlite/migrations/071_proactive_inbox.sql

@@ -0,0 +1,45 @@
+CREATE TABLE proactive_inbox_items (
+  inbox_item_id TEXT PRIMARY KEY,
+  insight_id TEXT NOT NULL UNIQUE,
+  status TEXT NOT NULL CHECK (status IN ('unread', 'read', 'snoozed', 'resolved')),
+  snoozed_until TEXT,
+  resolution TEXT,
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL,
+  FOREIGN KEY (insight_id) REFERENCES proactive_insights(insight_id) ON DELETE CASCADE
+);
+
+CREATE TABLE proactive_decisions (
+  decision_id TEXT PRIMARY KEY,
+  inbox_item_id TEXT NOT NULL,
+  choice TEXT NOT NULL,
+  note TEXT NOT NULL,
+  created_at TEXT NOT NULL,
+  FOREIGN KEY (inbox_item_id) REFERENCES proactive_inbox_items(inbox_item_id) ON DELETE CASCADE
+);
+
+CREATE TABLE proactive_delivery_outbox (
+  delivery_id TEXT PRIMARY KEY,
+  inbox_item_id TEXT NOT NULL UNIQUE,
+  status TEXT NOT NULL CHECK (status IN ('pending', 'delivering', 'delivered', 'retryable', 'failed')),
+  attempt INTEGER NOT NULL DEFAULT 0 CHECK (attempt >= 0),
+  next_attempt_at TEXT NOT NULL,
+  lease_expires_at TEXT,
+  error_message TEXT,
+  created_at TEXT NOT NULL,
+  delivered_at TEXT,
+  updated_at TEXT NOT NULL,
+  FOREIGN KEY (inbox_item_id) REFERENCES proactive_inbox_items(inbox_item_id) ON DELETE CASCADE
+);
+
+CREATE TABLE proactive_feedback (
+  feedback_id TEXT PRIMARY KEY,
+  inbox_item_id TEXT NOT NULL,
+  rating TEXT NOT NULL CHECK (rating IN ('useful', 'not_useful')),
+  note TEXT NOT NULL,
+  created_at TEXT NOT NULL,
+  FOREIGN KEY (inbox_item_id) REFERENCES proactive_inbox_items(inbox_item_id) ON DELETE CASCADE
+);
+
+CREATE INDEX idx_proactive_inbox_status ON proactive_inbox_items(status, updated_at DESC);
+CREATE INDEX idx_proactive_outbox_ready ON proactive_delivery_outbox(status, next_attempt_at);

package/dist/src/storage/sqlite/migrations/072_proactive_judgments.sql

@@ -0,0 +1,14 @@
+ALTER TABLE proactive_insights ADD COLUMN work_done TEXT NOT NULL DEFAULT '';
+ALTER TABLE proactive_insights ADD COLUMN decision_json TEXT;
+
+CREATE TABLE proactive_instruction_feedback (
+  instruction_id TEXT PRIMARY KEY,
+  inbox_item_id TEXT NOT NULL,
+  prompt_revision_id TEXT NOT NULL,
+  instruction TEXT NOT NULL,
+  created_at TEXT NOT NULL,
+  FOREIGN KEY (inbox_item_id) REFERENCES proactive_inbox_items(inbox_item_id) ON DELETE CASCADE,
+  FOREIGN KEY (prompt_revision_id) REFERENCES proactive_prompt_revisions(revision_id)
+);
+
+CREATE INDEX idx_proactive_instruction_item ON proactive_instruction_feedback(inbox_item_id, created_at DESC);

package/dist/src/storage/sqlite/migrations/073_enable_default_proactive_scenarios.sql

@@ -0,0 +1,13 @@
+INSERT OR IGNORE INTO proactive_scenario_subscriptions (
+  subscription_id,
+  scenario_key,
+  workspace_id,
+  scope_kind,
+  scope_id,
+  enabled,
+  created_at,
+  updated_at
+) VALUES
+  ('default-project-delivery-risk', 'project_delivery_risk', 'default', 'workspace', 'default', 1, datetime('now'), datetime('now')),
+  ('default-blocked-work', 'blocked_work', 'default', 'workspace', 'default', 1, datetime('now'), datetime('now')),
+  ('default-automation-failure-impact', 'automation_failure_impact', 'default', 'workspace', 'default', 1, datetime('now'), datetime('now'));

package/dist/src/storage/sqlite/migrations/074_deduplicate_blocked_work_routing.sql

@@ -0,0 +1,5 @@
+UPDATE proactive_scenarios
+SET condition_json = '{"op":"neq","field":"payload.after.status","value":"blocked"}',
+    version = version + 1,
+    updated_at = datetime('now')
+WHERE scenario_key = 'project_delivery_risk';

package/dist/src/storage/sqlite/migrations/runner.d.ts

@@ -3,7 +3,7 @@ import type { ApplyMigrationsOptions } from './types.js';
 /** Baseline schema version applied from schema.sql on first open. */
 export declare const XOPC_DB_BASELINE_SCHEMA_VERSION = 11;
 /** Latest schema version this release supports (increment when adding migrations). */
-export declare const XOPC_DB_SCHEMA_VERSION = 67;
+export declare const XOPC_DB_SCHEMA_VERSION = 74;
 export declare function resolveMigrationsDir(override?: string): string;
 /**
  * Apply sequential SQL migrations from (currentVersion + 1) through targetVersion.