devrites 4.5.0 → 4.7.0

package/engine/internal/lib/migrate.go

@@ -0,0 +1,219 @@
+package lib
+
+import (
+	"flag"
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"github.com/devrites/devrites/internal/devritespaths"
+	"github.com/devrites/devrites/internal/fsutil"
+	"github.com/devrites/devrites/internal/state"
+)
+
+// migrateStep is one deterministic action of a migration plan.
+type migrateStep struct {
+	kind   string // "phase", "cursor", "schema", or "stub"
+	path   string // workspace-relative file a stub creates
+	detail string
+}
+
+type migrateQuestion struct {
+	id     string
+	prompt string
+}
+
+type migratePlan struct {
+	phase     string
+	steps     []migrateStep
+	questions []migrateQuestion
+}
+
+// Migrate normalizes a pre-v5 feature workspace to the current schema: it
+// converts legacy bullet cursor fields into canonical table rows, records the
+// schema row, and creates missing required artifacts as empty stubs. Bound
+// proof files are preserved byte-exact; content is never synthesized. The
+// command is one-shot and fail-closed: on ambiguity it writes nothing, prints
+// its questions, and exits non-zero; answers arrive on rerun via
+// --answer id=choice. --dry-run prints the plan and always writes nothing.
+func Migrate(root string, args []string, stdout, stderr io.Writer) int {
+	flags := flag.NewFlagSet("migrate", flag.ContinueOnError)
+	flags.SetOutput(io.Discard)
+	dryRun := flags.Bool("dry-run", false, "print the plan without writing")
+	var answerPairs stringSlice
+	flags.Var(&answerPairs, "answer", "answer a migration question: id=choice")
+	// Parse with interleaving support: stdlib stops at the first positional,
+	// so re-parse the remainder and collect positionals along the way.
+	var positionals []string
+	remaining := args
+	for {
+		if err := flags.Parse(remaining); err != nil {
+			fmt.Fprintf(stderr, "devrites: %v\n", err)
+			return 2
+		}
+		rest := flags.Args()
+		if len(rest) == 0 {
+			break
+		}
+		positionals = append(positionals, rest[0])
+		remaining = rest[1:]
+	}
+	if len(positionals) != 1 {
+		fmt.Fprintln(stderr, "usage: devrites-engine migrate <slug> [--dry-run] [--answer id=choice]")
+		return 2
+	}
+	slug := positionals[0]
+
+	work, err := devritespaths.ExistingFeatureDirChecked(root, slug)
+	if err != nil {
+		fmt.Fprintf(stderr, "migrate: %v\n", err)
+		return 2
+	}
+	answered := map[string]string{}
+	for _, pair := range answerPairs {
+		id, value, ok := strings.Cut(pair, "=")
+		if !ok || strings.TrimSpace(id) == "" {
+			fmt.Fprintf(stderr, "devrites: invalid --answer %q (want id=choice)\n", pair)
+			return 2
+		}
+		answered[strings.TrimSpace(id)] = strings.TrimSpace(value)
+	}
+
+	// Read, plan, and apply under one feature lock so a concurrent
+	// `state resolve`/`close` can never be clobbered by a stale read.
+	ledger := filepath.Join(work, "state.md")
+	var applied int
+	var exit int
+	var result string
+	err = state.WithFeatureLock(root, slug, func() error {
+		raw, err := os.ReadFile(ledger)
+		if err != nil {
+			return err
+		}
+		lines := strings.Split(strings.ReplaceAll(string(raw), "\r\n", "\n"), "\n")
+
+		version, err := state.WorkspaceSchema(root, slug)
+		if err != nil {
+			return err
+		}
+		if version > state.SchemaVersion {
+			fmt.Fprintf(stderr, "migrate: workspace %s declares schema %d, newer than this engine's %d; upgrade devrites\n", slug, version, state.SchemaVersion)
+			exit = 3
+			return nil
+		}
+		if version == state.SchemaVersion {
+			result = fmt.Sprintf("migrate: %s already at schema %d; nothing to do\n", slug, version)
+			exit = 0
+			return nil
+		}
+
+		plan := buildMigratePlan(root, slug, lines, answered)
+		if len(plan.questions) > 0 {
+			for _, q := range plan.questions {
+				fmt.Fprintf(stderr, "migrate: question %s: %s\n", q.id, q.prompt)
+			}
+			fmt.Fprintln(stderr, "migrate: nothing written; re-run with --answer id=choice")
+			exit = 3
+			return nil
+		}
+
+		if *dryRun {
+			fmt.Fprintf(stdout, "migrate: plan for %s\n", slug)
+			for _, step := range plan.steps {
+				fmt.Fprintf(stdout, "  [%s] %s\n", step.kind, step.detail)
+			}
+			fmt.Fprintln(stdout, "migrate: dry run; nothing written")
+			exit = 0
+			return nil
+		}
+
+		// New stub files go first: they are idempotent, never bound, and
+		// state.md is the commit point written last.
+		for _, step := range plan.steps {
+			if step.kind != "stub" {
+				continue
+			}
+			path := filepath.Join(work, filepath.FromSlash(step.path))
+			if _, statErr := os.Stat(path); statErr == nil {
+				return fmt.Errorf("stub target %s appeared during migration; re-run migrate", step.path)
+			}
+			if err := fsutil.WriteFileAtomic(path, nil, 0o644); err != nil {
+				return err
+			}
+			applied++
+		}
+		next := lines
+		for _, step := range plan.steps {
+			if step.kind == "phase" {
+				next = state.UpsertCursorField(next, state.CursorPhase, plan.phase)
+			}
+		}
+		if converted, changed := state.ConvertCursorToTable(next); changed {
+			next = converted
+		}
+		next = state.UpsertCursorField(next, state.CursorSchema, fmt.Sprint(state.SchemaVersion))
+		if err := fsutil.WriteFileAtomic(ledger, []byte(strings.Join(next, "\n")), 0o644); err != nil {
+			return err
+		}
+		result = fmt.Sprintf("migrate: %s normalized to schema %d (%d stub(s) created)\n", slug, state.SchemaVersion, applied)
+		exit = 0
+		return nil
+	})
+	if err != nil {
+		fmt.Fprintf(stderr, "migrate: %v\n", err)
+		return 1
+	}
+	fmt.Fprint(stdout, result)
+	return exit
+}
+
+func buildMigratePlan(root, slug string, lines []string, answered map[string]string) migratePlan {
+	plan := migratePlan{}
+	phase, hasPhase := state.CursorField(lines, state.CursorPhase)
+
+	if value, ok := answered["phase"]; ok {
+		plan.steps = append(plan.steps, migrateStep{kind: "phase", detail: "record phase " + value + " from answer"})
+		phase, hasPhase = value, true
+	}
+	if !hasPhase {
+		plan.questions = append(plan.questions, migrateQuestion{id: "phase",
+			prompt: "state.md records no phase; re-run with --answer phase=<phase>"})
+		return plan
+	}
+	if _, ok := state.PolicyFor(state.Phase(phase)); !ok {
+		plan.questions = append(plan.questions, migrateQuestion{id: "phase",
+			prompt: "state.md records unknown phase " + phase + "; re-run with --answer phase=<phase>"})
+		return plan
+	}
+	plan.phase = phase
+
+	if state.CursorForm(lines) == "legacy" {
+		plan.steps = append(plan.steps, migrateStep{kind: "cursor", detail: "convert legacy cursor bullets to canonical table rows"})
+	}
+	plan.steps = append(plan.steps, migrateStep{kind: "schema", detail: fmt.Sprintf("record schema %d in state.md", state.SchemaVersion)})
+
+	policy, _ := state.PolicyFor(state.Phase(phase))
+	for _, artifact := range policy.RequiredArtifacts {
+		name := string(artifact)
+		if name == state.LedgerFile {
+			continue
+		}
+		if _, err := os.Stat(filepath.Join(devritespaths.FeatureDir(root, slug), filepath.FromSlash(name))); err == nil {
+			continue
+		}
+		plan.steps = append(plan.steps, migrateStep{kind: "stub", path: name, detail: "create missing " + name + " as an empty stub"})
+	}
+	return plan
+}
+
+// stringSlice collects repeated string flag values.
+type stringSlice []string
+
+func (s *stringSlice) String() string { return strings.Join(*s, ",") }
+
+func (s *stringSlice) Set(value string) error {
+	*s = append(*s, value)
+	return nil
+}

package/engine/internal/lib/migrate_test.go

@@ -0,0 +1,154 @@
+package lib
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+// seedPreV5Workspace builds a pre-v5 workspace with a bullet cursor, prose,
+// and no required artifacts beyond state.md.
+func seedPreV5Workspace(t *testing.T, phase string) (root, workspace string) {
+	t.Helper()
+	root = t.TempDir()
+	workspace = filepath.Join(root, "work", "feature")
+	if err := os.MkdirAll(workspace, 0o755); err != nil {
+		t.Fatal(err)
+	}
+	body := "- Phase: " + phase + "\n- Status: running\n- Next step: continue slice S-2\n\n# Status\n\nMinting middleware landed.\n"
+	if err := os.WriteFile(filepath.Join(workspace, "state.md"), []byte(body), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	return root, workspace
+}
+
+func TestMigrateDryRunPlansWithoutWriting(t *testing.T) {
+	root, workspace := seedPreV5Workspace(t, "build")
+	var stdout, stderr strings.Builder
+	if code := Migrate(root, []string{"feature", "--dry-run"}, &stdout, &stderr); code != 0 {
+		t.Fatalf("code=%d stderr=%q", code, stderr.String())
+	}
+	out := stdout.String()
+	if !strings.Contains(out, "migrate: plan for feature") ||
+		!strings.Contains(out, "[cursor] convert legacy cursor bullets") ||
+		!strings.Contains(out, "[schema] record schema") ||
+		!strings.Contains(out, "[stub] create missing spec.md") {
+		t.Fatalf("plan incomplete:\n%s", out)
+	}
+	// Nothing written: state.md bytes unchanged and no stub exists.
+	body, err := os.ReadFile(filepath.Join(workspace, "state.md"))
+	if err != nil || !strings.HasPrefix(string(body), "- Phase: build\n") {
+		t.Fatalf("state.md changed during dry run: %v %q", err, body)
+	}
+	if _, err := os.Stat(filepath.Join(workspace, "spec.md")); !os.IsNotExist(err) {
+		t.Fatalf("stub created during dry run: %v", err)
+	}
+}
+
+func TestMigrateExecutesCursorConversionAndStubs(t *testing.T) {
+	root, workspace := seedPreV5Workspace(t, "build")
+	var stdout, stderr strings.Builder
+	if code := Migrate(root, []string{"feature"}, &stdout, &stderr); code != 0 {
+		t.Fatalf("code=%d stderr=%q", code, stderr.String())
+	}
+	body, err := os.ReadFile(filepath.Join(workspace, "state.md"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	text := string(body)
+	if !strings.Contains(text, "| phase | build |") || !strings.Contains(text, "| status | running |") {
+		t.Fatalf("cursor bullets not converted:\n%s", text)
+	}
+	if !strings.Contains(text, "| next_action | continue slice S-2 |") {
+		t.Fatalf("next step not converted to canonical spelling:\n%s", text)
+	}
+	if strings.Contains(text, "- Next step:") {
+		t.Fatalf("legacy next step bullet survived:\n%s", text)
+	}
+	if !strings.Contains(text, "| schema | 3 |") {
+		t.Fatalf("schema row missing:\n%s", text)
+	}
+	if !strings.Contains(text, "# Status\n\nMinting middleware landed.") {
+		t.Fatalf("prose not preserved:\n%s", text)
+	}
+	// Required artifacts for build exist as empty stubs.
+	for _, name := range []string{"spec.md", "brief.md", "eng-review.md", "test-plan.md"} {
+		info, err := os.Stat(filepath.Join(workspace, name))
+		if err != nil {
+			t.Fatalf("stub %s: %v", name, err)
+		}
+		if info.Size() != 0 {
+			t.Fatalf("stub %s synthesized content", name)
+		}
+	}
+	// Idempotent: a second run is a no-op.
+	stdout.Reset()
+	if code := Migrate(root, []string{"feature"}, &stdout, &stderr); code != 0 {
+		t.Fatalf("second run code=%d stderr=%q", code, stderr.String())
+	}
+	if !strings.Contains(stdout.String(), "nothing to do") {
+		t.Fatalf("second run should be a no-op, got %q", stdout.String())
+	}
+}
+
+func TestMigrateUnknownPhaseAsksAndWritesNothing(t *testing.T) {
+	root, workspace := seedPreV5Workspace(t, "research")
+	var stdout, stderr strings.Builder
+	if code := Migrate(root, []string{"feature"}, &stdout, &stderr); code != 3 {
+		t.Fatalf("code=%d want 3", code)
+	}
+	if !strings.Contains(stderr.String(), "question phase:") || !strings.Contains(stderr.String(), "nothing written") {
+		t.Fatalf("stderr=%q", stderr.String())
+	}
+	body, _ := os.ReadFile(filepath.Join(workspace, "state.md"))
+	if !strings.HasPrefix(string(body), "- Phase: research\n") {
+		t.Fatalf("state.md changed on refusal: %q", body)
+	}
+
+	// Answering the question on rerun proceeds.
+	if code := Migrate(root, []string{"feature", "--answer", "phase=build"}, &stdout, &stderr); code != 0 {
+		t.Fatalf("answer rerun code=%d stderr=%q", code, stderr.String())
+	}
+	body, _ = os.ReadFile(filepath.Join(workspace, "state.md"))
+	if !strings.Contains(string(body), "| phase | build |") || !strings.Contains(string(body), "| schema | 3 |") {
+		t.Fatalf("answer rerun did not migrate:\n%s", body)
+	}
+}
+
+// A done workspace migrates like any other: it is fully artifacted (zero
+// stubs), and normalizing it unblocks `state close`, which refuses pre-v5
+// workspaces. A special no-op would strand done workspaces between migrate
+// and close.
+func TestMigrateDoneWorkspaceNormalizesWithoutStubs(t *testing.T) {
+	root, workspace := seedPreV5Workspace(t, "done")
+	var stdout, stderr strings.Builder
+	if code := Migrate(root, []string{"feature"}, &stdout, &stderr); code != 0 {
+		t.Fatalf("code=%d stderr=%q", code, stderr.String())
+	}
+	body, _ := os.ReadFile(filepath.Join(workspace, "state.md"))
+	if !strings.Contains(string(body), "| schema | 3 |") {
+		t.Fatalf("done workspace not normalized:\n%s", body)
+	}
+	if !strings.Contains(stdout.String(), "normalized to schema 3") {
+		t.Fatalf("stdout=%q", stdout.String())
+	}
+}
+
+func TestMigrateCurrentAndNewerSchemaAreRefused(t *testing.T) {
+	root, workspace := seedPreV5Workspace(t, "build")
+	if err := os.WriteFile(filepath.Join(workspace, "state.md"), []byte("| phase | build |\n| schema | 3 |\n"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	var stdout, stderr strings.Builder
+	if code := Migrate(root, []string{"feature"}, &stdout, &stderr); code != 0 || !strings.Contains(stdout.String(), "nothing to do") {
+		t.Fatalf("current schema: code=%d stdout=%q", code, stdout.String())
+	}
+
+	if err := os.WriteFile(filepath.Join(workspace, "state.md"), []byte("| phase | build |\n| schema | 9 |\n"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	if code := Migrate(root, []string{"feature"}, &stdout, &stderr); code != 3 || !strings.Contains(stderr.String(), "upgrade devrites") {
+		t.Fatalf("newer schema: code=%d stderr=%q", code, stderr.String())
+	}
+}

package/engine/internal/lib/resolve.go

@@ -35,6 +35,9 @@ func Resolve(root string, args []string, stdout, stderr io.Writer) int {
 	if !isFile(sfile) {
 		return fail(stderr, "state.md missing at "+sfile, 2)
 	}
+	if err := state.RequireWorkspaceSchema(root, slug); err != nil {
+		return fail(stderr, err.Error(), 3)
+	}
 
 	var mode, qid, payload string
 	switch first := argAt(args, 0); first {

package/engine/internal/lib/resolve_remediation_test.go

@@ -55,6 +55,6 @@ func resolveWorkspace(t *testing.T, questions string) string {
 	root := t.TempDir()
 	testutil.WriteFile(t, filepath.Join(root, "ACTIVE"), "feat\n")
 	testutil.WriteFile(t, filepath.Join(root, "work", "feat", "questions.md"), questions)
-	testutil.WriteFile(t, filepath.Join(root, "work", "feat", "state.md"), "- Status: running\n- Next step: continue\n")
+	testutil.WriteFile(t, filepath.Join(root, "work", "feat", "state.md"), "- Status: running\n- Next step: continue\n- Schema: 3\n")
 	return root
 }

package/engine/internal/lib/secretscan_test.go

@@ -348,6 +348,7 @@ func TestSecretScanBlocksHighSeverityTouchedFile(t *testing.T) {
 	root := filepath.Join(project, ".devrites")
 	testutil.WriteFile(t, filepath.Join(root, "ACTIVE"), "leak\n")
 	testutil.WriteFile(t, filepath.Join(root, "work", "leak", "touched-files.md"), candidateTestManifest(candidateTestRow{state: "present", path: "secrets.txt", slice: "S-1", reason: "Credential check."}))
+	testutil.WriteFile(t, filepath.Join(root, "work", "leak", "state.md"), "| schema | 3 |\n")
 	secret := "ghp_" + strings.Repeat("f", 32)
 	testutil.WriteFile(t, filepath.Join(project, "secrets.txt"), secret+"\n")
 	var out, err bytes.Buffer

package/engine/internal/lib/taskgraph_test.go

@@ -259,7 +259,7 @@ func TestObserveSummaryExposesTaskGraphProblems(t *testing.T) {
 	if err := os.MkdirAll(workspace, 0o755); err != nil {
 		t.Fatal(err)
 	}
-	if err := os.WriteFile(filepath.Join(workspace, "state.md"), []byte("| phase | define |\n"), 0o644); err != nil {
+	if err := os.WriteFile(filepath.Join(workspace, "state.md"), []byte("| phase | define |\n| schema | 3 |\n"), 0o644); err != nil {
 		t.Fatal(err)
 	}
 	body := `# Tasks
@@ -308,7 +308,7 @@ func TestObserveSummaryExposesProblemsWhenNoSliceHeaders(t *testing.T) {
 	if err := os.MkdirAll(workspace, 0o755); err != nil {
 		t.Fatal(err)
 	}
-	if err := os.WriteFile(filepath.Join(workspace, "state.md"), []byte("| phase | define |\n"), 0o644); err != nil {
+	if err := os.WriteFile(filepath.Join(workspace, "state.md"), []byte("| phase | define |\n| schema | 3 |\n"), 0o644); err != nil {
 		t.Fatal(err)
 	}
 	if err := os.WriteFile(filepath.Join(workspace, "tasks.md"), []byte("# Tasks\n\n- do the work\n"), 0o644); err != nil {

package/engine/internal/parallel/ops.go

@@ -9,6 +9,16 @@ import (
 	"strings"
 )
 
+// Test seams: indirection over the real primitives so discriminating tests
+// can inject transient failures without touching the filesystem.
+var (
+	writeLease     = WriteLease
+	removeWorktree = worktreeRemove
+	warnf          = func(format string, args ...any) {
+		fmt.Fprintf(os.Stderr, "warning: parallel: "+format+"\n", args...)
+	}
+)
+
 // CreateOpts configures parallel worktree creation.
 type CreateOpts struct {
 	Root    string
@@ -54,13 +64,16 @@ func Create(opts CreateOpts) (*Lease, error) {
 	createdBranches := make([]string, 0, len(opts.Slices))
 	cleanupPartial := func() {
 		for _, p := range createdPaths {
-			_ = worktreeRemove(opts.Root, p)
+			if err := removeWorktree(opts.Root, p); err != nil {
+				warnf("worktree cleanup %s: %v", p, err)
+			}
 		}
 		for _, b := range createdBranches {
-			_ = deleteBranch(opts.Root, b)
+			if err := deleteBranch(opts.Root, b); err != nil {
+				warnf("branch cleanup %s: %v", b, err)
+			}
 		}
 	}
-
 	slices := make([]LeaseSlice, 0, len(opts.Slices))
 	for _, sp := range opts.Slices {
 		if err := validateSliceID(sp.ID); err != nil {
@@ -252,12 +265,28 @@ func Integrate(opts IntegrateOpts) (tip string, lease *Lease, err error) {
 	}
 
 	fail := func(reason error) (string, *Lease, error) {
-		_ = worktreeRemove(opts.Root, stageWT)
-		_ = deleteBranch(opts.Root, ibranch)
-		_, _ = git(opts.Root, "worktree", "prune")
+		if err := removeWorktree(opts.Root, stageWT); err != nil {
+			warnf("staging worktree cleanup: %v", err)
+		}
+		if err := deleteBranch(opts.Root, ibranch); err != nil {
+			warnf("integrate branch cleanup: %v", err)
+		}
+		if _, err := git(opts.Root, "worktree", "prune"); err != nil {
+			warnf("worktree prune: %v", err)
+		}
 		lease.Status = StatusIntegrateFailed
-		_ = WriteLease(leasePath, lease)
-		_ = ensureControlAtBase(opts.Root, base, true)
+		if err := writeLease(leasePath, lease); err != nil {
+			// The integrate-failed transition must survive a transient write
+			// failure: a stale running lease still blocks create and stays
+			// retryable, but the honest state must be recorded when possible.
+			if retryErr := writeLease(leasePath, lease); retryErr != nil {
+				warnf("lease %s still status=%s (write failed twice: %v)",
+					leasePath, StatusRunning, retryErr)
+			}
+		}
+		if err := ensureControlAtBase(opts.Root, base, true); err != nil {
+			warnf("control reset to base: %v", err)
+		}
 		return "", lease, reason
 	}
 
@@ -313,8 +342,18 @@ func Integrate(opts IntegrateOpts) (tip string, lease *Lease, err error) {
 	if err != nil {
 		return fail(err)
 	}
-	_ = worktreeRemove(opts.Root, stageWT)
-	_, _ = git(opts.Root, "worktree", "prune")
+	if err := removeWorktree(opts.Root, stageWT); err != nil {
+		if _, statErr := os.Stat(stageWT); statErr == nil {
+			// The directory is genuinely stuck; failing now keeps the lease in
+			// integrate-failed and avoids compounding into un-cleanable branch
+			// state. Retrying integrate re-attempts the same removals.
+			return fail(fmt.Errorf("staging worktree could not be removed; retry integrate after cleanup: %w", err))
+		}
+		warnf("staging worktree cleanup: %v", err)
+	}
+	if _, err := git(opts.Root, "worktree", "prune"); err != nil {
+		warnf("worktree prune: %v", err)
+	}
 
 	if opts.ApplyToControl {
 		if err := mergeFFOnly(opts.Root, tip); err != nil {
@@ -361,17 +400,29 @@ func Cleanup(repoRoot, slug string, force bool) error {
 	}
 	for _, sl := range lease.Slices {
 		if sl.WorktreePath != "" {
-			_ = worktreeRemove(repoRoot, sl.WorktreePath)
-			_ = os.RemoveAll(sl.WorktreePath)
+			if err := removeWorktree(repoRoot, sl.WorktreePath); err != nil {
+				warnf("worktree cleanup %s: %v", sl.WorktreePath, err)
+			}
+			if err := os.RemoveAll(sl.WorktreePath); err != nil {
+				warnf("worktree dir cleanup %s: %v", sl.WorktreePath, err)
+			}
 		}
 		if sl.Branch != "" {
-			_ = deleteBranch(repoRoot, sl.Branch)
+			if err := deleteBranch(repoRoot, sl.Branch); err != nil {
+				warnf("branch cleanup %s: %v", sl.Branch, err)
+			}
 		}
 	}
 	ibranch := IntegrateBranchName(slug, lease.BatchID)
-	_ = deleteBranch(repoRoot, ibranch)
-	_ = os.RemoveAll(filepath.Join(ScratchRoot(repoRoot), lease.BatchID))
-	_, _ = git(repoRoot, "worktree", "prune")
+	if err := deleteBranch(repoRoot, ibranch); err != nil {
+		warnf("integrate branch cleanup %s: %v", ibranch, err)
+	}
+	if err := os.RemoveAll(filepath.Join(ScratchRoot(repoRoot), lease.BatchID)); err != nil {
+		warnf("scratch cleanup: %v", err)
+	}
+	if _, err := git(repoRoot, "worktree", "prune"); err != nil {
+		warnf("worktree prune: %v", err)
+	}
 	return ClearLease(leasePath)
 }