@xopcai/xopc 0.0.180 → 0.0.188

package/dist/src/storage/sqlite/migrations/101_session_response_language.sql

@@ -0,0 +1 @@
+ALTER TABLE session_config ADD COLUMN response_language TEXT;

package/dist/src/storage/sqlite/migrations/102_session_user_context_mode.sql

@@ -0,0 +1,2 @@
+ALTER TABLE session_config
+ADD COLUMN user_context_mode TEXT CHECK (user_context_mode IN ('enabled', 'off'));

package/dist/src/storage/sqlite/migrations/103_finalize_structured_memory.sql

@@ -0,0 +1,3 @@
+UPDATE memory_records
+SET kind = 'user_note'
+WHERE kind = 'curated_note';

package/dist/src/storage/sqlite/migrations/104_turn_memory_feedback.sql

@@ -0,0 +1,77 @@
+CREATE TEMP TABLE legacy_memory_feedback AS
+SELECT trace_id, COALESCE(turn_id, trace_id) AS turn_id, feedback_json, created_at
+FROM memory_trace_events
+WHERE json_extract(feedback_json, '$.rating') IN ('helpful', 'not_helpful', 'mixed', 'irrelevant');
+
+CREATE TABLE memory_trace_events_next (
+  trace_id TEXT PRIMARY KEY,
+  session_key TEXT,
+  turn_id TEXT,
+  phase TEXT NOT NULL,
+  provider_id TEXT NOT NULL,
+  request_json TEXT NOT NULL DEFAULT '{}',
+  result_count INTEGER,
+  selected_record_ids_json TEXT NOT NULL DEFAULT '[]',
+  skipped_reason TEXT,
+  error TEXT,
+  duration_ms INTEGER NOT NULL DEFAULT 0,
+  created_at INTEGER NOT NULL,
+  user_id TEXT NOT NULL DEFAULT 'local-owner',
+  source_agent_id TEXT
+);
+
+INSERT INTO memory_trace_events_next
+SELECT trace_id, session_key, turn_id, phase, provider_id, request_json,
+       result_count, selected_record_ids_json, skipped_reason, error,
+       duration_ms, created_at, user_id, source_agent_id
+FROM memory_trace_events;
+
+DROP TABLE memory_trace_events;
+ALTER TABLE memory_trace_events_next RENAME TO memory_trace_events;
+
+CREATE INDEX idx_memory_trace_created ON memory_trace_events(created_at DESC);
+CREATE INDEX idx_memory_trace_provider_created ON memory_trace_events(provider_id, created_at DESC);
+CREATE INDEX idx_memory_trace_session_created ON memory_trace_events(session_key, created_at DESC);
+CREATE INDEX idx_memory_trace_user_created ON memory_trace_events(user_id, created_at DESC);
+CREATE INDEX idx_memory_trace_source_agent_created ON memory_trace_events(source_agent_id, created_at DESC);
+CREATE UNIQUE INDEX idx_memory_trace_turn_inject
+  ON memory_trace_events(turn_id)
+  WHERE phase = 'inject' AND turn_id IS NOT NULL;
+
+CREATE TABLE memory_feedback (
+  feedback_id TEXT PRIMARY KEY,
+  trace_id TEXT NOT NULL REFERENCES memory_trace_events(trace_id) ON DELETE CASCADE,
+  turn_id TEXT NOT NULL,
+  record_id TEXT REFERENCES memory_records(record_id) ON DELETE CASCADE,
+  level TEXT NOT NULL CHECK (level IN ('response', 'record')),
+  rating TEXT NOT NULL CHECK (rating IN (
+    'helpful', 'not_helpful', 'mixed', 'irrelevant', 'incorrect', 'outdated', 'sensitive'
+  )),
+  score REAL,
+  reason_code TEXT,
+  note TEXT,
+  source TEXT NOT NULL CHECK (source IN ('user', 'evaluator', 'system')),
+  created_at INTEGER NOT NULL,
+  updated_at INTEGER NOT NULL,
+  CHECK ((level = 'response' AND record_id IS NULL) OR (level = 'record' AND record_id IS NOT NULL))
+);
+
+CREATE UNIQUE INDEX idx_memory_feedback_target_source
+  ON memory_feedback(trace_id, level, COALESCE(record_id, ''), source);
+CREATE INDEX idx_memory_feedback_turn ON memory_feedback(turn_id, updated_at DESC);
+CREATE INDEX idx_memory_feedback_record ON memory_feedback(record_id, updated_at DESC);
+
+INSERT INTO memory_feedback (
+  feedback_id, trace_id, turn_id, record_id, level, rating, score,
+  reason_code, note, source, created_at, updated_at
+)
+SELECT
+  lower(hex(randomblob(16))), trace_id, turn_id, NULL, 'response',
+  json_extract(feedback_json, '$.rating'), json_extract(feedback_json, '$.score'),
+  json_extract(feedback_json, '$.reason'), NULL,
+  COALESCE(json_extract(feedback_json, '$.source'), 'user'),
+  COALESCE(strftime('%s', json_extract(feedback_json, '$.createdAt')) * 1000, created_at),
+  COALESCE(strftime('%s', json_extract(feedback_json, '$.updatedAt')) * 1000, created_at)
+FROM legacy_memory_feedback;
+
+DROP TABLE legacy_memory_feedback;

package/dist/src/storage/sqlite/migrations/105_dreaming_ledger.sql

@@ -0,0 +1,34 @@
+CREATE TABLE dreaming_runs (
+  run_id TEXT PRIMARY KEY,
+  agent_id TEXT NOT NULL,
+  workspace_id TEXT NOT NULL,
+  phase TEXT NOT NULL CHECK (phase IN ('light', 'deep', 'rem')),
+  mode TEXT NOT NULL CHECK (mode IN ('observe', 'review', 'automatic')),
+  trigger_kind TEXT NOT NULL CHECK (trigger_kind IN ('schedule', 'manual')),
+  status TEXT NOT NULL CHECK (status IN ('running', 'completed', 'failed')),
+  reason TEXT,
+  metrics_json TEXT NOT NULL DEFAULT '{}',
+  started_at INTEGER NOT NULL,
+  completed_at INTEGER
+);
+
+CREATE INDEX idx_dreaming_runs_agent_started
+  ON dreaming_runs(agent_id, started_at DESC);
+CREATE INDEX idx_dreaming_runs_workspace_started
+  ON dreaming_runs(workspace_id, started_at DESC);
+
+CREATE TABLE dreaming_decisions (
+  decision_id TEXT PRIMARY KEY,
+  run_id TEXT NOT NULL REFERENCES dreaming_runs(run_id) ON DELETE CASCADE,
+  record_id TEXT REFERENCES memory_records(record_id) ON DELETE SET NULL,
+  action TEXT NOT NULL CHECK (action IN ('observe', 'propose', 'activate', 'skip')),
+  reason_code TEXT NOT NULL,
+  score REAL,
+  evidence_json TEXT NOT NULL DEFAULT '{}',
+  created_at INTEGER NOT NULL
+);
+
+CREATE INDEX idx_dreaming_decisions_run
+  ON dreaming_decisions(run_id, created_at);
+CREATE INDEX idx_dreaming_decisions_record
+  ON dreaming_decisions(record_id, created_at DESC);

package/dist/src/storage/sqlite/migrations/106_dreaming_run_reproducibility.sql

@@ -0,0 +1,2 @@
+ALTER TABLE dreaming_runs ADD COLUMN algorithm_version TEXT NOT NULL DEFAULT 'structured-v1';
+ALTER TABLE dreaming_runs ADD COLUMN config_snapshot_json TEXT NOT NULL DEFAULT '{}';

package/dist/src/storage/sqlite/migrations/107_connector_accounts.sql

@@ -0,0 +1,146 @@
+CREATE TABLE connector_accounts (
+  id                     TEXT PRIMARY KEY,
+  connector_id           TEXT NOT NULL,
+  principal_id           TEXT NOT NULL,
+  identity_key           TEXT,
+  identity_json          TEXT NOT NULL DEFAULT '{}',
+  current_connection_id  TEXT,
+  created_at             TEXT NOT NULL,
+  updated_at             TEXT NOT NULL
+);
+
+CREATE UNIQUE INDEX idx_connector_accounts_identity
+  ON connector_accounts(principal_id, connector_id, identity_key)
+  WHERE identity_key IS NOT NULL;
+
+ALTER TABLE connector_connections ADD COLUMN account_id TEXT REFERENCES connector_accounts(id) ON DELETE CASCADE;
+
+INSERT INTO connector_accounts (
+  id, connector_id, principal_id, identity_json, current_connection_id, created_at, updated_at
+)
+SELECT
+  'account:' || id, connector_id, principal_id, identity_json, id, created_at, updated_at
+FROM connector_connections;
+
+UPDATE connector_connections SET account_id = 'account:' || id;
+
+CREATE TEMP TABLE connector_source_instance_migrations (
+  old_id TEXT PRIMARY KEY,
+  new_id TEXT NOT NULL
+);
+
+INSERT INTO connector_source_instance_migrations (old_id, new_id)
+SELECT
+  'composio:' || connector_id || ':' || id,
+  'composio:' || connector_id || ':' || account_id
+FROM connector_connections
+WHERE provider = 'composio';
+
+UPDATE knowledge_source_items
+SET source_instance_id = (
+  SELECT new_id FROM connector_source_instance_migrations
+  WHERE old_id = knowledge_source_items.source_instance_id
+)
+WHERE source_instance_id IN (SELECT old_id FROM connector_source_instance_migrations);
+
+UPDATE knowledge_sync_runs
+SET source_instance_id = (
+  SELECT new_id FROM connector_source_instance_migrations
+  WHERE old_id = knowledge_sync_runs.source_instance_id
+)
+WHERE source_instance_id IN (SELECT old_id FROM connector_source_instance_migrations);
+
+UPDATE knowledge_collection_state
+SET source_instance_id = (
+  SELECT new_id FROM connector_source_instance_migrations
+  WHERE old_id = knowledge_collection_state.source_instance_id
+)
+WHERE source_instance_id IN (SELECT old_id FROM connector_source_instance_migrations);
+
+UPDATE knowledge_source_changes
+SET source_instance_id = (
+  SELECT new_id FROM connector_source_instance_migrations
+  WHERE old_id = knowledge_source_changes.source_instance_id
+)
+WHERE source_instance_id IN (SELECT old_id FROM connector_source_instance_migrations);
+
+UPDATE knowledge_consumer_watermarks
+SET source_instance_id = (
+  SELECT new_id FROM connector_source_instance_migrations
+  WHERE old_id = knowledge_consumer_watermarks.source_instance_id
+)
+WHERE source_instance_id IN (SELECT old_id FROM connector_source_instance_migrations);
+
+UPDATE user_claim_evidence
+SET source_instance_id = (
+  SELECT new_id FROM connector_source_instance_migrations
+  WHERE old_id = user_claim_evidence.source_instance_id
+)
+WHERE source_instance_id IN (SELECT old_id FROM connector_source_instance_migrations);
+
+UPDATE connector_learning_jobs
+SET source_instance_id = (
+  SELECT new_id FROM connector_source_instance_migrations
+  WHERE old_id = connector_learning_jobs.source_instance_id
+)
+WHERE source_instance_id IN (SELECT old_id FROM connector_source_instance_migrations);
+
+UPDATE memory_records
+SET source_json = json_set(
+  source_json,
+  '$.sourceInstanceId',
+  (SELECT new_id FROM connector_source_instance_migrations
+   WHERE old_id = json_extract(memory_records.source_json, '$.sourceInstanceId'))
+)
+WHERE json_extract(source_json, '$.sourceInstanceId') IN (
+  SELECT old_id FROM connector_source_instance_migrations
+);
+
+DROP TABLE connector_source_instance_migrations;
+
+CREATE UNIQUE INDEX idx_connector_connections_provider_identity
+  ON connector_connections(provider, provider_connection_id);
+CREATE INDEX idx_connector_connections_account
+  ON connector_connections(account_id, status, updated_at DESC);
+
+ALTER TABLE connector_learning_jobs ADD COLUMN account_id TEXT REFERENCES connector_accounts(id) ON DELETE CASCADE;
+UPDATE connector_learning_jobs
+SET account_id = (
+  SELECT account_id FROM connector_connections
+  WHERE connector_connections.id = connector_learning_jobs.connection_id
+);
+CREATE INDEX idx_connector_learning_jobs_account
+  ON connector_learning_jobs(account_id, created_at DESC);
+
+ALTER TABLE connector_sync_policies RENAME TO connector_sync_policies_by_connection;
+
+CREATE TABLE connector_sync_policies (
+  account_id                  TEXT PRIMARY KEY REFERENCES connector_accounts(id) ON DELETE CASCADE,
+  scan_enabled               INTEGER NOT NULL DEFAULT 1 CHECK(scan_enabled IN (0, 1)),
+  proactive_enabled          INTEGER NOT NULL DEFAULT 0 CHECK(proactive_enabled IN (0, 1)),
+  interval_minutes           INTEGER CHECK(interval_minutes IS NULL OR interval_minutes BETWEEN 5 AND 1440),
+  allowed_scenario_keys_json TEXT NOT NULL DEFAULT '[]',
+  revision                   INTEGER NOT NULL DEFAULT 1,
+  updated_at                 INTEGER NOT NULL
+);
+
+INSERT INTO connector_sync_policies (
+  account_id, scan_enabled, proactive_enabled, interval_minutes,
+  allowed_scenario_keys_json, revision, updated_at
+)
+SELECT
+  connector_connections.account_id,
+  connector_sync_policies_by_connection.scan_enabled,
+  connector_sync_policies_by_connection.proactive_enabled,
+  connector_sync_policies_by_connection.interval_minutes,
+  connector_sync_policies_by_connection.allowed_scenario_keys_json,
+  connector_sync_policies_by_connection.revision,
+  connector_sync_policies_by_connection.updated_at
+FROM connector_sync_policies_by_connection
+JOIN connector_connections
+  ON connector_connections.id = connector_sync_policies_by_connection.connection_id;
+
+DROP TABLE connector_sync_policies_by_connection;
+
+CREATE INDEX idx_connector_sync_policies_proactive
+  ON connector_sync_policies(proactive_enabled, account_id);

package/dist/src/storage/sqlite/migrations/108_repair_user_memory_provider.sql

@@ -0,0 +1,18 @@
+UPDATE memory_records
+SET provider_id = 'local'
+WHERE provider_id IN ('personal-context', 'connected-understanding')
+  AND EXISTS (
+    SELECT 1
+    FROM json_each(memory_records.tags_json)
+    WHERE json_each.value = 'user-understanding'
+  );
+
+DELETE FROM memory_records_fts;
+
+INSERT INTO memory_records_fts (
+  content, record_id, provider_id, kind, user_id, source_agent_id, workspace_id
+)
+SELECT
+  content, record_id, provider_id, kind, user_id, source_agent_id, workspace_id
+FROM memory_records
+WHERE trim(content) <> '';

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 = 89;
+export declare const XOPC_DB_SCHEMA_VERSION = 108;
 export declare function resolveMigrationsDir(override?: string): string;
 /**
  * Apply sequential SQL migrations from (currentVersion + 1) through targetVersion.

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

@@ -4,7 +4,7 @@ import { readSchemaVersion, setSchemaVersion } from "../schema-version.js";
 import { discoverSqlMigrations } from "./discover.js";
 import { DatabaseSchemaMigrationGapError, DatabaseSchemaTooNewError } from "./errors.js";
 import { dirname, join } from "node:path";
-import { existsSync } from "node:fs";
+import { chmodSync, existsSync, writeFileSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 //#region src/storage/sqlite/migrations/runner.ts
 init_logger();
@@ -12,8 +12,19 @@ const log = createLogger("Sqlite:Migrations");
 /** Baseline schema version applied from schema.sql on first open. */
 const XOPC_DB_BASELINE_SCHEMA_VERSION = 11;
 /** Latest schema version this release supports (increment when adding migrations). */
-const XOPC_DB_SCHEMA_VERSION = 89;
+const XOPC_DB_SCHEMA_VERSION = 108;
 const MODULE_DIR = dirname(fileURLToPath(import.meta.url));
+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");
@@ -46,23 +57,44 @@ 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 ?? 89;
+	const targetVersion = options.targetVersion ?? 108;
 	let currentVersion = readSchemaVersion(db);
 	if (currentVersion > targetVersion) throw new DatabaseSchemaTooNewError(currentVersion, targetVersion);
 	if (currentVersion >= targetVersion) return currentVersion;
 	const migrations = discoverSqlMigrations(resolveMigrationsDir(options.migrationsDir));
+	let cutoverBackupPath;
 	while (currentVersion < targetVersion) {
 		const nextVersion = currentVersion + 1;
 		const migration = migrationByTarget(migrations, nextVersion);
 		if (!migration) throw new DatabaseSchemaMigrationGapError(currentVersion, targetVersion, nextVersion);
-		applySingleMigration(db, migration);
+		if (nextVersion === 100 && options.databasePath && options.databasePath !== ":memory:") cutoverBackupPath = backupBeforeTaskCutover(db, options.databasePath);
+		try {
+			applySingleMigration(db, migration);
+		} 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()
+			});
+			throw error;
+		}
 		currentVersion = nextVersion;
+		if (cutoverBackupPath && currentVersion === 100) writeMigrationReport(cutoverBackupPath, {
+			fromVersion: 99,
+			targetVersion: 100,
+			status: "succeeded",
+			backupPath: cutoverBackupPath,
+			occurredAt: (/* @__PURE__ */ new Date()).toISOString()
+		});
 	}
 	return currentVersion;
 }
 /** Inspect schema version without mutating the database. */
 function inspectSchemaMigrationStatus(db, options = {}) {
-	const appVersion = options.targetVersion ?? 89;
+	const appVersion = options.targetVersion ?? 108;
 	const dbVersion = readSchemaVersion(db);
 	if (dbVersion > appVersion) return {
 		dbVersion,

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

@@ -1,4 +1,4 @@
-import { existsSync } from 'node:fs';
+import { chmodSync, existsSync, writeFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 
@@ -19,10 +19,24 @@ const log = createLogger('Sqlite:Migrations');
 export const XOPC_DB_BASELINE_SCHEMA_VERSION = 11;
 
 /** Latest schema version this release supports (increment when adding migrations). */
-export const XOPC_DB_SCHEMA_VERSION = 89;
+export const XOPC_DB_SCHEMA_VERSION = 108;
 
 const MODULE_DIR = dirname(fileURLToPath(import.meta.url));
 
+function backupBeforeTaskCutover(db: DatabaseSync, databasePath: string): string {
+  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, 0o600);
+  return backupPath;
+}
+
+function writeMigrationReport(backupPath: string, report: Record<string, unknown>): void {
+  const reportPath = `${backupPath}.report.json`;
+  writeFileSync(reportPath, `${JSON.stringify(report, null, 2)}\n`, { mode: 0o600 });
+}
+
 export function resolveMigrationsDir(override?: string): string {
   if (override) {
     return override;
@@ -84,6 +98,7 @@ export function applyPendingMigrations(
   }
 
   const migrations = discoverSqlMigrations(resolveMigrationsDir(options.migrationsDir));
+  let cutoverBackupPath: string | undefined;
 
   while (currentVersion < targetVersion) {
     const nextVersion = currentVersion + 1;
@@ -91,8 +106,34 @@ export function applyPendingMigrations(
     if (!migration) {
       throw new DatabaseSchemaMigrationGapError(currentVersion, targetVersion, nextVersion);
     }
-    applySingleMigration(db, migration);
+    if (nextVersion === 100 && options.databasePath && options.databasePath !== ':memory:') {
+      cutoverBackupPath = backupBeforeTaskCutover(db, options.databasePath);
+    }
+    try {
+      applySingleMigration(db, migration);
+    } 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: new Date().toISOString(),
+        });
+      }
+      throw error;
+    }
     currentVersion = nextVersion;
+    if (cutoverBackupPath && currentVersion === 100) {
+      writeMigrationReport(cutoverBackupPath, {
+        fromVersion: 99,
+        targetVersion: 100,
+        status: 'succeeded',
+        backupPath: cutoverBackupPath,
+        occurredAt: new Date().toISOString(),
+      });
+    }
   }
 
   return currentVersion;

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

@@ -9,4 +9,6 @@ export type ApplyMigrationsOptions = {
     migrationsDir?: string;
     /** Target schema version. Defaults to {@link XOPC_DB_SCHEMA_VERSION}. */
     targetVersion?: number;
+    /** Database file path used to create the mandatory pre-v100 backup. */
+    databasePath?: string;
 };

package/dist/src/storage/sqlite/migrations/types.ts

@@ -10,4 +10,6 @@ export type ApplyMigrationsOptions = {
   migrationsDir?: string;
   /** Target schema version. Defaults to {@link XOPC_DB_SCHEMA_VERSION}. */
   targetVersion?: number;
+  /** Database file path used to create the mandatory pre-v100 backup. */
+  databasePath?: string;
 };

package/dist/src/storage/sqlite/row-mappers.d.ts

@@ -26,7 +26,6 @@ export type SessionRow = {
     project_id: string | null;
     routing_json: string | null;
     custom_data_json: string | null;
-    abort_cutoff_timestamp: number | null;
     message_count: number;
     estimated_tokens: number;
     compacted_count: number;
@@ -54,6 +53,8 @@ export type SessionConfigRow = {
     model_override: string | null;
     provider_override: string | null;
     working_directory_override: string | null;
+    response_language: string | null;
+    user_context_mode: string | null;
     updated_at: number;
 };
 export declare function sessionRowToMetadata(sessionKey: string, row: SessionRow): SessionMetadata;
@@ -81,7 +82,6 @@ export declare function metadataToSessionInsert(sessionKey: string, sessionId: s
     projectId: string | null;
     routingJson: string | null;
     customDataJson: string | null;
-    abortCutoffTimestamp: number | null;
     messageCount: number;
     estimatedTokens: number;
     compactedCount: number;

package/dist/src/storage/sqlite/row-mappers.js

@@ -47,7 +47,6 @@ function sessionRowToMetadata(sessionKey, row) {
 		projectId: row.project_id ?? void 0,
 		...routing ? { routing } : {},
 		...customData ? { customData } : {},
-		abortCutoffTimestamp: row.abort_cutoff_timestamp ?? void 0,
 		messageCount: row.message_count,
 		estimatedTokens: row.estimated_tokens,
 		compactedCount: row.compacted_count,
@@ -88,7 +87,6 @@ function metadataToSessionInsert(sessionKey, sessionId, metadata, thinkingLevel,
 		projectId: metadata.projectId ?? null,
 		routingJson: metadata.routing ? JSON.stringify(metadata.routing) : null,
 		customDataJson: metadata.customData ? JSON.stringify(metadata.customData) : null,
-		abortCutoffTimestamp: metadata.abortCutoffTimestamp ?? null,
 		messageCount: metadata.messageCount,
 		estimatedTokens: metadata.estimatedTokens,
 		compactedCount: metadata.compactedCount,
@@ -107,6 +105,8 @@ function sessionConfigRowToConfig(row) {
 		...row.model_override ? { modelOverride: row.model_override } : {},
 		...row.provider_override ? { providerOverride: row.provider_override } : {},
 		...row.working_directory_override ? { workingDirectoryOverride: row.working_directory_override } : {},
+		...row.response_language ? { responseLanguage: row.response_language } : {},
+		...row.user_context_mode ? { userContextMode: row.user_context_mode } : {},
 		updatedAt: row.updated_at
 	};
 }

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

@@ -4,4 +4,6 @@ export { XOPC_DB_BASELINE_SCHEMA_VERSION, XOPC_DB_SCHEMA_VERSION, } from './migr
 /**
  * Ensure schema_meta exists, apply baseline schema.sql on first open, then run pending migrations.
  */
-export declare function ensureXopcDatabaseSchema(db: DatabaseSync): void;
+export declare function ensureXopcDatabaseSchema(db: DatabaseSync, options?: {
+    databasePath?: string;
+}): void;

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

@@ -24,14 +24,17 @@ function bootstrapFreshDatabase(db) {
 /**
 * Ensure schema_meta exists, apply baseline schema.sql on first open, then run pending migrations.
 */
-function ensureXopcDatabaseSchema(db) {
+function ensureXopcDatabaseSchema(db, options = {}) {
 	ensureSchemaMetaTable(db);
 	let currentVersion = readSchemaVersion(db);
 	if (currentVersion === 0) {
 		bootstrapFreshDatabase(db);
 		currentVersion = 11;
 	}
-	applyPendingMigrations(db, { targetVersion: 89 });
+	applyPendingMigrations(db, {
+		targetVersion: 108,
+		databasePath: options.databasePath
+	});
 }
 //#endregion
 export { SCHEMA_META_SCHEMA_VERSION_KEY, XOPC_DB_BASELINE_SCHEMA_VERSION, XOPC_DB_SCHEMA_VERSION, ensureSchemaMetaTable, ensureXopcDatabaseSchema, readSchemaVersion, readSchemaVersionForTest, setSchemaVersion };