@iaforged/context-code 1.0.72 → 1.0.74

package/dist/src/utils/model/providerProfilesDb.js

@@ -0,0 +1,886 @@
+import { createRequire } from 'module';
+import { randomUUID } from 'node:crypto';
+import { join } from 'path';
+import { getGlobalConfig, saveGlobalConfig } from '../config.js';
+import { getClaudeConfigHomeDir } from '../envUtils.js';
+import { getFsImplementation } from '../fsOperations.js';
+const require = createRequire(import.meta.url);
+let database = null;
+let initialized = false;
+let sqliteUnavailable = false;
+const DB_FILENAME = 'provider-state.sqlite3';
+const SCHEMA_VERSION = 7;
+const ACTIVE_PROVIDER_STATE_KEY = 'active_provider';
+const ACTIVE_PROFILE_STATE_KEY = 'active_profile_id';
+const PROFILED_PROVIDERS = [
+    'claude',
+    'openai',
+    'openrouter',
+    'ollama',
+    'ollama-cloud',
+    'zai',
+    'minimax',
+];
+const DEFAULT_PROFILE_NAMES = {
+    claude: 'main',
+    openai: 'main',
+    openrouter: 'main',
+    ollama: 'local',
+    'ollama-cloud': 'main',
+    zai: 'main',
+    minimax: 'main',
+};
+const DEFAULT_AGENT_NAMES = {
+    claude: 'claude',
+    openai: 'openai',
+    openrouter: 'openrouter',
+    ollama: 'ollama-local',
+    'ollama-cloud': 'ollama-cloud',
+    zai: 'z-ai',
+    minimax: 'minimax',
+};
+const DEFAULT_PROFILE_BASE_URLS = {
+    openrouter: 'https://openrouter.ai/api/v1',
+    ollama: 'http://localhost:11434/v1',
+    'ollama-cloud': 'http://localhost:11434/v1',
+    zai: 'https://api.z.ai/api/coding/paas/v4',
+    minimax: 'https://api.minimax.io/anthropic',
+};
+const DEFAULT_WORKSPACE_DISPLAY_NAMES = {
+    claude: 'Claude',
+    openai: 'OpenAI',
+    openrouter: 'OpenRouter',
+    ollama: 'Ollama Local',
+    'ollama-cloud': 'Ollama Cloud',
+    zai: 'Z.AI',
+    minimax: 'MiniMax',
+};
+const BASE_URL_PROVIDERS = [
+    'openrouter',
+    'ollama',
+    'ollama-cloud',
+    'zai',
+    'minimax',
+];
+function sanitizeProfileSegment(value) {
+    const normalized = value
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '');
+    return normalized || 'default';
+}
+function buildProfileId(provider, name) {
+    return `${provider}/${sanitizeProfileSegment(name)}`;
+}
+function buildDefaultAgentName(provider, name) {
+    const baseName = DEFAULT_AGENT_NAMES[provider];
+    const segment = sanitizeProfileSegment(name);
+    const defaultSegment = sanitizeProfileSegment(DEFAULT_PROFILE_NAMES[provider]);
+    return segment === defaultSegment ? baseName : `${baseName}-${segment}`;
+}
+function seedDefaultProviderWorkspaces(db) {
+    const now = new Date().toISOString();
+    const insertWorkspace = db.prepare(`
+    INSERT OR IGNORE INTO provider_workspaces (
+      id, provider, display_name, domain_focus, is_enabled, created_at, updated_at
+    ) VALUES (?, ?, ?, ?, ?, ?, ?)
+  `);
+    for (const provider of PROFILED_PROVIDERS) {
+        insertWorkspace.run(randomUUID(), provider, DEFAULT_WORKSPACE_DISPLAY_NAMES[provider], null, 1, now, now);
+    }
+}
+function getDatabasePath() {
+    return join(getClaudeConfigHomeDir(), DB_FILENAME);
+}
+function openDatabase() {
+    if (sqliteUnavailable) {
+        throw new Error('SQLite no disponible en este runtime.');
+    }
+    if (database) {
+        return database;
+    }
+    const fs = getFsImplementation();
+    fs.mkdirSync(getClaudeConfigHomeDir(), { mode: 0o700 });
+    let sqliteModule;
+    try {
+        sqliteModule = require('node:sqlite');
+    }
+    catch (error) {
+        sqliteUnavailable = true;
+        throw error;
+    }
+    database = new sqliteModule.DatabaseSync(getDatabasePath());
+    return database;
+}
+function rowToProfile(row) {
+    if (!row) {
+        return null;
+    }
+    const typed = row;
+    return {
+        id: typed.id,
+        provider: typed.provider,
+        name: typed.name,
+        agentName: typed.agent_name,
+        baseUrl: typed.base_url ?? undefined,
+        lastModel: typed.last_model,
+        createdAt: typed.created_at,
+        updatedAt: typed.updated_at,
+    };
+}
+function seedLegacyProfiles() {
+    const config = getGlobalConfig();
+    const state = config.providerProfiles;
+    const profiles = state && typeof state === 'object' && state.profiles ? state.profiles : {};
+    const lastProfileIdByProvider = state && typeof state === 'object' && state.lastProfileIdByProvider
+        ? state.lastProfileIdByProvider
+        : {};
+    const seededProfiles = {
+        ...profiles,
+    };
+    const seededLastProfileIds = {
+        ...lastProfileIdByProvider,
+    };
+    for (const provider of PROFILED_PROVIDERS) {
+        const alreadyExists = Object.values(seededProfiles).some(profile => profile.provider === provider);
+        const legacyBaseUrl = config.providerBaseUrls?.[provider];
+        const legacyModel = config.lastModelByProvider?.[provider] ?? null;
+        const shouldSeedDefault = alreadyExists ||
+            config.activeProvider === provider ||
+            Boolean(legacyBaseUrl) ||
+            legacyModel !== null;
+        if (!shouldSeedDefault || alreadyExists) {
+            continue;
+        }
+        const name = DEFAULT_PROFILE_NAMES[provider];
+        const id = buildProfileId(provider, name);
+        const now = new Date().toISOString();
+        seededProfiles[id] = {
+            id,
+            provider,
+            name,
+            agentName: buildDefaultAgentName(provider, name),
+            baseUrl: legacyBaseUrl ?? DEFAULT_PROFILE_BASE_URLS[provider],
+            lastModel: legacyModel,
+            createdAt: now,
+            updatedAt: now,
+        };
+        seededLastProfileIds[provider] = id;
+    }
+    const activeProfileId = (state && typeof state === 'object' ? state.activeProfileId : undefined) ??
+        (config.activeProvider &&
+            PROFILED_PROVIDERS.includes(config.activeProvider)
+            ? seededLastProfileIds[config.activeProvider]
+            : undefined);
+    return {
+        version: 1,
+        activeProfileId,
+        lastProfileIdByProvider: seededLastProfileIds,
+        profiles: seededProfiles,
+    };
+}
+function migrateFromLegacyConfig(db) {
+    const config = getGlobalConfig();
+    const seeded = seedLegacyProfiles();
+    const insertProfile = db.prepare(`
+    INSERT OR REPLACE INTO provider_profiles (
+      id, provider, name, agent_name, base_url, last_model, created_at, updated_at
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+  `);
+    const upsertLastProfile = db.prepare(`
+    INSERT INTO provider_last_profile (provider, profile_id)
+    VALUES (?, ?)
+    ON CONFLICT(provider) DO UPDATE SET profile_id = excluded.profile_id
+  `);
+    const upsertRuntime = db.prepare(`
+    INSERT INTO provider_runtime_state (key, value)
+    VALUES (?, ?)
+    ON CONFLICT(key) DO UPDATE SET value = excluded.value
+  `);
+    const upsertLastModel = db.prepare(`
+    INSERT INTO provider_last_model (provider, last_model, updated_at)
+    VALUES (?, ?, ?)
+    ON CONFLICT(provider) DO UPDATE SET
+      last_model = excluded.last_model,
+      updated_at = excluded.updated_at
+  `);
+    const upsertBaseUrl = db.prepare(`
+    INSERT INTO provider_base_url (provider, base_url, updated_at)
+    VALUES (?, ?, ?)
+    ON CONFLICT(provider) DO UPDATE SET
+      base_url = excluded.base_url,
+      updated_at = excluded.updated_at
+  `);
+    for (const profile of Object.values(seeded.profiles ?? {})) {
+        insertProfile.run(profile.id, profile.provider, profile.name, profile.agentName, profile.baseUrl ?? null, profile.lastModel ?? null, profile.createdAt, profile.updatedAt);
+    }
+    for (const [provider, profileId] of Object.entries(seeded.lastProfileIdByProvider ?? {})) {
+        if (profileId) {
+            upsertLastProfile.run(provider, profileId);
+        }
+    }
+    if (seeded.activeProfileId) {
+        upsertRuntime.run(ACTIVE_PROFILE_STATE_KEY, seeded.activeProfileId);
+    }
+    const legacyActiveProvider = config.activeProvider ??
+        (seeded.activeProfileId
+            ? seeded.profiles?.[seeded.activeProfileId]?.provider
+            : undefined);
+    if (legacyActiveProvider) {
+        upsertRuntime.run(ACTIVE_PROVIDER_STATE_KEY, legacyActiveProvider);
+    }
+    const legacyLastModels = {
+        claude: config.lastClaudeModel ??
+            config.lastModelByProvider?.claude ??
+            null,
+        openai: config.lastOpenAIModel ?? config.lastModelByProvider?.openai ?? null,
+        openrouter: config.lastOpenRouterModel ??
+            config.lastModelByProvider?.openrouter ??
+            null,
+        ollama: config.lastModelByProvider?.ollama ?? null,
+        'ollama-cloud': config.lastModelByProvider?.['ollama-cloud'] ?? null,
+        zai: config.lastModelByProvider?.zai ?? null,
+        minimax: config.lastModelByProvider?.minimax ?? null,
+    };
+    for (const provider of PROFILED_PROVIDERS) {
+        upsertLastModel.run(provider, legacyLastModels[provider] ?? null, new Date().toISOString());
+    }
+    for (const provider of BASE_URL_PROVIDERS) {
+        const baseUrl = config.providerBaseUrls?.[provider];
+        if (typeof baseUrl === 'string' && baseUrl.trim()) {
+            upsertBaseUrl.run(provider, baseUrl.trim(), new Date().toISOString());
+        }
+    }
+}
+export function purgeLegacyProviderStateInConfig() {
+    if (!hasLegacyProviderStateInConfig()) {
+        return;
+    }
+    saveGlobalConfig(config => ({
+        ...config,
+        activeProvider: undefined,
+        lastModelByProvider: {},
+        providerBaseUrls: undefined,
+        lastOpenAIModel: undefined,
+        lastClaudeModel: undefined,
+        lastOpenRouterModel: undefined,
+        providerProfiles: undefined,
+    }));
+}
+export function finalizeProviderProfilesMigration() {
+    ensureInitialized();
+    purgeLegacyProviderStateInConfig();
+}
+function ensureInitialized() {
+    const db = openDatabase();
+    if (initialized) {
+        return db;
+    }
+    db.exec(`
+    PRAGMA journal_mode = WAL;
+    PRAGMA foreign_keys = ON;
+    PRAGMA synchronous = NORMAL;
+
+    CREATE TABLE IF NOT EXISTS provider_profiles (
+      id TEXT PRIMARY KEY,
+      provider TEXT NOT NULL,
+      name TEXT NOT NULL,
+      agent_name TEXT NOT NULL,
+      base_url TEXT NULL,
+      last_model TEXT NULL,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS provider_last_profile (
+      provider TEXT PRIMARY KEY,
+      profile_id TEXT NOT NULL,
+      FOREIGN KEY (profile_id) REFERENCES provider_profiles(id) ON DELETE CASCADE
+    );
+
+    CREATE TABLE IF NOT EXISTS provider_runtime_state (
+      key TEXT PRIMARY KEY,
+      value TEXT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS provider_last_model (
+      provider TEXT PRIMARY KEY,
+      last_model TEXT NULL,
+      updated_at TEXT NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS provider_base_url (
+      provider TEXT PRIMARY KEY,
+      base_url TEXT NOT NULL,
+      updated_at TEXT NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS provider_workspaces (
+      id TEXT PRIMARY KEY,
+      provider TEXT NOT NULL UNIQUE,
+      display_name TEXT NOT NULL,
+      domain_focus TEXT NULL,
+      is_enabled INTEGER NOT NULL DEFAULT 1,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS provider_agents (
+      id TEXT PRIMARY KEY,
+      workspace_id TEXT NOT NULL,
+      profile_id TEXT NOT NULL,
+      name TEXT NOT NULL,
+      role_kind TEXT NULL,
+      system_prompt TEXT NULL,
+      model_override TEXT NULL,
+      tool_policy TEXT NULL,
+      autonomy_level TEXT NULL,
+      is_orchestrator INTEGER NOT NULL DEFAULT 0,
+      is_enabled INTEGER NOT NULL DEFAULT 1,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL,
+      FOREIGN KEY (workspace_id) REFERENCES provider_workspaces(id) ON DELETE CASCADE,
+      FOREIGN KEY (profile_id) REFERENCES provider_profiles(id) ON DELETE CASCADE,
+      UNIQUE (workspace_id, name)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_provider_agents_workspace_id
+      ON provider_agents(workspace_id);
+    CREATE INDEX IF NOT EXISTS idx_provider_agents_profile_id
+      ON provider_agents(profile_id);
+
+    CREATE TABLE IF NOT EXISTS provider_agent_capabilities (
+      id TEXT PRIMARY KEY,
+      agent_id TEXT NOT NULL,
+      capability TEXT NOT NULL,
+      weight REAL NOT NULL DEFAULT 1,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL,
+      FOREIGN KEY (agent_id) REFERENCES provider_agents(id) ON DELETE CASCADE,
+      UNIQUE (agent_id, capability)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_provider_agent_capabilities_agent_id
+      ON provider_agent_capabilities(agent_id);
+
+    CREATE TABLE IF NOT EXISTS teams (
+      id TEXT PRIMARY KEY,
+      name TEXT NOT NULL UNIQUE,
+      description TEXT NULL,
+      global_orchestrator_agent_id TEXT NULL,
+      is_enabled INTEGER NOT NULL DEFAULT 1,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL,
+      FOREIGN KEY (global_orchestrator_agent_id) REFERENCES provider_agents(id) ON DELETE SET NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS team_domains (
+      id TEXT PRIMARY KEY,
+      team_id TEXT NOT NULL,
+      domain_name TEXT NOT NULL,
+      workspace_id TEXT NULL,
+      local_orchestrator_agent_id TEXT NULL,
+      lead_agent_id TEXT NULL,
+      selection_mode TEXT NOT NULL DEFAULT 'manual',
+      required INTEGER NOT NULL DEFAULT 0,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL,
+      FOREIGN KEY (team_id) REFERENCES teams(id) ON DELETE CASCADE,
+      FOREIGN KEY (workspace_id) REFERENCES provider_workspaces(id) ON DELETE SET NULL,
+      FOREIGN KEY (local_orchestrator_agent_id) REFERENCES provider_agents(id) ON DELETE SET NULL,
+      FOREIGN KEY (lead_agent_id) REFERENCES provider_agents(id) ON DELETE SET NULL,
+      UNIQUE (team_id, domain_name)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_team_domains_team_id
+      ON team_domains(team_id);
+    CREATE INDEX IF NOT EXISTS idx_team_domains_workspace_id
+      ON team_domains(workspace_id);
+    CREATE INDEX IF NOT EXISTS idx_team_domains_local_orchestrator_agent_id
+      ON team_domains(local_orchestrator_agent_id);
+    CREATE INDEX IF NOT EXISTS idx_team_domains_lead_agent_id
+      ON team_domains(lead_agent_id);
+
+    CREATE TABLE IF NOT EXISTS team_domain_members (
+      id TEXT PRIMARY KEY,
+      team_domain_id TEXT NOT NULL,
+      agent_id TEXT NOT NULL,
+      duty TEXT NULL,
+      priority INTEGER NOT NULL DEFAULT 0,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL,
+      FOREIGN KEY (team_domain_id) REFERENCES team_domains(id) ON DELETE CASCADE,
+      FOREIGN KEY (agent_id) REFERENCES provider_agents(id) ON DELETE CASCADE,
+      UNIQUE (team_domain_id, agent_id)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_team_domain_members_team_domain_id
+      ON team_domain_members(team_domain_id);
+    CREATE INDEX IF NOT EXISTS idx_team_domain_members_agent_id
+      ON team_domain_members(agent_id);
+
+    CREATE TABLE IF NOT EXISTS orchestration_runs (
+      id TEXT PRIMARY KEY,
+      team_id TEXT NOT NULL,
+      goal TEXT NOT NULL,
+      global_orchestrator_agent_id TEXT NULL,
+      status TEXT NOT NULL,
+      created_at TEXT NOT NULL,
+      started_at TEXT NULL,
+      finished_at TEXT NULL,
+      FOREIGN KEY (team_id) REFERENCES teams(id) ON DELETE CASCADE,
+      FOREIGN KEY (global_orchestrator_agent_id) REFERENCES provider_agents(id) ON DELETE SET NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_orchestration_runs_team_id
+      ON orchestration_runs(team_id);
+    CREATE INDEX IF NOT EXISTS idx_orchestration_runs_status
+      ON orchestration_runs(status);
+
+    CREATE TABLE IF NOT EXISTS orchestration_tasks (
+      id TEXT PRIMARY KEY,
+      run_id TEXT NOT NULL,
+      parent_task_id TEXT NULL,
+      scope_type TEXT NOT NULL,
+      team_domain_id TEXT NULL,
+      assigned_agent_id TEXT NULL,
+      title TEXT NOT NULL,
+      instructions TEXT NOT NULL,
+      status TEXT NOT NULL,
+      result_summary TEXT NULL,
+      created_at TEXT NOT NULL,
+      finished_at TEXT NULL,
+      FOREIGN KEY (run_id) REFERENCES orchestration_runs(id) ON DELETE CASCADE,
+      FOREIGN KEY (parent_task_id) REFERENCES orchestration_tasks(id) ON DELETE SET NULL,
+      FOREIGN KEY (team_domain_id) REFERENCES team_domains(id) ON DELETE SET NULL,
+      FOREIGN KEY (assigned_agent_id) REFERENCES provider_agents(id) ON DELETE SET NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_orchestration_tasks_run_id
+      ON orchestration_tasks(run_id);
+    CREATE INDEX IF NOT EXISTS idx_orchestration_tasks_team_domain_id
+      ON orchestration_tasks(team_domain_id);
+    CREATE INDEX IF NOT EXISTS idx_orchestration_tasks_assigned_agent_id
+      ON orchestration_tasks(assigned_agent_id);
+
+    CREATE TABLE IF NOT EXISTS orchestration_messages (
+      id TEXT PRIMARY KEY,
+      run_id TEXT NOT NULL,
+      task_id TEXT NULL,
+      from_agent_id TEXT NULL,
+      to_agent_id TEXT NULL,
+      message_type TEXT NOT NULL,
+      content TEXT NOT NULL,
+      created_at TEXT NOT NULL,
+      FOREIGN KEY (run_id) REFERENCES orchestration_runs(id) ON DELETE CASCADE,
+      FOREIGN KEY (task_id) REFERENCES orchestration_tasks(id) ON DELETE SET NULL,
+      FOREIGN KEY (from_agent_id) REFERENCES provider_agents(id) ON DELETE SET NULL,
+      FOREIGN KEY (to_agent_id) REFERENCES provider_agents(id) ON DELETE SET NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_orchestration_messages_run_id
+      ON orchestration_messages(run_id);
+    CREATE INDEX IF NOT EXISTS idx_orchestration_messages_task_id
+      ON orchestration_messages(task_id);
+
+    CREATE TABLE IF NOT EXISTS orchestration_task_results (
+      id TEXT PRIMARY KEY,
+      run_id TEXT NOT NULL,
+      task_id TEXT NOT NULL,
+      agent_id TEXT NULL,
+      result_type TEXT NOT NULL,
+      status TEXT NOT NULL,
+      summary TEXT NULL,
+      content TEXT NULL,
+      metadata_json TEXT NULL,
+      created_at TEXT NOT NULL,
+      FOREIGN KEY (run_id) REFERENCES orchestration_runs(id) ON DELETE CASCADE,
+      FOREIGN KEY (task_id) REFERENCES orchestration_tasks(id) ON DELETE CASCADE,
+      FOREIGN KEY (agent_id) REFERENCES provider_agents(id) ON DELETE SET NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_orchestration_task_results_run_id
+      ON orchestration_task_results(run_id);
+    CREATE INDEX IF NOT EXISTS idx_orchestration_task_results_task_id
+      ON orchestration_task_results(task_id);
+    CREATE INDEX IF NOT EXISTS idx_orchestration_task_results_agent_id
+      ON orchestration_task_results(agent_id);
+
+    CREATE TABLE IF NOT EXISTS orchestration_domain_reports (
+      id TEXT PRIMARY KEY,
+      run_id TEXT NOT NULL,
+      team_domain_id TEXT NOT NULL,
+      local_orchestrator_agent_id TEXT NULL,
+      status TEXT NOT NULL,
+      summary TEXT NOT NULL,
+      blockers TEXT NULL,
+      output TEXT NULL,
+      metrics_json TEXT NULL,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL,
+      submitted_at TEXT NULL,
+      FOREIGN KEY (run_id) REFERENCES orchestration_runs(id) ON DELETE CASCADE,
+      FOREIGN KEY (team_domain_id) REFERENCES team_domains(id) ON DELETE CASCADE,
+      FOREIGN KEY (local_orchestrator_agent_id) REFERENCES provider_agents(id) ON DELETE SET NULL,
+      UNIQUE (run_id, team_domain_id)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_orchestration_domain_reports_run_id
+      ON orchestration_domain_reports(run_id);
+    CREATE INDEX IF NOT EXISTS idx_orchestration_domain_reports_team_domain_id
+      ON orchestration_domain_reports(team_domain_id);
+
+    CREATE TABLE IF NOT EXISTS orchestration_run_reports (
+      id TEXT PRIMARY KEY,
+      run_id TEXT NOT NULL UNIQUE,
+      status TEXT NOT NULL,
+      summary TEXT NOT NULL,
+      output TEXT NULL,
+      risks TEXT NULL,
+      next_steps TEXT NULL,
+      metrics_json TEXT NULL,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL,
+      submitted_at TEXT NULL,
+      FOREIGN KEY (run_id) REFERENCES orchestration_runs(id) ON DELETE CASCADE
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_orchestration_run_reports_run_id
+      ON orchestration_run_reports(run_id);
+
+    CREATE TABLE IF NOT EXISTS provider_agent_capability_rankings (
+      id TEXT PRIMARY KEY,
+      team_domain_id TEXT NULL,
+      capability TEXT NOT NULL,
+      agent_id TEXT NOT NULL,
+      score REAL NOT NULL DEFAULT 0,
+      reason TEXT NULL,
+      source TEXT NULL,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL,
+      FOREIGN KEY (team_domain_id) REFERENCES team_domains(id) ON DELETE CASCADE,
+      FOREIGN KEY (agent_id) REFERENCES provider_agents(id) ON DELETE CASCADE,
+      UNIQUE (team_domain_id, capability, agent_id)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_provider_agent_capability_rankings_domain
+      ON provider_agent_capability_rankings(team_domain_id);
+    CREATE INDEX IF NOT EXISTS idx_provider_agent_capability_rankings_capability
+      ON provider_agent_capability_rankings(capability);
+    CREATE INDEX IF NOT EXISTS idx_provider_agent_capability_rankings_agent
+      ON provider_agent_capability_rankings(agent_id);
+
+    CREATE TABLE IF NOT EXISTS secure_storage (
+      key TEXT PRIMARY KEY,
+      value TEXT NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS projects (
+      path TEXT PRIMARY KEY,
+      name TEXT NOT NULL,
+      created_at TEXT NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS permission_rules (
+      id TEXT PRIMARY KEY,
+      scope TEXT NOT NULL,
+      scope_path TEXT NULL,
+      tool_name TEXT NOT NULL,
+      behavior TEXT NOT NULL,
+      created_at TEXT NOT NULL,
+      expires_at TEXT NULL,
+      UNIQUE (scope, scope_path, tool_name)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_permission_rules_scope
+      ON permission_rules(scope, scope_path);
+    CREATE INDEX IF NOT EXISTS idx_permission_rules_tool_name
+      ON permission_rules(tool_name);
+
+    CREATE TABLE IF NOT EXISTS permission_mode_config (
+      id TEXT PRIMARY KEY,
+      scope TEXT NOT NULL,
+      scope_path TEXT NULL,
+      mode TEXT NOT NULL,
+      updated_at TEXT NOT NULL,
+      UNIQUE (scope, scope_path)
+    );
+
+    CREATE TABLE IF NOT EXISTS trusted_directories (
+      path TEXT PRIMARY KEY,
+      trust_level TEXT NOT NULL DEFAULT 'full',
+      created_at TEXT NOT NULL
+    );
+  `);
+    const userVersionRow = db
+        .prepare(`PRAGMA user_version`)
+        .get();
+    if ((userVersionRow?.user_version ?? 0) < SCHEMA_VERSION) {
+        db.exec(`PRAGMA user_version = ${SCHEMA_VERSION}`);
+    }
+    seedDefaultProviderWorkspaces(db);
+    const existingProfiles = db
+        .prepare(`SELECT COUNT(*) AS count FROM provider_profiles`)
+        .get();
+    if ((existingProfiles?.count ?? 0) === 0) {
+        migrateFromLegacyConfig(db);
+    }
+    else {
+        const lastModelCount = db
+            .prepare(`SELECT COUNT(*) AS count FROM provider_last_model`)
+            .get();
+        if ((lastModelCount?.count ?? 0) === 0) {
+            migrateFromLegacyConfig(db);
+        }
+        const baseUrlCount = db
+            .prepare(`SELECT COUNT(*) AS count FROM provider_base_url`)
+            .get();
+        if ((baseUrlCount?.count ?? 0) === 0) {
+            migrateFromLegacyConfig(db);
+        }
+    }
+    purgeLegacyProviderStateInConfig();
+    initialized = true;
+    return db;
+}
+export class ProviderProfilesDb {
+    static instance = null;
+    db;
+    constructor() {
+        this.db = ensureInitialized();
+    }
+    static async get() {
+        if (!ProviderProfilesDb.instance) {
+            ProviderProfilesDb.instance = new ProviderProfilesDb();
+        }
+        return ProviderProfilesDb.instance;
+    }
+}
+export function getProviderProfilesDbPath() {
+    return getDatabasePath();
+}
+export function getProviderProfilesStorageBackend() {
+    try {
+        ensureInitialized();
+        return 'sqlite';
+    }
+    catch {
+        return 'legacy';
+    }
+}
+export function hasLegacyProviderStateInConfig() {
+    try {
+        const config = getGlobalConfig();
+        return Boolean(config.activeProvider ||
+            config.lastClaudeModel ||
+            config.lastOpenAIModel ||
+            config.lastOpenRouterModel ||
+            Object.keys(config.lastModelByProvider ?? {}).length > 0 ||
+            Object.keys(config.providerBaseUrls ?? {}).length > 0 ||
+            config.providerProfiles?.activeProfileId ||
+            Object.keys(config.providerProfiles?.profiles ?? {}).length > 0 ||
+            Object.keys(config.providerProfiles?.lastProfileIdByProvider ?? {})
+                .length > 0);
+    }
+    catch {
+        return false;
+    }
+}
+export function getProviderProfilesStorageMode() {
+    if (getProviderProfilesStorageBackend() !== 'sqlite') {
+        return 'legacy';
+    }
+    return hasLegacyProviderStateInConfig()
+        ? 'sqlite-migration-pending'
+        : 'sqlite-only';
+}
+export function readProviderProfilesState() {
+    let db;
+    try {
+        db = ensureInitialized();
+    }
+    catch {
+        return seedLegacyProfiles();
+    }
+    const profiles = db
+        .prepare(`SELECT id, provider, name, agent_name, base_url, last_model, created_at, updated_at
+       FROM provider_profiles
+       ORDER BY provider, created_at, id`)
+        .all()
+        .map(rowToProfile)
+        .filter((profile) => profile !== null);
+    const lastProfileRows = db
+        .prepare(`SELECT provider, profile_id FROM provider_last_profile`)
+        .all();
+    const activeProfileRow = db
+        .prepare(`SELECT value FROM provider_runtime_state WHERE key = '${ACTIVE_PROFILE_STATE_KEY}'`)
+        .get();
+    return {
+        version: 1,
+        activeProfileId: activeProfileRow?.value,
+        lastProfileIdByProvider: Object.fromEntries(lastProfileRows.map(row => [row.provider, row.profile_id])),
+        profiles: Object.fromEntries(profiles.map(profile => [profile.id, profile])),
+    };
+}
+export function writeProviderProfilesState(state) {
+    let db;
+    try {
+        db = ensureInitialized();
+    }
+    catch {
+        return;
+    }
+    const profiles = Object.values(state.profiles ?? {});
+    const shouldClearRuntime = profiles.length === 0;
+    db.exec('BEGIN');
+    try {
+        db.exec(`DELETE FROM provider_last_profile`);
+        db.exec(`DELETE FROM provider_runtime_state WHERE key = '${ACTIVE_PROFILE_STATE_KEY}'`);
+        db.exec(`DELETE FROM provider_profiles`);
+        if (shouldClearRuntime) {
+            db.exec(`DELETE FROM provider_runtime_state WHERE key = '${ACTIVE_PROVIDER_STATE_KEY}'`);
+            db.exec(`DELETE FROM provider_last_model`);
+            db.exec(`DELETE FROM provider_base_url`);
+        }
+        const insertProfile = db.prepare(`
+      INSERT INTO provider_profiles (
+        id, provider, name, agent_name, base_url, last_model, created_at, updated_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+        for (const profile of profiles) {
+            insertProfile.run(profile.id, profile.provider, profile.name, profile.agentName, profile.baseUrl ?? null, profile.lastModel ?? null, profile.createdAt, profile.updatedAt);
+        }
+        const insertLastProfile = db.prepare(`
+      INSERT INTO provider_last_profile (provider, profile_id)
+      VALUES (?, ?)
+    `);
+        for (const [provider, profileId] of Object.entries(state.lastProfileIdByProvider ?? {})) {
+            if (profileId) {
+                insertLastProfile.run(provider, profileId);
+            }
+        }
+        if (state.activeProfileId) {
+            db.prepare(`
+        INSERT INTO provider_runtime_state (key, value)
+        VALUES ('${ACTIVE_PROFILE_STATE_KEY}', ?)
+      `).run(state.activeProfileId);
+        }
+        db.exec('COMMIT');
+    }
+    catch (error) {
+        db.exec('ROLLBACK');
+        throw error;
+    }
+}
+function readRuntimeStateValue(key) {
+    try {
+        const db = ensureInitialized();
+        const row = db
+            .prepare(`SELECT value FROM provider_runtime_state WHERE key = ?`)
+            .get(key);
+        return row?.value ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+function writeRuntimeStateValue(key, value) {
+    try {
+        const db = ensureInitialized();
+        if (value === null) {
+            db.prepare(`DELETE FROM provider_runtime_state WHERE key = ?`).run(key);
+            return;
+        }
+        db.prepare(`
+      INSERT INTO provider_runtime_state (key, value)
+      VALUES (?, ?)
+      ON CONFLICT(key) DO UPDATE SET value = excluded.value
+    `).run(key, value);
+    }
+    catch {
+        // Fallback legacy mode writes to config through existing callers.
+    }
+}
+function upsertLastModelForProvider(provider, model) {
+    try {
+        const db = ensureInitialized();
+        db.prepare(`
+      INSERT INTO provider_last_model (provider, last_model, updated_at)
+      VALUES (?, ?, ?)
+      ON CONFLICT(provider) DO UPDATE SET
+        last_model = excluded.last_model,
+        updated_at = excluded.updated_at
+    `).run(provider, model, new Date().toISOString());
+    }
+    catch {
+        // Legacy fallback handled by callers.
+    }
+}
+export function getStoredActiveProviderPreference() {
+    const stored = readRuntimeStateValue(ACTIVE_PROVIDER_STATE_KEY);
+    if (stored !== null) {
+        return stored;
+    }
+    return null;
+}
+export function setStoredActiveProviderPreference(provider) {
+    writeRuntimeStateValue(ACTIVE_PROVIDER_STATE_KEY, provider);
+}
+export function getStoredLastModelForProvider(provider) {
+    try {
+        const db = ensureInitialized();
+        const row = db
+            .prepare(`SELECT last_model FROM provider_last_model WHERE provider = ?`)
+            .get(provider);
+        if (row && Object.prototype.hasOwnProperty.call(row, 'last_model')) {
+            return row.last_model ?? null;
+        }
+    }
+    catch {
+        return undefined;
+    }
+    return undefined;
+}
+export function setStoredLastModelForProvider(provider, model) {
+    upsertLastModelForProvider(provider, model);
+}
+export function getStoredProviderBaseUrl(provider) {
+    try {
+        const db = ensureInitialized();
+        const row = db
+            .prepare(`SELECT base_url FROM provider_base_url WHERE provider = ?`)
+            .get(provider);
+        if (row?.base_url?.trim()) {
+            return row.base_url.trim();
+        }
+    }
+    catch {
+        return undefined;
+    }
+    return undefined;
+}
+export function setStoredProviderBaseUrl(provider, baseUrl) {
+    try {
+        const db = ensureInitialized();
+        db.prepare(`
+      INSERT INTO provider_base_url (provider, base_url, updated_at)
+      VALUES (?, ?, ?)
+      ON CONFLICT(provider) DO UPDATE SET
+        base_url = excluded.base_url,
+        updated_at = excluded.updated_at
+    `).run(provider, baseUrl, new Date().toISOString());
+    }
+    catch {
+        // Legacy fallback handled by callers.
+    }
+}
+export function clearStoredProviderBaseUrl(provider) {
+    try {
+        const db = ensureInitialized();
+        db.prepare(`DELETE FROM provider_base_url WHERE provider = ?`).run(provider);
+    }
+    catch {
+        // Legacy fallback handled by callers.
+    }
+}