@xopcai/xopc 0.0.308 → 0.0.311

package/dist/src/storage/sqlite/migrations/runner.js

@@ -1,50 +1,42 @@
 import { __esmMin } from "../../../../_virtual/_rolldown/runtime.js";
-import { backupBeforeConversationCutover, init_conversation_backup } from "./conversation-backup.js";
+import { init_sql_assets, resolveSqliteAssetPath } from "../sql-assets.js";
 import { createLogger } from "../../../utils/logger/index.js";
 import { init_logger } from "../../../utils/logger.js";
 import { init_schema_version, readSchemaVersion, setSchemaVersion } from "../schema-version.js";
+import { backupBeforeConversationCutover, init_conversation_backup } from "./conversation-backup.js";
 import { init_conversation_uuid, migrateConversationUuids } from "./conversation-uuid.js";
+import { discardExperimentalSceneData, init_scene_reset, resetExperimentalScenes } from "./scene-reset.js";
 import { discoverSqlMigrations, init_discover } from "./discover.js";
 import { DatabaseSchemaMigrationGapError, DatabaseSchemaTooNewError, DatabaseSchemaTooOldError, init_errors } from "./errors.js";
-import { dirname, join } from "node:path";
-import { chmodSync, existsSync, writeFileSync } from "node:fs";
-import { fileURLToPath } from "node:url";
+import { writeFileSync } from "node:fs";
 //#region src/storage/sqlite/migrations/runner.ts
-function backupBeforeTaskCutover(db, databasePath) {
-	db.exec("PRAGMA wal_checkpoint(FULL)");
-	const backupPath = `${databasePath}.pre-v100-${Date.now()}.bak`;
-	const quotedPath = backupPath.replaceAll("'", "''");
-	db.exec(`VACUUM INTO '${quotedPath}'`);
-	chmodSync(backupPath, 384);
-	return backupPath;
-}
 function writeMigrationReport(backupPath, report) {
 	writeFileSync(`${backupPath}.report.json`, `${JSON.stringify(report, null, 2)}\n`, { mode: 384 });
 }
 function resolveMigrationsDir(override) {
 	if (override) return override;
-	const siblingDir = join(MODULE_DIR, "migrations");
-	if (existsSync(siblingDir)) return siblingDir;
-	return MODULE_DIR;
+	return resolveSqliteAssetPath("migrations");
 }
 function migrationByTarget(migrations, targetVersion) {
 	return migrations.find((migration) => migration.targetVersion === targetVersion);
 }
-function applySingleMigration(db, migration) {
+function applySingleMigration(db, migration, discardOldScenes = false) {
 	log.info({
 		targetVersion: migration.targetVersion,
 		file: migration.filename
 	}, "Applying SQLite migration");
-	const rebuildParentTable = migration.targetVersion === 179 || migration.targetVersion === 182;
+	const requiresForeignKeyPause = discardOldScenes || migration.targetVersion === 179 || migration.targetVersion === 182 || migration.targetVersion === 188;
 	const foreignKeysEnabled = Number(db.prepare("PRAGMA foreign_keys").get()?.foreign_keys) === 1;
-	if (rebuildParentTable) db.exec("PRAGMA foreign_keys = OFF");
+	if (requiresForeignKeyPause) db.exec("PRAGMA foreign_keys = OFF");
 	let transactionStarted = false;
 	try {
 		db.exec("BEGIN IMMEDIATE");
 		transactionStarted = true;
+		if (discardOldScenes) discardExperimentalSceneData(db);
 		db.exec(migration.sql);
+		if (migration.targetVersion === 188) resetExperimentalScenes(db);
 		const summary = migration.targetVersion === 178 ? migrateConversationUuids(db) : void 0;
-		if (rebuildParentTable && db.prepare("PRAGMA foreign_key_check").all().length > 0) throw new Error("Parent table migration would violate foreign key integrity");
+		if (requiresForeignKeyPause && db.prepare("PRAGMA foreign_key_check").all().length > 0) throw new Error("Schema migration would violate foreign key integrity");
 		setSchemaVersion(db, migration.targetVersion);
 		db.exec("COMMIT");
 		return summary;
@@ -55,7 +47,7 @@ function applySingleMigration(db, migration) {
 		const em = error instanceof Error ? error.message : String(error);
 		throw new Error(`SQLite migration to v${migration.targetVersion} (${migration.filename}) failed: ${em}`, { cause: error });
 	} finally {
-		if (rebuildParentTable && foreignKeysEnabled) db.exec("PRAGMA foreign_keys = ON");
+		if (requiresForeignKeyPause && foreignKeysEnabled) db.exec("PRAGMA foreign_keys = ON");
 	}
 }
 /**
@@ -63,13 +55,12 @@ function applySingleMigration(db, migration) {
 * Each step runs in its own transaction and updates schema_meta on success.
 */
 function applyPendingMigrations(db, options = {}) {
-	const targetVersion = options.targetVersion ?? 185;
+	const targetVersion = options.targetVersion ?? 189;
 	let currentVersion = readSchemaVersion(db);
 	if (currentVersion > targetVersion) throw new DatabaseSchemaTooNewError(currentVersion, targetVersion);
 	if (!options.migrationsDir && currentVersion < 165) throw new DatabaseSchemaTooOldError(currentVersion, 165);
 	if (currentVersion >= targetVersion) return currentVersion;
 	const migrations = discoverSqlMigrations(resolveMigrationsDir(options.migrationsDir));
-	let cutoverBackupPath;
 	let conversationSummary;
 	const fromVersion = currentVersion;
 	const conversationBackup = currentVersion < 178 && targetVersion >= 178 && options.databasePath && options.databasePath !== ":memory:" ? backupBeforeConversationCutover(db, options.databasePath) : void 0;
@@ -77,18 +68,9 @@ function applyPendingMigrations(db, options = {}) {
 		const nextVersion = currentVersion + 1;
 		const migration = migrationByTarget(migrations, nextVersion);
 		if (!migration) throw new DatabaseSchemaMigrationGapError(currentVersion, targetVersion, nextVersion);
-		if (nextVersion === 100 && options.databasePath && options.databasePath !== ":memory:") cutoverBackupPath = backupBeforeTaskCutover(db, options.databasePath);
 		try {
-			conversationSummary = applySingleMigration(db, migration) ?? conversationSummary;
+			conversationSummary = applySingleMigration(db, migration, !options.migrationsDir && targetVersion >= 188 && fromVersion < 178 && currentVersion === fromVersion) ?? conversationSummary;
 		} catch (error) {
-			if (cutoverBackupPath && nextVersion === 100) writeMigrationReport(cutoverBackupPath, {
-				fromVersion: currentVersion,
-				targetVersion: nextVersion,
-				status: "failed",
-				rollback: "transaction",
-				error: error instanceof Error ? error.message : String(error),
-				occurredAt: (/* @__PURE__ */ new Date()).toISOString()
-			});
 			if (conversationBackup) writeMigrationReport(conversationBackup, {
 				fromVersion,
 				targetVersion,
@@ -99,13 +81,6 @@ function applyPendingMigrations(db, options = {}) {
 			throw error;
 		}
 		currentVersion = nextVersion;
-		if (cutoverBackupPath && currentVersion === 100) writeMigrationReport(cutoverBackupPath, {
-			fromVersion: 99,
-			targetVersion: 100,
-			status: "succeeded",
-			backupPath: cutoverBackupPath,
-			occurredAt: (/* @__PURE__ */ new Date()).toISOString()
-		});
 	}
 	if (conversationBackup) writeMigrationReport(conversationBackup, {
 		fromVersion,
@@ -118,7 +93,7 @@ function applyPendingMigrations(db, options = {}) {
 }
 /** Inspect schema version without mutating the database. */
 function inspectSchemaMigrationStatus(db, options = {}) {
-	const appVersion = options.targetVersion ?? 185;
+	const appVersion = options.targetVersion ?? 189;
 	const dbVersion = readSchemaVersion(db);
 	if (dbVersion > appVersion) return {
 		dbVersion,
@@ -147,18 +122,19 @@ function inspectSchemaMigrationStatus(db, options = {}) {
 		missingVersion
 	};
 }
-var log, XOPC_DB_BASELINE_SCHEMA_VERSION, XOPC_DB_SCHEMA_VERSION, MODULE_DIR;
+var log, XOPC_DB_BASELINE_SCHEMA_VERSION, XOPC_DB_SCHEMA_VERSION;
 var init_runner = __esmMin((() => {
-	init_conversation_backup();
 	init_logger();
 	init_schema_version();
+	init_sql_assets();
+	init_conversation_backup();
 	init_conversation_uuid();
+	init_scene_reset();
 	init_discover();
 	init_errors();
 	log = createLogger("Sqlite:Migrations");
 	XOPC_DB_BASELINE_SCHEMA_VERSION = 165;
-	XOPC_DB_SCHEMA_VERSION = 185;
-	MODULE_DIR = dirname(fileURLToPath(import.meta.url));
+	XOPC_DB_SCHEMA_VERSION = 189;
 }));
 //#endregion
 init_runner();

package/dist/src/storage/sqlite/migrations/scene-reset.d.ts

@@ -0,0 +1,5 @@
+import type { DatabaseSync } from 'node:sqlite';
+/** Discard obsolete payloads before historical migrations try to interpret them. */
+export declare function discardExperimentalSceneData(db: DatabaseSync): void;
+/** v188 installs current storage; the migration runner owns the transaction and FK checks. */
+export declare function resetExperimentalScenes(db: DatabaseSync): void;

package/dist/src/storage/sqlite/migrations/scene-reset.js

@@ -0,0 +1,40 @@
+import { __esmMin } from "../../../../_virtual/_rolldown/runtime.js";
+import { NOTIFICATION_LEDGER_TABLES, init_scenes_schema, installSceneStorage } from "../scenes-schema.js";
+//#region src/storage/sqlite/migrations/scene-reset.ts
+/** Discard obsolete payloads before historical migrations try to interpret them. */
+function discardExperimentalSceneData(db) {
+	const triggers = db.prepare("SELECT name, sql FROM sqlite_master WHERE type = 'trigger' AND tbl_name GLOB 'proactive_*'").all();
+	for (const trigger of triggers) db.exec(`DROP TRIGGER ${quote(String(trigger.name))}`);
+	const tables = db.prepare("SELECT name FROM sqlite_master WHERE type = 'table' AND (name GLOB 'proactive_*' OR name = 'heartbeat_checks') AND name NOT IN ('proactive_scenarios', 'proactive_scenario_versions')").all();
+	for (const table of tables) db.exec(`DELETE FROM ${quote(String(table.name))}`);
+	for (const trigger of triggers) db.exec(String(trigger.sql));
+	const discarded = "SELECT event_id FROM notification_events WHERE event_type IN ('proactive.insight', 'scene.result', 'scene.digest')";
+	for (const table of ["notification_deliveries", "notification_acknowledgements"]) db.exec(`DELETE FROM ${table} WHERE event_id IN (${discarded})`);
+	db.exec(`DELETE FROM notification_events WHERE event_id IN (${discarded})`);
+}
+/** v188 installs current storage; the migration runner owns the transaction and FK checks. */
+function resetExperimentalScenes(db) {
+	const ledger = new Set(NOTIFICATION_LEDGER_TABLES);
+	const tables = db.prepare("SELECT name FROM sqlite_master WHERE type = 'table'").all();
+	for (const table of tables) {
+		const name = String(table.name);
+		if (name.startsWith("scene_") || ledger.has(name)) db.exec(`DROP TABLE ${quote(name)}`);
+	}
+	discardExperimentalSceneData(db);
+	for (const table of tables) {
+		const name = String(table.name);
+		if (name.startsWith("proactive_") || name === "heartbeat_checks" || name === "project_monitoring_policies") db.exec(`DROP TABLE ${quote(name)}`);
+	}
+	db.exec(`DROP INDEX IF EXISTS idx_connector_sync_policies_proactive;
+    ALTER TABLE connector_sync_policies DROP COLUMN proactive_enabled;
+    ALTER TABLE connector_sync_policies DROP COLUMN allowed_scenario_keys_json;`);
+	installSceneStorage(db);
+}
+var quote;
+var init_scene_reset = __esmMin((() => {
+	init_scenes_schema();
+	quote = (name) => `"${name.replaceAll("\"", "\"\"")}"`;
+}));
+//#endregion
+init_scene_reset();
+export { discardExperimentalSceneData, init_scene_reset, resetExperimentalScenes };

package/dist/src/storage/sqlite/scenes-schema.d.ts

@@ -0,0 +1,8 @@
+import type { DatabaseSync } from 'node:sqlite';
+export declare const NOTIFICATION_LEDGER_TABLES: readonly ["notification_browser_keys", "notification_browser_subscriptions", "notification_dispatches", "notification_result_outbox", "notification_attention_budget", "notification_digest_queue", "notification_digests", "notification_digest_members", "notification_dispatch_decisions", "notification_browser_probes", "notification_presence"];
+export declare const SCENE_TABLES: readonly ["scene_source_health", "scene_activation_requests", "scene_activations", "scene_context_snapshots", "scene_events", "scene_feedback", "scene_feedback_history", "scene_intent_events", "scene_model_reservations", "scene_notes", "scene_outcomes", "scene_preferences", "scene_presentations", "scene_runs", "scene_schedule_cursors", "scene_template_versions", "scene_trigger_intents", "scene_work_items", "scene_mail_sources", "scene_model_usage", "scene_connector_usage"];
+/** Installs fresh tables; the normal versioned upgrade owns existing databases. */
+export declare function installSceneSchema(db: DatabaseSync): void;
+export declare function installNotificationLedgerSchema(db: DatabaseSync): void;
+export declare function installSceneStorage(db: DatabaseSync): void;
+export declare function assertSceneStorageReady(db: DatabaseSync): void;

package/dist/src/storage/sqlite/scenes-schema.js

@@ -0,0 +1,61 @@
+import { __esmMin } from "../../../_virtual/_rolldown/runtime.js";
+import { init_sql_assets, readSqliteAsset } from "./sql-assets.js";
+//#region src/storage/sqlite/scenes-schema.ts
+/** Installs fresh tables; the normal versioned upgrade owns existing databases. */
+function installSceneSchema(db) {
+	db.exec(readSqliteAsset("schemas/scenes.sql"));
+}
+function installNotificationLedgerSchema(db) {
+	db.exec(readSqliteAsset("schemas/notifications.sql"));
+}
+function installSceneStorage(db) {
+	installSceneSchema(db);
+	installNotificationLedgerSchema(db);
+}
+function assertSceneStorageReady(db) {
+	const tables = new Set(db.prepare("SELECT name FROM sqlite_master WHERE type = 'table'").all().map((row) => row.name));
+	if ([...SCENE_TABLES, ...NOTIFICATION_LEDGER_TABLES].some((name) => !tables.has(name))) throw new Error("Scene storage is not initialized");
+}
+var NOTIFICATION_LEDGER_TABLES, SCENE_TABLES;
+var init_scenes_schema = __esmMin((() => {
+	init_sql_assets();
+	NOTIFICATION_LEDGER_TABLES = [
+		"notification_browser_keys",
+		"notification_browser_subscriptions",
+		"notification_dispatches",
+		"notification_result_outbox",
+		"notification_attention_budget",
+		"notification_digest_queue",
+		"notification_digests",
+		"notification_digest_members",
+		"notification_dispatch_decisions",
+		"notification_browser_probes",
+		"notification_presence"
+	];
+	SCENE_TABLES = [
+		"scene_source_health",
+		"scene_activation_requests",
+		"scene_activations",
+		"scene_context_snapshots",
+		"scene_events",
+		"scene_feedback",
+		"scene_feedback_history",
+		"scene_intent_events",
+		"scene_model_reservations",
+		"scene_notes",
+		"scene_outcomes",
+		"scene_preferences",
+		"scene_presentations",
+		"scene_runs",
+		"scene_schedule_cursors",
+		"scene_template_versions",
+		"scene_trigger_intents",
+		"scene_work_items",
+		"scene_mail_sources",
+		"scene_model_usage",
+		"scene_connector_usage"
+	];
+}));
+//#endregion
+init_scenes_schema();
+export { NOTIFICATION_LEDGER_TABLES, SCENE_TABLES, assertSceneStorageReady, init_scenes_schema, installNotificationLedgerSchema, installSceneSchema, installSceneStorage };

package/dist/src/storage/sqlite/schema.js

@@ -1,17 +1,12 @@
 import { __esmMin } from "../../../_virtual/_rolldown/runtime.js";
+import { init_sql_assets, readSqliteAsset } from "./sql-assets.js";
 import { SCHEMA_META_SCHEMA_VERSION_KEY, ensureSchemaMetaTable, init_schema_version, readSchemaVersion, readSchemaVersionForTest, setSchemaVersion } from "./schema-version.js";
 import { XOPC_DB_BASELINE_SCHEMA_VERSION, XOPC_DB_SCHEMA_VERSION, applyPendingMigrations, init_runner } from "./migrations/runner.js";
-import { dirname, join } from "node:path";
-import { readFileSync } from "node:fs";
-import { fileURLToPath } from "node:url";
 //#region src/storage/sqlite/schema.ts
-function readSchemaSql() {
-	return readFileSync(join(SCHEMA_DIR, "schema.sql"), "utf8");
-}
 function bootstrapFreshDatabase(db) {
 	db.exec("BEGIN IMMEDIATE");
 	try {
-		db.exec(readSchemaSql());
+		db.exec(readSqliteAsset("schema.sql"));
 		setSchemaVersion(db, 165);
 		db.exec("COMMIT");
 	} catch (error) {
@@ -33,15 +28,14 @@ function ensureXopcDatabaseSchema(db, options = {}) {
 		currentVersion = 165;
 	}
 	applyPendingMigrations(db, {
-		targetVersion: 185,
+		targetVersion: 189,
 		databasePath: fresh ? void 0 : options.databasePath
 	});
 }
-var SCHEMA_DIR;
 var init_schema = __esmMin((() => {
+	init_sql_assets();
 	init_runner();
 	init_schema_version();
-	SCHEMA_DIR = dirname(fileURLToPath(import.meta.url));
 }));
 //#endregion
 init_schema();

package/dist/src/storage/sqlite/schemas/notifications.sql

@@ -0,0 +1,65 @@
+CREATE TABLE notification_browser_keys (
+      id INTEGER PRIMARY KEY CHECK(id = 1), public_key TEXT NOT NULL, private_key TEXT NOT NULL
+    );
+    CREATE TABLE notification_browser_subscriptions (
+      id TEXT PRIMARY KEY, owner_id TEXT NOT NULL, workspace_id TEXT NOT NULL,
+      endpoint TEXT NOT NULL UNIQUE, auth_key TEXT NOT NULL, public_key TEXT NOT NULL,
+      expires_at INTEGER, language TEXT NOT NULL CHECK(language IN ('en', 'zh')), created_at INTEGER NOT NULL
+    );
+    CREATE INDEX notification_browser_owner ON notification_browser_subscriptions(owner_id, workspace_id);
+    CREATE TABLE notification_presence (
+      owner_id TEXT NOT NULL, workspace_id TEXT NOT NULL, client_id TEXT NOT NULL,
+      surface TEXT NOT NULL CHECK(surface IN ('web', 'electron', 'mobile')),
+      expires_at INTEGER NOT NULL, subject_id TEXT, subject_revision INTEGER,
+      PRIMARY KEY(owner_id, workspace_id, client_id)
+    );
+    CREATE TABLE notification_dispatches (
+      id TEXT PRIMARY KEY, notification_id TEXT NOT NULL REFERENCES notification_events(event_id),
+      owner_id TEXT NOT NULL, workspace_id TEXT NOT NULL,
+      channel TEXT NOT NULL CHECK(channel IN ('browser', 'telegram')),
+      destination_id TEXT NOT NULL, destination_json TEXT CHECK(destination_json IS NULL OR json_valid(destination_json)),
+      subject_id TEXT, subject_revision INTEGER NOT NULL CHECK(subject_revision > 0),
+      status TEXT NOT NULL CHECK(status IN ('pending', 'sending', 'accepted', 'failed', 'unknown', 'cancelled')),
+      attempt INTEGER NOT NULL CHECK(attempt >= 0), failure_count INTEGER NOT NULL DEFAULT 0 CHECK(failure_count >= 0),
+      next_attempt_at INTEGER NOT NULL,
+      lease_until INTEGER, provider_message_id TEXT, last_error TEXT,
+      UNIQUE(notification_id, channel, destination_id)
+    );
+    CREATE INDEX notification_dispatch_due ON notification_dispatches(status, next_attempt_at);
+    CREATE INDEX notification_dispatch_owner ON notification_dispatches(owner_id, workspace_id);
+    CREATE TABLE notification_result_outbox (
+      id TEXT PRIMARY KEY, owner_id TEXT NOT NULL, workspace_id TEXT NOT NULL, subject_id TEXT NOT NULL UNIQUE,
+      status TEXT NOT NULL CHECK(status IN ('pending', 'processing', 'settled', 'failed')),
+      attempt INTEGER NOT NULL CHECK(attempt >= 0), next_attempt_at INTEGER NOT NULL,
+      lease_until INTEGER, last_error TEXT, decision_reason TEXT,
+      created_at INTEGER NOT NULL, settled_at INTEGER, updated_at INTEGER NOT NULL
+    );
+    CREATE TABLE notification_attention_budget (
+      dedupe_key TEXT PRIMARY KEY, owner_id TEXT NOT NULL, workspace_id TEXT NOT NULL,
+      local_day TEXT NOT NULL, created_at INTEGER NOT NULL
+    );
+    CREATE INDEX notification_attention_day ON notification_attention_budget(owner_id, workspace_id, local_day);
+    CREATE TABLE notification_digest_queue (
+      subject_id TEXT PRIMARY KEY, owner_id TEXT NOT NULL, workspace_id TEXT NOT NULL,
+      subject_revision INTEGER NOT NULL CHECK(subject_revision > 0), mode TEXT NOT NULL CHECK(mode IN ('daily', 'quiet')),
+      due_at INTEGER NOT NULL, consumed_at INTEGER,
+      status TEXT NOT NULL CHECK(status IN ('held', 'pending', 'consumed'))
+    );
+    CREATE TABLE notification_digests (
+      id TEXT PRIMARY KEY, owner_id TEXT NOT NULL, workspace_id TEXT NOT NULL, occurrence_key TEXT NOT NULL,
+      created_at INTEGER NOT NULL, notification_id TEXT REFERENCES notification_events(event_id),
+      UNIQUE(owner_id, workspace_id, occurrence_key)
+    );
+    CREATE TABLE notification_digest_members (
+      digest_id TEXT NOT NULL REFERENCES notification_digests(id), subject_id TEXT NOT NULL,
+      subject_revision INTEGER NOT NULL CHECK(subject_revision > 0), PRIMARY KEY(digest_id, subject_id)
+    );
+    CREATE TABLE notification_dispatch_decisions (
+      dedupe_key TEXT PRIMARY KEY, owner_id TEXT NOT NULL, workspace_id TEXT NOT NULL,
+      disposition TEXT NOT NULL, created_at INTEGER NOT NULL
+    );
+    CREATE TABLE notification_browser_probes (
+      id TEXT PRIMARY KEY, owner_id TEXT NOT NULL, workspace_id TEXT NOT NULL, subscription_id TEXT NOT NULL,
+      status TEXT NOT NULL CHECK(status IN ('accepted', 'opened', 'failed', 'unknown')),
+      created_at INTEGER NOT NULL, opened_at INTEGER, error TEXT
+    );

package/dist/src/storage/sqlite/schemas/scenes.sql

@@ -0,0 +1,212 @@
+-- Current scene storage. Historical experimental data is discarded.
+CREATE TABLE scene_template_versions (
+  template_key TEXT NOT NULL,
+  version TEXT NOT NULL,
+  content_hash TEXT NOT NULL,
+  manifest_json TEXT NOT NULL CHECK(json_valid(manifest_json)),
+  PRIMARY KEY(template_key, version)
+);
+
+CREATE TABLE scene_activations (
+  id TEXT PRIMARY KEY,
+  owner_id TEXT NOT NULL,
+  workspace_id TEXT NOT NULL,
+  template_key TEXT NOT NULL,
+  template_version TEXT NOT NULL,
+  goal TEXT NOT NULL,
+  scope_json TEXT NOT NULL CHECK(json_valid(scope_json)),
+  permissions_json TEXT NOT NULL CHECK(json_valid(permissions_json)),
+  status TEXT NOT NULL CHECK(status IN ('needs_setup', 'active', 'paused', 'completed', 'archived')),
+  revision INTEGER NOT NULL CHECK(revision > 0),
+  FOREIGN KEY(template_key, template_version) REFERENCES scene_template_versions(template_key, version)
+);
+
+CREATE INDEX scene_activations_owner ON scene_activations(owner_id, workspace_id, status);
+
+CREATE TABLE scene_preferences (
+  owner_id TEXT NOT NULL, workspace_id TEXT NOT NULL,
+  preferences_json TEXT NOT NULL CHECK(json_valid(preferences_json)), revision INTEGER NOT NULL CHECK(revision > 0),
+  PRIMARY KEY(owner_id, workspace_id)
+);
+
+CREATE TABLE scene_notes (
+  activation_id TEXT PRIMARY KEY REFERENCES scene_activations(id),
+  content TEXT NOT NULL,
+  revision INTEGER NOT NULL CHECK(revision > 0),
+  valid_until INTEGER,
+  updated_at INTEGER NOT NULL
+);
+
+CREATE TABLE scene_activation_requests (
+  owner_id TEXT NOT NULL,
+  workspace_id TEXT NOT NULL,
+  request_id TEXT NOT NULL,
+  content_hash TEXT NOT NULL,
+  activation_id TEXT NOT NULL REFERENCES scene_activations(id),
+  PRIMARY KEY(owner_id, workspace_id, request_id)
+);
+
+CREATE TABLE scene_work_items (
+  id TEXT PRIMARY KEY,
+  activation_id TEXT NOT NULL REFERENCES scene_activations(id),
+  subject_id TEXT NOT NULL,
+  account_id TEXT NOT NULL,
+  due_at INTEGER NOT NULL,
+  revision INTEGER NOT NULL CHECK(revision > 0),
+  status TEXT NOT NULL CHECK(status IN ('watching', 'paused', 'completed')),
+  last_triggered_revision INTEGER,
+  last_check_reason TEXT,
+  observed_fingerprint TEXT,
+  observation_sequence INTEGER NOT NULL DEFAULT 0,
+  UNIQUE(activation_id, account_id, subject_id)
+);
+
+CREATE TABLE scene_events (
+  id TEXT PRIMARY KEY,
+  owner_id TEXT NOT NULL,
+  workspace_id TEXT NOT NULL,
+  source TEXT NOT NULL,
+  source_event_id TEXT NOT NULL,
+  event_type TEXT NOT NULL,
+  subject_id TEXT NOT NULL,
+  occurred_at INTEGER NOT NULL,
+  received_at INTEGER NOT NULL,
+  account_id TEXT,
+  UNIQUE(owner_id, workspace_id, source, source_event_id)
+);
+
+CREATE TABLE scene_trigger_intents (
+  id TEXT PRIMARY KEY,
+  activation_id TEXT NOT NULL REFERENCES scene_activations(id),
+  activation_revision INTEGER NOT NULL,
+  trigger_key TEXT NOT NULL,
+  occurrence_key TEXT NOT NULL,
+  event_id TEXT REFERENCES scene_events(id),
+  due_at INTEGER NOT NULL,
+  status TEXT NOT NULL CHECK(status IN ('pending', 'claimed', 'resolved', 'cancelled')),
+  UNIQUE(activation_id, trigger_key, occurrence_key)
+);
+
+CREATE INDEX scene_intents_due ON scene_trigger_intents(status, due_at);
+
+CREATE TABLE scene_schedule_cursors (
+  activation_id TEXT NOT NULL REFERENCES scene_activations(id),
+  trigger_key TEXT NOT NULL,
+  schedule_json TEXT NOT NULL CHECK(json_valid(schedule_json)),
+  revision INTEGER NOT NULL CHECK(revision > 0),
+  next_due_at INTEGER NOT NULL,
+  PRIMARY KEY(activation_id, trigger_key)
+);
+
+CREATE INDEX scene_schedules_due ON scene_schedule_cursors(next_due_at);
+
+CREATE TABLE scene_runs (
+  id TEXT PRIMARY KEY,
+  intent_id TEXT NOT NULL UNIQUE REFERENCES scene_trigger_intents(id),
+  activation_id TEXT NOT NULL REFERENCES scene_activations(id),
+  activation_revision INTEGER NOT NULL,
+  status TEXT NOT NULL CHECK(status IN ('running', 'succeeded', 'skipped', 'retry_wait', 'failed', 'cancelled')),
+  attempt INTEGER NOT NULL CHECK(attempt > 0),
+  lease_epoch INTEGER NOT NULL CHECK(lease_epoch > 0),
+  lease_owner TEXT,
+  lease_until INTEGER,
+  retry_at INTEGER,
+  reason TEXT,
+  created_at INTEGER NOT NULL
+);
+
+CREATE INDEX scene_runs_lease ON scene_runs(status, lease_until);
+
+CREATE TABLE scene_model_reservations (
+  run_id TEXT NOT NULL REFERENCES scene_runs(id),
+  lease_epoch INTEGER NOT NULL,
+  owner_id TEXT NOT NULL,
+  activation_id TEXT NOT NULL REFERENCES scene_activations(id),
+  reserved_at INTEGER NOT NULL,
+  PRIMARY KEY(run_id, lease_epoch)
+);
+
+CREATE INDEX scene_model_budget ON scene_model_reservations(owner_id, reserved_at);
+
+CREATE UNIQUE INDEX scene_runs_single_active ON scene_runs(activation_id) WHERE status IN ('running', 'retry_wait');
+
+CREATE TABLE scene_context_snapshots (
+  run_id TEXT NOT NULL REFERENCES scene_runs(id),
+  lease_epoch INTEGER NOT NULL,
+  content_hash TEXT NOT NULL,
+  evidence_ids_json TEXT NOT NULL CHECK(json_valid(evidence_ids_json)),
+  created_at INTEGER NOT NULL,
+  PRIMARY KEY(run_id, lease_epoch)
+);
+
+CREATE TABLE scene_outcomes (
+  id TEXT PRIMARY KEY,
+  run_id TEXT NOT NULL UNIQUE REFERENCES scene_runs(id),
+  kind TEXT NOT NULL CHECK(kind IN ('no_change', 'observation', 'artifact', 'decision', 'state_change', 'effect_proposal', 'receipt')),
+  content_json TEXT NOT NULL CHECK(json_valid(content_json)),
+  created_at INTEGER NOT NULL
+);
+
+CREATE TABLE scene_presentations (
+  id TEXT PRIMARY KEY,
+  outcome_id TEXT NOT NULL UNIQUE REFERENCES scene_outcomes(id),
+  destination TEXT NOT NULL CHECK(destination = 'inbox'),
+  status TEXT NOT NULL CHECK(status IN ('unread', 'read', 'snoozed', 'resolved', 'withdrawn')),
+  created_at INTEGER NOT NULL,
+  updated_at INTEGER, snoozed_until INTEGER, expires_at INTEGER, withdrawn_at INTEGER, actionable_until INTEGER,
+  resolution TEXT, revision INTEGER NOT NULL DEFAULT 1 CHECK(revision > 0),
+  notification_revision INTEGER NOT NULL DEFAULT 1 CHECK(notification_revision > 0), correlation_key TEXT
+);
+
+CREATE TABLE scene_feedback (
+  presentation_id TEXT PRIMARY KEY REFERENCES scene_presentations(id),
+  rating TEXT NOT NULL CHECK(rating IN ('useful', 'not_useful')),
+  note TEXT NOT NULL,
+  revision INTEGER NOT NULL CHECK(revision > 0),
+  updated_at INTEGER NOT NULL
+);
+
+CREATE TABLE scene_feedback_history (
+  id TEXT PRIMARY KEY,
+  presentation_id TEXT NOT NULL REFERENCES scene_presentations(id),
+  rating TEXT NOT NULL CHECK(rating IN ('useful', 'not_useful')),
+  note TEXT NOT NULL,
+  revision INTEGER NOT NULL CHECK(revision > 0),
+  recorded_at INTEGER NOT NULL,
+  UNIQUE(presentation_id, revision)
+);
+
+CREATE INDEX scene_feedback_history_time ON scene_feedback_history(recorded_at);
+
+CREATE TABLE scene_intent_events (
+  intent_id TEXT NOT NULL REFERENCES scene_trigger_intents(id), event_id TEXT NOT NULL REFERENCES scene_events(id),
+  added_at INTEGER NOT NULL, PRIMARY KEY(intent_id, event_id)
+);
+
+CREATE TABLE scene_mail_sources (
+  id TEXT PRIMARY KEY, owner_id TEXT NOT NULL, workspace_id TEXT NOT NULL,
+  account_id TEXT NOT NULL, thread_id TEXT NOT NULL, subject TEXT NOT NULL, sender TEXT NOT NULL,
+  selected_at INTEGER NOT NULL,
+  UNIQUE(owner_id, workspace_id, account_id, thread_id)
+);
+
+CREATE TABLE scene_model_usage (
+  run_id TEXT NOT NULL REFERENCES scene_runs(id), lease_epoch INTEGER NOT NULL,
+  provider TEXT NOT NULL, model TEXT NOT NULL, input_tokens INTEGER NOT NULL,
+  output_tokens INTEGER NOT NULL, total_tokens INTEGER NOT NULL, estimated_cost REAL NOT NULL,
+  recorded_at INTEGER NOT NULL, PRIMARY KEY(run_id, lease_epoch)
+);
+
+CREATE TABLE scene_connector_usage (
+  owner_id TEXT NOT NULL, workspace_id TEXT NOT NULL, account_id TEXT NOT NULL,
+  utc_day INTEGER NOT NULL, request_count INTEGER NOT NULL,
+  PRIMARY KEY(owner_id, workspace_id, account_id, utc_day)
+);
+CREATE TABLE IF NOT EXISTS scene_source_health (
+  activation_id TEXT PRIMARY KEY REFERENCES scene_activations(id) ON DELETE CASCADE,
+  last_attempt_at INTEGER NOT NULL,
+  last_success_at INTEGER,
+  reason TEXT,
+  consecutive_failures INTEGER NOT NULL DEFAULT 0,
+  retry_at INTEGER
+);

package/dist/src/storage/sqlite/session-read-repository.d.ts

@@ -0,0 +1,8 @@
+import type { DatabaseSync } from 'node:sqlite';
+import type { SessionMetadata } from '../../session/types.js';
+import { type SessionRow } from './row-mappers.js';
+export declare const SESSION_COLUMNS = "\n  s.conversation_id, s.agent_id, s.active_transcript_id, s.status, s.name, s.tags_json,\n  s.created_at, s.updated_at, s.last_accessed_at, s.session_started_at, s.last_interaction_at,\n  s.source_channel, s.source_chat_id, s.session_type, s.hidden_from_session_list,\n  s.parent_conversation_id, s.workflow_run_id, s.workflow_definition_id, s.workflow_agent_id, s.workflow_agent_label,\n  s.project_id, s.routing_json, s.custom_data_json,\n  s.message_count, s.estimated_tokens, s.compacted_count,\n  s.last_flushed_at, s.flush_count,\n  s.thinking_level, s.verbose_level,\n  t.cwd AS cwd\n";
+export declare const SESSION_FROM_JOIN = "\n  FROM sessions s\n  LEFT JOIN transcripts t ON t.transcript_id = s.active_transcript_id\n";
+export declare function readSessionRow(db: DatabaseSync, conversationId: string): SessionRow | undefined;
+/** Read metadata without importing session lifecycle operations. */
+export declare function getSessionMetadata(conversationId: string): SessionMetadata | null;

package/dist/src/storage/sqlite/session-read-repository.js

@@ -0,0 +1,35 @@
+import { __esmMin } from "../../../_virtual/_rolldown/runtime.js";
+import { getSqliteDatabase, init_transaction } from "./transaction.js";
+import { init_row_mappers, sessionRowToMetadata } from "./row-mappers.js";
+//#region src/storage/sqlite/session-read-repository.ts
+function readSessionRow(db, conversationId) {
+	return db.prepare(`SELECT ${SESSION_COLUMNS} ${SESSION_FROM_JOIN} WHERE s.conversation_id = ?`).get(conversationId);
+}
+/** Read metadata without importing session lifecycle operations. */
+function getSessionMetadata(conversationId) {
+	const row = readSessionRow(getSqliteDatabase(), conversationId);
+	return row ? sessionRowToMetadata(conversationId, row) : null;
+}
+var SESSION_COLUMNS, SESSION_FROM_JOIN;
+var init_session_read_repository = __esmMin((() => {
+	init_row_mappers();
+	init_transaction();
+	SESSION_COLUMNS = `
+  s.conversation_id, s.agent_id, s.active_transcript_id, s.status, s.name, s.tags_json,
+  s.created_at, s.updated_at, s.last_accessed_at, s.session_started_at, s.last_interaction_at,
+  s.source_channel, s.source_chat_id, s.session_type, s.hidden_from_session_list,
+  s.parent_conversation_id, s.workflow_run_id, s.workflow_definition_id, s.workflow_agent_id, s.workflow_agent_label,
+  s.project_id, s.routing_json, s.custom_data_json,
+  s.message_count, s.estimated_tokens, s.compacted_count,
+  s.last_flushed_at, s.flush_count,
+  s.thinking_level, s.verbose_level,
+  t.cwd AS cwd
+`;
+	SESSION_FROM_JOIN = `
+  FROM sessions s
+  LEFT JOIN transcripts t ON t.transcript_id = s.active_transcript_id
+`;
+}));
+//#endregion
+init_session_read_repository();
+export { SESSION_COLUMNS, SESSION_FROM_JOIN, getSessionMetadata, init_session_read_repository, readSessionRow };

package/dist/src/storage/sqlite/session-repository.d.ts

@@ -2,10 +2,10 @@ import type { DatabaseSync } from 'node:sqlite';
 import type { SessionListQuery, SessionMetadata, PaginatedResult } from '../../session/types.js';
 import { type SessionMetadataSeed } from './session-metadata.js';
 import { buildGlobalSessionStats } from './row-mappers.js';
+export { getSessionMetadata } from './session-read-repository.js';
 export declare function ensureSessionInTransaction(db: DatabaseSync, conversationId: string, cwd: string, seed?: SessionMetadataSeed): SessionMetadata;
 export declare function ensureSessionRecord(conversationId: string, cwd: string, seed?: SessionMetadataSeed): SessionMetadata;
 export { readCurrentTranscriptId } from './session-instance-repository.js';
-export declare function getSessionMetadata(conversationId: string): SessionMetadata | null;
 export declare function getCurrentTranscriptId(conversationId: string): string | null;
 export declare function listSessionMetadata(query?: SessionListQuery): PaginatedResult<SessionMetadata>;
 export declare function patchSessionMetadata(conversationId: string, updates: Partial<SessionMetadata>): SessionMetadata;