devrites 6.0.4 → 6.1.1

package/engine/internal/lib/resolve.go

@@ -6,10 +6,12 @@ import (
 	"os"
 	"path/filepath"
 	"regexp"
+	"slices"
 	"strings"
 	"time"
 
 	"github.com/devrites/devrites/internal/fsutil"
+	"github.com/devrites/devrites/internal/markdowntext"
 	"github.com/devrites/devrites/internal/state"
 	"github.com/devrites/devrites/internal/workflow"
 )
@@ -39,16 +41,17 @@ func Resolve(root string, args []string, stdout, stderr io.Writer) int {
 		return fail(stderr, err.Error(), 3)
 	}
 
-	human := argAt(args, 0) == "--human"
-	if human {
-		args = args[1:]
-	}
+	const usage = `Usage: devrites-engine state resolve [--human] <qid> "<answer>"  |  state resolve [--human] --drop <qid> ["<reason>"]  |  state resolve [--human] --batch <file>`
+	human := slices.Contains(args, "--human")
+	args = slices.DeleteFunc(slices.Clone(args), func(arg string) bool { return arg == "--human" })
 	var mode, qid, payload string
+	maxArgs := 2
 	switch first := argAt(args, 0); first {
 	case "--drop":
 		mode = "drop"
 		qid = argAt(args, 1)
 		payload = argAt(args, 2)
+		maxArgs = 3
 		if payload == "" {
 			payload = "dropped"
 		}
@@ -59,7 +62,7 @@ func Resolve(root string, args []string, stdout, stderr io.Writer) int {
 			return fail(stderr, "Batch file not found: "+payload, 5)
 		}
 	case "":
-		return fail(stderr, `Usage: devrites-engine state resolve [--human] <qid> "<answer>"  |  state resolve [--human] --drop <qid> ["<reason>"]  |  state resolve [--human] --batch <file>`, 5)
+		return fail(stderr, usage, 5)
 	default:
 		mode = "answer"
 		qid = first
@@ -68,6 +71,11 @@ func Resolve(root string, args []string, stdout, stderr io.Writer) int {
 			return fail(stderr, "Answer text required for "+qid, 5)
 		}
 	}
+	// An unknown flag or a stray argument must never be recorded as a qid or
+	// an answer.
+	if len(args) > maxArgs || strings.HasPrefix(qid, "-") || mode != "batch" && strings.HasPrefix(payload, "--") {
+		return fail(stderr, usage, 5)
+	}
 
 	code := 0
 	if err := state.WithFeatureLock(root, slug, func() error {
@@ -107,31 +115,49 @@ func resolveMutation(mode, qid, payload, qfile, sfile string, human bool, stdout
 		if err != nil {
 			return fail(stderr, "Batch file not found: "+payload, 5)
 		}
+		// Every line is parsed and applied in memory first, so a bad line
+		// leaves questions.md untouched instead of half-resolved.
+		type batchEntry struct{ qid, status, text string }
+		var entries []batchEntry
 		for _, line := range batchLines(data) {
+			line = strings.TrimSpace(line)
 			if line == "" || strings.HasPrefix(line, "#") {
 				continue
 			}
-			if strings.HasPrefix(line, "--drop") {
-				rest := strings.TrimPrefix(line, "--drop ")
-				bid, reason := splitColon(rest)
-				reason = strings.TrimPrefix(reason, " ")
-				if code := resolveQuestion(qfile, bid, "dropped", reason, human, stderr); code != 0 {
-					return code
-				}
-				if err := clearAwaiting(sfile, bid); err != nil {
-					return fail(stderr, err.Error(), 1)
-				}
-				fmt.Fprintf(stdout, "Dropped:  %s: %s\n", bid, reason)
+			status := "answered"
+			if rest, ok := strings.CutPrefix(line, "--drop "); ok {
+				status, line = "dropped", rest
+			}
+			bid, text, ok := strings.Cut(line, ":")
+			bid = strings.TrimSpace(bid)
+			if !ok || bid == "" || strings.HasPrefix(bid, "-") {
+				return fail(stderr, "Malformed batch line (want `<qid>: <answer>` or `--drop <qid>: <reason>`): "+line, 5)
+			}
+			entries = append(entries, batchEntry{bid, status, strings.TrimPrefix(text, " ")})
+		}
+		// #nosec G304 -- questions.md path inside the feature workspace
+		qdata, err := os.ReadFile(qfile)
+		if err != nil {
+			return fail(stderr, "questions.md missing at "+qfile, 2)
+		}
+		lines := splitLinesNoTrailing(qdata)
+		for _, entry := range entries {
+			var code int
+			if lines, code = applyResolution(lines, entry.qid, entry.status, entry.text, human, stderr); code != 0 {
+				return code
+			}
+		}
+		if err := fsutil.WriteFileAtomic(qfile, joinRecords(lines), 0o644); err != nil {
+			return fail(stderr, err.Error(), 1)
+		}
+		for _, entry := range entries {
+			if err := clearAwaiting(sfile, entry.qid); err != nil {
+				return fail(stderr, err.Error(), 1)
+			}
+			if entry.status == "dropped" {
+				fmt.Fprintf(stdout, "Dropped:  %s: %s\n", entry.qid, entry.text)
 			} else {
-				bid, ans := splitColon(line)
-				ans = strings.TrimPrefix(ans, " ")
-				if code := resolveQuestion(qfile, bid, "answered", ans, human, stderr); code != 0 {
-					return code
-				}
-				if err := clearAwaiting(sfile, bid); err != nil {
-					return fail(stderr, err.Error(), 1)
-				}
-				fmt.Fprintf(stdout, "Resolved: %s\n", bid)
+				fmt.Fprintf(stdout, "Resolved: %s\n", entry.qid)
 			}
 		}
 	}
@@ -171,16 +197,6 @@ func batchLines(data []byte) []string {
 	return lines
 }
 
-// splitColon splits s at the first ':', returning the parts before and after it
-// (both the whole string when there is no ':').
-func splitColon(s string) (before, after string) {
-	before, after, ok := strings.Cut(s, ":")
-	if !ok {
-		return s, s
-	}
-	return before, after
-}
-
 // clockNow is the resolve command's single wall-clock read. DEVRITES_NOW accepts
 // an RFC-3339 timestamp or YYYY-MM-DD date so tests can keep date-derived
 // question IDs stable. See ADR-0006.
@@ -210,16 +226,9 @@ func resolveQuestion(qfile, qid, status, answer string, human bool, stderr io.Wr
 	if err != nil {
 		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, human)
-	if !found {
-		return fail(stderr, "qid not found: "+qid, 3)
-	}
-	if notOpen {
-		return fail(stderr, "qid not open (already answered/dropped): "+qid, 4)
+	updated, code := applyResolution(splitLinesNoTrailing(data), qid, status, answer, human, stderr)
+	if code != 0 {
+		return code
 	}
 	if err := fsutil.WriteFileAtomic(qfile, joinRecords(updated), 0o644); err != nil {
 		return fail(stderr, err.Error(), 1)
@@ -228,10 +237,35 @@ func resolveQuestion(qfile, qid, status, answer string, human bool, stderr io.Wr
 	return 0
 }
 
+// applyResolution rewrites the <qid> block in the questions.md lines in memory.
+// Returns 0, or 3 (qid not found) / 4 (qid not open), writing the message on
+// failure.
+func applyResolution(lines []string, qid, status, answer string, human bool, stderr io.Writer) ([]string, int) {
+	// Locate blocks on the fence-masked text, as the readiness gate does, so a
+	// fenced example is never rewritten and never shadows the real question.
+	var visible []string
+	if len(lines) > 0 {
+		masked, err := markdowntext.Structural([]byte(strings.Join(lines, "\n")))
+		if err != nil {
+			return nil, fail(stderr, "questions.md is not readable Markdown: "+err.Error(), 1)
+		}
+		visible = strings.Split(string(masked), "\n")
+	}
+	target := regexp.MustCompile(`^## ` + regexp.QuoteMeta(qid) + `([[:space:]]|$)`)
+	updated, found, notOpen := rewriteQuestionFields(lines, visible, target, status, oneLine(answer), nowUTC(), human)
+	if !found {
+		return nil, fail(stderr, "qid not found: "+qid, 3)
+	}
+	if notOpen {
+		return nil, fail(stderr, "qid not open (already answered/dropped): "+qid, 4)
+	}
+	return updated, 0
+}
+
 var (
 	qHeaderRe    = regexp.MustCompile(`(?i)^## q-`)
-	statusLineRe = regexp.MustCompile(`^status:`)
-	statusStrip  = regexp.MustCompile(`^status:[[:space:]]*`)
+	statusLineRe = regexp.MustCompile(`(?i)^status:`)
+	statusStrip  = regexp.MustCompile(`(?i)^status:[[:space:]]*`)
 	answeredAtRe = regexp.MustCompile(`^answered_at:`)
 	answerRe     = regexp.MustCompile(`^answer:`)
 	answeredByRe = regexp.MustCompile(`(?i)^[[:space:]]*answered_by:`)
@@ -241,8 +275,9 @@ var (
 // block, sets status and rewrites any answered_at/answer lines already present. It
 // reports whether the block was found and whether it was already not open (an
 // attempt to re-answer). A target block with no status line at all gets a full set
-// of closing fields appended.
-func rewriteQuestionFields(lines []string, target *regexp.Regexp, status, answer, ts string, human bool) (out []string, found, notOpen bool) {
+// of closing fields appended. Structure is matched on visible (lines with
+// fenced blocks masked, same length); unmatched lines are copied from lines.
+func rewriteQuestionFields(lines, visible []string, target *regexp.Regexp, status, answer, ts string, human bool) (out []string, found, notOpen bool) {
 	inQ := false
 	statusSeen, answeredAtSeen, answerSeen, answeredBySeen := false, false, false, false
 	closeBlock := func() {
@@ -262,7 +297,8 @@ func rewriteQuestionFields(lines []string, target *regexp.Regexp, status, answer
 			out = append(out, "answered_by: human")
 		}
 	}
-	for _, line := range lines {
+	for i, original := range lines {
+		line := visible[i]
 		switch {
 		case qHeaderRe.MatchString(line):
 			closeBlock()
@@ -271,11 +307,18 @@ func rewriteQuestionFields(lines []string, target *regexp.Regexp, status, answer
 			if inQ {
 				found = true
 			}
-			out = append(out, line)
+			out = append(out, original)
+		case inQ && hdrSpaceRe.MatchString(line):
+			// Any level-two heading ends the question block, as the gate reads it.
+			closeBlock()
+			inQ = false
+			out = append(out, original)
 		case inQ && statusLineRe.MatchString(line):
 			statusSeen = true
 			cur := statusStrip.ReplaceAllString(line, "")
-			if cur != "open" {
+			// Trim and fold case the way the readiness gate does, so a
+			// question the gate counts as open is always resolvable.
+			if !strings.EqualFold(strings.TrimSpace(cur), "open") {
 				out = append(out, "status: "+cur)
 				inQ = false
 				notOpen = true
@@ -294,7 +337,7 @@ func rewriteQuestionFields(lines []string, target *regexp.Regexp, status, answer
 				out = append(out, "answered_by: human")
 			}
 		default:
-			out = append(out, line)
+			out = append(out, original)
 		}
 	}
 	closeBlock()

package/engine/internal/lib/secretscan.go

@@ -147,7 +147,7 @@ func SecretScan(root string, args []string, stdin io.Reader, stdout, stderr io.W
 		}
 	}
 	if !staged && slug == "" && !readStdin {
-		changed, err := gitDiffNames(project)
+		changed, err := gitChangedAndUntrackedNames(project)
 		if err != nil {
 			fmt.Fprintln(stderr, "secret-scan: cannot inspect changed paths")
 			return 2
@@ -191,6 +191,29 @@ func SecretScan(root string, args []string, stdin io.Reader, stdout, stderr io.W
 	return writeSecretScanResult(findings, stdout, stderr)
 }
 
+// gitChangedAndUntrackedNames lists every path that differs from HEAD (staged
+// or not) plus untracked, non-ignored files. On an unborn branch every tracked
+// path is staged, so the index diff stands in for the HEAD diff. Both lists
+// are relative to project, which scanWorktreePaths joins them onto.
+func gitChangedAndUntrackedNames(project string) ([]string, error) {
+	changed, err := gitDiffNames(project, "--relative", "HEAD", "--")
+	if err != nil {
+		if changed, err = gitDiffNames(project, "--relative", "--cached"); err != nil {
+			return nil, err
+		}
+	}
+	out, err := runGitCommand(project, nil, "ls-files", "--others", "--exclude-standard", "-z")
+	if err != nil {
+		return nil, err
+	}
+	for _, path := range strings.Split(string(out), "\x00") {
+		if path != "" {
+			changed = append(changed, path)
+		}
+	}
+	return changed, nil
+}
+
 func projectDir(root string) string {
 	if filepath.Base(root) == ".devrites" {
 		return filepath.Dir(root)

package/engine/internal/lib/taskgraph.go

@@ -1,6 +1,11 @@
 package lib
 
-import "github.com/devrites/devrites/internal/state"
+import (
+	"fmt"
+	"strings"
+
+	"github.com/devrites/devrites/internal/state"
+)
 
 // TaskSlice is one SLICE-### block parsed from tasks.md.
 type TaskSlice = state.TaskSlice
@@ -21,3 +26,28 @@ func CheckTaskGraph(root, slug string) (TaskGraphResult, error) {
 	}
 	return ParseTaskGraph(raw), nil
 }
+
+// edgeAdvisories names each dependency edge that does not say what crosses it:
+// no `(via <interface>)`, or a via the dependency's Consumes / Produces lacks.
+// An edge the dependent reads nothing across only serializes work.
+func edgeAdvisories(graph TaskGraphResult) []string {
+	produces := make(map[string]string, len(graph.Slices))
+	for _, s := range graph.Slices {
+		produces[s.ID] = s.ConsumesProduces
+	}
+	var lines []string
+	for _, s := range graph.Slices {
+		for _, dep := range s.Dependencies {
+			via := s.Via[dep]
+			switch {
+			case via == "":
+				lines = append(lines, fmt.Sprintf(`ADVISORY edge: %s -> %s names no crossing interface (add "(via <interface>)" or drop the edge)`, s.ID, dep))
+			case produces[dep] == "":
+				lines = append(lines, fmt.Sprintf("ADVISORY edge: %s -> %s via %q but %s declares no Consumes / Produces", s.ID, dep, via, dep))
+			case !strings.Contains(strings.ToLower(produces[dep]), strings.ToLower(via)):
+				lines = append(lines, fmt.Sprintf("ADVISORY edge: %s -> %s via %q is not in %s Consumes / Produces", s.ID, dep, via, dep))
+			}
+		}
+	}
+	return lines
+}

package/engine/internal/lib/util.go

@@ -94,13 +94,15 @@ func runGitCommandIO(dir string, env []string, input []byte, stdout io.Writer, a
 		"PAGER=cat",
 		"LC_ALL=C",
 	)
-	var output cappedGitOutput
+	// stderr gets its own buffer: git warnings (e.g. core.autocrlf) must never
+	// be parsed as output, only reported when the command fails.
+	var output, errOutput cappedGitOutput
 	if stdout == nil {
 		cmd.Stdout = &output
 	} else {
 		cmd.Stdout = stdout
 	}
-	cmd.Stderr = &output
+	cmd.Stderr = &errOutput
 	err := cmd.Run()
 	if err == nil {
 		if output.truncated {
@@ -116,8 +118,8 @@ func runGitCommandIO(dir string, env []string, input []byte, stdout io.Writer, a
 	if ctx.Err() != nil {
 		err = ctx.Err()
 	}
-	detail := output.String()
-	if output.truncated {
+	detail := errOutput.String()
+	if errOutput.truncated {
 		detail += "\n[git output truncated]"
 	}
 	return nil, &gitCommandError{
@@ -130,13 +132,21 @@ func runGitCommandIO(dir string, env []string, input []byte, stdout io.Writer, a
 
 // gitDiffNames lists the paths that differ, relative to gitRoot. With one ref it
 // diffs the working tree against that ref; with two it diffs the two tree objects.
+// Renames are split into their deletion and addition so both names surface, and
+// -z keeps non-ASCII paths unquoted.
 func gitDiffNames(gitRoot string, refs ...string) ([]string, error) {
-	args := append([]string{"diff", "--name-only"}, refs...)
+	args := append([]string{"diff", "--name-only", "--no-renames", "-z"}, refs...)
 	out, err := runGitCommand(gitRoot, nil, args...)
 	if err != nil {
 		return nil, err
 	}
-	return splitLinesNoTrailing(out), nil
+	var paths []string
+	for _, path := range strings.Split(string(out), "\x00") {
+		if path != "" {
+			paths = append(paths, path)
+		}
+	}
+	return paths, nil
 }
 
 // argAt returns args[i] or "": the Go analogue of bash's ${N:-} positional reads.
@@ -159,8 +169,9 @@ func activeSlug(root string) string {
 	return slug
 }
 
+// splitLinesNoTrailing splits data into lines, treating CRLF as LF.
 func splitLinesNoTrailing(data []byte) []string {
-	value := strings.TrimSuffix(string(data), "\n")
+	value := strings.TrimSuffix(strings.ReplaceAll(string(data), "\r\n", "\n"), "\n")
 	if value == "" {
 		return nil
 	}

package/engine/internal/lib/windows.go

@@ -50,12 +50,14 @@ Exit 0 clean or fully waived, 3 unwaived markers or blocked.`
 // deferralTokenRe catches uppercase comment markers: TODO, FIXME, XXX, HACK.
 var deferralTokenRe = regexp.MustCompile(`(?:^|[^A-Za-z0-9_])(TODO|FIXME|XXX|HACK)(?:[^A-Za-z0-9_]|$)`)
 
-// deferralIdioms are substring signals for skipped tests and stub bodies.
+// deferralIdioms are signals for skipped tests and stub bodies. An idiom that
+// starts with an identifier character matches only at a word start, so
+// os.Exit( is not xit( and benefit( is not fit(.
 var deferralIdioms = []string{
 	"t.Skip(", "t.Skipf(",
 	"test.skip(", "it.skip(", "describe.skip(", "context.skip(",
 	"xit(", "xdescribe(", "xtest(", "xcontext(", "fit(", "fdescribe(",
-	"pytest.mark.skip", "unittest.skip", "SkipTest",
+	"pytest.mark.skip", "pytest.skip(", "pytest.xfail(", "unittest.skip", "SkipTest",
 	"@Disabled", "#[ignore]",
 	"todo!(", "unimplemented!(",
 	"NotImplementedError",
@@ -104,7 +106,7 @@ type windowWaiver struct {
 func windowsMarkers(line string) []string {
 	var idioms []string
 	for _, idiom := range deferralIdioms {
-		if strings.Contains(line, idiom) {
+		if containsIdiom(line, idiom) {
 			idioms = append(idioms, idiom)
 		}
 	}
@@ -128,6 +130,37 @@ func windowsMarkers(line string) []string {
 	return out
 }
 
+// containsIdiom reports whether idiom occurs in line at a word start.
+func containsIdiom(line, idiom string) bool {
+	for i := 0; ; {
+		j := strings.Index(line[i:], idiom)
+		if j < 0 {
+			return false
+		}
+		at := i + j
+		if at == 0 || !isIdentByte(idiom[0]) || !isIdentByte(line[at-1]) {
+			return true
+		}
+		i = at + 1
+	}
+}
+
+func isIdentByte(b byte) bool {
+	return b == '_' || b >= '0' && b <= '9' || b >= 'a' && b <= 'z' || b >= 'A' && b <= 'Z'
+}
+
+// diffHeaderPath decodes a `--- `/`+++ ` header path, unquoting git's C-style
+// quoting of non-ASCII and special characters.
+func diffHeaderPath(raw string) string {
+	p := strings.TrimSpace(raw)
+	if strings.HasPrefix(p, `"`) {
+		if decoded, err := strconv.Unquote(p); err == nil {
+			return decoded
+		}
+	}
+	return p
+}
+
 // isTestPath reports whether a project-relative path names a test source file.
 func isTestPath(p string) bool {
 	base := path.Base(p)
@@ -157,9 +190,9 @@ func removedTestHits(diff string) []windowHit {
 		case strings.HasPrefix(line, "diff --git "):
 			inHeader, deleted, file = true, false, ""
 		case inHeader && strings.HasPrefix(line, "--- "):
-			oldPath = strings.TrimPrefix(strings.Trim(strings.TrimSpace(line[4:]), `"`), "a/")
+			oldPath = strings.TrimPrefix(diffHeaderPath(line[4:]), "a/")
 		case inHeader && strings.HasPrefix(line, "+++ "):
-			newPath := strings.Trim(strings.TrimSpace(line[4:]), `"`)
+			newPath := diffHeaderPath(line[4:])
 			if newPath == "/dev/null" {
 				deleted = true
 				if isTestPath(oldPath) {
@@ -203,8 +236,7 @@ func addedLinesFromDiff(diff string) ([]windowHit, map[string]bool) {
 	for _, line := range strings.Split(diff, "\n") {
 		switch {
 		case strings.HasPrefix(line, "+++ "):
-			p := strings.TrimSpace(strings.TrimPrefix(line, "+++ "))
-			p = strings.Trim(p, `"`)
+			p := diffHeaderPath(strings.TrimPrefix(line, "+++ "))
 			if p == "/dev/null" {
 				path = ""
 				continue
@@ -272,14 +304,16 @@ func windowsHits(opts diffScopeOpts) ([]windowHit, error) {
 		dir = opts.root
 	}
 	var hits []windowHit
-	var diffArgs []string
+	// Repository diff config (color, external diff, textconv, mnemonic or no
+	// prefixes) must not reshape the patch this parser reads.
+	diffArgs := []string{"diff", "--no-ext-diff", "--no-textconv", "--no-color", "--src-prefix=a/", "--dst-prefix=b/"}
 	switch opts.mode {
 	case "staged":
-		diffArgs = []string{"diff", "--cached", "-M", "-U0", "--"}
+		diffArgs = append(diffArgs, "--cached", "-M", "-U0", "--")
 	case "base":
-		diffArgs = []string{"diff", opts.base, "-M", "-U0", "--"}
+		diffArgs = append(diffArgs, opts.base, "-M", "-U0", "--")
 	default:
-		diffArgs = []string{"diff", "HEAD", "-M", "-U0", "--"}
+		diffArgs = append(diffArgs, "HEAD", "-M", "-U0", "--")
 	}
 	diff, err := runGitCommand(dir, nil, diffArgs...)
 	var diffPaths map[string]bool
@@ -293,6 +327,9 @@ func windowsHits(opts diffScopeOpts) ([]windowHit, error) {
 	default:
 		return nil, err
 	}
+	// Git paths are repo-root-relative; the project's own workspace may sit
+	// in a subdirectory ("sub/.devrites") when the project is nested.
+	control := devritesRepoPrefix(dir, opts.root)
 	if opts.mode == "worktree" {
 		// Whole files whose diff produced no hunks: staged additions land in
 		// `git diff HEAD`, untracked files never do — scan those in full.
@@ -307,17 +344,26 @@ func windowsHits(opts diffScopeOpts) ([]windowHit, error) {
 		}
 		repo := strings.TrimSpace(string(repoRoot))
 		for _, p := range status {
-			if diffPaths[p] || strings.HasPrefix(p, ".devrites/") {
+			if diffPaths[p] || strings.HasPrefix(p, control+"/") {
 				continue
 			}
 			hits = scanWholeFile(repo, p, hits)
 		}
 	}
+	// windows.md rows name project-relative paths, so hits are rebased from
+	// the repository root onto the project directory that holds control.
+	project := path.Dir(control)
 	var kept []windowHit
 	for _, h := range hits {
-		if !strings.HasPrefix(h.Path, ".devrites/") {
-			kept = append(kept, h)
+		if strings.HasPrefix(h.Path, control+"/") {
+			continue
 		}
+		if project != "." {
+			if rel, err := filepath.Rel(filepath.FromSlash(project), filepath.FromSlash(h.Path)); err == nil {
+				h.Path = filepath.ToSlash(rel)
+			}
+		}
+		kept = append(kept, h)
 	}
 	return kept, nil
 }
@@ -362,7 +408,7 @@ func parseWindowsWaivers(raw string) (map[windowWaiver]int, []string) {
 // parseWindowsArgs accepts the diff-scope mode flags plus a slug; the allowlist
 // flags do not apply to marker scanning.
 func parseWindowsArgs(root string, args []string, stderr io.Writer) (diffScopeOpts, int) {
-	opts := diffScopeOpts{mode: "worktree", phase: "seal", root: root}
+	opts := diffScopeOpts{mode: "worktree", root: root}
 	var positional []string
 	for i := 0; i < len(args); i++ {
 		switch args[i] {
@@ -376,6 +422,10 @@ func parseWindowsArgs(root string, args []string, stderr io.Writer) (diffScopeOp
 		case "--base":
 			opts.mode = "base"
 			opts.base = argAt(args, i+1)
+			if strings.HasPrefix(opts.base, "-") {
+				fmt.Fprintln(stderr, "windows: --base requires a ref (not a flag)")
+				return opts, 2
+			}
 			i++
 		case "--cwd":
 			opts.cwd = argAt(args, i+1)
@@ -393,6 +443,9 @@ func parseWindowsArgs(root string, args []string, stderr io.Writer) (diffScopeOp
 		return opts, 2
 	}
 	opts.slug = positional[0]
+	if opts.phase == "" {
+		opts.phase = cursorPhase(root, opts.slug)
+	}
 	return opts, 0
 }
 

package/engine/internal/markdowntext/markdowntext.go

@@ -54,6 +54,16 @@ func Structural(input []byte) ([]byte, error) {
 					start = closeEnd + 1
 					continue
 				}
+			} else if fence, closeEnd := markerLineFence(input, line, lineEnd, afterBlank || anchor >= 0); closeEnd >= 0 {
+				anchor, afterBlank = -1, false
+				if !loneCR(input[start:closeEnd]) {
+					mask(out[start+fence : closeEnd])
+				}
+				if closeEnd == len(input) {
+					break
+				}
+				start = closeEnd + 1
+				continue
 			} else {
 				column, ok := topLevelItem(line)
 				if ok && (afterBlank || anchor >= 0) {
@@ -167,23 +177,52 @@ func fenceStart(line []byte, limit int) (int, bool) {
 	return start, columns <= limit && start < len(line) && (line[start] == '`' || line[start] == '~')
 }
 
+// markerLineFence handles a top-level list item whose content opens a fence
+// (`- ```bash`). It returns the fence's byte offset in line and the end offset
+// of the closer, or -1 unless a closer at the item's content column follows
+// and every line before it stays inside the item. Without this, an indented
+// closer would reopen a top-level fence and mask the rest of the file.
+// Ordered items other than 1 cannot interrupt a paragraph, so they need
+// separated (a preceding blank line or list item).
+func markerLineFence(input, line []byte, lineEnd int, separated bool) (int, int) {
+	column, next, ok := itemContent(line)
+	if !ok || (!separated && line[0] >= '2' && line[0] <= '9') {
+		return 0, -1
+	}
+	marker, width, ok := openingFence(line[next:], 0)
+	if !ok {
+		return 0, -1
+	}
+	return next, listFenceEnd(input, lineEnd, marker, width, column, column)
+}
+
 // topLevelItem returns the content column of a list item whose marker sits at
 // column 0 and whose content is neither another list marker, a heading marker,
 // a fence nor part of a thematic break.
 func topLevelItem(line []byte) (int, bool) {
-	if len(line) < 2 || isThematicBreak(line) {
+	column, next, ok := itemContent(line)
+	if !ok || startsBlock(line[next:]) {
 		return 0, false
 	}
+	return column, true
+}
+
+// itemContent returns the content column and byte offset of a list item whose
+// marker sits at column 0.
+func itemContent(line []byte) (int, int, bool) {
+	if len(line) < 2 || isThematicBreak(line) {
+		return 0, 0, false
+	}
 	markerEnd := 1
 	switch c := line[0]; {
 	case c == '-' || c == '*' || c == '+':
 	case c >= '1' && c <= '9' && line[1] == '.':
 		markerEnd = 2
 	default:
-		return 0, false
+		return 0, 0, false
 	}
 	if markerEnd >= len(line) || (line[markerEnd] != ' ' && line[markerEnd] != '\t') {
-		return 0, false
+		return 0, 0, false
 	}
 	column, next := markerEnd, markerEnd
 	for next < len(line) && (line[next] == ' ' || line[next] == '\t') {
@@ -194,10 +233,10 @@ func topLevelItem(line []byte) (int, bool) {
 		}
 		next++
 	}
-	if next == len(line) || column-markerEnd > 4 || startsBlock(line[next:]) {
-		return 0, false
+	if next == len(line) || column-markerEnd > 4 {
+		return 0, 0, false
 	}
-	return column, true
+	return column, next, true
 }
 
 // startsBlock reports content that opens a list marker, heading or fence.

package/engine/internal/notes/cli.go

@@ -93,11 +93,13 @@ func cmdAdd(root string, args []string, stdout, stderr io.Writer) int {
 	}
 	slug := args[0]
 	subject := filepath.ToSlash(oneLine(args[1]))
-	quote := oneLine(args[2])
-	title := oneLine(args[3])
+	// ParseNotes trims attribute values, so a value is stored trimmed and a
+	// whitespace-only one is blank.
+	quote := strings.TrimSpace(oneLine(args[2]))
+	title := strings.TrimSpace(oneLine(args[3]))
 	body := ""
 	if len(args) == 5 {
-		body = oneLine(args[4])
+		body = strings.TrimSpace(oneLine(args[4]))
 	}
 	if err := ValidateSubject(subject); err != nil {
 		fmt.Fprintf(stderr, "note add: %v\n", err)