funolio-agent 1.0.53 → 1.1.65

package/dist/commands/start.js

@@ -36,6 +36,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapServerBotsToAgents = mapServerBotsToAgents;
+exports.isServerSeedAgentId = isServerSeedAgentId;
+exports.selectPreferredActiveAgentId = selectPreferredActiveAgentId;
+exports.normalizeLocalModeAgents = normalizeLocalModeAgents;
 exports.startCommand = startCommand;
 const path = __importStar(require("path"));
 const fs = __importStar(require("fs"));
@@ -45,14 +49,18 @@ const chalk_1 = __importDefault(require("chalk"));
 const config_1 = require("../config");
 const mqtt_client_1 = require("../mqtt-client");
 const bot_manager_1 = require("../bot-manager");
+const mqtt_data_relay_1 = require("../mqtt-data-relay");
 const service_mode_1 = require("../service-mode");
 const index_1 = require("../providers/index");
 const sync_cli_config_1 = require("../mcp/sync-cli-config");
 const agent_config_1 = require("../agent-config");
+const service_setup_only_1 = require("../service-setup-only");
 // refreshOAuthToken removed — token refresh now handled per-request in message-loop.ts
 const local_db_1 = require("../local-db");
 const local_server_1 = require("../local-server");
 const data = __importStar(require("../local-data"));
+const chat_sync_1 = require("../chat-sync");
+const pool_1 = require("./pool");
 const AUTH_SESSION_KEY = 'auth.session';
 const DESKTOP_PREFS_KEY = 'desktop.preferences';
 const WIZARD_PROFILE_KEY = 'wizard.profile';
@@ -60,6 +68,58 @@ const LOCAL_SERVER_PORT = Number(process.env.FUNOLIO_LOCAL_PORT || 18420);
 const MESSAGE_ACTIVITY_RETENTION_HOURS = 24;
 const MAINTENANCE_INTERVAL_MS = 5 * 60 * 1000;
 const AGENT_IDLE_RESTART_MS = 30 * 60 * 1000;
+const LAST_MAINTENANCE_RESTART_KEY = 'agent.last_maintenance_restart_at';
+const MIN_MAINTENANCE_RESTART_INTERVAL_MS = 20 * 60 * 60 * 1000;
+const SERVICE_LOCK_FILENAME = 'service.lock';
+function resolveServiceLockPath() {
+    return path.join((0, config_1.getConfigDir)(), SERVICE_LOCK_FILENAME);
+}
+function isPidAlive(pid) {
+    if (!Number.isFinite(pid) || pid <= 0)
+        return false;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function releaseServiceLock(lockPath) {
+    try {
+        if (fs.existsSync(lockPath))
+            fs.unlinkSync(lockPath);
+    }
+    catch {
+        // best effort
+    }
+}
+function acquireServiceLock(mode, userId) {
+    const lockPath = resolveServiceLockPath();
+    if (fs.existsSync(lockPath)) {
+        try {
+            const existing = JSON.parse(fs.readFileSync(lockPath, 'utf8'));
+            if (existing?.pid && isPidAlive(existing.pid)) {
+                return { lockPath, acquired: false, existingPid: existing.pid };
+            }
+            fs.unlinkSync(lockPath);
+        }
+        catch {
+            try {
+                fs.unlinkSync(lockPath);
+            }
+            catch { }
+        }
+    }
+    const payload = {
+        pid: process.pid,
+        createdAt: new Date().toISOString(),
+        mode,
+        userId,
+    };
+    fs.writeFileSync(lockPath, JSON.stringify(payload));
+    return { lockPath, acquired: true };
+}
 function cleanupExpiredMessageActivityRows() {
     try {
         const deleted = data.deleteExpiredMessageActivities();
@@ -78,7 +138,17 @@ function readLastInteractionAtMs() {
     const parsed = Date.parse(raw);
     return Number.isNaN(parsed) ? 0 : parsed;
 }
-function shouldRunNightlyRestart(now, lastInteractionAtMs, botManager) {
+function readLastMaintenanceRestartAtMs() {
+    const raw = data.getSetting(LAST_MAINTENANCE_RESTART_KEY);
+    if (!raw)
+        return 0;
+    const parsed = Date.parse(raw);
+    return Number.isNaN(parsed) ? 0 : parsed;
+}
+function markMaintenanceRestartAt(now) {
+    data.setSetting(LAST_MAINTENANCE_RESTART_KEY, now.toISOString());
+}
+function shouldRunNightlyRestart(now, lastInteractionAtMs, lastMaintenanceRestartAtMs, botManager, processStartAtMs) {
     const hour = now.getHours();
     if (hour < 1 || hour >= 4)
         return false;
@@ -86,7 +156,282 @@ function shouldRunNightlyRestart(now, lastInteractionAtMs, botManager) {
         return false;
     if (!lastInteractionAtMs)
         return false;
-    return (now.getTime() - lastInteractionAtMs) >= AGENT_IDLE_RESTART_MS;
+    if (lastMaintenanceRestartAtMs && (now.getTime() - lastMaintenanceRestartAtMs) < MIN_MAINTENANCE_RESTART_INTERVAL_MS)
+        return false;
+    // Count idle from the most recent of (process start, last interaction). Without this
+    // floor, a stale `agent.last_interaction_at` value in local.db would make the timer
+    // fire ~5 minutes after a cold start instead of after a real idle window.
+    const idleReference = Math.max(lastInteractionAtMs, processStartAtMs);
+    return (now.getTime() - idleReference) >= AGENT_IDLE_RESTART_MS;
+}
+function isAgentPermissionMode(value) {
+    return value === 'autopilot' || value === 'approve-destructive' || value === 'approve-all';
+}
+function toManagedAgentConfigName(agent) {
+    const safeName = (agent.name || 'agent')
+        .toLowerCase()
+        .replace(/[^a-z0-9-_]+/g, '-')
+        .replace(/^-+|-+$/g, '')
+        .slice(0, 24) || 'agent';
+    const safeId = (agent.id || 'bot')
+        .toLowerCase()
+        .replace(/[^a-z0-9]/g, '')
+        .slice(0, 12) || 'bot';
+    return `managed-${safeName}-${safeId}`;
+}
+function mapServerBotsToAgents(serverBots, existingAgents = []) {
+    const existingById = new Map(existingAgents.map((agent) => [agent.id, agent]));
+    const mappedById = new Map(serverBots
+        .filter((bot) => !!bot?.id && !!bot?.name)
+        .map((bot) => {
+        const existing = existingById.get(bot.id);
+        return [
+            bot.id,
+            {
+                id: bot.id,
+                name: bot.name,
+                projectDir: existing?.projectDir || '.',
+                provider: bot.llmProvider || existing?.provider || bot.runtimeProvider || 'openai',
+                model: bot.llmModel || existing?.model || bot.runtimeModel || 'claude-opus-4-6',
+                runtimeProvider: bot.runtimeProvider || existing?.runtimeProvider || undefined,
+                runtimeModel: bot.runtimeModel || existing?.runtimeModel || undefined,
+                accessMode: bot.accessMode || existing?.accessMode || undefined,
+                enabledTools: Array.isArray(bot.tools) ? bot.tools : existing?.enabledTools,
+                enabledMcpTools: Array.isArray(bot.enabledMcpTools) ? bot.enabledMcpTools : existing?.enabledMcpTools,
+                permissionMode: isAgentPermissionMode(bot.permissionMode)
+                    ? bot.permissionMode
+                    : (existing?.permissionMode || 'autopilot'),
+                systemPrompt: existing?.systemPrompt,
+                agentDescription: existing?.agentDescription,
+                createdAt: existing?.createdAt || new Date().toISOString(),
+            },
+        ];
+    }));
+    const merged = [];
+    for (const existing of existingAgents) {
+        const mapped = mappedById.get(existing.id);
+        merged.push(mapped || existing);
+        if (mapped)
+            mappedById.delete(existing.id);
+    }
+    for (const mapped of mappedById.values()) {
+        merged.push(mapped);
+    }
+    return merged;
+}
+function isServerSeedAgentId(agentId) {
+    return typeof agentId === 'string' && /^seed-bot-/i.test(agentId);
+}
+function selectPreferredActiveAgentId(agents, providers, preferredId) {
+    if (!Array.isArray(agents) || agents.length === 0)
+        return null;
+    const providerIds = new Set((providers || []).map((provider) => provider.id));
+    const isRunnable = (agent) => providerIds.has(agent.runtimeProvider || agent.provider);
+    const preferred = preferredId ? agents.find((agent) => agent.id === preferredId) : undefined;
+    if (preferred && isRunnable(preferred))
+        return preferred.id;
+    const firstRunnable = agents.find(isRunnable);
+    if (firstRunnable)
+        return firstRunnable.id;
+    return preferred?.id || agents[0]?.id || null;
+}
+function normalizeLocalModeAgents(config) {
+    const existingAgents = Array.isArray(config.agents) ? config.agents : [];
+    const filteredAgents = existingAgents.filter((agent) => !isServerSeedAgentId(agent.id));
+    const removedCount = existingAgents.length - filteredAgents.length;
+    const preferredId = isServerSeedAgentId(config.activeAgentId) ? null : config.activeAgentId;
+    const selectedActiveAgentId = selectPreferredActiveAgentId(filteredAgents, config.providers, preferredId);
+    let changed = false;
+    if (removedCount > 0) {
+        config.agents = filteredAgents;
+        changed = true;
+    }
+    if ((selectedActiveAgentId || null) !== (config.activeAgentId || null)) {
+        config.activeAgentId = selectedActiveAgentId || undefined;
+        changed = true;
+    }
+    return { changed, removedCount };
+}
+function syncConfiguredAgentsToLocalConfigs(agents) {
+    if (!Array.isArray(agents) || agents.length === 0)
+        return;
+    let synced = 0;
+    for (const agent of agents) {
+        if (!agent?.id)
+            continue;
+        const configName = toManagedAgentConfigName(agent);
+        (0, agent_config_1.saveAgentConfig)(configName, {
+            name: agent.name || agent.id,
+            botId: agent.id,
+            provider: agent.provider,
+            runtimeProvider: agent.runtimeProvider,
+            model: agent.model,
+            runtimeModel: agent.runtimeModel,
+            accessMode: agent.accessMode,
+            workspace: agent.projectDir || '.',
+            permissionMode: agent.permissionMode,
+            enabledTools: agent.enabledTools,
+            enabledMcpTools: agent.enabledMcpTools,
+            systemPrompt: agent.systemPrompt || agent.agentDescription,
+            createdAt: agent.createdAt || new Date().toISOString(),
+        });
+        synced++;
+    }
+    if (synced > 0) {
+        console.log(chalk_1.default.gray(`  Synced ${synced} managed agent config(s) to ~/.funolio/agents/`));
+    }
+}
+async function fetchMcpInstallations(apiUrl, authToken) {
+    const res = await fetch(`${apiUrl}/api/v1/bot/mcp-installations`, {
+        headers: { Authorization: `Bearer ${authToken}` },
+    });
+    if (!res.ok) {
+        const text = await res.text().catch(() => '');
+        throw new Error(`mcp-installations ${res.status}: ${text}`);
+    }
+    const data = (await res.json());
+    return Array.isArray(data.installations) ? data.installations : [];
+}
+/**
+ * Sync approved MCP installations from the cloud into the local MCP manager.
+ *
+ * Flow:
+ *   1. Fetch installations from /api/v1/bot/mcp-installations
+ *   2. For each "ready" installation, ensure the MCP is launched with the
+ *      current env vars (Google refresh token in particular rotates).
+ *   3. Skip installations with status "needs_reauth" or "unknown_server";
+ *      log why.
+ *
+ * Idempotent: MCPManager.installAndLaunch short-circuits when a server is
+ * already running. Env-var changes trigger reloadIntegrationServers for the
+ * Google family so the subprocess restarts with fresh tokens.
+ */
+async function syncCloudMcpInstallations(opts) {
+    const { apiUrl, authToken, mcpManager } = opts;
+    let installations;
+    try {
+        installations = await fetchMcpInstallations(apiUrl, authToken);
+    }
+    catch (err) {
+        throw new Error(`fetch failed: ${err?.message || err}`);
+    }
+    if (installations.length === 0) {
+        if (process.env.FUNOLIO_AGENT_DEBUG === 'true') {
+            console.log(chalk_1.default.gray('  [mcp-sync] no approved MCP installations for this user'));
+        }
+        return;
+    }
+    const { MCP_REGISTRY } = await Promise.resolve().then(() => __importStar(require('../mcp/registry-shared')));
+    let launched = 0;
+    let skipped = 0;
+    let googleRefreshed = false;
+    for (const inst of installations) {
+        if (inst.status !== 'ready') {
+            skipped++;
+            if (process.env.FUNOLIO_AGENT_DEBUG === 'true') {
+                console.log(chalk_1.default.gray(`  [mcp-sync] skipping ${inst.serverId}: ${inst.status}${inst.error ? ` (${inst.error})` : ''}`));
+            }
+            continue;
+        }
+        const entry = MCP_REGISTRY.find((e) => e.id === inst.serverId);
+        if (!entry) {
+            skipped++;
+            continue;
+        }
+        const runningInfo = mcpManager.getServerInfo(inst.serverId);
+        if (runningInfo) {
+            // Already running. If this is a Google-family MCP we may still want
+            // to restart it so the subprocess picks up a rotated refresh token.
+            // The batch-restart below handles that.
+            continue;
+        }
+        try {
+            await mcpManager.installAndLaunch(entry, inst.envVars, inst.alwaysOn);
+            launched++;
+        }
+        catch (err) {
+            console.error(chalk_1.default.yellow(`  [mcp-sync] failed to launch ${inst.serverId}: ${err?.message || err}`));
+        }
+    }
+    // If any already-running Google MCP has a changed refresh token, restart
+    // the Google family so they pick up the fresh credential. The manager's
+    // existing reloadIntegrationServers does the heavy lifting.
+    try {
+        const hasGoogleReady = installations.some((i) => i.status === 'ready' && /^google-|^gmail$/.test(i.serverId));
+        if (hasGoogleReady) {
+            const running = mcpManager.getRunningServers();
+            const googleRunning = running.some((id) => /^google-|^gmail$/.test(id));
+            if (googleRunning) {
+                await mcpManager.reloadIntegrationServers('google');
+                googleRefreshed = true;
+            }
+        }
+    }
+    catch (err) {
+        console.error(chalk_1.default.yellow(`  [mcp-sync] google reload failed: ${err?.message || err}`));
+    }
+    if (launched > 0 || googleRefreshed) {
+        console.log(chalk_1.default.green(`  ✓ MCP sync: ${launched} launched, ${skipped} skipped${googleRefreshed ? ', google refreshed' : ''}`));
+    }
+}
+async function fetchPoolSubscriptions(apiUrl, authToken) {
+    const res = await fetch(`${apiUrl}/api/v1/bot/pool-subscriptions`, {
+        headers: { Authorization: `Bearer ${authToken}` },
+    });
+    if (!res.ok) {
+        const text = await res.text().catch(() => '');
+        throw new Error(`pool-subscriptions ${res.status}: ${text}`);
+    }
+    const data = (await res.json());
+    return Array.isArray(data.subscriptions) ? data.subscriptions : [];
+}
+async function setupPoolSubscriptions(opts) {
+    const { apiUrl, authToken, mqttClient, config } = opts;
+    let subs = [];
+    try {
+        subs = await fetchPoolSubscriptions(apiUrl, authToken);
+    }
+    catch (err) {
+        console.error(chalk_1.default.yellow(`⚠ Failed to fetch pool subscriptions: ${err?.message || err}`));
+        return;
+    }
+    if (subs.length === 0) {
+        console.log(chalk_1.default.gray('  No team pool provider instances for this user.'));
+        return;
+    }
+    console.log(chalk_1.default.blue(`  Subscribing to ${subs.length} team-pool request topic(s)...`));
+    const publisher = {
+        publish: (topic, payload, o) => mqttClient.publish(topic, payload, { qos: (o?.qos ?? 1) }),
+    };
+    for (const sub of subs) {
+        const { teamId, instanceId, provider: providerName } = sub;
+        const providerConfig = (config.providers || []).find((p) => p.id === providerName);
+        if (!providerConfig) {
+            console.log(chalk_1.default.yellow(`  ⚠ No local provider config for "${providerName}" (teamId=${teamId.slice(0, 8)}); skipping`));
+            continue;
+        }
+        const topic = `funolio/team/${teamId}/provider/${instanceId}/request/+`;
+        mqttClient.subscribeTopic(topic, async (_t, payload) => {
+            let request;
+            try {
+                request = JSON.parse(payload.toString());
+            }
+            catch {
+                console.error(chalk_1.default.red('Pool request: failed to parse payload'));
+                return;
+            }
+            console.log(chalk_1.default.blue(`📨 Pool request ${String(request.requestId).slice(0, 8)}... team=${teamId.slice(0, 8)} model=${request.model}`));
+            await (0, pool_1.handlePoolRequest)({
+                teamId,
+                instanceId,
+                providerName,
+                providerConfig,
+                request,
+                publisher,
+            });
+        }, { qos: 1 });
+        console.log(chalk_1.default.gray(`    • ${topic}`));
+    }
 }
 function parseJson(value) {
     if (!value)
@@ -107,10 +452,25 @@ function loadDbRuntimeConfig() {
         const botRows = data.listAgentProfiles();
         const projects = data.listProjects({ includeArchived: true });
         const firstProviderId = providerRows[0]?.provider_id;
-        const defaultBot = botRows.find((bot) => bot.is_default === 1) || botRows[0];
+        const providerByConnectionId = new Map(providerRows.map((row) => [row.id, row]));
+        const providerByProviderId = new Map(providerRows.map((row) => [row.provider_id, row]));
+        const resolveBotProviderConnection = (bot) => {
+            if (bot.provider_connection_id) {
+                const direct = providerByConnectionId.get(bot.provider_connection_id);
+                if (direct)
+                    return direct;
+            }
+            return providerByProviderId.get(bot.provider);
+        };
+        const isRunnableBot = (bot) => !!resolveBotProviderConnection(bot);
+        const defaultBot = botRows.find((bot) => bot.is_default === 1 && isRunnableBot(bot))
+            || botRows.find((bot) => bot.is_active === 1 && isRunnableBot(bot))
+            || botRows.find(isRunnableBot)
+            || botRows.find((bot) => bot.is_default === 1)
+            || botRows[0];
         const providers = providerRows.map((row) => ({
             id: row.provider_id,
-            authType: row.auth_type === 'oauth' ? 'oauth' : 'apiKey',
+            authType: row.auth_type === 'oauth' ? 'oauth' : row.auth_type === 'cli' ? 'cli' : 'apiKey',
             apiKey: row.api_key_enc || undefined,
             oauthToken: row.oauth_token || undefined,
             oauthRefreshToken: row.oauth_refresh_token || undefined,
@@ -119,13 +479,16 @@ function loadDbRuntimeConfig() {
             label: row.label || undefined,
         }));
         const agents = botRows.map((row) => {
+            const resolvedConnection = resolveBotProviderConnection(row);
+            const resolvedProviderId = resolvedConnection?.provider_id || row.provider;
+            const resolvedModel = row.model || resolvedConnection?.default_model || config_1.DEFAULT_MODELS[resolvedProviderId] || '';
             const projectDir = projects.find((project) => project.bot_ids.includes(row.id) && project.folder)?.folder || '.';
             return {
                 id: row.id,
                 name: row.name,
                 projectDir,
-                provider: row.provider,
-                model: row.model,
+                provider: resolvedProviderId,
+                model: resolvedModel,
                 enabledTools: parseJson(row.enabled_builtin_tools_json),
                 enabledMcpTools: parseJson(row.enabled_mcp_tools_json),
                 permissionMode: row.permission_mode || 'autopilot',
@@ -140,7 +503,7 @@ function loadDbRuntimeConfig() {
         return {
             auth,
             providers,
-            defaultProvider: defaultBot?.provider || firstProviderId,
+            defaultProvider: (defaultBot ? (resolveBotProviderConnection(defaultBot)?.provider_id || defaultBot.provider) : undefined) || firstProviderId,
             agents,
             activeAgentId: defaultBot?.id,
             autostart: !!desktopPrefs?.launchOnStartup,
@@ -179,13 +542,22 @@ async function startCommand(projectDir, options) {
         process.env.FUNOLIO_RUN_CONTEXT = 'windows-service';
     }
     const isServiceMode = options.mode === 'service' || options.mode === 'windows-service';
+    let serviceLockPath = null;
     if (isServiceMode) {
         (0, service_mode_1.enableServiceMode)();
+        const lock = acquireServiceLock(options.mode || 'service');
+        if (!lock.acquired) {
+            console.error(chalk_1.default.red(`✗ Another service agent is already running (pid ${lock.existingPid}).`));
+            process.exit(1);
+        }
+        serviceLockPath = lock.lockPath;
+    }
+    const config = (0, config_1.migrateConfig)((0, config_1.loadConfig)());
+    const useDbRuntime = (0, config_1.hasDbConfig)();
+    if (options.mode === 'service' && config.connectionMode === 'local') {
+        process.env.LOCAL_FIRST_ENABLED = 'true';
+        process.env.FUNOLIO_RUN_CONTEXT = process.env.FUNOLIO_RUN_CONTEXT || 'service';
     }
-    const legacyConfig = (0, config_1.migrateConfig)((0, config_1.loadConfig)());
-    const dbConfig = loadDbRuntimeConfig();
-    const useDbRuntime = !!dbConfig;
-    const config = dbConfig || legacyConfig;
     const authConfig = config.auth || null;
     const hasAuth = !!authConfig;
     const authExpired = hasAuth
@@ -193,9 +565,7 @@ async function startCommand(projectDir, options) {
         : true;
     const runSetupOnly = async (reason) => {
         if (isServiceMode) {
-            console.log(chalk_1.default.yellow(`Setup-only mode: ${reason}`));
-            (0, service_mode_1.emitEvent)('status', { status: 'setup_only', reason });
-            await new Promise(() => { });
+            await (0, service_setup_only_1.waitForServiceSetup)(reason, service_mode_1.emitEvent, options.setupOnlySignal);
             return true;
         }
         return false;
@@ -204,6 +574,15 @@ async function startCommand(projectDir, options) {
     let localServerStarted = false;
     const runtimeConnectionMode = config.connectionMode === 'server' ? 'server' : 'local';
     const runtimeServerBaseUrl = typeof config.serverBaseUrl === 'string' ? config.serverBaseUrl.trim() : '';
+    if (runtimeConnectionMode === 'local') {
+        const localNormalization = normalizeLocalModeAgents(config);
+        if (localNormalization.changed) {
+            (0, config_1.saveConfig)(config);
+            if (localNormalization.removedCount > 0) {
+                console.log(chalk_1.default.gray(`  Removed ${localNormalization.removedCount} server-only bot profile(s) from local mode`));
+            }
+        }
+    }
     process.env.FUNOLIO_CONNECTION_MODE = runtimeConnectionMode;
     if (runtimeServerBaseUrl) {
         process.env.FUNOLIO_SERVER_BASE_URL = runtimeServerBaseUrl;
@@ -222,6 +601,9 @@ async function startCommand(projectDir, options) {
             const dbInfo = (0, local_db_1.initLocalDb)();
             console.log(chalk_1.default.green(`✓ Local DB ready: ${dbInfo.path}`));
             console.log(chalk_1.default.gray(`  WAL mode: ${dbInfo.walMode}, tables: ${dbInfo.tableCount}, write: ${dbInfo.testWrite}, read: ${dbInfo.testRead}`));
+            if (dbInfo.claudeSessionCounterSync?.updated) {
+                console.log(chalk_1.default.gray(`  Claude session counter advanced from ${dbInfo.claudeSessionCounterSync.dbValueBefore} to ${dbInfo.claudeSessionCounterSync.dbValueAfter} to match existing ~/.claude Funolio sessions`));
+            }
             cleanupExpiredMessageActivityRows();
             if (isServiceMode) {
                 (0, service_mode_1.emitEvent)('local_db', { status: 'ready', path: dbInfo.path, walMode: dbInfo.walMode });
@@ -308,55 +690,69 @@ async function startCommand(projectDir, options) {
             process.exit(1);
         }
     }
-    // Re-sync provider credentials from server (picks up web re-auth tokens)
-    if (config.providers?.some(p => p.authType === 'oauth')) {
-        try {
-            const res = await fetch(`${config_1.FUNOLIO_API_URL}/api/v1/agent/config`, {
-                headers: { Authorization: `Bearer ${auth.token}` },
-            });
-            if (res.ok) {
-                const serverConfig = await res.json();
-                if (serverConfig.providers) {
-                    let updated = false;
-                    for (const sp of serverConfig.providers) {
-                        if (sp.connectionType !== 'oauth' || !sp.access_token)
-                            continue;
-                        const local = config.providers.find(p => p.id === sp.id);
-                        if (!local || local.authType !== 'oauth')
-                            continue;
-                        // Only update if server has a different (newer) token
-                        if (local.oauthToken !== sp.access_token) {
-                            local.oauthToken = sp.access_token;
-                            local.oauthRefreshToken = sp.refresh_token;
-                            local.oauthExpiresAt = sp.expires_at;
-                            updated = true;
-                            console.log(chalk_1.default.green(`✓ Updated ${sp.id} OAuth token from server`));
-                        }
+    // Re-sync providers from server (picks up web re-auth tokens).
+    // In local mode, keep the local bot roster authoritative and do not import
+    // the server seed-bot catalog into the desktop agent list.
+    try {
+        const res = await fetch(`${config_1.FUNOLIO_API_URL}/api/v1/agent/config`, {
+            headers: { Authorization: `Bearer ${auth.token}` },
+        });
+        if (res.ok) {
+            const serverConfig = await res.json();
+            let updated = false;
+            if (serverConfig.providers && config.providers?.some(p => p.authType === 'oauth')) {
+                for (const sp of serverConfig.providers) {
+                    if (sp.connectionType !== 'oauth' || !sp.access_token)
+                        continue;
+                    const local = config.providers.find(p => p.id === sp.id);
+                    if (!local || local.authType !== 'oauth')
+                        continue;
+                    // Only update if server has a different (newer) token
+                    if (local.oauthToken !== sp.access_token) {
+                        local.oauthToken = sp.access_token;
+                        local.oauthRefreshToken = sp.refresh_token;
+                        local.oauthExpiresAt = sp.expires_at;
+                        updated = true;
+                        console.log(chalk_1.default.green(`✓ Updated ${sp.id} OAuth token from server`));
                     }
-                    if (updated) {
-                        (0, config_1.saveConfig)(config);
-                        // Also update agent config files on disk
-                        for (const p of config.providers) {
-                            if (p.authType !== 'oauth' || !p.oauthToken)
-                                continue;
-                            const { listAgents, loadAgentConfig: loadAC, saveAgentConfig: saveAC } = await Promise.resolve().then(() => __importStar(require('../agent-config')));
-                            for (const agentName of listAgents()) {
-                                const ac = loadAC(agentName);
-                                if (ac && ac.provider === p.id && ac.oauthToken) {
-                                    ac.oauthToken = p.oauthToken;
-                                    ac.oauthRefreshToken = p.oauthRefreshToken;
-                                    ac.oauthExpiresAt = p.oauthExpiresAt;
-                                    saveAC(agentName, ac);
-                                }
-                            }
+                }
+            }
+            if (runtimeConnectionMode === 'server' && Array.isArray(serverConfig.bots) && serverConfig.bots.length > 0) {
+                const nextAgents = mapServerBotsToAgents(serverConfig.bots, config.agents || []);
+                const sameAgents = JSON.stringify(config.agents || []) === JSON.stringify(nextAgents);
+                if (!sameAgents) {
+                    config.agents = nextAgents;
+                    updated = true;
+                    console.log(chalk_1.default.green(`✓ Synced ${nextAgents.length} bot profile(s) from server`));
+                }
+                const selectedActiveAgentId = selectPreferredActiveAgentId(nextAgents, config.providers, config.activeAgentId);
+                if (selectedActiveAgentId && selectedActiveAgentId !== config.activeAgentId) {
+                    config.activeAgentId = selectedActiveAgentId;
+                    updated = true;
+                }
+            }
+            if (updated) {
+                (0, config_1.saveConfig)(config);
+                // Also update agent config files on disk for OAuth providers
+                for (const p of config.providers || []) {
+                    if (p.authType !== 'oauth' || !p.oauthToken)
+                        continue;
+                    const { listAgents, loadAgentConfig: loadAC, saveAgentConfig: saveAC } = await Promise.resolve().then(() => __importStar(require('../agent-config')));
+                    for (const agentName of listAgents()) {
+                        const ac = loadAC(agentName);
+                        if (ac && ac.provider === p.id && ac.oauthToken) {
+                            ac.oauthToken = p.oauthToken;
+                            ac.oauthRefreshToken = p.oauthRefreshToken;
+                            ac.oauthExpiresAt = p.oauthExpiresAt;
+                            saveAC(agentName, ac);
                         }
                     }
                 }
             }
         }
-        catch (err) {
-            console.log(chalk_1.default.gray(`  Server config re-sync skipped: ${err.message}`));
-        }
+    }
+    catch (err) {
+        console.log(chalk_1.default.gray(`  Server config re-sync skipped: ${err.message}`));
     }
     // Load agent-specific config if --agent was specified
     const agentLocalConfig = options.agent ? (0, agent_config_1.loadAgentConfig)(options.agent) : null;
@@ -481,8 +877,10 @@ async function startCommand(projectDir, options) {
     // Enforce strict subscription routing semantics.
     if (effectiveAccessMode === 'openai_subscription') {
         apiKey = undefined;
-        if (provider === 'codex-cli')
-            provider = 'openai';
+        oauthToken = undefined;
+        // Preserve codex-cli when it was explicitly selected. The CLI manages its
+        // own auth/session state and should not be rewritten into the raw OpenAI
+        // API path during local-agent startup.
     }
     if (effectiveAccessMode === 'anthropic_subscription') {
         provider = 'claude-cli';
@@ -492,10 +890,17 @@ async function startCommand(projectDir, options) {
             model = 'claude-code';
         }
     }
-    // Auto-detect Claude Code CLI if no API key/token and no provider explicitly set.
+    // Auto-detect Claude Code CLI only when the provider was not explicitly chosen.
+    // Otherwise we can accidentally rewrite an explicit Codex/OpenAI bot selection
+    // into Claude just because no API key was passed on the outer config object.
+    const providerWasExplicit = !!(options.provider ||
+        agentLocalConfig?.runtimeProvider ||
+        activeAgentConfig?.runtimeProvider ||
+        agentLocalConfig?.provider ||
+        activeAgentConfig?.provider);
     // OAuth tokens from claude.ai can't be used with the Anthropic API directly,
     // so we prefer claude-cli when Claude Code is installed.
-    if (!apiKey && !oauthToken && !options.provider && !agentLocalConfig?.provider && provider !== 'claude-cli') {
+    if (!apiKey && !oauthToken && !providerWasExplicit && provider !== 'claude-cli') {
         const claudeVersion = detectClaudeCli();
         if (claudeVersion) {
             console.log(chalk_1.default.green(`✓ Claude Code detected (${claudeVersion}), using your subscription`));
@@ -571,6 +976,9 @@ async function startCommand(projectDir, options) {
             const dbInfo = (0, local_db_1.initLocalDb)();
             console.log(chalk_1.default.green(`✓ Local DB ready: ${dbInfo.path}`));
             console.log(chalk_1.default.gray(`  WAL mode: ${dbInfo.walMode}, tables: ${dbInfo.tableCount}, write: ${dbInfo.testWrite}, read: ${dbInfo.testRead}`));
+            if (dbInfo.claudeSessionCounterSync?.updated) {
+                console.log(chalk_1.default.gray(`  Claude session counter advanced from ${dbInfo.claudeSessionCounterSync.dbValueBefore} to ${dbInfo.claudeSessionCounterSync.dbValueAfter} to match existing ~/.claude Funolio sessions`));
+            }
             cleanupExpiredMessageActivityRows();
             if (isServiceMode) {
                 (0, service_mode_1.emitEvent)('local_db', { status: 'ready', path: dbInfo.path, walMode: dbInfo.walMode });
@@ -621,6 +1029,10 @@ async function startCommand(projectDir, options) {
         authToken: auth.token,
         refreshUrl: `${config_1.FUNOLIO_API_URL}/api/v1/agent/auth/refresh`,
     });
+    (0, chat_sync_1.configureChatSyncPublisher)({
+        userId: auth.userId,
+        publish: (topic, payload, opts) => mqttClient.publish(topic, payload, opts),
+    });
     // Create and auto-launch MCP manager for persistent tool discovery
     const { MCPManager } = await Promise.resolve().then(() => __importStar(require('../mcp/manager')));
     const mcpManager = new MCPManager();
@@ -649,6 +1061,7 @@ async function startCommand(projectDir, options) {
     });
     let maintenanceTimer = null;
     let maintenanceRestartPending = false;
+    const processStartAtMs = Date.now();
     // Handle shutdown
     const shutdown = async () => {
         console.log(chalk_1.default.yellow('\nShutting down...'));
@@ -666,6 +1079,8 @@ async function startCommand(projectDir, options) {
         }).catch(() => { });
         await mcpManager.shutdown();
         await mqttClient.disconnect();
+        if (serviceLockPath)
+            releaseServiceLock(serviceLockPath);
         process.exit(0);
     };
     process.on('SIGINT', shutdown);
@@ -759,6 +1174,9 @@ async function startCommand(projectDir, options) {
         console.log(chalk_1.default.gray('     This terminal can stay open or run in background.\n'));
         // Start the active agent loop (driven by agents[] + activeAgentId)
         await botManager.startActive();
+        // Materialize configured server bots into local agent files so explicit
+        // bot routing can resolve botId -> loop mappings after restarts.
+        syncConfiguredAgentsToLocalConfigs(config.agents);
         // Start all additional bot loops from ~/.funolio/agents/ configs
         await botManager.startAllBots();
         try {
@@ -775,9 +1193,11 @@ async function startCommand(projectDir, options) {
                 return;
             const now = new Date();
             const lastInteractionAtMs = readLastInteractionAtMs();
-            if (!shouldRunNightlyRestart(now, lastInteractionAtMs, botManager))
+            const lastMaintenanceRestartAtMs = readLastMaintenanceRestartAtMs();
+            if (!shouldRunNightlyRestart(now, lastInteractionAtMs, lastMaintenanceRestartAtMs, botManager, processStartAtMs))
                 return;
             maintenanceRestartPending = true;
+            markMaintenanceRestartAt(now);
             const reason = `nightly maintenance restart after ${MESSAGE_ACTIVITY_RETENTION_HOURS}h activity retention window`;
             console.log(chalk_1.default.yellow(`  Restarting agent for ${reason}`));
             try {
@@ -793,7 +1213,10 @@ async function startCommand(projectDir, options) {
             if (isServiceMode) {
                 (0, service_mode_1.emitEvent)('agent_restart', { reason });
             }
-            setTimeout(() => process.exit(0), 1500);
+            // Exit with EX_TEMPFAIL (75) so systemd's `Restart=on-failure` triggers a
+            // restart. `process.exit(0)` is treated as clean and would leave the agent
+            // dead until a human starts it (observed incident: ~2 days of downtime).
+            setTimeout(() => process.exit(75), 1500);
         }, MAINTENANCE_INTERVAL_MS);
         if (config.agents && config.agents.length > 1) {
             console.log(chalk_1.default.blue(`  ${config.agents.length} agent(s) configured (active: ${activeAgentConfig?.name || 'default'})`));
@@ -824,6 +1247,71 @@ async function startCommand(projectDir, options) {
             }
         }
         console.log(chalk_1.default.gray('  Waiting for commands...\n'));
+        // Subscribe to team-pool request topics for every provider instance this user hosts.
+        // Without this, V2 TeamBot chats routed through the team pool never reach this agent
+        // and time out at 120s. Previously this subscription was only done by the dedicated
+        // `funolio-agent pool provide` command, not by `start --mode service`.
+        setupPoolSubscriptions({
+            apiUrl: config_1.FUNOLIO_API_URL,
+            authToken: auth.token,
+            mqttClient,
+            config,
+        }).catch((err) => {
+            console.error(chalk_1.default.yellow(`⚠ Pool subscription setup failed: ${err?.message || err}`));
+        });
+        // Keep liveness fresh: re-poll /api/v1/bot/pool-subscriptions every 2 minutes.
+        // The GET side-effects a `lastSeenAt = NOW()` update on all of this user's
+        // TeamLlmProviderInstance rows. Without this, the server's V2 completions
+        // route fast-fails with 503 NO_RUNTIME because the staleness check
+        // (>5 min = offline) trips — even while the agent is actively subscribed
+        // to the pool topic.
+        //
+        // The re-poll also picks up any new teams the user joined after the agent
+        // started: fetchPoolSubscriptions returns the up-to-date set, so any newly
+        // added instance gets subscribed on the next tick.
+        const POOL_LIVENESS_INTERVAL_MS = 2 * 60 * 1000;
+        setInterval(() => {
+            fetchPoolSubscriptions(config_1.FUNOLIO_API_URL, auth.token)
+                .then(() => {
+                // Discovery of brand-new team memberships is handled in a later
+                // iteration; for now the GET alone is enough to keep liveness fresh.
+            })
+                .catch((err) => {
+                // Non-fatal — next tick will retry. Don't spam logs.
+                if (process.env.FUNOLIO_AGENT_DEBUG === 'true') {
+                    console.error(chalk_1.default.gray(`  [pool-liveness] refresh failed: ${err?.message || err}`));
+                }
+            });
+        }, POOL_LIVENESS_INTERVAL_MS).unref();
+        // Sync approved MCP installations from the cloud. The user approves MCPs
+        // via the web UI (stored in UserMcpServer rows server-side), but the
+        // agent's MCP manager only auto-launches from ~/.funolio/mcp-servers.json
+        // which is never populated on VM/remote agent installs. Without this
+        // sync, users who approved Google Workspace/Drive/Gmail/Chat via the web
+        // see `mcp=0` in the tool filter at startup and tool calls fail.
+        syncCloudMcpInstallations({
+            apiUrl: config_1.FUNOLIO_API_URL,
+            authToken: auth.token,
+            mcpManager,
+        }).catch((err) => {
+            console.error(chalk_1.default.yellow(`⚠ MCP installation sync failed: ${err?.message || err}`));
+        });
+        // Re-sync every 10 minutes so newly approved MCPs show up and Google
+        // tokens get refreshed before they expire (GOOGLE_REFRESH_BUFFER_MS on
+        // the server is 5 min; polling at 10 min is well inside the safety
+        // margin of a typical 1-hour access token TTL).
+        const MCP_SYNC_INTERVAL_MS = 10 * 60 * 1000;
+        setInterval(() => {
+            syncCloudMcpInstallations({
+                apiUrl: config_1.FUNOLIO_API_URL,
+                authToken: auth.token,
+                mcpManager,
+            }).catch((err) => {
+                if (process.env.FUNOLIO_AGENT_DEBUG === 'true') {
+                    console.error(chalk_1.default.gray(`  [mcp-sync] refresh failed: ${err?.message || err}`));
+                }
+            });
+        }, MCP_SYNC_INTERVAL_MS).unref();
         // OAuth token refresh is handled per-request in message-loop.ts via ensureFreshToken()
         // No background timer needed — this matches the pi-ai/Claude Code CLI pattern of
         // refreshing lazily before each API call, avoiding race conditions on single-use refresh tokens
@@ -846,6 +1334,14 @@ async function startCommand(projectDir, options) {
         // Start listening for commands — BotManager routes to the right bot
         // Also handle MCP marketplace install/uninstall commands
         mqttClient.onCommand(async (message) => {
+            // Local-DB data relay (mobile1.txt Phase 1). When the cloud needs to
+            // serve a personal-desktop user's data via mobile/web, it publishes a
+            // data_request command here; we forward to the local HTTP server and
+            // reply on the results topic. Always handle this BEFORE existing
+            // command dispatch since it's its own message type.
+            if (await (0, mqtt_data_relay_1.handleDataRequestMessage)(message, mqttClient)) {
+                return;
+            }
             if (message.type === 'command' && message.action === 'mcp_install') {
                 const { serverId, envVars } = message;
                 console.log(chalk_1.default.cyan(`📦 Marketplace: installing MCP server "${serverId}"...`));