feat: add repo hibernate command to archive and stop work (#315)

* feat: add repo hibernate command to archive and stop work

Adds `multiclaude repo hibernate` command that cleanly stops all work
in a repository while preserving uncommitted changes:

- Archives uncommitted changes as patch files to ~/.multiclaude/archive/<repo>/<timestamp>/
- Saves metadata (branch, task, worktree path) for each agent
- Lists untracked files separately for manual restoration
- Stops workers and review agents by default (--all for persistent agents)
- Force-removes worktrees after archiving to ensure clean shutdown

Also adds ArchiveDir to Paths config and updates all test files to include it.

Usage: multiclaude repo hibernate [--repo <repo>] [--all] [--yes]

Co-Authored-By: Claude Opus 4.5 <[email protected]>

* fix: address lint issues in hibernate command

- Check error return from client.Send (errcheck)
- Fix formatting with gofmt

Co-Authored-By: Claude Opus 4.5 <[email protected]>

---------

Co-authored-by: Claude Opus 4.5 <[email protected]>

Author: aronchick

internal/bugreport/collector_test.go

@@ -31,6 +31,7 @@ func TestCollector_Collect(t *testing.T) {
 		MessagesDir:     filepath.Join(tmpDir, "messages"),
 		OutputDir:       filepath.Join(tmpDir, "output"),
 		ClaudeConfigDir: filepath.Join(tmpDir, "claude-config"),
+		ArchiveDir:      filepath.Join(tmpDir, "archive"),
 	}
 
 	// Create a test state file
@@ -123,6 +124,7 @@ func TestCollector_CollectVerbose(t *testing.T) {
 		MessagesDir:     filepath.Join(tmpDir, "messages"),
 		OutputDir:       filepath.Join(tmpDir, "output"),
 		ClaudeConfigDir: filepath.Join(tmpDir, "claude-config"),
+		ArchiveDir:      filepath.Join(tmpDir, "archive"),
 	}
 
 	// Create a test state file with multiple repos

internal/cli/cli.go

@@ -426,6 +426,13 @@ func (c *CLI) registerCommands() {
 		Run:         c.showHistory,
 	}
 
+	repoCmd.Subcommands["hibernate"] = &Command{
+		Name:        "hibernate",
+		Description: "Hibernate a repository, archiving uncommitted changes",
+		Usage:       "multiclaude repo hibernate [--repo <repo>] [--all] [--yes]",
+		Run:         c.hibernateRepo,
+	}
+
 	c.rootCmd.Subcommands["repo"] = repoCmd
 
 	// Backward compatibility aliases for root-level repo commands
@@ -2859,6 +2866,245 @@ func (c *CLI) removeWorker(args []string) error {
 	return nil
 }
 
+// hibernateRepo stops all work in a repository and archives uncommitted changes
+func (c *CLI) hibernateRepo(args []string) error {
+	flags, _ := ParseFlags(args)
+	skipConfirm := flags["yes"] == "true"
+	hibernateAll := flags["all"] == "true" // Also hibernate persistent agents (supervisor, workspace)
+
+	// Determine repository
+	repoName, err := c.resolveRepo(flags)
+	if err != nil {
+		return errors.NotInRepo()
+	}
+
+	// Get agent list from daemon
+	client := socket.NewClient(c.paths.DaemonSock)
+	resp, err := client.Send(socket.Request{
+		Command: "list_agents",
+		Args: map[string]interface{}{
+			"repo": repoName,
+		},
+	})
+	if err != nil {
+		return errors.DaemonCommunicationFailed("getting agent info", err)
+	}
+	if !resp.Success {
+		return errors.Wrap(errors.CategoryRuntime, "failed to get agent info", fmt.Errorf("%s", resp.Error))
+	}
+
+	agents, _ := resp.Data.([]interface{})
+	if len(agents) == 0 {
+		fmt.Printf("No agents running in repository '%s'\n", repoName)
+		return nil
+	}
+
+	// Filter agents to hibernate (workers, review agents; optionally all)
+	var agentsToHibernate []map[string]interface{}
+	var agentsWithChanges []map[string]interface{}
+
+	for _, agent := range agents {
+		agentMap, ok := agent.(map[string]interface{})
+		if !ok {
+			continue
+		}
+
+		agentType, _ := agentMap["type"].(string)
+		wtPath, _ := agentMap["worktree_path"].(string)
+
+		// Determine if this agent should be hibernated
+		shouldHibernate := false
+		switch agentType {
+		case "worker", "review":
+			shouldHibernate = true
+		case "supervisor", "merge-queue", "pr-shepherd", "workspace", "generic-persistent":
+			shouldHibernate = hibernateAll
+		}
+
+		if !shouldHibernate {
+			continue
+		}
+
+		agentsToHibernate = append(agentsToHibernate, agentMap)
+
+		// Check for uncommitted changes
+		if wtPath != "" {
+			hasUncommitted, err := worktree.HasUncommittedChanges(wtPath)
+			if err == nil && hasUncommitted {
+				agentsWithChanges = append(agentsWithChanges, agentMap)
+			}
+		}
+	}
+
+	if len(agentsToHibernate) == 0 {
+		fmt.Printf("No agents to hibernate in repository '%s'\n", repoName)
+		if !hibernateAll {
+			fmt.Println("Use --all to also hibernate persistent agents (supervisor, workspace, etc.)")
+		}
+		return nil
+	}
+
+	// Show summary and confirm
+	fmt.Printf("Hibernating %d agent(s) in repository '%s':\n", len(agentsToHibernate), repoName)
+	for _, agent := range agentsToHibernate {
+		name, _ := agent["name"].(string)
+		agentType, _ := agent["type"].(string)
+		hasChanges := false
+		for _, changed := range agentsWithChanges {
+			if changed["name"] == name {
+				hasChanges = true
+				break
+			}
+		}
+		changeMarker := ""
+		if hasChanges {
+			changeMarker = " [has uncommitted changes]"
+		}
+		fmt.Printf("  - %s (%s)%s\n", name, agentType, changeMarker)
+	}
+
+	if len(agentsWithChanges) > 0 {
+		fmt.Printf("\n%d agent(s) have uncommitted changes that will be archived.\n", len(agentsWithChanges))
+	}
+
+	if !skipConfirm {
+		fmt.Print("\nContinue? [y/N]: ")
+		var response string
+		fmt.Scanln(&response)
+		if response != "y" && response != "Y" {
+			fmt.Println("Cancelled")
+			return nil
+		}
+	}
+
+	// Create archive directory with timestamp
+	timestamp := time.Now().Format("2006-01-02_15-04-05")
+	archiveDir := filepath.Join(c.paths.RepoArchiveDir(repoName), timestamp)
+	if len(agentsWithChanges) > 0 {
+		if err := os.MkdirAll(archiveDir, 0755); err != nil {
+			return fmt.Errorf("failed to create archive directory: %w", err)
+		}
+		fmt.Printf("\nArchiving to: %s\n", archiveDir)
+	}
+
+	// Archive uncommitted changes
+	var archivedAgents []string
+	for _, agent := range agentsWithChanges {
+		name, _ := agent["name"].(string)
+		wtPath, _ := agent["worktree_path"].(string)
+		branch, _ := agent["branch"].(string)
+		task, _ := agent["task"].(string)
+
+		fmt.Printf("Archiving changes from %s...\n", name)
+
+		// Create patch file with git diff
+		patchPath := filepath.Join(archiveDir, name+".patch")
+		cmd := exec.Command("git", "diff", "HEAD")
+		cmd.Dir = wtPath
+		output, err := cmd.Output()
+		if err != nil {
+			fmt.Printf("Warning: failed to create patch for %s: %v\n", name, err)
+			continue
+		}
+
+		// Include untracked files in the patch
+		untrackedCmd := exec.Command("git", "ls-files", "--others", "--exclude-standard")
+		untrackedCmd.Dir = wtPath
+		untrackedOutput, _ := untrackedCmd.Output()
+
+		// Write patch file
+		if err := os.WriteFile(patchPath, output, 0644); err != nil {
+			fmt.Printf("Warning: failed to write patch for %s: %v\n", name, err)
+			continue
+		}
+
+		// Write untracked files list if any
+		if len(untrackedOutput) > 0 {
+			untrackedPath := filepath.Join(archiveDir, name+".untracked")
+			os.WriteFile(untrackedPath, untrackedOutput, 0644)
+		}
+
+		// Write metadata for this agent
+		metaPath := filepath.Join(archiveDir, name+".json")
+		meta := map[string]interface{}{
+			"name":          name,
+			"type":          agent["type"],
+			"branch":        branch,
+			"task":          task,
+			"worktree_path": wtPath,
+			"archived_at":   time.Now().Format(time.RFC3339),
+		}
+		metaData, _ := json.MarshalIndent(meta, "", "  ")
+		os.WriteFile(metaPath, metaData, 0644)
+
+		archivedAgents = append(archivedAgents, name)
+	}
+
+	// Write summary metadata
+	if len(agentsWithChanges) > 0 {
+		summaryPath := filepath.Join(archiveDir, "hibernate-summary.json")
+		summary := map[string]interface{}{
+			"repo":              repoName,
+			"hibernated_at":     time.Now().Format(time.RFC3339),
+			"agents_hibernated": len(agentsToHibernate),
+			"agents_archived":   archivedAgents,
+		}
+		summaryData, _ := json.MarshalIndent(summary, "", "  ")
+		os.WriteFile(summaryPath, summaryData, 0644)
+	}
+
+	// Stop agents
+	tmuxSession := sanitizeTmuxSessionName(repoName)
+	repoPath := c.paths.RepoDir(repoName)
+	wt := worktree.NewManager(repoPath)
+
+	fmt.Println()
+	for _, agent := range agentsToHibernate {
+		name, _ := agent["name"].(string)
+		wtPath, _ := agent["worktree_path"].(string)
+		tmuxWindow, _ := agent["tmux_window"].(string)
+
+		fmt.Printf("Stopping %s...\n", name)
+
+		// Kill tmux window
+		if tmuxWindow != "" {
+			cmd := exec.Command("tmux", "kill-window", "-t", fmt.Sprintf("%s:%s", tmuxSession, tmuxWindow))
+			cmd.Run() // Ignore errors
+		}
+
+		// Remove worktree (force since we archived changes)
+		if wtPath != "" {
+			if err := wt.Remove(wtPath, true); err != nil {
+				// Try harder with force
+				cmd := exec.Command("git", "worktree", "remove", "--force", wtPath)
+				cmd.Dir = repoPath
+				cmd.Run()
+			}
+		}
+
+		// Unregister from daemon (ignore errors during cleanup)
+		_, _ = client.Send(socket.Request{
+			Command: "remove_agent",
+			Args: map[string]interface{}{
+				"repo":  repoName,
+				"agent": name,
+			},
+		})
+	}
+
+	fmt.Println()
+	fmt.Printf("✓ Hibernated %d agent(s) in '%s'\n", len(agentsToHibernate), repoName)
+	if len(archivedAgents) > 0 {
+		fmt.Printf("✓ Archived %d agent(s) with uncommitted changes to:\n", len(archivedAgents))
+		fmt.Printf("  %s\n", archiveDir)
+		fmt.Println("\nTo restore archived patches:")
+		fmt.Println("  cd <worktree>")
+		fmt.Printf("  git apply %s/<agent>.patch\n", archiveDir)
+	}
+
+	return nil
+}
+
 // Workspace command implementations
 
 // workspaceDefault handles `multiclaude workspace` with no subcommand or `multiclaude workspace <name>`

internal/cli/cli_test.go

@@ -316,6 +316,7 @@ func setupTestEnvironment(t *testing.T) (*CLI, *daemon.Daemon, func()) {
 		MessagesDir:     filepath.Join(tmpDir, "messages"),
 		OutputDir:       filepath.Join(tmpDir, "output"),
 		ClaudeConfigDir: filepath.Join(tmpDir, "claude-config"),
+		ArchiveDir:      filepath.Join(tmpDir, "archive"),
 	}
 
 	if err := paths.EnsureDirectories(); err != nil {
@@ -662,6 +663,7 @@ func TestCLISendMessageFallbackWhenDaemonUnavailable(t *testing.T) {
 		MessagesDir:     filepath.Join(tmpDir, "messages"),
 		OutputDir:       filepath.Join(tmpDir, "output"),
 		ClaudeConfigDir: filepath.Join(tmpDir, "claude-config"),
+		ArchiveDir:      filepath.Join(tmpDir, "archive"),
 	}
 
 	if err := paths.EnsureDirectories(); err != nil {
@@ -1044,6 +1046,7 @@ func TestNewWithPaths(t *testing.T) {
 		MessagesDir:     filepath.Join(tmpDir, "messages"),
 		OutputDir:       filepath.Join(tmpDir, "output"),
 		ClaudeConfigDir: filepath.Join(tmpDir, "claude-config"),
+		ArchiveDir:      filepath.Join(tmpDir, "archive"),
 	}
 
 	// Test CLI creation

internal/daemon/daemon_test.go

@@ -39,6 +39,7 @@ func setupTestDaemon(t *testing.T) (*Daemon, func()) {
 		MessagesDir:     filepath.Join(tmpDir, "messages"),
 		OutputDir:       filepath.Join(tmpDir, "output"),
 		ClaudeConfigDir: filepath.Join(tmpDir, "claude-config"),
+		ArchiveDir:      filepath.Join(tmpDir, "archive"),
 	}
 
 	// Create directories

internal/daemon/handlers_test.go

@@ -33,6 +33,7 @@ func setupTestDaemonWithState(t *testing.T, setupFn func(*state.State)) (*Daemon
 		MessagesDir:     filepath.Join(tmpDir, "messages"),
 		OutputDir:       filepath.Join(tmpDir, "output"),
 		ClaudeConfigDir: filepath.Join(tmpDir, "claude-config"),
+		ArchiveDir:      filepath.Join(tmpDir, "archive"),
 	}
 
 	if err := paths.EnsureDirectories(); err != nil {

internal/daemon/worktree_test.go

@@ -72,6 +72,7 @@ func setupTestDaemonWithGitRepo(t *testing.T) (*Daemon, string, func()) {
 		MessagesDir:     filepath.Join(tmpDir, "messages"),
 		OutputDir:       filepath.Join(tmpDir, "output"),
 		ClaudeConfigDir: filepath.Join(tmpDir, "claude-config"),
+		ArchiveDir:      filepath.Join(tmpDir, "archive"),
 	}
 
 	// Create directories

pkg/config/config.go

@@ -19,6 +19,7 @@ type Paths struct {
 	MessagesDir     string // messages/
 	OutputDir       string // output/
 	ClaudeConfigDir string // claude-config/
+	ArchiveDir      string // archive/ (for paused work)
 }
 
 // DefaultPaths returns the default paths for multiclaude
@@ -41,6 +42,7 @@ func DefaultPaths() (*Paths, error) {
 		MessagesDir:     filepath.Join(root, "messages"),
 		OutputDir:       filepath.Join(root, "output"),
 		ClaudeConfigDir: filepath.Join(root, "claude-config"),
+		ArchiveDir:      filepath.Join(root, "archive"),
 	}, nil
 }
 
@@ -53,6 +55,7 @@ func (p *Paths) EnsureDirectories() error {
 		p.MessagesDir,
 		p.OutputDir,
 		p.ClaudeConfigDir,
+		p.ArchiveDir,
 	}
 
 	for _, dir := range dirs {
@@ -138,5 +141,11 @@ func NewTestPaths(tmpDir string) *Paths {
 		MessagesDir:     filepath.Join(tmpDir, "messages"),
 		OutputDir:       filepath.Join(tmpDir, "output"),
 		ClaudeConfigDir: filepath.Join(tmpDir, "claude-config"),
+		ArchiveDir:      filepath.Join(tmpDir, "archive"),
 	}
 }
+
+// RepoArchiveDir returns the path for a repository's archived work
+func (p *Paths) RepoArchiveDir(repoName string) string {
+	return filepath.Join(p.ArchiveDir, repoName)
+}

pkg/config/config_test.go

@@ -60,14 +60,15 @@ func TestEnsureDirectories(t *testing.T) {
 		MessagesDir:     filepath.Join(tmpDir, "test-multiclaude", "messages"),
 		OutputDir:       filepath.Join(tmpDir, "test-multiclaude", "output"),
 		ClaudeConfigDir: filepath.Join(tmpDir, "test-multiclaude", "claude-config"),
+		ArchiveDir:      filepath.Join(tmpDir, "test-multiclaude", "archive"),
 	}
 
 	if err := paths.EnsureDirectories(); err != nil {
 		t.Fatalf("EnsureDirectories() failed: %v", err)
 	}
 
 	// Verify directories were created
-	dirs := []string{paths.Root, paths.ReposDir, paths.WorktreesDir, paths.MessagesDir, paths.OutputDir, paths.ClaudeConfigDir}
+	dirs := []string{paths.Root, paths.ReposDir, paths.WorktreesDir, paths.MessagesDir, paths.OutputDir, paths.ClaudeConfigDir, paths.ArchiveDir}
 	for _, dir := range dirs {
 		if _, err := os.Stat(dir); os.IsNotExist(err) {
 			t.Errorf("Directory not created: %s", dir)