@xopcai/xopc 0.0.309 → 0.0.311

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: 186,
+		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;

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

@@ -9,11 +9,9 @@ import { cancelConnectionObjective, init_connection_wait_repository } from "./co
 import { init_changes, notifyUserContextChange } from "../../user-context/changes.js";
 import { SESSION_PURPOSE_SQL, SESSION_SOURCE_SQL, init_session_identity_sql } from "./session-identity-sql.js";
 import { buildFts5SearchQuery, init_fts } from "./fts.js";
+import { SESSION_COLUMNS, SESSION_FROM_JOIN, getSessionMetadata, init_session_read_repository, readSessionRow } from "./session-read-repository.js";
 import { randomUUID } from "node:crypto";
 //#region src/storage/sqlite/session-repository.ts
-function readSessionRow(db, conversationId) {
-	return db.prepare(SELECT_SESSION).get(conversationId);
-}
 function insertSessionAndTranscript(db, conversationId, transcriptId, cwd, metadata) {
 	const row = metadataToSessionInsert(conversationId, transcriptId, metadata);
 	db.prepare(`INSERT INTO sessions (
@@ -59,11 +57,6 @@ function ensureSessionInTransaction(db, conversationId, cwd, seed) {
 function ensureSessionRecord(conversationId, cwd, seed) {
 	return runSqliteWriteTransaction((db) => ensureSessionInTransaction(db, conversationId, cwd, seed));
 }
-function getSessionMetadata(conversationId) {
-	const row = readSessionRow(getSqliteDatabase(), conversationId);
-	if (!row) return null;
-	return sessionRowToMetadata(conversationId, row);
-}
 function getCurrentTranscriptId(conversationId) {
 	return readCurrentTranscriptId(getSqliteDatabase(), conversationId);
 }
@@ -335,7 +328,6 @@ function getGlobalSessionStats() {
 function resolveSessionAgentId(conversationId) {
 	return getSessionMetadata(conversationId)?.routing?.agentId ?? "main";
 }
-var SESSION_COLUMNS, SESSION_FROM_JOIN, SELECT_SESSION;
 var init_session_repository = __esmMin((() => {
 	init_connection_wait_repository();
 	init_src();
@@ -346,22 +338,7 @@ var init_session_repository = __esmMin((() => {
 	init_transaction();
 	init_session_identity_sql();
 	init_fts();
-	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
-`;
-	SELECT_SESSION = `SELECT ${SESSION_COLUMNS} ${SESSION_FROM_JOIN} WHERE s.conversation_id = ?`;
+	init_session_read_repository();
 }));
 //#endregion
 init_session_repository();

package/dist/src/storage/sqlite/sql-assets.d.ts

@@ -0,0 +1,2 @@
+export declare function resolveSqliteAssetPath(relativePath: string): string;
+export declare function readSqliteAsset(relativePath: string): string;

package/dist/src/storage/sqlite/sql-assets.js

@@ -0,0 +1,18 @@
+import { __esmMin } from "../../../_virtual/_rolldown/runtime.js";
+import { dirname, join } from "node:path";
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+//#region src/storage/sqlite/sql-assets.ts
+function resolveSqliteAssetPath(relativePath) {
+	return join(SQL_ASSET_ROOT, relativePath);
+}
+function readSqliteAsset(relativePath) {
+	return readFileSync(resolveSqliteAssetPath(relativePath), "utf8");
+}
+var SQL_ASSET_ROOT;
+var init_sql_assets = __esmMin((() => {
+	SQL_ASSET_ROOT = dirname(fileURLToPath(import.meta.url));
+}));
+//#endregion
+init_sql_assets();
+export { init_sql_assets, readSqliteAsset, resolveSqliteAssetPath };

package/dist/src/storage/sqlite/transaction.d.ts

@@ -9,3 +9,5 @@ import type { DatabaseSync } from 'node:sqlite';
  */
 export declare function runSqliteWriteTransaction<T>(fn: (db: DatabaseSync) => T): T;
 export declare function getSqliteDatabase(): DatabaseSync;
+/** Compose with domain-owned transactions on an explicitly supplied connection. */
+export declare function runSqliteSavepoint<T>(db: DatabaseSync, operation: () => T): T;

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

@@ -106,6 +106,25 @@ function runSqliteWriteTransaction(fn) {
 function getSqliteDatabase() {
 	return getXopcDatabase().db;
 }
+/** Compose with domain-owned transactions on an explicitly supplied connection. */
+function runSqliteSavepoint(db, operation) {
+	const name = nextSavepointName();
+	const depth = getTransactionDepth(db);
+	db.exec(`SAVEPOINT ${name}`);
+	setTransactionDepth(db, depth + 1);
+	try {
+		const result = operation();
+		assertSyncTransactionResult(result);
+		db.exec(`RELEASE ${name}`);
+		return result;
+	} catch (error) {
+		db.exec(`ROLLBACK TO ${name}`);
+		db.exec(`RELEASE ${name}`);
+		throw error;
+	} finally {
+		setTransactionDepth(db, depth);
+	}
+}
 var RETRYABLE_COMMIT_CODES, MAX_COMMIT_ATTEMPTS, nextSavepointId, transactionDepthByDatabase;
 var init_transaction = __esmMin((() => {
 	init_connection();
@@ -116,4 +135,4 @@ var init_transaction = __esmMin((() => {
 }));
 //#endregion
 init_transaction();
-export { getSqliteDatabase, init_transaction, runSqliteWriteTransaction };
+export { getSqliteDatabase, init_transaction, runSqliteSavepoint, runSqliteWriteTransaction };

package/dist/src/tasks/home-query-service.d.ts

@@ -1,7 +1,6 @@
 import type { HomeAttention, HomeDecision, HomeResponse } from '@xopcai/gateway-contract';
 import type { AutomationService } from '../automations/service/automation-service.js';
 import type { Config } from '../config/schema.js';
-import type { ProactiveInboxService } from '../proactive/inbox/service.js';
 import type { ProjectService } from '../projects/project-service.js';
 import type { WorkflowRunSummary } from '../workflows/domain/index.js';
 import type { WorkflowRunService } from '../workflows/service/workflow-run-service.js';
@@ -29,7 +28,6 @@ interface HomeGatewayPort {
     readonly currentConfig: Config;
     readonly automationServiceInstance: AutomationService;
     readonly projects: ProjectService;
-    readonly proactiveInbox: ProactiveInboxService;
     readonly sessions: {
         listActiveRuns(): Array<{
             conversationId: string;

package/dist/src/tasks/home-query-service.js

@@ -329,50 +329,20 @@ var HomeQueryService = class {
 		const upcomingAutomations = automations.filter((automation) => automation.notificationPolicy !== "none").map(toHomeAutomation).filter((automation) => Boolean(automation)).sort((a, b) => Date.parse(a.nextRunAt) - Date.parse(b.nextRunAt));
 		const latestAutomationRuns = [...automationRuns].sort((left, right) => right.createdAtMs - left.createdAtMs).filter((run, index, all) => all.findIndex((candidate) => candidate.automationId === run.automationId) === index);
 		const automationsById = new Map(automations.map((automation) => [automation.id, automation]));
-		const decisionCandidates = [
-			...this.service.proactiveInbox.list({ limit: 20 }).filter((item) => item.status === "unread" || item.status === "read").map((item) => ({
-				id: `agent-judgment:${item.id}`,
-				kind: "agent_judgment",
-				title: item.insight.title,
-				detail: item.insight.summary,
-				reason: item.insight.disposition === "request_approval" ? "approval_required" : item.insight.attentionKind === "decision" ? "decision_needed" : "insight_available",
-				urgency: item.insight.urgency === "critical" || item.insight.urgency === "high" ? "now" : "soon",
-				href: `/assistant-work?item=${encodeURIComponent(item.id)}`,
-				updatedAt: Date.parse(item.updatedAt),
-				judgment: {
-					inboxItemId: item.id,
-					whyNow: item.insight.whyNow,
-					impact: item.insight.impact,
-					workDone: item.insight.workDone,
-					recommendation: item.insight.recommendation,
-					confidence: item.insight.confidence,
-					valueScore: item.insight.valueScore,
-					evidenceIds: item.insight.evidenceIds,
-					attentionKind: item.insight.attentionKind,
-					disposition: item.insight.disposition,
-					dispositionReason: item.insight.dispositionReason,
-					...item.insight.actionStatus ? { actionStatus: item.insight.actionStatus } : {},
-					...item.insight.proposedAction ? { proposedActionTitle: item.insight.proposedAction.input.title } : {},
-					...item.insight.actionError ? { actionError: item.insight.actionError } : {},
-					...item.insight.decision && (!item.insight.proposedAction || item.insight.actionStatus === "approval_required") ? { decision: item.insight.decision } : {}
-				}
-			})),
-			...activeTasks.map((task) => decisionFromTask(this.#projector.project(task), task.projectId ? projectsById.get(task.projectId)?.name : void 0, locale)).filter((item) => Boolean(item)),
-			...connectorApprovals.filter((approval) => Date.parse(approval.expiresAt) > nowMs).map((approval) => ({
-				id: `connector-approval:${approval.id}`,
+		const decisionCandidates = [...activeTasks.map((task) => decisionFromTask(this.#projector.project(task), task.projectId ? projectsById.get(task.projectId)?.name : void 0, locale)).filter((item) => Boolean(item)), ...connectorApprovals.filter((approval) => Date.parse(approval.expiresAt) > nowMs).map((approval) => ({
+			id: `connector-approval:${approval.id}`,
+			kind: "connector_approval",
+			title: approval.actionId,
+			detail: `${approval.connectorId} · ${approval.scope}\n${JSON.stringify(approval.argumentsPreview).slice(0, 1600)}`,
+			reason: "approval_required",
+			urgency: "now",
+			href: approval.conversationId ? `/chat/${encodeURIComponent(approval.conversationId)}` : "/connectors",
+			updatedAt: Date.parse(approval.createdAt),
+			response: {
 				kind: "connector_approval",
-				title: approval.actionId,
-				detail: `${approval.connectorId} · ${approval.scope}\n${JSON.stringify(approval.argumentsPreview).slice(0, 1600)}`,
-				reason: "approval_required",
-				urgency: "now",
-				href: approval.conversationId ? `/chat/${encodeURIComponent(approval.conversationId)}` : "/connectors",
-				updatedAt: Date.parse(approval.createdAt),
-				response: {
-					kind: "connector_approval",
-					approvalId: approval.id
-				}
-			}))
-		];
+				approvalId: approval.id
+			}
+		}))];
 		const attentionCandidates = [...failedWorkflowRuns.filter((run) => !isHomeAttentionAcknowledged("workflow_run", run.id)).map((run) => ({
 			id: `workflow_run:${run.id}`,
 			kind: "workflow_run",

package/dist/src/tasks/index.d.ts

@@ -8,7 +8,6 @@ export * from './task-contract-planner.js';
 export * from './task-context-assembler.js';
 export * from './task-run-coordinator.js';
 export * from './project-operating-view-service.js';
-export * from './project-monitoring-service.js';
 export * from './task-value-metrics-service.js';
 export * from './task-application-service.js';
 export * from './task-change-events.js';