feat(storage): centralize all project storage in ~/.taskwing/

Move all project data (memory.db, config, policies, activity logs,
backups) from local {project}/.taskwing/ to ~/.taskwing/projects/<slug>/.
Projects identified by SHA256-based slugs with symlink resolution.

Key changes:
- Add ProjectSlug(), GetProjectStorePath(), RegisterProject() in paths.go
- Rewrite GetMemoryBasePath() to resolve via global store
- Add tiered MCP context dumps (summary default, detail=full paginated)
- Add global knowledge DB with union queries across project+global
- Add config layering: global > profile > project via Viper merge
- Remove .taskwing as project marker, remove MarkerTaskWing enum
- Remove legacy backward-compat stubs and fallbacks
- Fix all local .taskwing path references across 37 files

Author: josephgoksu

cmd/bootstrap.go

@@ -94,9 +94,6 @@ func runBootstrap(cmd *cobra.Command, args []string) error {
 		return fmt.Errorf("get current directory: %w", err)
 	}
 
-	// Track user input for crash logging
-	config.SetLastInput(fmt.Sprintf("bootstrap (skip-analyze=%v, dir=%s)", flags.SkipAnalyze, cwd))
-
 	// Debug mode: dump diagnostic info early
 	if flags.Debug {
 		fmt.Fprintln(os.Stderr, "")
@@ -192,8 +189,12 @@ func runBootstrap(cmd *cobra.Command, args []string) error {
 		}
 	}
 
-	// Initialize Service
-	svc := bootstrap.NewService(cwd, llmCfg)
+	// Initialize Service with global store path
+	storePath, err := config.GetProjectStorePath(cwd)
+	if err != nil {
+		return fmt.Errorf("resolve project store: %w", err)
+	}
+	svc := bootstrap.NewService(cwd, storePath, llmCfg)
 	svc.SetVersion(version)
 
 	// Prompt for repo selection in multi-repo workspaces.
@@ -288,12 +289,6 @@ func executeAction(ctx context.Context, action bootstrap.Action, svc *bootstrap.
 		if err := executeInitProject(svc, flags, plan); err != nil {
 			return err
 		}
-		// Re-detect project context now that local .taskwing/ exists.
-		// Without this, the cached context still points to ~/.taskwing/ (HOME)
-		// and all subsequent DB operations write to the wrong database.
-		if freshCtx, err := project.Detect(cwd); err == nil {
-			_ = config.SetProjectContext(freshCtx)
-		}
 		return nil
 
 	case bootstrap.ActionGenerateAIConfigs:
@@ -795,7 +790,11 @@ func setupTrace(stream *core.StreamingOutput, trace bool, traceFile string, trac
 	// Enable full payload capture so trace includes LLM messages and responses
 	stream.SetIncludePayloads(true)
 	if traceFile == "" {
-		traceFile = filepath.Join(cwd, ".taskwing", "logs", "bootstrap.trace.jsonl")
+		if sp, err := config.GetProjectStorePath(cwd); err == nil {
+			traceFile = filepath.Join(sp, "bootstrap.trace.jsonl")
+		} else {
+			traceFile = filepath.Join(cwd, "bootstrap.trace.jsonl")
+		}
 	}
 	var out *os.File
 	var cleanup func()

cmd/cli_helpers.go

@@ -3,6 +3,7 @@ package cmd
 import (
 	"bufio"
 	"encoding/json"
+	"errors"
 	"fmt"
 	"os"
 	"strings"
@@ -81,7 +82,10 @@ func isMissingProjectMemoryError(err error) bool {
 	if err == nil {
 		return false
 	}
-	return strings.Contains(err.Error(), "no .taskwing directory found at project root")
+	errStr := err.Error()
+	return errors.Is(err, config.ErrProjectContextNotSet) ||
+		strings.Contains(errStr, "no project marker found") ||
+		strings.Contains(errStr, "no project detected")
 }
 
 func confirmOrAbort(prompt string) bool {

cmd/config.go

@@ -33,29 +33,61 @@ func initConfig() {
 	// This finds the nearest .taskwing, go.mod, package.json, etc.
 	projectCtx := detectProjectRoot()
 
-	// ALWAYS add global config path first (highest priority for user settings)
-	viper.AddConfigPath(filepath.Join(home, ".taskwing"))
+	// Layered config loading: global first, then project merges on top.
+	// Resolution order: project > profile > global > env vars > defaults
+	viper.SetConfigType("yaml")
 
-	// Add detected project root's .taskwing directory for project-specific config
-	if projectCtx != nil && projectCtx.RootPath != "" {
-		projectConfigPath := filepath.Join(projectCtx.RootPath, ".taskwing")
-		if info, err := os.Stat(projectConfigPath); err == nil && info.IsDir() {
-			viper.AddConfigPath(projectConfigPath)
+	// 1. Load global config as base layer
+	globalConfigFile := filepath.Join(home, ".taskwing", "config.yaml")
+	if _, err := os.Stat(globalConfigFile); err == nil {
+		viper.SetConfigFile(globalConfigFile)
+		if err := viper.ReadInConfig(); err == nil {
+			if viper.GetBool("verbose") && !viper.GetBool("json") {
+				fmt.Fprintln(os.Stderr, "Loaded global config:", globalConfigFile)
+			}
 		}
 	}
 
-	// Legacy: Also check CWD's .taskwing directory (for backwards compatibility)
-	if _, err := os.Stat(".taskwing"); !os.IsNotExist(err) {
-		viper.AddConfigPath(".taskwing")
+	// 2. Load profile config (merges on top of global)
+	// Check env var first, then scan os.Args for --profile flag
+	// (Cobra hasn't parsed flags yet when initConfig runs)
+	profileName := os.Getenv("TASKWING_PROFILE")
+	if profileName == "" {
+		profileName = viper.GetString("profile") // from global config.yaml
+	}
+	if profileName == "" {
+		profileName = scanFlagFromArgs("profile")
+	}
+	if profileName != "" && filepath.Base(profileName) == profileName && !strings.Contains(profileName, "..") {
+		profileFile := filepath.Join(home, ".taskwing", "profiles", profileName+".yaml")
+		if _, err := os.Stat(profileFile); err == nil {
+			profileViper := viper.New()
+			profileViper.SetConfigFile(profileFile)
+			if err := profileViper.ReadInConfig(); err == nil {
+				if err := viper.MergeConfigMap(profileViper.AllSettings()); err == nil {
+					if viper.GetBool("verbose") && !viper.GetBool("json") {
+						fmt.Fprintln(os.Stderr, "Loaded profile config:", profileFile)
+					}
+				}
+			}
+		}
 	}
 
-	viper.SetConfigName("config") // looks for config.yaml
-	viper.SetConfigType("yaml")
-
-	// Attempt to read the configuration file
-	if err := viper.ReadInConfig(); err == nil {
-		if viper.GetBool("verbose") && !viper.GetBool("json") {
-			fmt.Fprintln(os.Stderr, "Using config file:", viper.ConfigFileUsed())
+	// 3. Load project config from global store (merges on top, highest file-based priority)
+	if projectCtx != nil && projectCtx.RootPath != "" {
+		if storePath, err := config.GetProjectStorePath(projectCtx.RootPath); err == nil {
+			projectConfigFile := filepath.Join(storePath, "config.yaml")
+			if _, err := os.Stat(projectConfigFile); err == nil {
+				projectViper := viper.New()
+				projectViper.SetConfigFile(projectConfigFile)
+				if err := projectViper.ReadInConfig(); err == nil {
+					if err := viper.MergeConfigMap(projectViper.AllSettings()); err == nil {
+						if viper.GetBool("verbose") && !viper.GetBool("json") {
+							fmt.Fprintln(os.Stderr, "Loaded project config:", projectConfigFile)
+						}
+					}
+				}
+			}
 		}
 	}
 
@@ -66,11 +98,8 @@ func initConfig() {
 	viper.SetDefault("preview", false)
 
 	// Memory store path: do NOT set a default here.
-	// GetMemoryBasePath() has FAIL-FAST semantics:
-	// 1. If user sets memory.path in config → use that
-	// 2. Detected project root → use {project_root}/.taskwing/memory
-	// 3. Otherwise → return error (no silent fallbacks)
-	// For non-project commands (help, version), GetMemoryBasePathOrGlobal() provides ~/.taskwing fallback.
+	// GetMemoryBasePath() resolves to ~/.taskwing/projects/<slug>/ via GetProjectStorePath.
+	// For non-project commands (help, version), GetMemoryBasePathOrGlobal() provides fallback.
 
 	// LLM defaults (for bootstrap scanner)
 	// Do NOT set defaults for llm.provider, llm.apiKey, or llm.model
@@ -115,3 +144,18 @@ func detectProjectRoot() *project.Context {
 
 	return ctx
 }
+
+// scanFlagFromArgs extracts a flag value from os.Args before Cobra parses them.
+// Supports --flag=value and --flag value forms.
+func scanFlagFromArgs(name string) string {
+	prefix := "--" + name
+	for i, arg := range os.Args {
+		if arg == prefix && i+1 < len(os.Args) {
+			return os.Args[i+1]
+		}
+		if val, ok := strings.CutPrefix(arg, prefix+"="); ok {
+			return val
+		}
+	}
+	return ""
+}

cmd/doctor.go

@@ -11,6 +11,7 @@ import (
 	"strings"
 
 	"github.com/josephgoksu/TaskWing/internal/bootstrap"
+	"github.com/josephgoksu/TaskWing/internal/config"
 	"github.com/josephgoksu/TaskWing/internal/task"
 	"github.com/josephgoksu/TaskWing/internal/ui"
 	"github.com/spf13/cobra"
@@ -403,31 +404,30 @@ func applyRepairPrimitive(primitive, aiName, cwd, binPath string, init *bootstra
 }
 
 func checkTaskWingInit(cwd string) DoctorCheck {
-	taskwingDir := filepath.Join(cwd, ".taskwing")
-	memoryDir := filepath.Join(taskwingDir, "memory")
-
-	if _, err := os.Stat(taskwingDir); os.IsNotExist(err) {
+	storePath, err := config.GetProjectStorePath(cwd)
+	if err != nil {
 		return DoctorCheck{
 			Name:    "Initialization",
 			Status:  "fail",
-			Message: "Not initialized",
+			Message: "Cannot resolve project store",
 			Hint:    "Run: taskwing bootstrap",
 		}
 	}
 
-	if _, err := os.Stat(memoryDir); os.IsNotExist(err) {
+	dbPath := filepath.Join(storePath, "memory.db")
+	if _, err := os.Stat(dbPath); os.IsNotExist(err) {
 		return DoctorCheck{
 			Name:    "Initialization",
 			Status:  "warn",
-			Message: "Partially initialized (missing memory/)",
+			Message: fmt.Sprintf("Project store exists at %s but no memory.db", storePath),
 			Hint:    "Run: taskwing bootstrap",
 		}
 	}
 
 	return DoctorCheck{
 		Name:    "Initialization",
 		Status:  "ok",
-		Message: ".taskwing/ directory exists",
+		Message: fmt.Sprintf("Project store: %s", storePath),
 	}
 }
 

cmd/hook.go

@@ -637,12 +637,10 @@ func resolveHookMemoryPath() (string, error) {
 		return memoryPath, nil
 	}
 
-	// Claude hooks expose CLAUDE_PROJECT_DIR; use it before global fallback
-	// to keep session state isolated per project even if project context wasn't set.
+	// Claude hooks expose CLAUDE_PROJECT_DIR; use it to resolve the global project store.
 	if projectDir := strings.TrimSpace(os.Getenv("CLAUDE_PROJECT_DIR")); projectDir != "" {
-		taskwingDir := filepath.Join(projectDir, ".taskwing")
-		if info, statErr := os.Stat(taskwingDir); statErr == nil && info.IsDir() {
-			return filepath.Join(taskwingDir, "memory"), nil
+		if storePath, err := config.GetProjectStorePath(projectDir); err == nil {
+			return storePath, nil
 		}
 	}