feat(migrate): add taskwing migrate command and auto-migration on upgrade

Existing users with local .taskwing/ directories get their knowledge
automatically migrated to ~/.taskwing/projects/<slug>/ on first run
after upgrading. The auto-migration runs silently during the version
upgrade hook and only copies if the global store is empty.

For manual control, `taskwing migrate` copies memory.db, ARCHITECTURE.md,
config.yaml, policies, and version files. Idempotent by default, use
--force to overwrite existing global data.

Author: josephgoksu

cmd/doctor.go

@@ -24,7 +24,7 @@ var doctorCmd = &cobra.Command{
 	Long: `Validate your TaskWing installation and configuration.
 
 Checks:
-  • TaskWing initialization (.taskwing/ directory)
+  • TaskWing initialization (global project store)
   • MCP server registration for AI tools
   • Hooks configuration for autonomous execution
   • Active plan and task status

cmd/migrate.go

@@ -0,0 +1,69 @@
+package cmd
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+
+	"github.com/josephgoksu/TaskWing/internal/config"
+	"github.com/josephgoksu/TaskWing/internal/migration"
+	"github.com/spf13/cobra"
+)
+
+var migrateCmd = &cobra.Command{
+	Use:   "migrate",
+	Short: "Migrate local .taskwing/ data to global store",
+	Long: `Migrate project data from a local .taskwing/ directory to the global store at ~/.taskwing/projects/.
+
+This is needed after upgrading to v1.22.6+ which centralizes all storage.
+After migration, you can safely delete the local .taskwing/ directory.
+
+The command is idempotent and will not overwrite existing data in the global store
+unless --force is used.`,
+	RunE: runMigrate,
+}
+
+func init() {
+	rootCmd.AddCommand(migrateCmd)
+	migrateCmd.Flags().Bool("force", false, "Overwrite existing data in global store")
+}
+
+func runMigrate(cmd *cobra.Command, args []string) error {
+	force, _ := cmd.Flags().GetBool("force")
+
+	cwd, err := os.Getwd()
+	if err != nil {
+		return fmt.Errorf("get working directory: %w", err)
+	}
+
+	result, err := migration.MigrateLocalToGlobal(cwd, force)
+	if err != nil {
+		return err
+	}
+
+	switch {
+	case result.AlreadyMigrated:
+		fmt.Println("Nothing to migrate. Global store already has data for this project.")
+		fmt.Printf("   Store: %s\n", result.StorePath)
+	case result.NoLocalDir:
+		fmt.Println("No local .taskwing/ directory found. Nothing to migrate.")
+	default:
+		fmt.Println("Migrated successfully.")
+		fmt.Printf("   From: %s\n", filepath.Join(cwd, ".taskwing"))
+		fmt.Printf("   To:   %s\n", result.StorePath)
+		for _, f := range result.FilesMigrated {
+			fmt.Printf("   - %s\n", f)
+		}
+		fmt.Println()
+		fmt.Println("You can now delete the local .taskwing/ directory:")
+		fmt.Printf("   rm -rf %s\n", filepath.Join(cwd, ".taskwing"))
+	}
+
+	// Also check if global store path is properly registered
+	storePath, err := config.GetProjectStorePath(cwd)
+	if err == nil && storePath != "" {
+		fmt.Printf("\n   Global store: %s\n", storePath)
+	}
+
+	return nil
+}

internal/migration/local_to_global.go

@@ -0,0 +1,175 @@
+package migration
+
+import (
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+
+	"github.com/josephgoksu/TaskWing/internal/config"
+)
+
+// MigrateResult describes what happened during migration.
+type MigrateResult struct {
+	StorePath       string
+	FilesMigrated   []string
+	NoLocalDir      bool
+	AlreadyMigrated bool
+}
+
+// MigrateLocalToGlobal moves data from {projectDir}/.taskwing/ to the global store.
+// It copies memory.db, ARCHITECTURE.md, config.yaml, and version files.
+// Does not overwrite existing files in the global store unless force is true.
+func MigrateLocalToGlobal(projectDir string, force bool) (*MigrateResult, error) {
+	localDir := filepath.Join(projectDir, ".taskwing")
+
+	// Check if local .taskwing/ exists
+	if _, err := os.Stat(localDir); os.IsNotExist(err) {
+		return &MigrateResult{NoLocalDir: true}, nil
+	}
+
+	// Resolve global store path
+	storePath, err := config.GetProjectStorePath(projectDir)
+	if err != nil {
+		return nil, fmt.Errorf("resolve global store: %w", err)
+	}
+
+	// Files to migrate (source relative to .taskwing/, dest relative to store)
+	migrations := []struct {
+		src string // relative to localDir
+		dst string // relative to storePath
+	}{
+		{"memory/memory.db", "memory.db"},
+		{"memory/memory.db-wal", "memory.db-wal"},
+		{"memory/memory.db-shm", "memory.db-shm"},
+		{"memory/ARCHITECTURE.md", "ARCHITECTURE.md"},
+		{"config.yaml", "config.yaml"},
+		{"version", "version"},
+	}
+
+	var migrated []string
+	skippedExisting := false
+
+	for _, m := range migrations {
+		srcPath := filepath.Join(localDir, m.src)
+		dstPath := filepath.Join(storePath, m.dst)
+
+		// Skip if source doesn't exist
+		if _, err := os.Stat(srcPath); os.IsNotExist(err) {
+			continue
+		}
+
+		// Check if destination already exists
+		if _, err := os.Stat(dstPath); err == nil {
+			if !force {
+				skippedExisting = true
+				continue
+			}
+		}
+
+		if err := copyFile(srcPath, dstPath); err != nil {
+			return nil, fmt.Errorf("copy %s: %w", m.src, err)
+		}
+		migrated = append(migrated, m.dst)
+	}
+
+	// Also migrate policies directory if it exists
+	localPolicies := filepath.Join(localDir, "policies")
+	if info, err := os.Stat(localPolicies); err == nil && info.IsDir() {
+		dstPolicies := filepath.Join(storePath, "policies")
+		if err := copyDir(localPolicies, dstPolicies, force); err != nil {
+			return nil, fmt.Errorf("copy policies: %w", err)
+		}
+		migrated = append(migrated, "policies/")
+	}
+
+	if len(migrated) == 0 && skippedExisting {
+		return &MigrateResult{StorePath: storePath, AlreadyMigrated: true}, nil
+	}
+
+	return &MigrateResult{
+		StorePath:     storePath,
+		FilesMigrated: migrated,
+	}, nil
+}
+
+// AutoMigrateIfNeeded silently migrates local .taskwing/ data on version upgrade.
+// Returns true if migration occurred.
+func AutoMigrateIfNeeded(projectDir string) bool {
+	localDB := filepath.Join(projectDir, ".taskwing", "memory", "memory.db")
+	if _, err := os.Stat(localDB); os.IsNotExist(err) {
+		return false
+	}
+
+	storePath, err := config.GetProjectStorePath(projectDir)
+	if err != nil {
+		return false
+	}
+
+	globalDB := filepath.Join(storePath, "memory.db")
+	if _, err := os.Stat(globalDB); err == nil {
+		return false // Already has data, don't overwrite
+	}
+
+	if err := copyFile(localDB, globalDB); err != nil {
+		fmt.Fprintf(os.Stderr, "taskwing: auto-migration of local knowledge failed: %v\n", err)
+		return false
+	}
+
+	// Also copy ARCHITECTURE.md if present
+	localArch := filepath.Join(projectDir, ".taskwing", "memory", "ARCHITECTURE.md")
+	globalArch := filepath.Join(storePath, "ARCHITECTURE.md")
+	if _, err := os.Stat(localArch); err == nil {
+		_ = copyFile(localArch, globalArch)
+	}
+
+	fmt.Fprintf(os.Stderr, "taskwing: migrated local knowledge to %s\n", storePath)
+	return true
+}
+
+func copyFile(src, dst string) error {
+	if err := os.MkdirAll(filepath.Dir(dst), 0700); err != nil {
+		return err
+	}
+
+	in, err := os.Open(src)
+	if err != nil {
+		return err
+	}
+	defer in.Close()
+
+	out, err := os.OpenFile(dst, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, 0600)
+	if err != nil {
+		return err
+	}
+	defer out.Close()
+
+	if _, err := io.Copy(out, in); err != nil {
+		return err
+	}
+	return out.Close()
+}
+
+func copyDir(src, dst string, force bool) error {
+	return filepath.Walk(src, func(path string, info os.FileInfo, err error) error {
+		if err != nil {
+			return err
+		}
+
+		rel, err := filepath.Rel(src, path)
+		if err != nil {
+			return err
+		}
+		dstPath := filepath.Join(dst, rel)
+
+		if info.IsDir() {
+			return os.MkdirAll(dstPath, 0700)
+		}
+
+		if _, err := os.Stat(dstPath); err == nil && !force {
+			return nil // Skip existing
+		}
+
+		return copyFile(path, dstPath)
+	})
+}

internal/migration/upgrade.go

@@ -53,6 +53,9 @@ func CheckAndMigrate(projectDir, currentVersion string) (warnings []string, err
 
 	// --- Version mismatch: run migration ---
 
+	// 0. Auto-migrate local .taskwing/ to global store if needed
+	AutoMigrateIfNeeded(projectDir)
+
 	// 1. Silent local migration: regenerate slash commands for managed AIs
 	migrateLocalConfigs(projectDir)