devrites 5.2.4 → 5.3.0

package/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 All notable changes to DevRites are documented here. The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/) and DevRites adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html). Releases are generated automatically by [semantic-release](https://semantic-release.gitbook.io/) from Conventional Commits on `main`.
 
+## [5.3.0](https://github.com/ViktorsBaikers/DevRites/compare/v5.2.4...v5.3.0) (2026-09-13)
+
+### Added
+
+* **rite:** preserve parallel batch work, harden lease lifecycle ([#66](https://github.com/ViktorsBaikers/DevRites/issues/66)) ([f8d3e2e](https://github.com/ViktorsBaikers/DevRites/commit/f8d3e2e9870b2adaa11da0384f2b0ff23ee8785b))
+
 ## [5.2.4](https://github.com/ViktorsBaikers/DevRites/compare/v5.2.3...v5.2.4) (2026-09-12)
 
 ### Fixed

package/README.md

@@ -33,7 +33,7 @@ project-conventional push, tag, or PR action, and archive the workspace.
 Unattended runs may create local WIP checkpoint commits along the way, but they
 remain local unless Ship's disclosed plan includes an approved remote action.
 
-**Status:** [`v5.2.4`](https://github.com/ViktorsBaikers/DevRites/releases/tag/v5.2.4): see [`CHANGELOG.md`](CHANGELOG.md) for release notes.
+**Status:** [`v5.3.0`](https://github.com/ViktorsBaikers/DevRites/releases/tag/v5.3.0): see [`CHANGELOG.md`](CHANGELOG.md) for release notes.
 
 This is the latest published release; `main` may contain unreleased work.
 

package/engine/internal/install/uninstall.go

@@ -115,5 +115,8 @@ func (r *runner) uninstall() error {
 	if exists(filepath.Join(r.target, ".devrites", "ACTIVE")) {
 		fmt.Fprintln(r.opts.Stdout, "  kept .devrites/ACTIVE (active-feature cursor)")
 	}
+	if exists(filepath.Join(r.target, ".scratch", "parallel-wt")) {
+		fmt.Fprintln(r.opts.Stdout, "  kept .scratch/parallel-wt/ (live parallel worktrees — inspect before removing)")
+	}
 	return nil
 }

package/engine/internal/lib/resolve.go

@@ -140,6 +140,12 @@ func fail(stderr io.Writer, msg string, code int) int {
 	return code
 }
 
+// oneLine flattens an operator-supplied answer to a single line so it cannot
+// corrupt the questions.md field structure (answer: is a one-line field).
+func oneLine(s string) string {
+	return strings.Join(strings.Fields(s), " ")
+}
+
 func isDir(path string) bool {
 	info, err := os.Stat(path)
 	return err == nil && info.IsDir()
@@ -195,6 +201,7 @@ func resolveQuestion(qfile, qid, status, answer string, stderr io.Writer) int {
 		return fail(stderr, "questions.md missing at "+qfile, 2)
 	}
 	ts := nowUTC()
+	answer = oneLine(answer)
 	target := regexp.MustCompile(`^## ` + regexp.QuoteMeta(qid) + `([[:space:]]|$)`)
 
 	updated, found, notOpen := rewriteQuestionFields(splitLinesNoTrailing(data), target, status, answer, ts)

package/engine/internal/parallel/cli.go

@@ -113,8 +113,8 @@ func parallelUsage() string {
 Subcommands:
   create          --root --slug --batch --base --json
   record-green    --root --slug --slice --commit
-  abort           --root --slug [--force]
-  integrate       --root --slug [--apply-to-control] [--force]
+  abort           --root --slug
+  integrate       --root --slug [--apply-to-control]
   cleanup         --root --slug [--force]
   status          --root --slug
   lease-write     --root --slug --json
@@ -203,7 +203,11 @@ func parseFlags(args []string, stderr io.Writer) (flagSet, []string, int) {
 		case "--force":
 			f.Force = true
 		default:
-			return f, args[i:], ExitOK
+			// No parallel subcommand takes positional args; anything
+			// unrecognized (typo'd flag, stray word) is a usage error, not
+			// something to silently drop.
+			fmt.Fprintf(stderr, "parallel: unknown argument %q\n", a)
+			return f, nil, ExitUsage
 		}
 		i++
 	}
@@ -237,6 +241,9 @@ func cmdCreate(args []string, stdin io.Reader, stdout, stderr io.Writer) int {
 	if code := requireRootSlug(f, stderr); code != ExitOK {
 		return code
 	}
+	if code := rejectUnsupportedFlags(f, stderr, false, false); code != ExitOK {
+		return code
+	}
 	if f.Batch == "" || f.Base == "" || f.JSON == "" {
 		fmt.Fprintln(stderr, "usage: parallel create --root --slug --batch --base --json")
 		return ExitUsage
@@ -267,6 +274,21 @@ func cmdCreate(args []string, stdin io.Reader, stdout, stderr io.Writer) int {
 	return ExitOK
 }
 
+// rejectUnsupportedFlags reports flags a subcommand parses but must not
+// silently ignore: --force only exists for cleanup, --apply-to-control only
+// for integrate.
+func rejectUnsupportedFlags(f flagSet, stderr io.Writer, force, applyToControl bool) int {
+	if f.Force && !force {
+		fmt.Fprintln(stderr, "parallel: --force is only supported by cleanup")
+		return ExitUsage
+	}
+	if f.ApplyToControl && !applyToControl {
+		fmt.Fprintln(stderr, "parallel: --apply-to-control is only supported by integrate")
+		return ExitUsage
+	}
+	return ExitOK
+}
+
 func cmdRecordGreen(args []string, stdout, stderr io.Writer) int {
 	f, _, code := parseFlags(args, stderr)
 	if code != ExitOK {
@@ -275,6 +297,9 @@ func cmdRecordGreen(args []string, stdout, stderr io.Writer) int {
 	if code := requireRootSlug(f, stderr); code != ExitOK {
 		return code
 	}
+	if code := rejectUnsupportedFlags(f, stderr, false, false); code != ExitOK {
+		return code
+	}
 	if f.Slice == "" || f.Commit == "" {
 		fmt.Fprintln(stderr, "usage: parallel record-green --root --slug --slice --commit")
 		return ExitUsage
@@ -296,7 +321,10 @@ func cmdAbort(args []string, stdout, stderr io.Writer) int {
 	if code := requireRootSlug(f, stderr); code != ExitOK {
 		return code
 	}
-	lease, err := Abort(f.Root, f.Slug, f.Force)
+	if code := rejectUnsupportedFlags(f, stderr, false, false); code != ExitOK {
+		return code
+	}
+	lease, err := Abort(f.Root, f.Slug)
 	if err != nil {
 		fmt.Fprintf(stderr, "parallel abort: %v\n", err)
 		return ExitBlocked
@@ -313,11 +341,13 @@ func cmdIntegrate(args []string, stdout, stderr io.Writer) int {
 	if code := requireRootSlug(f, stderr); code != ExitOK {
 		return code
 	}
+	if code := rejectUnsupportedFlags(f, stderr, false, true); code != ExitOK {
+		return code
+	}
 	tip, lease, err := Integrate(IntegrateOpts{
 		Root:           f.Root,
 		Slug:           f.Slug,
 		ApplyToControl: f.ApplyToControl,
-		Force:          f.Force,
 	})
 	if err != nil {
 		fmt.Fprintf(stderr, "parallel integrate: %v\n", err)
@@ -335,10 +365,21 @@ func cmdCleanup(args []string, stdout, stderr io.Writer) int {
 	if code := requireRootSlug(f, stderr); code != ExitOK {
 		return code
 	}
-	if err := Cleanup(f.Root, f.Slug, f.Force); err != nil {
+	if code := rejectUnsupportedFlags(f, stderr, true, false); code != ExitOK {
+		return code
+	}
+	salvaged, err := Cleanup(f.Root, f.Slug, f.Force)
+	if err != nil {
 		fmt.Fprintf(stderr, "parallel cleanup: %v\n", err)
 		return ExitBlocked
 	}
+	for _, s := range salvaged {
+		fmt.Fprintf(stdout, "salvaged: slice=%s branch=%s commit=%s", s.SliceID, s.Branch, s.Commit)
+		if s.Worktree != "" {
+			fmt.Fprintf(stdout, " worktree=%s(kept)", s.Worktree)
+		}
+		fmt.Fprintln(stdout)
+	}
 	fmt.Fprintln(stdout, "cleanup: done")
 	return ExitOK
 }
@@ -351,6 +392,9 @@ func cmdStatus(args []string, stdout, stderr io.Writer) int {
 	if code := requireRootSlug(f, stderr); code != ExitOK {
 		return code
 	}
+	if code := rejectUnsupportedFlags(f, stderr, false, false); code != ExitOK {
+		return code
+	}
 	text, err := StatusReport(f.Root, f.Slug)
 	if err != nil {
 		fmt.Fprintf(stderr, "parallel status: %v\n", err)
@@ -385,12 +429,16 @@ func cmdLeaseWrite(args []string, stdin io.Reader, stdout, stderr io.Writer) int
 	if lease.CreatedAt == "" {
 		lease.CreatedAt = NowUTC()
 	}
+	if code := rejectUnsupportedFlags(f, stderr, false, false); code != ExitOK {
+		return code
+	}
 	path, err := LeasePath(f.Root, f.Slug)
 	if err != nil {
 		fmt.Fprintf(stderr, "parallel lease-write: %v\n", err)
 		return ExitUsage
 	}
-	if err := WriteLease(path, &lease); err != nil {
+	err = withLeaseLock(f.Root, f.Slug, func() error { return WriteLease(path, &lease) })
+	if err != nil {
 		fmt.Fprintf(stderr, "parallel lease-write: %v\n", err)
 		return ExitBlocked
 	}
@@ -406,6 +454,9 @@ func cmdLeaseRead(args []string, stdout, stderr io.Writer) int {
 	if code := requireRootSlug(f, stderr); code != ExitOK {
 		return code
 	}
+	if code := rejectUnsupportedFlags(f, stderr, false, false); code != ExitOK {
+		return code
+	}
 	path, err := LeasePath(f.Root, f.Slug)
 	if err != nil {
 		fmt.Fprintf(stderr, "parallel lease-read: %v\n", err)
@@ -454,12 +505,15 @@ func cmdLeaseClear(args []string, stdout, stderr io.Writer) int {
 	if code := requireRootSlug(f, stderr); code != ExitOK {
 		return code
 	}
+	if code := rejectUnsupportedFlags(f, stderr, false, false); code != ExitOK {
+		return code
+	}
 	path, err := LeasePath(f.Root, f.Slug)
 	if err != nil {
 		fmt.Fprintf(stderr, "parallel lease-clear: %v\n", err)
 		return ExitUsage
 	}
-	if err := ClearLease(path); err != nil {
+	if err := withLeaseLock(f.Root, f.Slug, func() error { return ClearLease(path) }); err != nil {
 		fmt.Fprintf(stderr, "parallel lease-clear: %v\n", err)
 		return ExitBlocked
 	}

package/engine/internal/parallel/git.go

@@ -7,6 +7,7 @@ import (
 	"fmt"
 	"os"
 	"os/exec"
+	"path/filepath"
 	"strings"
 	"time"
 
@@ -120,19 +121,57 @@ func headSHA(repo string) (string, error) {
 	return revParse(repo, "HEAD")
 }
 
-func resetHard(repo, sha string) error {
-	_, err := git(repo, "reset", "--hard", sha)
-	return err
+// ensureScratchExcluded lists the parallel worktree root in .git/info/exclude
+// so control `git status`/`git add -A` never sees nested worker worktrees.
+// Best-effort: an unwritable exclude file must not fail create.
+func ensureScratchExcluded(repo string) {
+	gitDir, err := git(repo, "rev-parse", "--git-common-dir")
+	if err != nil {
+		return
+	}
+	if !filepath.IsAbs(gitDir) {
+		gitDir = filepath.Join(repo, gitDir)
+	}
+	excludePath := filepath.Join(gitDir, "info", "exclude")
+	const line = ".scratch/parallel-wt/"
+	// #nosec G304 -- exclude file inside the repo's own resolved git dir
+	if data, err := os.ReadFile(excludePath); err == nil && strings.Contains(string(data), line) {
+		return
+	}
+	if err := os.MkdirAll(filepath.Dir(excludePath), 0o755); err != nil {
+		return
+	}
+	// #nosec G304 -- exclude file inside the repo's own resolved git dir
+	f, err := os.OpenFile(excludePath, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0o644)
+	if err != nil {
+		return
+	}
+	defer func() { _ = f.Close() }()
+	_, _ = fmt.Fprintln(f, line)
 }
 
-func porcelainDirty(repo string) (bool, error) {
-	out, err := git(repo, "status", "--porcelain", "--untracked-files=no")
+func porcelainDirtyPaths(repo string, paths []string) (bool, error) {
+	args := append([]string{"status", "--porcelain", "--untracked-files=all", "--"}, paths...)
+	out, err := git(repo, args...)
 	if err != nil {
 		return false, err
 	}
 	return out != "", nil
 }
 
+// stagePathsAndCommit commits every change under paths (modifications,
+// deletions, and untracked files) and returns the new HEAD sha.
+func stagePathsAndCommit(repo, msg string, paths []string) (string, error) {
+	addArgs := append([]string{"add", "-A", "--ignore-errors", "--"}, paths...)
+	if _, err := git(repo, addArgs...); err != nil {
+		return "", err
+	}
+	if _, err := git(repo, "commit", "-m", msg); err != nil {
+		return "", err
+	}
+	return headSHA(repo)
+}
+
 func branchExists(repo, branch string) (bool, error) {
 	_, err := git(repo, "show-ref", "--verify", "--quiet", "refs/heads/"+branch)
 	if err == nil {
@@ -172,8 +211,8 @@ func mergeFFOnly(repo, commit string) error {
 	return err
 }
 
-func cherryPickRange(repo, fromExclusive, toInclusive string) error {
-	_, err := git(repo, "cherry-pick", "-x", fromExclusive+".."+toInclusive)
+func cherryPickNoCommit(repo, fromExclusive, toInclusive string) error {
+	_, err := git(repo, "cherry-pick", "-n", fromExclusive+".."+toInclusive)
 	return err
 }
 

package/engine/internal/parallel/lease.go

@@ -73,6 +73,13 @@ func IntegrateBranchName(slug, batchID string) string {
 	return fmt.Sprintf("devrites/parallel/%s/%s/integrate", slug, batchID)
 }
 
+// ownedBranchName reports whether branch is inside this batch's namespace —
+// devrites/parallel/<slug>/<batch>/…. Cleanup deletes only owned branches;
+// a lease naming anything else (e.g. a forged "main") is left alone.
+func ownedBranchName(slug, batchID, branch string) bool {
+	return strings.HasPrefix(branch, fmt.Sprintf("devrites/parallel/%s/%s/", slug, batchID))
+}
+
 func WorkerWorktreePath(repoRoot, batchID, sliceID string) string {
 	return filepath.Join(ScratchRoot(repoRoot), batchID, sliceID)
 }