fix(tools): make worktree bootstrap retries idempotent

commit: 6f3e28f83c725d9139ce8f28a1f93a291c2e6c73
author: brice · 2mo ago · 2026-08-07 08:42 UTC
committer: brice · 2mo ago · 2026-08-07 08:44 UTC
parent: 84a0b9d
signature: GPG VerifiedCD88F9E564E0102646FB6077A1A07C7C7C3E349D · arch-gpg Verified for the committer email

2 files · +96 -6

M packages/agent/tools/create_worktree.go +18 -4


@@ -255,9 +255,6 @@ func (t *CreateWorktreeTool) plan(ctx context.Context, raw json.RawMessage) (cre
255	255		return createWorktreePlan{}, fmt.Errorf("create_worktree: read local worktree configuration: %w", err)
256	256		}
257	257		bootstrapRoot := strings.TrimSpace(args.BootstrapRoot)
258		-	if configured && bootstrapRoot != "" {
259		-	return createWorktreePlan{}, errors.New("create_worktree: worktree root is already configured; change the local Git configuration explicitly before bootstrapping again")
260		-	}
261	258
262	259		rootSource := "existing .worktrees directory"
263	260		configValue := ""

@@ -269,6 +266,23 @@ func (t *CreateWorktreeTool) plan(ctx context.Context, raw json.RawMessage) (cre
269	266		if err != nil {
270	267		return createWorktreePlan{}, err
271	268		}
	269	+	if bootstrapRoot != "" {
	270	+	requestedRoot, requestedDefault, _, err := resolveBootstrapWorktreeRoot(repoRoot, bootstrapRoot)
	271	+	if err != nil {
	272	+	return createWorktreePlan{}, err
	273	+	}
	274	+	configuredCanonical, err := canonicalOrParent(worktreeRoot)
	275	+	if err != nil {
	276	+	return createWorktreePlan{}, fmt.Errorf("create_worktree: resolve configured worktree root: %w", err)
	277	+	}
	278	+	requestedCanonical, err := canonicalOrParent(requestedRoot)
	279	+	if err != nil {
	280	+	return createWorktreePlan{}, fmt.Errorf("create_worktree: resolve bootstrap_root: %w", err)
	281	+	}
	282	+	if defaultRoot != requestedDefault \|\| configuredCanonical != requestedCanonical {
	283	+	return createWorktreePlan{}, errors.New("create_worktree: worktree root is already configured; change the local Git configuration explicitly before bootstrapping again")
	284	+	}
	285	+	}
272	286		rootSource = "local Git config"
273	287		} else {
274	288		defaultPath := filepath.Join(repoRoot, defaultWorktreeRoot)

@@ -280,7 +294,7 @@ func (t *CreateWorktreeTool) plan(ctx context.Context, raw json.RawMessage) (cre
280	294		return bootstrapRequiredPlan(branch, repoRoot), nil
281	295		}
282	296		if exists {
283		-	if bootstrapRoot != "" {
	297	+	if bootstrapRoot != "" && bootstrapRoot != defaultWorktreeRoot {
284	298		return createWorktreePlan{}, errors.New("create_worktree: worktree root is already established; omit bootstrap_root")
285	299		}
286	300		worktreeRoot = defaultPath

 		return createWorktreePlan{}, fmt.Errorf("create_worktree: read local worktree configuration: %w", err)
 	}
 	bootstrapRoot := strings.TrimSpace(args.BootstrapRoot)
-	if configured && bootstrapRoot != "" {
-		return createWorktreePlan{}, errors.New("create_worktree: worktree root is already configured; change the local Git configuration explicitly before bootstrapping again")
-	}
 	rootSource := "existing .worktrees directory"
 	configValue := ""
 		if err != nil {
 			return createWorktreePlan{}, err
 		}
+		if bootstrapRoot != "" {
+			requestedRoot, requestedDefault, _, err := resolveBootstrapWorktreeRoot(repoRoot, bootstrapRoot)
+			if err != nil {
+				return createWorktreePlan{}, err
+			}
+			configuredCanonical, err := canonicalOrParent(worktreeRoot)
+			if err != nil {
+				return createWorktreePlan{}, fmt.Errorf("create_worktree: resolve configured worktree root: %w", err)
+			}
+			requestedCanonical, err := canonicalOrParent(requestedRoot)
+			if err != nil {
+				return createWorktreePlan{}, fmt.Errorf("create_worktree: resolve bootstrap_root: %w", err)
+			}
+			if defaultRoot != requestedDefault || configuredCanonical != requestedCanonical {
+				return createWorktreePlan{}, errors.New("create_worktree: worktree root is already configured; change the local Git configuration explicitly before bootstrapping again")
+			}
+		}
 		rootSource = "local Git config"
 	} else {
 		defaultPath := filepath.Join(repoRoot, defaultWorktreeRoot)
 			return bootstrapRequiredPlan(branch, repoRoot), nil
 		}
 		if exists {
-			if bootstrapRoot != "" {
+			if bootstrapRoot != "" && bootstrapRoot != defaultWorktreeRoot {
 				return createWorktreePlan{}, errors.New("create_worktree: worktree root is already established; omit bootstrap_root")
 			}
 			worktreeRoot = defaultPath

M packages/agent/tools/create_worktree_test.go +78 -2


@@ -60,6 +60,19 @@ func TestCreateWorktreeBootstrapsDefaultAtRepositoryRoot(t *testing.T) {
60	60		if got := gitTestOutput(t, repo, "config", "--local", "--get", worktreeConfigKey); got != defaultWorktreeRoot {
61	61		t.Fatalf("saved worktree root = %q, want %q", got, defaultWorktreeRoot)
62	62		}
	63	+	followupArgs := mustJSON(t, map[string]string{
	64	+	"branch": "feature/default-followup",
	65	+	"bootstrap_root": defaultWorktreeRoot,
	66	+	})
	67	+	if _, err := tool.Preview(context.Background(), followupArgs); err != nil {
	68	+	t.Fatal(err)
	69	+	}
	70	+	if _, err := tool.Execute(context.Background(), followupArgs, nil); err != nil {
	71	+	t.Fatal(err)
	72	+	}
	73	+	if _, err := os.Stat(filepath.Join(repo, defaultWorktreeRoot, "feature", "default-followup")); err != nil {
	74	+	t.Fatalf("configured default root was not reused: %v", err)
	75	+	}
63	76		}
64	77
65	78		func TestCreateWorktreeRequiresBootstrapForUnconfiguredRepository(t *testing.T) {

@@ -93,7 +106,39 @@ func TestCreateWorktreeRequiresBootstrapForUnconfiguredRepository(t *testing.T)
93	106		}
94	107		}
95	108
96		-	func TestCreateWorktreeRejectsBootstrapRootWhenDefaultRootExists(t *testing.T) {
	109	+	func TestCreateWorktreeAcceptsDefaultBootstrapRootWhenDefaultRootExists(t *testing.T) {
	110	+	if _, err := exec.LookPath("git"); err != nil {
	111	+	t.Skip("git is required")
	112	+	}
	113	+	repo := initWorktreeTestRepo(t)
	114	+	if err := os.Mkdir(filepath.Join(repo, defaultWorktreeRoot), 0o755); err != nil {
	115	+	t.Fatal(err)
	116	+	}
	117	+	tool := newCreateWorktreeTestTool(repo)
	118	+	args := mustJSON(t, map[string]string{
	119	+	"branch": "feature/existing-default-root",
	120	+	"bootstrap_root": defaultWorktreeRoot,
	121	+	})
	122	+
	123	+	if _, err := tool.Preview(context.Background(), args); err != nil {
	124	+	t.Fatal(err)
	125	+	}
	126	+	result, err := tool.Execute(context.Background(), args, nil)
	127	+	if err != nil {
	128	+	t.Fatal(err)
	129	+	}
	130	+	if _, err := os.Stat(filepath.Join(repo, defaultWorktreeRoot, "feature", "existing-default-root")); err != nil {
	131	+	t.Fatalf("worktree was not created: %v", err)
	132	+	}
	133	+	if source, _ := result.Details.(map[string]any)["root_source"].(string); source != "existing .worktrees directory" {
	134	+	t.Fatalf("root source = %q", source)
	135	+	}
	136	+	if got := gitTestOutputAllowExit(t, repo, "config", "--local", "--get", worktreeConfigKey); got.exitCode != 1 {
	137	+	t.Fatalf("existing default root saved config: %#v", got)
	138	+	}
	139	+	}
	140	+
	141	+	func TestCreateWorktreeRejectsConflictingBootstrapRootWhenDefaultRootExists(t *testing.T) {
97	142		if _, err := exec.LookPath("git"); err != nil {
98	143		t.Skip("git is required")
99	144		}

@@ -118,6 +163,30 @@ func TestCreateWorktreeRejectsBootstrapRootWhenDefaultRootExists(t *testing.T) {
118	163		}
119	164		}
120	165
	166	+	func TestCreateWorktreeRejectsConflictingBootstrapRootWhenRootIsConfigured(t *testing.T) {
	167	+	if _, err := exec.LookPath("git"); err != nil {
	168	+	t.Skip("git is required")
	169	+	}
	170	+	repo := initWorktreeTestRepo(t)
	171	+	gitTestOutput(t, repo, "config", "--local", worktreeConfigKey, defaultWorktreeRoot)
	172	+	tool := newCreateWorktreeTestTool(repo)
	173	+	args := mustJSON(t, map[string]string{
	174	+	"branch": "feature/conflicting-configured-bootstrap",
	175	+	"bootstrap_root": t.TempDir(),
	176	+	})
	177	+
	178	+	if _, err := tool.Preview(context.Background(), args); err == nil \|\| !strings.Contains(err.Error(), "already configured") {
	179	+	t.Fatalf("preview error = %v, want configured-root error", err)
	180	+	}
	181	+	_, err := tool.Execute(context.Background(), args, nil)
	182	+	if err == nil \|\| !strings.Contains(err.Error(), "already configured") {
	183	+	t.Fatalf("error = %v, want configured-root error", err)
	184	+	}
	185	+	if got := gitTestOutputAllowExit(t, repo, "show-ref", "--verify", "--quiet", "refs/heads/feature/conflicting-configured-bootstrap"); got.exitCode != 1 {
	186	+	t.Fatalf("conflicting bootstrap created branch: %#v", got)
	187	+	}
	188	+	}
	189	+
121	190		func TestCreateWorktreeBootstrapsExternalRootWithoutChangingGitignore(t *testing.T) {
122	191		if _, err := exec.LookPath("git"); err != nil {
123	192		t.Skip("git is required")

@@ -153,7 +222,14 @@ func TestCreateWorktreeBootstrapsExternalRootWithoutChangingGitignore(t *testing
153	222		if state, _ := result.Details.(map[string]any)["state"].(string); state != "created" {
154	223		t.Fatalf("state = %q, want created", state)
155	224		}
156		-	followup, err := tool.Execute(context.Background(), json.RawMessage(`{"branch":"feature/external-followup"}`), nil)
	225	+	followupArgs := mustJSON(t, map[string]string{
	226	+	"branch": "feature/external-followup",
	227	+	"bootstrap_root": externalRoot,
	228	+	})
	229	+	if _, err := tool.Preview(context.Background(), followupArgs); err != nil {
	230	+	t.Fatal(err)
	231	+	}
	232	+	followup, err := tool.Execute(context.Background(), followupArgs, nil)
157	233		if err != nil {
158	234		t.Fatal(err)
159	235		}


@@ -60,6 +60,19 @@ func TestCreateWorktreeBootstrapsDefaultAtRepositoryRoot(t *testing.T) {
60		if got := gitTestOutput(t, repo, "config", "--local", "--get", worktreeConfigKey); got != defaultWorktreeRoot {	60		if got := gitTestOutput(t, repo, "config", "--local", "--get", worktreeConfigKey); got != defaultWorktreeRoot {
61		t.Fatalf("saved worktree root = %q, want %q", got, defaultWorktreeRoot)	61		t.Fatalf("saved worktree root = %q, want %q", got, defaultWorktreeRoot)
62		}	62		}
			63	+	followupArgs := mustJSON(t, map[string]string{
			64	+	"branch": "feature/default-followup",
			65	+	"bootstrap_root": defaultWorktreeRoot,
			66	+	})
			67	+	if _, err := tool.Preview(context.Background(), followupArgs); err != nil {
			68	+	t.Fatal(err)
			69	+	}
			70	+	if _, err := tool.Execute(context.Background(), followupArgs, nil); err != nil {
			71	+	t.Fatal(err)
			72	+	}
			73	+	if _, err := os.Stat(filepath.Join(repo, defaultWorktreeRoot, "feature", "default-followup")); err != nil {
			74	+	t.Fatalf("configured default root was not reused: %v", err)
			75	+	}
63		}	76		}
64			77
65		func TestCreateWorktreeRequiresBootstrapForUnconfiguredRepository(t *testing.T) {	78		func TestCreateWorktreeRequiresBootstrapForUnconfiguredRepository(t *testing.T) {

@@ -93,7 +106,39 @@ func TestCreateWorktreeRequiresBootstrapForUnconfiguredRepository(t *testing.T)
93		}	106		}
94		}	107		}
95			108
96	-	func TestCreateWorktreeRejectsBootstrapRootWhenDefaultRootExists(t *testing.T) {	109	+	func TestCreateWorktreeAcceptsDefaultBootstrapRootWhenDefaultRootExists(t *testing.T) {
			110	+	if _, err := exec.LookPath("git"); err != nil {
			111	+	t.Skip("git is required")
			112	+	}
			113	+	repo := initWorktreeTestRepo(t)
			114	+	if err := os.Mkdir(filepath.Join(repo, defaultWorktreeRoot), 0o755); err != nil {
			115	+	t.Fatal(err)
			116	+	}
			117	+	tool := newCreateWorktreeTestTool(repo)
			118	+	args := mustJSON(t, map[string]string{
			119	+	"branch": "feature/existing-default-root",
			120	+	"bootstrap_root": defaultWorktreeRoot,
			121	+	})
			122	+
			123	+	if _, err := tool.Preview(context.Background(), args); err != nil {
			124	+	t.Fatal(err)
			125	+	}
			126	+	result, err := tool.Execute(context.Background(), args, nil)
			127	+	if err != nil {
			128	+	t.Fatal(err)
			129	+	}
			130	+	if _, err := os.Stat(filepath.Join(repo, defaultWorktreeRoot, "feature", "existing-default-root")); err != nil {
			131	+	t.Fatalf("worktree was not created: %v", err)
			132	+	}
			133	+	if source, _ := result.Details.(map[string]any)["root_source"].(string); source != "existing .worktrees directory" {
			134	+	t.Fatalf("root source = %q", source)
			135	+	}
			136	+	if got := gitTestOutputAllowExit(t, repo, "config", "--local", "--get", worktreeConfigKey); got.exitCode != 1 {
			137	+	t.Fatalf("existing default root saved config: %#v", got)
			138	+	}
			139	+	}
			140	+
			141	+	func TestCreateWorktreeRejectsConflictingBootstrapRootWhenDefaultRootExists(t *testing.T) {
97		if _, err := exec.LookPath("git"); err != nil {	142		if _, err := exec.LookPath("git"); err != nil {
98		t.Skip("git is required")	143		t.Skip("git is required")
99		}	144		}

@@ -118,6 +163,30 @@ func TestCreateWorktreeRejectsBootstrapRootWhenDefaultRootExists(t *testing.T) {
118		}	163		}
119		}	164		}
120			165
			166	+	func TestCreateWorktreeRejectsConflictingBootstrapRootWhenRootIsConfigured(t *testing.T) {
			167	+	if _, err := exec.LookPath("git"); err != nil {
			168	+	t.Skip("git is required")
			169	+	}
			170	+	repo := initWorktreeTestRepo(t)
			171	+	gitTestOutput(t, repo, "config", "--local", worktreeConfigKey, defaultWorktreeRoot)
			172	+	tool := newCreateWorktreeTestTool(repo)
			173	+	args := mustJSON(t, map[string]string{
			174	+	"branch": "feature/conflicting-configured-bootstrap",
			175	+	"bootstrap_root": t.TempDir(),
			176	+	})
			177	+
			178	+	if _, err := tool.Preview(context.Background(), args); err == nil \|\| !strings.Contains(err.Error(), "already configured") {
			179	+	t.Fatalf("preview error = %v, want configured-root error", err)
			180	+	}
			181	+	_, err := tool.Execute(context.Background(), args, nil)
			182	+	if err == nil \|\| !strings.Contains(err.Error(), "already configured") {
			183	+	t.Fatalf("error = %v, want configured-root error", err)
			184	+	}
			185	+	if got := gitTestOutputAllowExit(t, repo, "show-ref", "--verify", "--quiet", "refs/heads/feature/conflicting-configured-bootstrap"); got.exitCode != 1 {
			186	+	t.Fatalf("conflicting bootstrap created branch: %#v", got)
			187	+	}
			188	+	}
			189	+
121		func TestCreateWorktreeBootstrapsExternalRootWithoutChangingGitignore(t *testing.T) {	190		func TestCreateWorktreeBootstrapsExternalRootWithoutChangingGitignore(t *testing.T) {
122		if _, err := exec.LookPath("git"); err != nil {	191		if _, err := exec.LookPath("git"); err != nil {
123		t.Skip("git is required")	192		t.Skip("git is required")

@@ -153,7 +222,14 @@ func TestCreateWorktreeBootstrapsExternalRootWithoutChangingGitignore(t *testing
153		if state, _ := result.Details.(map[string]any)["state"].(string); state != "created" {	222		if state, _ := result.Details.(map[string]any)["state"].(string); state != "created" {
154		t.Fatalf("state = %q, want created", state)	223		t.Fatalf("state = %q, want created", state)
155		}	224		}
156	-	followup, err := tool.Execute(context.Background(), json.RawMessage(`{"branch":"feature/external-followup"}`), nil)	225	+	followupArgs := mustJSON(t, map[string]string{
			226	+	"branch": "feature/external-followup",
			227	+	"bootstrap_root": externalRoot,
			228	+	})
			229	+	if _, err := tool.Preview(context.Background(), followupArgs); err != nil {
			230	+	t.Fatal(err)
			231	+	}
			232	+	followup, err := tool.Execute(context.Background(), followupArgs, nil)
157		if err != nil {	233		if err != nil {
158		t.Fatal(err)	234		t.Fatal(err)
159		}	235		}