@sylphx/flow 3.12.1 → 3.13.1

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # @sylphx/flow
 
+## 3.13.1 (2026-02-04)
+
+### ⚡️ Performance
+
+- major performance optimizations ([aaaf25c](https://github.com/SylphxAI/flow/commit/aaaf25cd20555a2fa2a52713ae78c15368565c34))
+
+### ♻️ Refactoring
+
+- **auto-upgrade:** fully non-blocking background updates ([eb0a2da](https://github.com/SylphxAI/flow/commit/eb0a2da355ad6418e3c96b19dfe3ee1d6222724c))
+- **auto-upgrade:** remove target CLI upgrade logic - only manage Flow updates ([65ad241](https://github.com/SylphxAI/flow/commit/65ad241e40aaf772b9e9e3a55c8f11693adfefe5))
+- **auto-upgrade:** remove blocking startup check, keep only periodic background check ([4f29c01](https://github.com/SylphxAI/flow/commit/4f29c01ce31bb30457240b9ff90114d3dd03c66e))
+
+## 3.13.0 (2026-02-04)
+
+### ✨ Features
+
+- **auto-upgrade:** add periodic background update check every 30 minutes ([4a14414](https://github.com/SylphxAI/flow/commit/4a14414350f31899a5dadaf596216c53406f7ffc))
+
 ## 3.12.1 (2026-02-04)
 
 ### 🐛 Bug Fixes

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@sylphx/flow",
-	"version": "3.12.1",
+	"version": "3.13.1",
 	"description": "One CLI to rule them all. Unified orchestration layer for AI coding assistants. Auto-detection, auto-installation, auto-upgrade.",
 	"type": "module",
 	"bin": {

package/src/commands/flow/execute-v2.ts

@@ -161,14 +161,15 @@ export async function executeFlowV2(
 ): Promise<void> {
   const projectPath = process.cwd();
 
-  // Initialize config service early to check for saved preferences
+  // Initialize services and load config in parallel
   const configService = new GlobalConfigService();
-  await configService.initialize();
-
-  // Step 1: Determine target (silent auto-detect, only prompt when necessary)
   const targetInstaller = new TargetInstaller(projectPath);
-  const installedTargets = await targetInstaller.detectInstalledTargets();
-  const settings = await configService.loadSettings();
+
+  const [, installedTargets, settings] = await Promise.all([
+    configService.initialize(),
+    targetInstaller.detectInstalledTargets(),
+    configService.loadSettings(),
+  ]);
 
   let selectedTargetId: string | null = null;
 
@@ -238,17 +239,8 @@ export async function executeFlowV2(
   // Show minimal header
   showHeader(version, targetName);
 
-  // Step 2: Auto-upgrade (silent, returns status)
-  const autoUpgrade = new AutoUpgrade(projectPath);
-  const upgradeResult = await autoUpgrade.runAutoUpgrade(selectedTargetId);
-
-  // Show upgrade notice (minimal - only if upgraded)
-  if (upgradeResult.flowUpgraded && upgradeResult.flowVersion) {
-    console.log(chalk.dim(`↑ flow ${upgradeResult.flowVersion.latest}`));
-  }
-  if (upgradeResult.targetUpgraded && upgradeResult.targetVersion) {
-    console.log(chalk.dim(`↑ ${targetName.toLowerCase()} ${upgradeResult.targetVersion.latest}`));
-  }
+  // Step 2: Start background auto-upgrade (non-blocking)
+  new AutoUpgrade().start();
 
   // Create executor
   const executor = new FlowExecutor();
@@ -284,9 +276,11 @@ export async function executeFlowV2(
       agent = enabledAgents.length > 0 ? enabledAgents[0] : 'builder';
     }
 
-    // Load agent content
-    const enabledRules = await configService.getEnabledRules();
-    const enabledOutputStyles = await configService.getEnabledOutputStyles();
+    // Load agent content (parallel fetch rules and styles)
+    const [enabledRules, enabledOutputStyles] = await Promise.all([
+      configService.getEnabledRules(),
+      configService.getEnabledOutputStyles(),
+    ]);
 
     const agentContent = await loadAgentContent(
       agent,

package/src/core/template-loader.ts

@@ -22,39 +22,41 @@ export class TemplateLoader {
   }
 
   /**
-   * Load all templates for target
+   * Load all templates for target (parallel loading for performance)
    * Uses flat assets directory structure (no target-specific subdirectories)
    */
   async loadTemplates(_target: Target | string): Promise<FlowTemplates> {
-    const templates: FlowTemplates = {
-      agents: [],
-      commands: [],
-      skills: [],
-      rules: undefined,
-      mcpServers: [],
-      hooks: [],
-      singleFiles: [],
-    };
-
-    // Load agents
     const agentsDir = path.join(this.assetsDir, 'agents');
-    if (existsSync(agentsDir)) {
-      templates.agents = await this.loadAgents(agentsDir);
-    }
-
-    // Load commands (slash-commands directory)
     const commandsDir = path.join(this.assetsDir, 'slash-commands');
-    if (existsSync(commandsDir)) {
-      templates.commands = await this.loadCommands(commandsDir);
-    }
-
-    // Load skills (skills/<domain>/SKILL.md structure)
     const skillsDir = path.join(this.assetsDir, 'skills');
-    if (existsSync(skillsDir)) {
-      templates.skills = await this.loadSkills(skillsDir);
-    }
+    const mcpConfigPath = path.join(this.assetsDir, 'mcp-servers.json');
+    const outputStylesDir = path.join(this.assetsDir, 'output-styles');
 
-    // Load rules (check multiple possible locations)
+    // Load all directories in parallel
+    const [agents, commands, skills, mcpServers, singleFiles, rules] = await Promise.all([
+      existsSync(agentsDir) ? this.loadAgents(agentsDir) : [],
+      existsSync(commandsDir) ? this.loadCommands(commandsDir) : [],
+      existsSync(skillsDir) ? this.loadSkills(skillsDir) : [],
+      existsSync(mcpConfigPath) ? this.loadMCPServers(mcpConfigPath) : [],
+      existsSync(outputStylesDir) ? this.loadSingleFiles(outputStylesDir) : [],
+      this.loadRules(),
+    ]);
+
+    return {
+      agents,
+      commands,
+      skills,
+      rules,
+      mcpServers,
+      hooks: [],
+      singleFiles,
+    };
+  }
+
+  /**
+   * Load rules from possible locations
+   */
+  private async loadRules(): Promise<string | undefined> {
     const rulesLocations = [
       path.join(this.assetsDir, 'rules', 'AGENTS.md'),
       path.join(this.assetsDir, 'AGENTS.md'),
@@ -62,92 +64,67 @@ export class TemplateLoader {
 
     for (const rulesPath of rulesLocations) {
       if (existsSync(rulesPath)) {
-        templates.rules = await fs.readFile(rulesPath, 'utf-8');
-        break;
+        return fs.readFile(rulesPath, 'utf-8');
       }
     }
-
-    // Load MCP servers (if any)
-    const mcpConfigPath = path.join(this.assetsDir, 'mcp-servers.json');
-    if (existsSync(mcpConfigPath)) {
-      templates.mcpServers = await this.loadMCPServers(mcpConfigPath);
-    }
-
-    // Load output styles (single files)
-    const outputStylesDir = path.join(this.assetsDir, 'output-styles');
-    if (existsSync(outputStylesDir)) {
-      templates.singleFiles = await this.loadSingleFiles(outputStylesDir);
-    }
-
-    return templates;
+    return undefined;
   }
 
   /**
-   * Load agents from directory
+   * Load agents from directory (parallel file reads)
    */
   private async loadAgents(agentsDir: string): Promise<Array<{ name: string; content: string }>> {
-    const agents = [];
     const files = await fs.readdir(agentsDir);
-
-    for (const file of files) {
-      if (!file.endsWith('.md')) {
-        continue;
-      }
-
-      const content = await fs.readFile(path.join(agentsDir, file), 'utf-8');
-      agents.push({ name: file, content });
-    }
-
-    return agents;
+    const mdFiles = files.filter((f) => f.endsWith('.md'));
+
+    return Promise.all(
+      mdFiles.map(async (file) => ({
+        name: file,
+        content: await fs.readFile(path.join(agentsDir, file), 'utf-8'),
+      }))
+    );
   }
 
   /**
-   * Load commands/modes from directory
+   * Load commands/modes from directory (parallel file reads)
    */
   private async loadCommands(
     commandsDir: string
   ): Promise<Array<{ name: string; content: string }>> {
-    const commands = [];
     const files = await fs.readdir(commandsDir);
-
-    for (const file of files) {
-      if (!file.endsWith('.md')) {
-        continue;
-      }
-
-      const content = await fs.readFile(path.join(commandsDir, file), 'utf-8');
-      commands.push({ name: file, content });
-    }
-
-    return commands;
+    const mdFiles = files.filter((f) => f.endsWith('.md'));
+
+    return Promise.all(
+      mdFiles.map(async (file) => ({
+        name: file,
+        content: await fs.readFile(path.join(commandsDir, file), 'utf-8'),
+      }))
+    );
   }
 
   /**
-   * Load skills from directory
+   * Load skills from directory (parallel loading)
    * Skills are stored as <domain>/SKILL.md subdirectories
    */
   private async loadSkills(skillsDir: string): Promise<Array<{ name: string; content: string }>> {
-    const skills = [];
     const domains = await fs.readdir(skillsDir);
 
-    for (const domain of domains) {
-      const domainPath = path.join(skillsDir, domain);
-      const stat = await fs.stat(domainPath);
+    const results = await Promise.all(
+      domains.map(async (domain) => {
+        const domainPath = path.join(skillsDir, domain);
+        const stat = await fs.stat(domainPath);
 
-      if (!stat.isDirectory()) {
-        continue;
-      }
+        if (!stat.isDirectory()) return null;
+
+        const skillFile = path.join(domainPath, 'SKILL.md');
+        if (!existsSync(skillFile)) return null;
 
-      // Look for SKILL.md in each domain directory
-      const skillFile = path.join(domainPath, 'SKILL.md');
-      if (existsSync(skillFile)) {
         const content = await fs.readFile(skillFile, 'utf-8');
-        // Name includes subdirectory: "auth/SKILL.md"
-        skills.push({ name: `${domain}/SKILL.md`, content });
-      }
-    }
+        return { name: `${domain}/SKILL.md`, content };
+      })
+    );
 
-    return skills;
+    return results.filter((r): r is { name: string; content: string } => r !== null);
   }
 
   /**
@@ -166,25 +143,26 @@ export class TemplateLoader {
   }
 
   /**
-   * Load single files (CLAUDE.md, .cursorrules, etc.)
+   * Load single files (parallel loading)
    */
   private async loadSingleFiles(
     singleFilesDir: string
   ): Promise<Array<{ path: string; content: string }>> {
-    const files = [];
     const entries = await fs.readdir(singleFilesDir);
 
-    for (const entry of entries) {
-      const filePath = path.join(singleFilesDir, entry);
-      const stat = await fs.stat(filePath);
+    const results = await Promise.all(
+      entries.map(async (entry) => {
+        const filePath = path.join(singleFilesDir, entry);
+        const stat = await fs.stat(filePath);
+
+        if (!stat.isFile()) return null;
 
-      if (stat.isFile()) {
         const content = await fs.readFile(filePath, 'utf-8');
-        files.push({ path: entry, content });
-      }
-    }
+        return { path: entry, content };
+      })
+    );
 
-    return files;
+    return results.filter((r): r is { path: string; content: string } => r !== null);
   }
 
   /**

package/src/index.ts

@@ -4,9 +4,6 @@
  * AI-powered development flow management
  */
 
-import { readFileSync } from 'node:fs';
-import { dirname, join } from 'node:path';
-import { fileURLToPath } from 'node:url';
 import { Command } from 'commander';
 import { executeFlow } from './commands/flow/execute-v2.js';
 import {
@@ -20,13 +17,10 @@ import {
 import { hookCommand } from './commands/hook-command.js';
 import { settingsCommand } from './commands/settings-command.js';
 import { UserCancelledError } from './utils/errors.js';
+// @ts-expect-error - Bun resolves JSON imports
+import pkg from '../package.json';
 
-// Read version from package.json
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-const packageJsonPath = join(__dirname, '..', 'package.json');
-const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf8'));
-const VERSION = packageJson.version;
+const VERSION = pkg.version;
 
 /**
  * Create the main CLI application with enhanced Commander.js configuration

package/src/services/auto-upgrade.ts

@@ -1,399 +1,189 @@
 /**
  * Auto-Upgrade Service
- * Non-blocking version check with cache
- * Checks in background, shows result on next run
+ * Fully non-blocking background updates
+ * Only manages Flow updates - target CLIs manage their own updates
  */
 
 import { exec } from 'node:child_process';
-import { existsSync } from 'node:fs';
 import fs from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { promisify } from 'node:util';
-import chalk from 'chalk';
-import ora from 'ora';
-import { detectPackageManager, getUpgradeCommand } from '../utils/package-manager-detector.js';
-import { TargetInstaller } from './target-installer.js';
+import { getUpgradeCommand } from '../utils/package-manager-detector.js';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
-// Version info file (stores last background check result)
 const VERSION_FILE = path.join(os.homedir(), '.sylphx-flow', 'versions.json');
+const DEFAULT_CHECK_INTERVAL_MS = 30 * 60 * 1000; // 30 minutes
 
 interface VersionInfo {
   flowLatest?: string;
-  targetLatest?: Record<string, string>;
-  targetCurrent?: Record<string, string>;
+  lastCheckTime?: number;
 }
 
 const execAsync = promisify(exec);
 
-export interface UpgradeStatus {
-  flowNeedsUpgrade: boolean;
-  targetNeedsUpgrade: boolean;
-  flowVersion: { current: string; latest: string } | null;
-  targetVersion: { current: string; latest: string } | null;
-}
+export class AutoUpgrade {
+  private periodicCheckInterval: NodeJS.Timeout | null = null;
 
-export interface AutoUpgradeOptions {
-  verbose?: boolean;
-  skipFlow?: boolean;
-  skipTarget?: boolean;
-}
+  /**
+   * Start background update service
+   * Runs first check immediately (if not recently checked), then every intervalMs
+   * All checks and upgrades are non-blocking
+   */
+  start(intervalMs: number = DEFAULT_CHECK_INTERVAL_MS): void {
+    this.stop();
 
-export class AutoUpgrade {
-  private projectPath: string;
-  private options: AutoUpgradeOptions;
-  private targetInstaller: TargetInstaller;
+    // First check immediately (non-blocking) - skips if recently checked
+    this.checkAndUpgrade(intervalMs);
 
-  constructor(projectPath: string = process.cwd(), options: AutoUpgradeOptions = {}) {
-    this.projectPath = projectPath;
-    this.options = options;
-    this.targetInstaller = new TargetInstaller(projectPath);
+    // Then periodic checks
+    this.periodicCheckInterval = setInterval(() => {
+      this.checkAndUpgrade(intervalMs);
+    }, intervalMs);
+
+    // Don't prevent process from exiting
+    this.periodicCheckInterval.unref();
   }
 
   /**
-   * Read version info from last background check
+   * Stop background update service
    */
-  private async readVersionInfo(): Promise<VersionInfo | null> {
-    try {
-      if (!existsSync(VERSION_FILE)) {
-        return null;
-      }
-      const data = await fs.readFile(VERSION_FILE, 'utf-8');
-      return JSON.parse(data);
-    } catch {
-      return null;
+  stop(): void {
+    if (this.periodicCheckInterval) {
+      clearInterval(this.periodicCheckInterval);
+      this.periodicCheckInterval = null;
     }
   }
 
   /**
-   * Write version info
+   * Check for updates and upgrade if available (non-blocking)
+   * Skips if checked within intervalMs
+   * Fire and forget - errors are silently ignored
    */
-  private async writeVersionInfo(info: VersionInfo): Promise<void> {
-    try {
-      const dir = path.dirname(VERSION_FILE);
-      await fs.mkdir(dir, { recursive: true });
-      await fs.writeFile(VERSION_FILE, JSON.stringify(info, null, 2));
-    } catch {
-      // Silent fail
-    }
+  private checkAndUpgrade(intervalMs: number = DEFAULT_CHECK_INTERVAL_MS): void {
+    this.shouldCheck(intervalMs).then((shouldCheck) => {
+      if (shouldCheck) {
+        this.performCheck().catch(() => {
+          // Silent fail
+        });
+      }
+    });
   }
 
   /**
-   * Get current Flow version from package.json (instant, local file)
+   * Check if enough time has passed since last check
    */
-  private async getCurrentFlowVersion(): Promise<string> {
+  private async shouldCheck(intervalMs: number): Promise<boolean> {
     try {
-      const packageJsonPath = path.join(__dirname, '..', '..', 'package.json');
-      const packageJson = JSON.parse(await fs.readFile(packageJsonPath, 'utf-8'));
-      return packageJson.version;
+      const info = await this.readVersionInfo();
+      if (!info?.lastCheckTime) return true;
+      return Date.now() - info.lastCheckTime >= intervalMs;
     } catch {
-      return 'unknown';
+      return true;
     }
   }
 
   /**
-   * Check for available upgrades (instant, reads from last background check)
-   * Background check runs every time for fresh data next run
+   * Read version info from disk
    */
-  async checkForUpgrades(targetId?: string): Promise<UpgradeStatus> {
-    const info = await this.readVersionInfo();
-    const currentVersion = await this.getCurrentFlowVersion();
-
-    // Trigger background check for next run (non-blocking, every time)
-    this.checkInBackground(targetId);
-
-    // No previous check = no upgrade info yet
-    if (!info) {
-      return {
-        flowNeedsUpgrade: false,
-        targetNeedsUpgrade: false,
-        flowVersion: null,
-        targetVersion: null,
-      };
-    }
-
-    // Check if Flow needs upgrade
-    const flowVersion =
-      info.flowLatest && info.flowLatest !== currentVersion
-        ? { current: currentVersion, latest: info.flowLatest }
-        : null;
-
-    // Check if target needs upgrade
-    let targetVersion: { current: string; latest: string } | null = null;
-    if (targetId && info.targetLatest?.[targetId] && info.targetCurrent?.[targetId]) {
-      const current = info.targetCurrent[targetId];
-      const latest = info.targetLatest[targetId];
-      if (current !== latest) {
-        targetVersion = { current, latest };
-      }
+  private async readVersionInfo(): Promise<VersionInfo | null> {
+    try {
+      const data = await fs.readFile(VERSION_FILE, 'utf-8');
+      return JSON.parse(data);
+    } catch {
+      return null;
     }
-
-    return {
-      flowNeedsUpgrade: !!flowVersion,
-      targetNeedsUpgrade: !!targetVersion,
-      flowVersion,
-      targetVersion,
-    };
   }
 
   /**
-   * Check versions in background (non-blocking)
-   * Runs every time, updates info for next run
+   * Perform version check and upgrade if needed
    */
-  private checkInBackground(targetId?: string): void {
-    // Fire and forget - don't await
-    this.performBackgroundCheck(targetId).catch(() => {
-      // Silent fail
+  private async performCheck(): Promise<void> {
+    const currentVersion = await this.getCurrentVersion();
+    const latestVersion = await this.fetchLatestVersion();
+
+    // Save check time regardless of result
+    await this.saveVersionInfo({
+      flowLatest: latestVersion || undefined,
+      lastCheckTime: Date.now(),
     });
-  }
 
-  /**
-   * Perform the actual version check (called in background)
-   */
-  private async performBackgroundCheck(targetId?: string): Promise<void> {
-    const oldInfo = await this.readVersionInfo();
-
-    const newInfo: VersionInfo = {
-      targetLatest: oldInfo?.targetLatest || {},
-      targetCurrent: oldInfo?.targetCurrent || {},
-    };
-
-    // Check Flow version from npm (with timeout)
-    try {
-      const { stdout } = await execAsync('npm view @sylphx/flow version', { timeout: 5000 });
-      newInfo.flowLatest = stdout.trim();
-    } catch {
-      // Keep old value if check fails
-      newInfo.flowLatest = oldInfo?.flowLatest;
-    }
-
-    // Check target version from npm and local (with timeout)
-    if (targetId) {
-      const installation = this.targetInstaller.getInstallationInfo(targetId);
-      if (installation) {
-        // Check latest version from npm
-        try {
-          const { stdout } = await execAsync(`npm view ${installation.package} version`, {
-            timeout: 5000,
-          });
-          newInfo.targetLatest = newInfo.targetLatest || {};
-          newInfo.targetLatest[targetId] = stdout.trim();
-        } catch {
-          // Keep old value
-        }
+    if (!latestVersion) return;
 
-        // Check current installed version (local command)
-        try {
-          const { stdout } = await execAsync(installation.checkCommand, { timeout: 5000 });
-          const match = stdout.match(/v?(\d+\.\d+\.\d+)/);
-          if (match) {
-            newInfo.targetCurrent = newInfo.targetCurrent || {};
-            newInfo.targetCurrent[targetId] = match[1];
-          }
-        } catch {
-          // Keep old value
-        }
-      }
+    // Upgrade if newer version available
+    if (latestVersion !== currentVersion) {
+      await this.upgrade();
     }
-
-    await this.writeVersionInfo(newInfo);
   }
 
   /**
-   * Detect which package manager was used to install Flow globally
-   * by checking the executable path
+   * Get current Flow version from package.json
    */
-  private async detectFlowPackageManager(): Promise<'bun' | 'npm' | 'pnpm' | 'yarn'> {
+  private async getCurrentVersion(): Promise<string> {
     try {
-      const { stdout } = await execAsync('which flow || where flow');
-      const flowPath = stdout.trim().toLowerCase();
-
-      if (flowPath.includes('bun')) {
-        return 'bun';
-      }
-      if (flowPath.includes('pnpm')) {
-        return 'pnpm';
-      }
-      if (flowPath.includes('yarn')) {
-        return 'yarn';
-      }
+      const packageJsonPath = path.join(__dirname, '..', '..', 'package.json');
+      const packageJson = JSON.parse(await fs.readFile(packageJsonPath, 'utf-8'));
+      return packageJson.version;
     } catch {
-      // Fall through to default
+      return 'unknown';
     }
-
-    // Default to bun as it's the recommended install method
-    return 'bun';
   }
 
   /**
-   * Upgrade Flow to latest version using the package manager that installed it
-   * @returns True if upgrade successful, false otherwise
+   * Fetch latest version from npm registry
    */
-  async upgradeFlow(): Promise<boolean> {
-    const spinner = ora('Upgrading Flow...').start();
-
+  private async fetchLatestVersion(): Promise<string | null> {
     try {
-      // Detect which package manager was used to install Flow
-      const flowPm = await this.detectFlowPackageManager();
-      const upgradeCmd = getUpgradeCommand('@sylphx/flow', flowPm);
-
-      if (this.options.verbose) {
-        console.log(chalk.dim(`   Using ${flowPm}: ${upgradeCmd}`));
-      }
-
-      await execAsync(upgradeCmd);
-
-      spinner.succeed(chalk.green('✓ Flow upgraded (new version used on next run)'));
-      return true;
-    } catch (error) {
-      spinner.fail(chalk.red('✗ Flow upgrade failed'));
-
-      if (this.options.verbose) {
-        console.error(error);
-      }
-
-      return false;
+      const { stdout } = await execAsync('npm view @sylphx/flow version', { timeout: 5000 });
+      return stdout.trim();
+    } catch {
+      return null;
     }
   }
 
   /**
-   * Upgrade target CLI to latest version
-   * Tries built-in upgrade command first, falls back to package manager
-   * @param targetId - Target CLI ID to upgrade
-   * @returns True if upgrade successful, false otherwise
+   * Detect package manager used to install Flow
    */
-  async upgradeTarget(targetId: string): Promise<boolean> {
-    const installation = this.targetInstaller.getInstallationInfo(targetId);
-    if (!installation) {
-      return false;
-    }
-
-    const packageManager = detectPackageManager(this.projectPath);
-    const spinner = ora(`Upgrading ${installation.name}...`).start();
-
+  private async detectPackageManager(): Promise<'bun' | 'npm' | 'pnpm' | 'yarn'> {
     try {
-      // For Claude Code, use built-in update command if available
-      if (targetId === 'claude-code') {
-        try {
-          await execAsync('claude update');
-          spinner.succeed(chalk.green(`✓ ${installation.name} upgraded`));
-          return true;
-        } catch {
-          // Fall back to npm upgrade
-        }
-      }
-
-      // For OpenCode, use built-in upgrade command if available
-      if (targetId === 'opencode') {
-        try {
-          await execAsync('opencode upgrade');
-          spinner.succeed(chalk.green(`✓ ${installation.name} upgraded`));
-          return true;
-        } catch {
-          // Fall back to npm upgrade
-        }
-      }
-
-      // Fall back to npm/bun/pnpm/yarn upgrade
-      const upgradeCmd = getUpgradeCommand(installation.package, packageManager);
-      await execAsync(upgradeCmd);
-
-      spinner.succeed(chalk.green(`✓ ${installation.name} upgraded`));
-      return true;
-    } catch (error) {
-      spinner.fail(chalk.red(`✗ ${installation.name} upgrade failed`));
-
-      if (this.options.verbose) {
-        console.error(error);
-      }
-
-      return false;
-    }
-  }
-
-  /**
-   * Run auto-upgrade check and upgrade if needed (silent)
-   * @param targetId - Optional target CLI ID to check and upgrade
-   * @returns Upgrade result with status info
-   */
-  async runAutoUpgrade(targetId?: string): Promise<{
-    flowUpgraded: boolean;
-    flowVersion?: { current: string; latest: string };
-    targetUpgraded: boolean;
-    targetVersion?: { current: string; latest: string };
-  }> {
-    const status = await this.checkForUpgrades(targetId);
-    const result = {
-      flowUpgraded: false,
-      flowVersion: status.flowVersion ?? undefined,
-      targetUpgraded: false,
-      targetVersion: status.targetVersion ?? undefined,
-    };
-
-    // Perform upgrades silently
-    if (status.flowNeedsUpgrade) {
-      result.flowUpgraded = await this.upgradeFlowSilent();
-    }
+      const { stdout } = await execAsync('which flow || where flow');
+      const flowPath = stdout.trim().toLowerCase();
 
-    if (status.targetNeedsUpgrade && targetId) {
-      result.targetUpgraded = await this.upgradeTargetSilent(targetId);
+      if (flowPath.includes('bun')) return 'bun';
+      if (flowPath.includes('pnpm')) return 'pnpm';
+      if (flowPath.includes('yarn')) return 'yarn';
+    } catch {
+      // Fall through
     }
-
-    return result;
+    return 'bun'; // Default
   }
 
   /**
-   * Upgrade Flow silently (no spinner/output)
+   * Upgrade Flow to latest version
    */
-  private async upgradeFlowSilent(): Promise<boolean> {
+  private async upgrade(): Promise<void> {
     try {
-      const flowPm = await this.detectFlowPackageManager();
-      const upgradeCmd = getUpgradeCommand('@sylphx/flow', flowPm);
-      await execAsync(upgradeCmd);
-      return true;
+      const pm = await this.detectPackageManager();
+      const cmd = getUpgradeCommand('@sylphx/flow', pm);
+      await execAsync(cmd);
     } catch {
-      return false;
+      // Silent fail
     }
   }
 
   /**
-   * Upgrade target CLI silently (no spinner/output)
+   * Save version info to disk
    */
-  private async upgradeTargetSilent(targetId: string): Promise<boolean> {
-    const installation = this.targetInstaller.getInstallationInfo(targetId);
-    if (!installation) {
-      return false;
-    }
-
+  private async saveVersionInfo(info: VersionInfo): Promise<void> {
     try {
-      if (targetId === 'claude-code') {
-        try {
-          await execAsync('claude update');
-          return true;
-        } catch {
-          // Fall back to npm
-        }
-      }
-
-      if (targetId === 'opencode') {
-        try {
-          await execAsync('opencode upgrade');
-          return true;
-        } catch {
-          // Fall back to npm
-        }
-      }
-
-      const packageManager = detectPackageManager(this.projectPath);
-      const upgradeCmd = getUpgradeCommand(installation.package, packageManager);
-      await execAsync(upgradeCmd);
-      return true;
+      const dir = path.dirname(VERSION_FILE);
+      await fs.mkdir(dir, { recursive: true });
+      await fs.writeFile(VERSION_FILE, JSON.stringify(info, null, 2));
     } catch {
-      return false;
+      // Silent fail
     }
   }
 }

package/src/services/global-config.ts

@@ -70,6 +70,7 @@ export interface MCPConfig {
 
 export class GlobalConfigService {
   private flowHomeDir: string;
+  private flowConfigCache: FlowConfig | null = null;
 
   constructor() {
     this.flowHomeDir = path.join(os.homedir(), '.sylphx-flow');
@@ -259,13 +260,18 @@ export class GlobalConfigService {
 
   /**
    * Load Flow config (agents, rules, output styles)
+   * Cached for performance - call invalidateFlowConfigCache() after saving
    */
   async loadFlowConfig(): Promise<FlowConfig> {
+    if (this.flowConfigCache) {
+      return this.flowConfigCache;
+    }
+
     const configPath = this.getFlowConfigPath();
 
     if (!existsSync(configPath)) {
       // Default: all agents, all rules, all output styles enabled
-      return {
+      this.flowConfigCache = {
         version: '1.0.0',
         agents: {
           builder: { enabled: true },
@@ -279,10 +285,19 @@ export class GlobalConfigService {
         },
         outputStyles: {},
       };
+      return this.flowConfigCache;
     }
 
     const data = await fs.readFile(configPath, 'utf-8');
-    return JSON.parse(data);
+    this.flowConfigCache = JSON.parse(data);
+    return this.flowConfigCache;
+  }
+
+  /**
+   * Invalidate flow config cache (call after saving)
+   */
+  invalidateFlowConfigCache(): void {
+    this.flowConfigCache = null;
   }
 
   /**
@@ -292,6 +307,7 @@ export class GlobalConfigService {
     await this.initialize();
     const configPath = this.getFlowConfigPath();
     await fs.writeFile(configPath, JSON.stringify(config, null, 2));
+    this.flowConfigCache = config; // Update cache
   }
 
   /**