@sylphx/flow 2.14.1 → 2.15.1

package/CHANGELOG.md

@@ -1,5 +1,47 @@
 # @sylphx/flow
 
+## 2.15.1 (2025-12-17)
+
+### Improvements
+
+- **cli**: Make CLI output truly minimal and modern
+  - Remove all verbose status messages (backup, restore, session recovery)
+  - Remove emoji icons (🔧, ✔) for cleaner output
+  - Remove "Attached" and "Running" status lines
+  - Silent git worktree operations
+  - Silent crash recovery on startup
+  - Only show header: `flow {version} → {target}`
+
+### ♻️ Refactoring
+
+- **cli:** make output truly minimal and modern ([3315e41](https://github.com/SylphxAI/flow/commit/3315e41fa34839d7c866af1ebbe3b6f2d9e3ee71))
+
+## 2.15.0 (2025-12-17)
+
+### Features
+
+- **cli**: Redesign CLI output with modern, minimalist interface
+  - Single-line header: `flow {version} → {target}`
+  - Consolidated status: `✓ Attached {n} agents, {n} commands, {n} MCP`
+  - Silent operations by default (backup, cleanup, provider selection)
+  - Upgrade notification: `↑ Flow {version} (next run)`
+
+### Bug Fixes
+
+- **auto-upgrade**: Remove auto-restart after Flow upgrade - new version used on next run instead
+
+### ✨ Features
+
+- **cli:** redesign output with modern minimalist interface ([654146d](https://github.com/SylphxAI/flow/commit/654146d3ba7a635b39a599125300e60cfdba2bec))
+
+### 🐛 Bug Fixes
+
+- **auto-upgrade:** don't restart after Flow upgrade ([8207417](https://github.com/SylphxAI/flow/commit/8207417921dc60357e97a2ed8db7d6d79f0b5a3e))
+
+### 🔧 Chores
+
+- fix package.json formatting ([1e9d940](https://github.com/SylphxAI/flow/commit/1e9d94086e7186fa2a3e80c8f6c98483840d865d))
+
 ## 2.14.1 (2025-12-17)
 
 ### Documentation

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@sylphx/flow",
-	"version": "2.14.1",
+	"version": "2.15.1",
 	"description": "One CLI to rule them all. Unified orchestration layer for Claude Code, OpenCode, Cursor and all AI development tools. Auto-detection, auto-installation, auto-upgrade.",
 	"type": "module",
 	"bin": {

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

@@ -1,8 +1,11 @@
 /**
  * Execution Logic for Flow Command (V2 - Attach Mode)
- * New execution flow with attach-mode lifecycle
+ * Minimal, modern CLI output design
  */
 
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
 import chalk from 'chalk';
 import inquirer from 'inquirer';
 import { FlowExecutor } from '../../core/flow-executor.js';
@@ -12,13 +15,29 @@ import { GlobalConfigService } from '../../services/global-config.js';
 import { TargetInstaller } from '../../services/target-installer.js';
 import type { RunCommandOptions } from '../../types.js';
 import { extractAgentInstructions, loadAgentContent } from '../../utils/agent-enhancer.js';
-import { showWelcome } from '../../utils/display/banner.js';
+import { showHeader } from '../../utils/display/banner.js';
 import { CLIError } from '../../utils/error-handler.js';
 import { UserCancelledError } from '../../utils/errors.js';
 import { ensureTargetInstalled, promptForTargetSelection } from '../../utils/target-selection.js';
 import { resolvePrompt } from './prompt.js';
 import type { FlowOptions } from './types.js';
 
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+/**
+ * Get Flow version from package.json
+ */
+async function getFlowVersion(): Promise<string> {
+  try {
+    const packageJsonPath = path.join(__dirname, '..', '..', '..', 'package.json');
+    const packageJson = JSON.parse(await fs.readFile(packageJsonPath, 'utf-8'));
+    return packageJson.version;
+  } catch {
+    return 'unknown';
+  }
+}
+
 /**
  * Configure provider environment variables
  */
@@ -40,14 +59,14 @@ function configureProviderEnv(provider: 'kimi' | 'zai', apiKey: string): void {
 }
 
 /**
- * Select and configure provider for Claude Code
+ * Select and configure provider for Claude Code (silent unless prompting)
  */
 async function selectProvider(configService: GlobalConfigService): Promise<void> {
   try {
     const providerConfig = await configService.loadProviderConfig();
     const defaultProvider = providerConfig.claudeCode.defaultProvider;
 
-    // If not "ask-every-time", use the default provider
+    // If not "ask-every-time", use the default provider silently
     if (defaultProvider !== 'ask-every-time') {
       if (defaultProvider === 'kimi' || defaultProvider === 'zai') {
         const provider = providerConfig.claudeCode.providers[defaultProvider];
@@ -63,7 +82,7 @@ async function selectProvider(configService: GlobalConfigService): Promise<void>
       {
         type: 'list',
         name: 'selectedProvider',
-        message: 'Select provider for this session:',
+        message: 'Select provider:',
         choices: [
           { name: 'Default (Claude Code built-in)', value: 'default' },
           { name: 'Kimi', value: 'kimi' },
@@ -83,7 +102,6 @@ async function selectProvider(configService: GlobalConfigService): Promise<void>
     if (rememberChoice) {
       providerConfig.claudeCode.defaultProvider = selectedProvider;
       await configService.saveProviderConfig(providerConfig);
-      console.log(chalk.dim('   (Saved to settings)\n'));
     }
 
     // Configure environment variables based on selection
@@ -91,16 +109,11 @@ async function selectProvider(configService: GlobalConfigService): Promise<void>
       const provider = providerConfig.claudeCode.providers[selectedProvider];
 
       if (!provider?.apiKey) {
-        console.log(chalk.yellow('⚠ API key not configured. Use: sylphx-flow settings\n'));
+        console.log(chalk.yellow('  API key not configured. Use: sylphx-flow settings'));
         return;
       }
 
       configureProviderEnv(selectedProvider, provider.apiKey);
-
-      const providerName = selectedProvider === 'kimi' ? 'Kimi' : 'Z.ai';
-      console.log(chalk.green(`✓ Using ${providerName} provider\n`));
-    } else {
-      console.log(chalk.green('✓ Using default Claude Code provider\n'));
     }
   } catch (error: unknown) {
     // Handle user cancellation (Ctrl+C)
@@ -140,7 +153,7 @@ function executeTargetCommand(
 }
 
 /**
- * Main flow execution with attach mode (V2)
+ * Main flow execution with attach mode (V2) - Minimal output design
  */
 export async function executeFlowV2(
   prompt: string | undefined,
@@ -148,39 +161,29 @@ export async function executeFlowV2(
 ): Promise<void> {
   const projectPath = process.cwd();
 
-  // Show welcome banner
-  showWelcome();
-
   // Initialize config service early to check for saved preferences
   const configService = new GlobalConfigService();
   await configService.initialize();
 
-  // Step 1: Determine target
+  // 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();
 
   let selectedTargetId: string | null = null;
 
-  // Distinguish between three cases:
-  // 1. User explicitly set "ask-every-time" → always prompt
-  // 2. User has no setting (undefined/null) → allow auto-detect
-  // 3. User has specific target → use that target
   const isAskEveryTime = settings.defaultTarget === 'ask-every-time';
   const hasNoSetting = !settings.defaultTarget;
   const hasSpecificTarget = settings.defaultTarget && settings.defaultTarget !== 'ask-every-time';
 
   if (isAskEveryTime) {
-    // User explicitly wants to be asked every time - ALWAYS prompt, never auto-detect
-    console.log(chalk.cyan('🔍 Detecting installed AI CLIs...\n'));
-
+    // User explicitly wants to be asked every time
     selectedTargetId = await promptForTargetSelection(
       installedTargets,
-      'Select AI CLI to use:',
+      'Select AI CLI:',
       'execution'
     );
 
-    const installation = targetInstaller.getInstallationInfo(selectedTargetId);
     const installed = await ensureTargetInstalled(
       selectedTargetId,
       targetInstaller,
@@ -190,28 +193,17 @@ export async function executeFlowV2(
     if (!installed) {
       process.exit(1);
     }
-
-    if (installedTargets.includes(selectedTargetId)) {
-      console.log(chalk.green(`✓ Using ${installation?.name}\n`));
-    }
   } else if (hasNoSetting) {
-    // No setting - use auto-detection (smart default behavior)
+    // No setting - use auto-detection
     if (installedTargets.length === 1) {
-      // Exactly 1 target found - use it automatically
       selectedTargetId = installedTargets[0];
-      const installation = targetInstaller.getInstallationInfo(selectedTargetId);
-      console.log(chalk.green(`✓ Using ${installation?.name} (auto-detected)\n`));
     } else {
-      // 0 or multiple targets - prompt for selection
-      console.log(chalk.cyan('🔍 Detecting installed AI CLIs...\n'));
-
       selectedTargetId = await promptForTargetSelection(
         installedTargets,
-        'Select AI CLI to use:',
+        'Select AI CLI:',
         'execution'
       );
 
-      const installation = targetInstaller.getInstallationInfo(selectedTargetId);
       const installed = await ensureTargetInstalled(
         selectedTargetId,
         targetInstaller,
@@ -221,110 +213,77 @@ export async function executeFlowV2(
       if (!installed) {
         process.exit(1);
       }
-
-      if (installedTargets.includes(selectedTargetId)) {
-        console.log(chalk.green(`✓ Using ${installation?.name}\n`));
-      }
     }
   } else if (hasSpecificTarget) {
-    // User has a specific target preference - ALWAYS use it
+    // User has a specific target preference
     selectedTargetId = settings.defaultTarget;
-    const installation = targetInstaller.getInstallationInfo(selectedTargetId);
 
-    // Check if the preferred target is installed
-    if (installedTargets.includes(selectedTargetId)) {
-      console.log(chalk.green(`✓ Using ${installation?.name} (from settings)\n`));
-    } else {
-      // Preferred target not installed - try to install it
-      console.log(chalk.yellow(`⚠️  ${installation?.name} is set as default but not installed\n`));
+    if (!installedTargets.includes(selectedTargetId)) {
+      const installation = targetInstaller.getInstallationInfo(selectedTargetId);
+      console.log(chalk.yellow(`\n  ${installation?.name} not installed`));
       const installed = await targetInstaller.install(selectedTargetId, true);
 
       if (!installed) {
-        // Installation failed - show error and exit
-        console.log(
-          chalk.red(
-            `\n✗ Cannot proceed: ${installation?.name} is not installed and auto-install failed`
-          )
-        );
-        console.log(chalk.yellow('   Please either:'));
-        console.log(chalk.cyan('   1. Install manually (see instructions above)'));
-        console.log(chalk.cyan('   2. Change default target: sylphx-flow settings\n'));
+        console.log(chalk.red(`  Cannot proceed: installation failed\n`));
         process.exit(1);
       }
-
-      console.log();
     }
   }
 
-  // Step 2: Auto-upgrade Flow and target CLI
+  // Get version and target name for header
+  const version = await getFlowVersion();
+  const targetInstallation = targetInstaller.getInstallationInfo(selectedTargetId);
+  const targetName = targetInstallation?.name || selectedTargetId;
+
+  // Show minimal header
+  showHeader(version, targetName);
+
+  // Step 2: Auto-upgrade (silent, returns status)
   const autoUpgrade = new AutoUpgrade(projectPath);
-  await autoUpgrade.runAutoUpgrade(selectedTargetId);
+  const upgradeResult = await autoUpgrade.runAutoUpgrade(selectedTargetId);
 
-  // Mode info
-  if (options.merge) {
-    console.log(
-      chalk.cyan('🔗 Merge mode: Flow settings will be merged with your existing settings')
-    );
-    console.log(chalk.dim('   Settings will be restored after execution\n'));
-  } else {
-    console.log(
-      chalk.yellow('🔄 Replace mode (default): All settings will use Flow configuration')
-    );
-    console.log(chalk.dim('   Use --merge to keep your existing settings\n'));
+  // 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}`));
   }
 
   // Create executor
   const executor = new FlowExecutor();
-  const _projectManager = executor.getProjectManager();
 
-  // Step 2: Execute attach mode lifecycle
+  // Step 3: Execute attach mode lifecycle
   try {
     // Attach Flow environment (backup → attach → register cleanup)
-    await executor.execute(projectPath, {
+    const attachResult = await executor.execute(projectPath, {
       verbose: options.verbose,
       skipBackup: false,
       skipSecrets: false,
       merge: options.merge || false,
     });
 
-    // Step 3: Use the target we already selected (don't re-detect)
-    // selectedTargetId was determined earlier based on settings/auto-detect/prompt
     const targetId = selectedTargetId;
 
-    // Step 3.5: Provider selection (Claude Code only)
+    // Provider selection (Claude Code only, silent unless prompting)
     if (targetId === 'claude-code') {
       await selectProvider(configService);
     }
 
-    // Step 3.6: Load Flow settings and determine agent to use
-    const settings = await configService.loadSettings();
+    // Determine which agent to use
     const flowConfig = await configService.loadFlowConfig();
+    let agent = options.agent || settings.defaultAgent || 'coder';
 
-    // Determine which agent to use (CLI option > settings default > 'coder')
-    const agent = options.agent || settings.defaultAgent || 'coder';
-
-    // Check if agent is enabled
+    // Check if agent is enabled (silent fallback)
     if (!flowConfig.agents[agent]?.enabled) {
-      console.log(chalk.yellow(`⚠️  Agent '${agent}' is not enabled in settings`));
-      console.log(chalk.yellow(`   Enable it with: sylphx-flow settings`));
-      console.log(chalk.yellow(`   Using 'coder' agent instead\n`));
-      // Fallback to first enabled agent or coder
       const enabledAgents = await configService.getEnabledAgents();
-      const fallbackAgent = enabledAgents.length > 0 ? enabledAgents[0] : 'coder';
-      options.agent = fallbackAgent;
+      agent = enabledAgents.length > 0 ? enabledAgents[0] : 'coder';
     }
 
-    console.log(chalk.cyan(`🤖 Running agent: ${agent}\n`));
-
-    // Load enabled rules and output styles from config
+    // Load agent content
     const enabledRules = await configService.getEnabledRules();
     const enabledOutputStyles = await configService.getEnabledOutputStyles();
 
-    console.log(chalk.dim(`   Enabled rules: ${enabledRules.join(', ')}`));
-    console.log(chalk.dim(`   Enabled output styles: ${enabledOutputStyles.join(', ')}\n`));
-
-    // Load agent content with enabled rules and output styles
-    // Rules are filtered: intersection of agent's frontmatter rules and globally enabled rules
     const agentContent = await loadAgentContent(
       agent,
       options.agentFile,
@@ -334,7 +293,6 @@ export async function executeFlowV2(
     const agentInstructions = extractAgentInstructions(agentContent);
 
     const systemPrompt = `AGENT INSTRUCTIONS:\n${agentInstructions}`;
-
     const userPrompt = prompt?.trim() || '';
 
     // Prepare run options
@@ -352,30 +310,27 @@ export async function executeFlowV2(
     // Step 4: Execute command
     await executeTargetCommand(targetId, systemPrompt, userPrompt, runOptions);
 
-    // Step 5: Cleanup (restore environment)
+    // Step 5: Cleanup (silent)
     await executor.cleanup(projectPath);
-
-    console.log(chalk.green('✓ Session complete\n'));
   } catch (error) {
     // Handle user cancellation gracefully
     if (error instanceof UserCancelledError) {
-      console.log(chalk.yellow('\n⚠️  Operation cancelled by user'));
+      console.log(chalk.yellow('\n  Cancelled'));
       try {
         await executor.cleanup(projectPath);
-        console.log(chalk.green('   ✓ Settings restored\n'));
-      } catch (cleanupError) {
-        console.error(chalk.red('   ✗ Cleanup failed:'), cleanupError);
+      } catch {
+        // Silent cleanup failure
       }
       process.exit(0);
     }
 
-    console.error(chalk.red.bold('\n✗ Execution failed:'), error);
+    console.error(chalk.red('\n  Error:'), error);
 
     // Ensure cleanup even on error
     try {
       await executor.cleanup(projectPath);
-    } catch (cleanupError) {
-      console.error(chalk.red('✗ Cleanup failed:'), cleanupError);
+    } catch {
+      // Silent cleanup failure
     }
 
     throw error;

package/src/core/attach-manager.ts

@@ -8,7 +8,6 @@ import { createHash } from 'node:crypto';
 import { existsSync } from 'node:fs';
 import fs from 'node:fs/promises';
 import path from 'node:path';
-import chalk from 'chalk';
 import { MCP_SERVER_REGISTRY, type MCPServerID } from '../config/servers.js';
 import { GlobalConfigService } from '../services/global-config.js';
 import type { Target } from '../types/target.types.js';
@@ -184,9 +183,6 @@ export class AttachManager {
       await this.attachSingleFiles(projectPath, templates.singleFiles, result, manifest);
     }
 
-    // Show conflict warnings
-    this.showConflictWarnings(result);
-
     return result;
   }
 
@@ -421,21 +417,4 @@ export class AttachManager {
       result.singleFilesMerged.push(file.path);
     }
   }
-
-  /**
-   * Show conflict warnings to user
-   */
-  private showConflictWarnings(result: AttachResult): void {
-    if (result.conflicts.length === 0) {
-      return;
-    }
-
-    console.log(chalk.yellow('\n⚠️  Conflicts detected:\n'));
-
-    for (const conflict of result.conflicts) {
-      console.log(chalk.yellow(`   • ${conflict.type}: ${conflict.name} - ${conflict.action}`));
-    }
-
-    console.log(chalk.dim("\n   Don't worry! All overridden content will be restored on exit.\n"));
-  }
 }

package/src/core/backup-manager.ts

@@ -7,7 +7,6 @@
 import { existsSync } from 'node:fs';
 import fs from 'node:fs/promises';
 import path from 'node:path';
-import ora from 'ora';
 import type { Target } from '../types/target.types.js';
 import type { ProjectManager } from './project-manager.js';
 import { targetManager } from './target-manager.js';
@@ -96,72 +95,63 @@ export class BackupManager {
     // Ensure backup directory exists
     await fs.mkdir(backupPath, { recursive: true });
 
-    const spinner = ora('Creating backup...').start();
+    // Get target config directory
+    const targetConfigDir = this.projectManager.getTargetConfigDir(projectPath, target);
 
-    try {
-      // Get target config directory
-      const targetConfigDir = this.projectManager.getTargetConfigDir(projectPath, target);
-
-      // Backup entire target directory if it exists
-      if (existsSync(targetConfigDir)) {
-        // Use configDir from target config (e.g., '.claude', '.opencode')
-        const backupTargetDir = path.join(backupPath, target.config.configDir);
-        await this.copyDirectory(targetConfigDir, backupTargetDir);
-      }
+    // Backup entire target directory if it exists
+    if (existsSync(targetConfigDir)) {
+      // Use configDir from target config (e.g., '.claude', '.opencode')
+      const backupTargetDir = path.join(backupPath, target.config.configDir);
+      await this.copyDirectory(targetConfigDir, backupTargetDir);
+    }
 
-      // Create manifest (store target ID as string for JSON serialization)
-      const manifest: BackupManifest = {
-        sessionId,
-        timestamp,
-        projectPath,
-        target: targetId,
-        backup: {
-          agents: { user: [], flow: [] },
-          commands: { user: [], flow: [] },
-          singleFiles: {},
-        },
-        secrets: {
-          mcpEnvExtracted: false,
-          storedAt: '',
-        },
-      };
-
-      await fs.writeFile(path.join(backupPath, 'manifest.json'), JSON.stringify(manifest, null, 2));
-
-      // Create symlink to latest (with fallback for Windows)
-      const latestLink = paths.latestBackup;
-      if (existsSync(latestLink)) {
-        await fs.unlink(latestLink);
-      }
-      try {
-        await fs.symlink(sessionId, latestLink);
-      } catch (symlinkError: unknown) {
-        // Windows without admin/Developer Mode can't create symlinks
-        // Fall back to writing session ID to a file
-        if (
-          symlinkError instanceof Error &&
-          'code' in symlinkError &&
-          symlinkError.code === 'EPERM'
-        ) {
-          await fs.writeFile(latestLink, sessionId, 'utf-8');
-        } else {
-          throw symlinkError;
-        }
-      }
+    // Create manifest (store target ID as string for JSON serialization)
+    const manifest: BackupManifest = {
+      sessionId,
+      timestamp,
+      projectPath,
+      target: targetId,
+      backup: {
+        agents: { user: [], flow: [] },
+        commands: { user: [], flow: [] },
+        singleFiles: {},
+      },
+      secrets: {
+        mcpEnvExtracted: false,
+        storedAt: '',
+      },
+    };
+
+    await fs.writeFile(path.join(backupPath, 'manifest.json'), JSON.stringify(manifest, null, 2));
 
-      spinner.succeed(`Backup created: ${sessionId}`);
-
-      return {
-        sessionId,
-        timestamp,
-        projectPath,
-        target: targetId,
-        backupPath,
-      };
-    } catch (error) {
-      spinner.fail('Backup failed');
-      throw error;
+    // Create symlink to latest (with fallback for Windows)
+    const latestLink = paths.latestBackup;
+    if (existsSync(latestLink)) {
+      await fs.unlink(latestLink);
     }
+    try {
+      await fs.symlink(sessionId, latestLink);
+    } catch (symlinkError: unknown) {
+      // Windows without admin/Developer Mode can't create symlinks
+      // Fall back to writing session ID to a file
+      if (
+        symlinkError instanceof Error &&
+        'code' in symlinkError &&
+        symlinkError.code === 'EPERM'
+      ) {
+        await fs.writeFile(latestLink, sessionId, 'utf-8');
+      } else {
+        throw symlinkError;
+      }
+    }
+
+    return {
+      sessionId,
+      timestamp,
+      projectPath,
+      target: targetId,
+      backupPath,
+    };
   }
 
   /**
@@ -175,38 +165,29 @@ export class BackupManager {
       throw new Error(`Backup not found: ${sessionId}`);
     }
 
-    const spinner = ora('Restoring backup...').start();
-
-    try {
-      // Read manifest
-      const manifestPath = path.join(backupPath, 'manifest.json');
-      const manifest: BackupManifest = JSON.parse(await fs.readFile(manifestPath, 'utf-8'));
-
-      const projectPath = manifest.projectPath;
-      const targetId = manifest.target;
+    // Read manifest
+    const manifestPath = path.join(backupPath, 'manifest.json');
+    const manifest: BackupManifest = JSON.parse(await fs.readFile(manifestPath, 'utf-8'));
 
-      // Resolve target to get config
-      const target = this.resolveTarget(targetId);
+    const projectPath = manifest.projectPath;
+    const targetId = manifest.target;
 
-      // Get target config directory
-      const targetConfigDir = this.projectManager.getTargetConfigDir(projectPath, target);
+    // Resolve target to get config
+    const target = this.resolveTarget(targetId);
 
-      // Remove current target directory
-      if (existsSync(targetConfigDir)) {
-        await fs.rm(targetConfigDir, { recursive: true, force: true });
-      }
+    // Get target config directory
+    const targetConfigDir = this.projectManager.getTargetConfigDir(projectPath, target);
 
-      // Restore from backup using target config's configDir
-      const backupTargetDir = path.join(backupPath, target.config.configDir);
+    // Remove current target directory
+    if (existsSync(targetConfigDir)) {
+      await fs.rm(targetConfigDir, { recursive: true, force: true });
+    }
 
-      if (existsSync(backupTargetDir)) {
-        await this.copyDirectory(backupTargetDir, targetConfigDir);
-      }
+    // Restore from backup using target config's configDir
+    const backupTargetDir = path.join(backupPath, target.config.configDir);
 
-      spinner.succeed('Backup restored');
-    } catch (error) {
-      spinner.fail('Restore failed');
-      throw error;
+    if (existsSync(backupTargetDir)) {
+      await this.copyDirectory(backupTargetDir, targetConfigDir);
     }
   }
 

package/src/core/cleanup-handler.ts

@@ -4,7 +4,6 @@
  * Handles process signals and ensures backup restoration
  */
 
-import chalk from 'chalk';
 import type { BackupManager } from './backup-manager.js';
 import type { ProjectManager } from './project-manager.js';
 import type { SessionManager } from './session-manager.js';
@@ -43,30 +42,26 @@ export class CleanupHandler {
 
     // SIGINT (Ctrl+C)
     process.on('SIGINT', async () => {
-      console.log(chalk.yellow('\n⚠️  Interrupted by user, cleaning up...'));
       await this.onSignal('SIGINT');
       process.exit(0);
     });
 
     // SIGTERM
     process.on('SIGTERM', async () => {
-      console.log(chalk.yellow('\n⚠️  Terminated, cleaning up...'));
       await this.onSignal('SIGTERM');
       process.exit(0);
     });
 
     // Uncaught exceptions
     process.on('uncaughtException', async (error) => {
-      console.error(chalk.red('\n✗ Uncaught Exception:'));
-      console.error(error);
+      console.error('\nUncaught Exception:', error);
       await this.onSignal('uncaughtException');
       process.exit(1);
     });
 
     // Unhandled rejections
     process.on('unhandledRejection', async (reason) => {
-      console.error(chalk.red('\n✗ Unhandled Rejection:'));
-      console.error(reason);
+      console.error('\nUnhandled Rejection:', reason);
       await this.onSignal('unhandledRejection');
       process.exit(1);
     });
@@ -97,6 +92,7 @@ export class CleanupHandler {
 
   /**
    * Signal-based cleanup (SIGINT, SIGTERM, etc.) with multi-session support
+   * Silent operation - no console output
    */
   private async onSignal(_signal: string): Promise<void> {
     if (!this.currentProjectHash) {
@@ -104,29 +100,22 @@ export class CleanupHandler {
     }
 
     try {
-      console.log(chalk.cyan('🧹 Cleaning up...'));
-
       const { shouldRestore, session } = await this.sessionManager.endSession(
         this.currentProjectHash
       );
 
       if (shouldRestore && session) {
-        // Last session - restore environment
-        console.log(chalk.cyan('   Restoring environment...'));
         await this.backupManager.restoreBackup(this.currentProjectHash, session.sessionId);
-        console.log(chalk.green('✓ Environment restored'));
-      } else if (!shouldRestore && session) {
-        // Other sessions still running
-        console.log(chalk.yellow(`   ${session.refCount} session(s) still running`));
       }
-    } catch (error) {
-      console.error(chalk.red('✗ Cleanup failed:'), error);
+    } catch (_error) {
+      // Silent fail
     }
   }
 
   /**
    * Recover on startup (for all projects)
    * Checks for orphaned sessions from crashes
+   * Silent operation - no console output
    */
   async recoverOnStartup(): Promise<void> {
     const orphanedSessions = await this.sessionManager.detectOrphanedSessions();
@@ -135,21 +124,12 @@ export class CleanupHandler {
       return;
     }
 
-    console.log(chalk.cyan(`\n🔧 Recovering ${orphanedSessions.size} crashed session(s)...\n`));
-
     for (const [projectHash, session] of orphanedSessions) {
-      console.log(chalk.dim(`   Project: ${session.projectPath}`));
-
       try {
-        // Restore backup
         await this.backupManager.restoreBackup(projectHash, session.sessionId);
-
-        // Clean up session
         await this.sessionManager.recoverSession(projectHash, session);
-
-        console.log(chalk.green('   ✓ Environment restored\n'));
-      } catch (error) {
-        console.error(chalk.red('   ✗ Recovery failed:'), error);
+      } catch (_error) {
+        // Silent fail - don't interrupt startup
       }
     }
   }

package/src/core/flow-executor.ts

@@ -6,7 +6,7 @@
 
 import chalk from 'chalk';
 import type { Target } from '../types/target.types.js';
-import { AttachManager, type AttachResult } from './attach-manager.js';
+import { AttachManager } from './attach-manager.js';
 import { BackupManager } from './backup-manager.js';
 import { CleanupHandler } from './cleanup-handler.js';
 import { GitStashManager } from './git-stash-manager.js';
@@ -50,8 +50,12 @@ export class FlowExecutor {
 
   /**
    * Execute complete flow with attach mode (with multi-session support)
+   * Returns summary for caller to display
    */
-  async execute(projectPath: string, options: FlowExecutorOptions = {}): Promise<void> {
+  async execute(
+    projectPath: string,
+    options: FlowExecutorOptions = {}
+  ): Promise<{ joined: boolean; agents?: number; commands?: number; mcp?: number }> {
     // Initialize Flow directories
     await this.projectManager.initialize();
 
@@ -72,44 +76,30 @@ export class FlowExecutor {
     const existingSession = await this.sessionManager.getActiveSession(projectHash);
 
     if (existingSession) {
-      // Joining existing session
-      console.log(chalk.cyan('🔗 Joining existing session...'));
-
-      const { session } = await this.sessionManager.startSession(
+      // Joining existing session - silent
+      await this.sessionManager.startSession(
         projectPath,
         projectHash,
         target,
         existingSession.backupPath
       );
-
-      // Register cleanup hooks
       this.cleanupHandler.registerCleanupHooks(projectHash);
-
-      console.log(chalk.green(`   ✓ Joined session (${session.refCount} active session(s))\n`));
-      console.log(chalk.green('✓ Flow environment ready!\n'));
-      return;
+      return { joined: true };
     }
 
-    // First session - stash settings changes, then create backup and attach
-    // Step 3: Stash git changes to hide Flow's modifications from git status
-    console.log(chalk.cyan('🔍 Checking git status...'));
+    // First session - stash, backup, attach (all silent)
     await this.gitStashManager.stashSettingsChanges(projectPath);
-
-    console.log(chalk.cyan('💾 Creating backup...'));
     const backup = await this.backupManager.createBackup(projectPath, projectHash, target);
 
-    // Step 4: Extract and save secrets
+    // Extract and save secrets (silent)
     if (!options.skipSecrets) {
-      console.log(chalk.cyan('🔐 Extracting secrets...'));
       const secrets = await this.secretsManager.extractMCPSecrets(projectPath, projectHash, target);
-
       if (Object.keys(secrets.servers).length > 0) {
         await this.secretsManager.saveSecrets(projectHash, secrets);
-        console.log(chalk.green(`   ✓ Saved ${Object.keys(secrets.servers).length} MCP secret(s)`));
       }
     }
 
-    // Step 5: Start session (use backup's sessionId to ensure consistency)
+    // Start session
     const { session } = await this.sessionManager.startSession(
       projectPath,
       projectHash,
@@ -118,21 +108,14 @@ export class FlowExecutor {
       backup.sessionId
     );
 
-    // Step 6: Register cleanup hooks
     this.cleanupHandler.registerCleanupHooks(projectHash);
 
-    // Step 7: Default replace mode - clear user files before attaching (unless merge flag is set)
+    // Clear and attach (silent)
     if (!options.merge) {
-      console.log(chalk.cyan('🔄 Clearing existing settings...'));
       await this.clearUserSettings(projectPath, target);
     }
 
-    // Step 8: Load templates
-    console.log(chalk.cyan('📦 Loading Flow templates...'));
     const templates = await this.templateLoader.loadTemplates(target);
-
-    // Step 9: Attach Flow environment
-    console.log(chalk.cyan('🚀 Attaching Flow environment...'));
     const manifest = await this.backupManager.getManifest(projectHash, session.sessionId);
 
     if (!manifest) {
@@ -147,13 +130,15 @@ export class FlowExecutor {
       manifest
     );
 
-    // Update manifest with attach results
     await this.backupManager.updateManifest(projectHash, session.sessionId, manifest);
 
-    // Show summary
-    this.showAttachSummary(attachResult);
-
-    console.log(chalk.green('\n✓ Flow environment ready!\n'));
+    // Return summary for caller to display
+    return {
+      joined: false,
+      agents: attachResult.agentsAdded.length,
+      commands: attachResult.commandsAdded.length,
+      mcp: attachResult.mcpServersAdded.length,
+    };
   }
 
   /**
@@ -260,65 +245,12 @@ export class FlowExecutor {
   }
 
   /**
-   * Cleanup after execution
+   * Cleanup after execution (silent)
    */
   async cleanup(projectPath: string): Promise<void> {
     const projectHash = this.projectManager.getProjectHash(projectPath);
-
-    console.log(chalk.cyan('\n🧹 Cleaning up...'));
-
     await this.cleanupHandler.cleanup(projectHash);
-
-    // Restore stashed git changes
     await this.gitStashManager.popSettingsChanges(projectPath);
-
-    console.log(chalk.green('   ✓ Environment restored'));
-    console.log(chalk.green('   ✓ Secrets preserved for next run\n'));
-  }
-
-  /**
-   * Show attach summary
-   */
-  private showAttachSummary(result: AttachResult): void {
-    const items = [];
-
-    if (result.agentsAdded.length > 0) {
-      items.push(`${result.agentsAdded.length} agent${result.agentsAdded.length > 1 ? 's' : ''}`);
-    }
-
-    if (result.commandsAdded.length > 0) {
-      items.push(
-        `${result.commandsAdded.length} command${result.commandsAdded.length > 1 ? 's' : ''}`
-      );
-    }
-
-    if (result.mcpServersAdded.length > 0) {
-      items.push(
-        `${result.mcpServersAdded.length} MCP server${result.mcpServersAdded.length > 1 ? 's' : ''}`
-      );
-    }
-
-    if (result.hooksAdded.length > 0) {
-      items.push(`${result.hooksAdded.length} hook${result.hooksAdded.length > 1 ? 's' : ''}`);
-    }
-
-    if (result.rulesAppended) {
-      items.push('rules');
-    }
-
-    if (items.length > 0) {
-      console.log(chalk.green(`   ✓ Added: ${items.join(', ')}`));
-    }
-
-    const overridden =
-      result.agentsOverridden.length +
-      result.commandsOverridden.length +
-      result.mcpServersOverridden.length +
-      result.hooksOverridden.length;
-
-    if (overridden > 0) {
-      console.log(chalk.yellow(`   ⚠ Overridden: ${overridden} item${overridden > 1 ? 's' : ''}`));
-    }
   }
 
   /**

package/src/core/git-stash-manager.ts

@@ -8,7 +8,6 @@ import { exec } from 'node:child_process';
 import { existsSync } from 'node:fs';
 import path from 'node:path';
 import { promisify } from 'node:util';
-import chalk from 'chalk';
 
 const execAsync = promisify(exec);
 
@@ -93,14 +92,8 @@ export class GitStashManager {
           // File might not exist or not tracked, skip it
         }
       }
-
-      if (this.skipWorktreeFiles.length > 0) {
-        console.log(
-          chalk.dim(`   ✓ Hiding ${this.skipWorktreeFiles.length} settings file(s) from git\n`)
-        );
-      }
     } catch (_error) {
-      console.log(chalk.yellow('   ⚠️  Could not hide settings from git\n'));
+      // Silent fail
     }
   }
 
@@ -123,15 +116,9 @@ export class GitStashManager {
         }
       }
 
-      console.log(
-        chalk.dim(`   ✓ Restored git tracking for ${this.skipWorktreeFiles.length} file(s)\n`)
-      );
       this.skipWorktreeFiles = [];
-    } catch {
-      console.log(chalk.yellow('   ⚠️  Could not restore git tracking'));
-      console.log(
-        chalk.yellow('   Run manually: git update-index --no-skip-worktree .claude/* .opencode/*\n')
-      );
+    } catch (_error) {
+      // Silent fail
     }
   }
 

package/src/services/auto-upgrade.ts

@@ -163,7 +163,7 @@ export class AutoUpgrade {
 
       await execAsync(upgradeCmd);
 
-      spinner.succeed(chalk.green('✓ Flow upgraded to latest version'));
+      spinner.succeed(chalk.green('✓ Flow upgraded (new version used on next run)'));
       return true;
     } catch (error) {
       spinner.fail(chalk.red('✗ Flow upgrade failed'));
@@ -232,64 +232,84 @@ export class AutoUpgrade {
   }
 
   /**
-   * Run auto-upgrade check and upgrade if needed
-   * Shows upgrade status and performs upgrades automatically
+   * 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<void> {
-    console.log(chalk.cyan('🔄 Checking for updates...\n'));
-
+  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();
+    }
+
+    if (status.targetNeedsUpgrade && targetId) {
+      result.targetUpgraded = await this.upgradeTargetSilent(targetId);
+    }
+
+    return result;
+  }
 
-    // Show upgrade status
-    if (status.flowNeedsUpgrade && status.flowVersion) {
-      console.log(
-        chalk.yellow(
-          `📦 Flow update available: ${status.flowVersion.current} → ${status.flowVersion.latest}`
-        )
-      );
-    } else if (!this.options.skipFlow) {
-      console.log(chalk.green('✓ Flow is up to date'));
+  /**
+   * Upgrade Flow silently (no spinner/output)
+   */
+  private async upgradeFlowSilent(): Promise<boolean> {
+    try {
+      const flowPm = await this.detectFlowPackageManager();
+      const upgradeCmd = getUpgradeCommand('@sylphx/flow', flowPm);
+      await execAsync(upgradeCmd);
+      return true;
+    } catch {
+      return false;
     }
+  }
 
-    if (status.targetNeedsUpgrade && status.targetVersion && targetId) {
-      const installation = this.targetInstaller.getInstallationInfo(targetId);
-      console.log(
-        chalk.yellow(
-          `📦 ${installation?.name} update available: ${status.targetVersion.current} → ${status.targetVersion.latest}`
-        )
-      );
-    } else if (!this.options.skipTarget && targetId) {
-      const installation = this.targetInstaller.getInstallationInfo(targetId);
-      console.log(chalk.green(`✓ ${installation?.name} is up to date`));
+  /**
+   * Upgrade target CLI silently (no spinner/output)
+   */
+  private async upgradeTargetSilent(targetId: string): Promise<boolean> {
+    const installation = this.targetInstaller.getInstallationInfo(targetId);
+    if (!installation) {
+      return false;
     }
 
-    // Perform upgrades if needed
-    if (status.flowNeedsUpgrade || status.targetNeedsUpgrade) {
-      console.log(chalk.cyan('\n📦 Installing updates...\n'));
-
-      if (status.flowNeedsUpgrade && !process.env.SYLPHX_FLOW_UPGRADED) {
-        const upgraded = await this.upgradeFlow();
-        if (upgraded) {
-          // Re-exec the process to use the new version
-          console.log(chalk.cyan('\n🔄 Restarting with updated version...\n'));
-          const { spawn } = await import('node:child_process');
-          const child = spawn(process.argv[0], process.argv.slice(1), {
-            stdio: 'inherit',
-            env: { ...process.env, SYLPHX_FLOW_UPGRADED: '1' },
-          });
-          child.on('exit', (code) => process.exit(code ?? 0));
-          return; // Don't continue with old code
+    try {
+      if (targetId === 'claude-code') {
+        try {
+          await execAsync('claude update');
+          return true;
+        } catch {
+          // Fall back to npm
         }
       }
 
-      if (status.targetNeedsUpgrade && targetId) {
-        await this.upgradeTarget(targetId);
+      if (targetId === 'opencode') {
+        try {
+          await execAsync('opencode upgrade');
+          return true;
+        } catch {
+          // Fall back to npm
+        }
       }
 
-      console.log(chalk.green('\n✓ All tools upgraded\n'));
-    } else {
-      console.log();
+      const packageManager = detectPackageManager(this.projectPath);
+      const upgradeCmd = getUpgradeCommand(installation.package, packageManager);
+      await execAsync(upgradeCmd);
+      return true;
+    } catch {
+      return false;
     }
   }
 }

package/src/utils/agent-enhancer.ts

@@ -59,8 +59,7 @@ async function loadRules(ruleNames?: string[]): Promise<string> {
         const stripped = await yamlUtils.stripFrontMatter(content);
         sections.push(stripped);
       } catch (_error) {
-        // Log warning if rule file not found, but continue with other rules
-        console.warn(`Warning: Rule file not found: ${ruleName}.md`);
+        // Silent - rule file not found, continue with other rules
       }
     }
 
@@ -89,7 +88,7 @@ async function loadOutputStyles(styleNames?: string[]): Promise<string> {
           const stripped = await yamlUtils.stripFrontMatter(content);
           sections.push(stripped);
         } catch (_error) {
-          console.warn(`Warning: Output style file not found: ${styleName}.md`);
+          // Silent - output style file not found, continue
         }
       }
     } else {

package/src/utils/display/banner.ts

@@ -1,25 +1,20 @@
 /**
  * Banner Display Utilities
- * Welcome messages and branding
+ * Minimal, modern CLI output
  */
 
-import boxen from 'boxen';
 import chalk from 'chalk';
 
 /**
- * Display welcome banner
+ * Show minimal header: flow {version} → {target}
+ */
+export function showHeader(version: string, target: string): void {
+  console.log(`\n${chalk.cyan('flow')} ${chalk.dim(version)} ${chalk.dim('→')} ${target}\n`);
+}
+
+/**
+ * @deprecated Use showHeader instead
  */
 export function showWelcome(): void {
-  console.log(
-    boxen(
-      `${chalk.cyan.bold('Sylphx Flow')} ${chalk.dim('- AI-Powered Development Framework')}\n` +
-        `${chalk.dim('Auto-initialization • Smart upgrades • One-click launch')}`,
-      {
-        padding: 1,
-        margin: { bottom: 1 },
-        borderStyle: 'round',
-        borderColor: 'cyan',
-      }
-    )
-  );
+  // No-op for backward compatibility during migration
 }