Merge origin/main into task branch, resolve conflicts in retry/quick input

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: bborn

internal/config/config.go

@@ -62,6 +62,19 @@ func (c *Config) GetProjectDir(project string) string {
 	return filepath.Join(c.ProjectsDir, project)
 }
 
+// ProjectUsesWorktrees returns whether a project uses git worktrees for task isolation.
+// Returns true by default (for backward compatibility and unknown projects).
+func (c *Config) ProjectUsesWorktrees(project string) bool {
+	if project == "" {
+		return true
+	}
+	p, err := c.db.GetProjectByName(project)
+	if err == nil && p != nil {
+		return p.UsesWorktrees()
+	}
+	return true
+}
+
 // SetProjectsDir sets the default projects directory.
 func (c *Config) SetProjectsDir(dir string) error {
 	if err := c.db.SetSetting(SettingProjectsDir, dir); err != nil {

internal/db/sqlite.go

@@ -269,6 +269,8 @@ func (db *DB) migrate() error {
 		`ALTER TABLE tasks ADD COLUMN source_branch TEXT DEFAULT ''`, // Existing branch to checkout instead of creating new branch
 		// Cached PR state as JSON for instant display on startup (avoids waiting for GitHub API)
 		`ALTER TABLE tasks ADD COLUMN pr_info_json TEXT DEFAULT ''`, // JSON blob of github.PRInfo
+		// Whether project uses git worktrees for task isolation (1=yes, 0=no, default 1 for backward compat)
+		`ALTER TABLE projects ADD COLUMN use_worktrees INTEGER DEFAULT 1`,
 	}
 
 	for _, m := range alterMigrations {

internal/db/sqlite_test.go

@@ -193,3 +193,83 @@ func TestProjectContext(t *testing.T) {
 		t.Error("expected error when setting context for non-existent project")
 	}
 }
+
+func TestProjectUseWorktrees(t *testing.T) {
+	tmpDir := t.TempDir()
+	dbPath := filepath.Join(tmpDir, "test.db")
+
+	db, err := Open(dbPath)
+	if err != nil {
+		t.Fatalf("failed to open database: %v", err)
+	}
+	defer db.Close()
+
+	// Default project (personal) should use worktrees
+	personal, err := db.GetProjectByName("personal")
+	if err != nil {
+		t.Fatalf("failed to get personal project: %v", err)
+	}
+	if !personal.UsesWorktrees() {
+		t.Error("personal project should default to using worktrees")
+	}
+
+	// Create a project with worktrees enabled (default)
+	gitProject := &Project{Name: "git-project", Path: filepath.Join(tmpDir, "git"), UseWorktrees: true}
+	if err := db.CreateProject(gitProject); err != nil {
+		t.Fatalf("failed to create git project: %v", err)
+	}
+
+	// Create a project with worktrees disabled
+	noGitProject := &Project{Name: "no-git-project", Path: filepath.Join(tmpDir, "nogit"), UseWorktrees: false}
+	if err := db.CreateProject(noGitProject); err != nil {
+		t.Fatalf("failed to create no-git project: %v", err)
+	}
+
+	// Verify via GetProjectByName
+	p, err := db.GetProjectByName("git-project")
+	if err != nil {
+		t.Fatalf("failed to get git-project: %v", err)
+	}
+	if !p.UsesWorktrees() {
+		t.Error("git-project should use worktrees")
+	}
+
+	p, err = db.GetProjectByName("no-git-project")
+	if err != nil {
+		t.Fatalf("failed to get no-git-project: %v", err)
+	}
+	if p.UsesWorktrees() {
+		t.Error("no-git-project should NOT use worktrees")
+	}
+
+	// Verify via ListProjects
+	projects, err := db.ListProjects()
+	if err != nil {
+		t.Fatalf("failed to list projects: %v", err)
+	}
+	for _, proj := range projects {
+		switch proj.Name {
+		case "git-project":
+			if !proj.UsesWorktrees() {
+				t.Error("git-project should use worktrees in list")
+			}
+		case "no-git-project":
+			if proj.UsesWorktrees() {
+				t.Error("no-git-project should NOT use worktrees in list")
+			}
+		}
+	}
+
+	// Test updating worktrees setting
+	noGitProject.UseWorktrees = true
+	if err := db.UpdateProject(noGitProject); err != nil {
+		t.Fatalf("failed to update project: %v", err)
+	}
+	p, err = db.GetProjectByName("no-git-project")
+	if err != nil {
+		t.Fatalf("failed to get updated project: %v", err)
+	}
+	if !p.UsesWorktrees() {
+		t.Error("no-git-project should use worktrees after update")
+	}
+}

internal/db/tasks.go

@@ -1076,9 +1076,16 @@ type Project struct {
 	Actions         []ProjectAction // actions triggered on task events (stored as JSON)
 	Color           string          // hex color for display (e.g., "#61AFEF")
 	ClaudeConfigDir string          // override CLAUDE_CONFIG_DIR for this project
+	UseWorktrees    bool            // whether to use git worktrees for task isolation (default true)
 	CreatedAt       LocalTime
 }
 
+// UsesWorktrees returns whether this project uses git worktrees for task isolation.
+// Defaults to true for backward compatibility.
+func (p *Project) UsesWorktrees() bool {
+	return p.UseWorktrees
+}
+
 // GetAction returns the action for a given trigger, or nil if not found.
 func (p *Project) GetAction(trigger string) *ProjectAction {
 	for i := range p.Actions {
@@ -1092,10 +1099,14 @@ func (p *Project) GetAction(trigger string) *ProjectAction {
 // CreateProject creates a new project.
 func (db *DB) CreateProject(p *Project) error {
 	actionsJSON, _ := json.Marshal(p.Actions)
+	useWorktrees := 1
+	if !p.UseWorktrees {
+		useWorktrees = 0
+	}
 	result, err := db.Exec(`
-		INSERT INTO projects (name, path, aliases, instructions, actions, color, claude_config_dir)
-		VALUES (?, ?, ?, ?, ?, ?, ?)
-	`, p.Name, p.Path, p.Aliases, p.Instructions, string(actionsJSON), p.Color, p.ClaudeConfigDir)
+		INSERT INTO projects (name, path, aliases, instructions, actions, color, claude_config_dir, use_worktrees)
+		VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+	`, p.Name, p.Path, p.Aliases, p.Instructions, string(actionsJSON), p.Color, p.ClaudeConfigDir, useWorktrees)
 	if err != nil {
 		return fmt.Errorf("insert project: %w", err)
 	}
@@ -1107,10 +1118,14 @@ func (db *DB) CreateProject(p *Project) error {
 // UpdateProject updates a project.
 func (db *DB) UpdateProject(p *Project) error {
 	actionsJSON, _ := json.Marshal(p.Actions)
+	useWorktrees := 1
+	if !p.UseWorktrees {
+		useWorktrees = 0
+	}
 	_, err := db.Exec(`
-		UPDATE projects SET name = ?, path = ?, aliases = ?, instructions = ?, actions = ?, color = ?, claude_config_dir = ?
+		UPDATE projects SET name = ?, path = ?, aliases = ?, instructions = ?, actions = ?, color = ?, claude_config_dir = ?, use_worktrees = ?
 		WHERE id = ?
-	`, p.Name, p.Path, p.Aliases, p.Instructions, string(actionsJSON), p.Color, p.ClaudeConfigDir, p.ID)
+	`, p.Name, p.Path, p.Aliases, p.Instructions, string(actionsJSON), p.Color, p.ClaudeConfigDir, useWorktrees, p.ID)
 	if err != nil {
 		return fmt.Errorf("update project: %w", err)
 	}
@@ -1151,7 +1166,7 @@ func (db *DB) CountTasksByProject(projectName string) (int, error) {
 // ListProjects returns all projects, with "personal" always first.
 func (db *DB) ListProjects() ([]*Project, error) {
 	rows, err := db.Query(`
-		SELECT id, name, path, aliases, instructions, COALESCE(actions, '[]'), COALESCE(color, ''), COALESCE(claude_config_dir, ''), created_at
+		SELECT id, name, path, aliases, instructions, COALESCE(actions, '[]'), COALESCE(color, ''), COALESCE(claude_config_dir, ''), COALESCE(use_worktrees, 1), created_at
 		FROM projects ORDER BY CASE WHEN name = 'personal' THEN 0 ELSE 1 END, name
 	`)
 	if err != nil {
@@ -1163,10 +1178,12 @@ func (db *DB) ListProjects() ([]*Project, error) {
 	for rows.Next() {
 		p := &Project{}
 		var actionsJSON string
-		if err := rows.Scan(&p.ID, &p.Name, &p.Path, &p.Aliases, &p.Instructions, &actionsJSON, &p.Color, &p.ClaudeConfigDir, &p.CreatedAt); err != nil {
+		var useWorktrees int
+		if err := rows.Scan(&p.ID, &p.Name, &p.Path, &p.Aliases, &p.Instructions, &actionsJSON, &p.Color, &p.ClaudeConfigDir, &useWorktrees, &p.CreatedAt); err != nil {
 			return nil, fmt.Errorf("scan project: %w", err)
 		}
 		json.Unmarshal([]byte(actionsJSON), &p.Actions)
+		p.UseWorktrees = useWorktrees != 0
 		projects = append(projects, p)
 	}
 	return projects, nil
@@ -1177,31 +1194,34 @@ func (db *DB) GetProjectByName(name string) (*Project, error) {
 	// First try exact name match
 	p := &Project{}
 	var actionsJSON string
+	var useWorktrees int
 	err := db.QueryRow(`
-		SELECT id, name, path, aliases, instructions, COALESCE(actions, '[]'), COALESCE(color, ''), COALESCE(claude_config_dir, ''), created_at
+		SELECT id, name, path, aliases, instructions, COALESCE(actions, '[]'), COALESCE(color, ''), COALESCE(claude_config_dir, ''), COALESCE(use_worktrees, 1), created_at
 		FROM projects WHERE name = ?
-	`, name).Scan(&p.ID, &p.Name, &p.Path, &p.Aliases, &p.Instructions, &actionsJSON, &p.Color, &p.ClaudeConfigDir, &p.CreatedAt)
+	`, name).Scan(&p.ID, &p.Name, &p.Path, &p.Aliases, &p.Instructions, &actionsJSON, &p.Color, &p.ClaudeConfigDir, &useWorktrees, &p.CreatedAt)
 	if err == nil {
 		json.Unmarshal([]byte(actionsJSON), &p.Actions)
+		p.UseWorktrees = useWorktrees != 0
 		return p, nil
 	}
 	if err != sql.ErrNoRows {
 		return nil, fmt.Errorf("query project: %w", err)
 	}
 
 	// Try alias match
-	rows, err := db.Query(`SELECT id, name, path, aliases, instructions, COALESCE(actions, '[]'), COALESCE(color, ''), COALESCE(claude_config_dir, ''), created_at FROM projects`)
+	rows, err := db.Query(`SELECT id, name, path, aliases, instructions, COALESCE(actions, '[]'), COALESCE(color, ''), COALESCE(claude_config_dir, ''), COALESCE(use_worktrees, 1), created_at FROM projects`)
 	if err != nil {
 		return nil, fmt.Errorf("query projects: %w", err)
 	}
 	defer rows.Close()
 
 	for rows.Next() {
 		p := &Project{}
-		if err := rows.Scan(&p.ID, &p.Name, &p.Path, &p.Aliases, &p.Instructions, &actionsJSON, &p.Color, &p.ClaudeConfigDir, &p.CreatedAt); err != nil {
+		if err := rows.Scan(&p.ID, &p.Name, &p.Path, &p.Aliases, &p.Instructions, &actionsJSON, &p.Color, &p.ClaudeConfigDir, &useWorktrees, &p.CreatedAt); err != nil {
 			return nil, fmt.Errorf("scan project: %w", err)
 		}
 		json.Unmarshal([]byte(actionsJSON), &p.Actions)
+		p.UseWorktrees = useWorktrees != 0
 		for _, alias := range splitAliases(p.Aliases) {
 			if alias == name {
 				return p, nil

internal/executor/executor.go

@@ -847,6 +847,12 @@ func (e *Executor) cleanupStaleWorktrees() {
 			continue
 		}
 
+		// Skip non-worktree projects - they share the project directory and should not be archived
+		if !e.config.ProjectUsesWorktrees(task.Project) {
+			e.db.ClearTaskWorktreePath(task.ID)
+			continue
+		}
+
 		// Skip if worktree path doesn't exist on disk (already cleaned up)
 		if _, err := os.Stat(task.WorktreePath); os.IsNotExist(err) {
 			// Path gone, just clear the DB reference
@@ -903,6 +909,13 @@ func (e *Executor) CleanupStaleWorktreesManual(maxAge time.Duration, dryRun bool
 
 	var cleaned []*db.Task
 	for _, task := range tasks {
+		// Skip non-worktree projects
+		if !e.config.ProjectUsesWorktrees(task.Project) {
+			e.db.ClearTaskWorktreePath(task.ID)
+			cleaned = append(cleaned, task)
+			continue
+		}
+
 		// Skip if worktree path doesn't exist on disk
 		if _, err := os.Stat(task.WorktreePath); os.IsNotExist(err) {
 			e.db.ClearTaskWorktreePath(task.ID)
@@ -934,6 +947,10 @@ func (e *Executor) pruneAllProjectWorktrees() {
 		return
 	}
 	for _, p := range projects {
+		// Skip non-worktree projects - no git worktrees to prune
+		if !p.UsesWorktrees() {
+			continue
+		}
 		dir := e.config.GetProjectDir(p.Name)
 		if dir == "" {
 			continue
@@ -1919,10 +1936,10 @@ func ensureTmuxDaemon() (string, error) {
 // SECURITY: workDir must be within a .task-worktrees directory to prevent Claude from
 // accidentally writing to the main project directory.
 func createTmuxWindow(daemonSession, windowName, workDir, script string) (string, error) {
-	// SECURITY: Validate that workDir is within a .task-worktrees directory
-	// This prevents Claude from running in the main project directory
-	if !isValidWorktreePath(workDir) {
-		return "", fmt.Errorf("security: refusing to create tmux window with workDir outside .task-worktrees: %s", workDir)
+	// SECURITY: Validate that workDir is within a .task-worktrees directory,
+	// OR is a valid project directory (for non-worktree projects).
+	if !isValidWorkDir(workDir) {
+		return "", fmt.Errorf("security: refusing to create tmux window with invalid workDir: %s", workDir)
 	}
 
 	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
@@ -3326,6 +3343,11 @@ func (e *Executor) setupWorktree(task *db.Task) (string, error) {
 		return "", fmt.Errorf("project directory not found for project: %s", task.Project)
 	}
 
+	// For non-worktree projects, all tasks share the project directory directly
+	if !e.config.ProjectUsesWorktrees(task.Project) {
+		return e.setupSharedWorkDir(task, projectDir, paths)
+	}
+
 	// Check if project is a git repo, initialize one if not
 	// Git is required for worktree isolation - tasks always run in worktrees
 	// NOTE: This should rarely happen now - git repos are initialized during project creation.
@@ -3540,6 +3562,36 @@ func (e *Executor) setupWorktree(task *db.Task) (string, error) {
 	return worktreePath, nil
 }
 
+// setupSharedWorkDir sets up a task to use the project directory directly,
+// without git worktree isolation. Used for non-git projects.
+func (e *Executor) setupSharedWorkDir(task *db.Task, projectDir string, paths claudePaths) (string, error) {
+	// Ensure project directory exists
+	if err := os.MkdirAll(projectDir, 0755); err != nil {
+		return "", fmt.Errorf("create project dir: %w", err)
+	}
+
+	// Set worktree path to the project directory itself
+	task.WorktreePath = projectDir
+	task.BranchName = "" // No branch for non-git projects
+	e.db.UpdateTask(task)
+
+	// Allocate a port if not already assigned
+	if task.Port == 0 {
+		port, err := e.db.AllocatePort(task.ID)
+		if err != nil {
+			e.logger.Warn("could not allocate port", "error", err)
+		} else {
+			task.Port = port
+		}
+	}
+
+	e.logLine(task.ID, "system", fmt.Sprintf("Using shared working directory: %s (no worktree isolation)", projectDir))
+
+	e.writeWorktreeEnvFile(projectDir, projectDir, task, paths.configDir)
+
+	return projectDir, nil
+}
+
 // getUserShell returns the login shell for the given username.
 // On macOS it uses dscl, on Linux it reads /etc/passwd.
 func getUserShell(username string) (string, error) {
@@ -4306,6 +4358,13 @@ func (e *Executor) ArchiveWorktree(task *db.Task) error {
 		return nil
 	}
 
+	// For non-worktree projects, just clear the worktree path reference.
+	// The shared working directory is never removed.
+	if !e.config.ProjectUsesWorktrees(task.Project) {
+		e.db.ClearTaskWorktreePath(task.ID)
+		return nil
+	}
+
 	// Get project directory to run git commands from
 	projectDir := e.getProjectDir(task.Project)
 	if projectDir == "" {
@@ -4427,6 +4486,18 @@ func (e *Executor) ArchiveWorktree(task *db.Task) error {
 // 3. Runs init script
 // 4. Clears the archive state from the database
 func (e *Executor) UnarchiveWorktree(task *db.Task) error {
+	// For non-worktree projects, just restore the worktree path to the project dir
+	if !e.config.ProjectUsesWorktrees(task.Project) {
+		projectDir := e.getProjectDir(task.Project)
+		if projectDir == "" {
+			return fmt.Errorf("could not find project directory for project: %s", task.Project)
+		}
+		task.WorktreePath = projectDir
+		task.BranchName = ""
+		e.db.UpdateTask(task)
+		return nil
+	}
+
 	// Check if task has archive state
 	if !task.HasArchiveState() {
 		return fmt.Errorf("task has no archive state to restore")
@@ -5076,6 +5147,7 @@ func (e *Executor) KillPiProcess(taskID int64) bool {
 // isValidWorktreePath validates that a working directory is within a .task-worktrees directory.
 // This prevents Claude from accidentally writing to the main project directory.
 // Returns true if the path is valid for task execution.
+// isValidWorktreePath validates that a working directory is within a .task-worktrees directory.
 func isValidWorktreePath(workDir string) bool {
 	// Empty path is never valid
 	if workDir == "" {
@@ -5100,6 +5172,23 @@ func isValidWorktreePath(workDir string) bool {
 	return strings.Contains(resolvedPath, string(filepath.Separator)+".task-worktrees"+string(filepath.Separator))
 }
 
+// isValidWorkDir validates that a working directory is either within a .task-worktrees directory
+// (for git worktree projects) or is an existing directory (for non-worktree projects).
+func isValidWorkDir(workDir string) bool {
+	// First check the traditional worktree path
+	if isValidWorktreePath(workDir) {
+		return true
+	}
+
+	// For non-worktree projects, the workDir is the project directory itself.
+	// Validate it exists and is a directory.
+	if workDir == "" {
+		return false
+	}
+	info, err := os.Stat(workDir)
+	return err == nil && info.IsDir()
+}
+
 // slugify converts a string to a URL/branch-friendly slug.
 func slugify(s string, maxLen int) string {
 	// Convert to lowercase