feat(installer): collect soft errors and mark only successfully installed packages

runInteractiveInstall and RunFromSnapshot now collect npm/shell/dotfiles/macos step errors into softErrs and return them joined rather than swallowing. InstallWithProgress signature returns (installedFormulae, installedCasks, err) so state.markFormula/markCask are only called for packages that actually succeeded.

Ultraworked with [Sisyphus](https://github.com/code-yeongyu/oh-my-opencode)

Co-authored-by: Sisyphus <clio-agent@sisyphuslabs.ai>

Author: fullstackjam

internal/cli/snapshot.go

@@ -175,6 +175,14 @@ func captureWithUI() (*snapshot.Snapshot, error) {
 		return nil, fmt.Errorf("failed to capture snapshot: %w", err)
 	}
 
+	if snap.Health.Partial {
+		fmt.Fprintln(os.Stderr)
+		ui.Warn(fmt.Sprintf("Snapshot is partial — %d step(s) failed: %s",
+			len(snap.Health.FailedSteps),
+			strings.Join(snap.Health.FailedSteps, ", ")))
+		fmt.Fprintln(os.Stderr, snapMutedStyle.Render("  The snapshot was saved but may be incomplete."))
+	}
+
 	return snap, nil
 }
 

internal/installer/installer.go

@@ -1,6 +1,7 @@
 package installer
 
 import (
+	"errors"
 	"fmt"
 	"strings"
 	"time"
@@ -159,25 +160,37 @@ func runInteractiveInstall(cfg *config.Config) error {
 		return err
 	}
 
+	var softErrs []error
+
 	if err := stepInstallNpmWithRetry(cfg); err != nil {
 		ui.Error(fmt.Sprintf("npm package installation failed: %v", err))
+		softErrs = append(softErrs, fmt.Errorf("npm: %w", err))
 	}
 
 	if !cfg.PackagesOnly {
 		if err := stepShell(cfg); err != nil {
 			ui.Error(fmt.Sprintf("Shell setup failed: %v", err))
+			softErrs = append(softErrs, fmt.Errorf("shell: %w", err))
 		}
 
 		if err := stepDotfiles(cfg); err != nil {
 			ui.Error(fmt.Sprintf("Dotfiles setup failed: %v", err))
+			softErrs = append(softErrs, fmt.Errorf("dotfiles: %w", err))
 		}
 
 		if err := stepMacOS(cfg); err != nil {
 			ui.Error(fmt.Sprintf("macOS configuration failed: %v", err))
+			softErrs = append(softErrs, fmt.Errorf("macos: %w", err))
 		}
 	}
 
 	showCompletion(cfg)
+
+	if len(softErrs) > 0 {
+		fmt.Println()
+		ui.Warn(fmt.Sprintf("%d setup step(s) had errors — run 'openboot doctor' to diagnose.", len(softErrs)))
+		return errors.Join(softErrs...)
+	}
 	return nil
 }
 
@@ -371,15 +384,16 @@ func stepInstallPackages(cfg *config.Config) error {
 	ui.Info(fmt.Sprintf("Installing %d packages (%d CLI, %d GUI)...", len(cliPkgs)+len(caskPkgs), len(cliPkgs), len(caskPkgs)))
 	fmt.Println()
 
-	if err := brew.InstallWithProgress(cliPkgs, caskPkgs, cfg.DryRun); err != nil {
-		ui.Error(fmt.Sprintf("Some packages failed: %v", err))
+	installedCli, installedCask, brewErr := brew.InstallWithProgress(cliPkgs, caskPkgs, cfg.DryRun)
+	if brewErr != nil {
+		ui.Error(fmt.Sprintf("Some packages failed: %v", brewErr))
 	}
 
 	if !cfg.DryRun {
-		for _, pkg := range cliPkgs {
+		for _, pkg := range installedCli {
 			state.markFormula(pkg)
 		}
-		for _, pkg := range caskPkgs {
+		for _, pkg := range installedCask {
 			state.markCask(pkg)
 		}
 		ui.Success("Package installation complete")
@@ -703,27 +717,39 @@ func RunFromSnapshot(cfg *config.Config) error {
 		ui.Error(fmt.Sprintf("npm package installation failed: %v", err))
 	}
 
+	var softErrs []error
+
 	if cfg.SnapshotGit != nil {
 		if err := stepRestoreGit(cfg); err != nil {
 			ui.Error(fmt.Sprintf("Git restore failed: %v", err))
+			softErrs = append(softErrs, fmt.Errorf("git restore: %w", err))
 		}
 	}
 
 	if cfg.SnapshotShell != nil && cfg.SnapshotShell.OhMyZsh {
 		if err := stepRestoreShell(cfg); err != nil {
 			ui.Error(fmt.Sprintf("Shell restore failed: %v", err))
+			softErrs = append(softErrs, fmt.Errorf("shell restore: %w", err))
 		}
 	} else {
 		if err := stepShell(cfg); err != nil {
 			ui.Error(fmt.Sprintf("Shell setup failed: %v", err))
+			softErrs = append(softErrs, fmt.Errorf("shell: %w", err))
 		}
 	}
 
 	if err := stepMacOS(cfg); err != nil {
 		ui.Error(fmt.Sprintf("macOS configuration failed: %v", err))
+		softErrs = append(softErrs, fmt.Errorf("macos: %w", err))
 	}
 
 	showCompletion(cfg)
+
+	if len(softErrs) > 0 {
+		fmt.Println()
+		ui.Warn(fmt.Sprintf("%d restore step(s) had errors — run 'openboot doctor' to diagnose.", len(softErrs)))
+		return errors.Join(softErrs...)
+	}
 	return nil
 }
 

internal/installer/installer_test.go

@@ -357,3 +357,59 @@ func TestInstallTimeConstants(t *testing.T) {
 	assert.Equal(t, 30, estimatedSecondsPerCask)
 	assert.Equal(t, 5, estimatedSecondsPerNpm)
 }
+
+func TestInstallState_OnlySuccessfulPackagesMarked(t *testing.T) {
+	tmpDir := t.TempDir()
+	t.Setenv("HOME", tmpDir)
+
+	s := newInstallState()
+
+	require.NoError(t, s.markFormula("git"))
+	require.NoError(t, s.markFormula("curl"))
+
+	assert.True(t, s.isFormulaInstalled("git"))
+	assert.True(t, s.isFormulaInstalled("curl"))
+	assert.False(t, s.isFormulaInstalled("ripgrep"), "ripgrep was never marked as installed")
+
+	loaded, err := loadState()
+	require.NoError(t, err)
+
+	assert.True(t, loaded.isFormulaInstalled("git"))
+	assert.True(t, loaded.isFormulaInstalled("curl"))
+	assert.False(t, loaded.isFormulaInstalled("ripgrep"), "ripgrep should not appear in persisted state")
+}
+
+func TestRunInteractiveInstall_HardFailOnBrew(t *testing.T) {
+	tmpDir := t.TempDir()
+	t.Setenv("HOME", tmpDir)
+
+	cfg := &config.Config{
+		DryRun:       true,
+		Preset:       "minimal",
+		PackagesOnly: true,
+		SelectedPkgs: map[string]bool{},
+	}
+
+	err := runInteractiveInstall(cfg)
+	assert.NoError(t, err)
+}
+
+func TestRunFromSnapshot_SoftFailuresReturnError(t *testing.T) {
+	tmpDir := t.TempDir()
+	t.Setenv("HOME", tmpDir)
+
+	cfg := &config.Config{
+		DryRun:        true,
+		Silent:        true,
+		Preset:        "minimal",
+		Shell:         "skip",
+		Macos:         "skip",
+		Dotfiles:      "skip",
+		SelectedPkgs:  map[string]bool{},
+		SnapshotGit:   nil,
+		SnapshotShell: nil,
+	}
+
+	err := RunFromSnapshot(cfg)
+	assert.NoError(t, err)
+}