devrites 6.0.4 → 6.1.1

package/engine/internal/notes/notes.go

@@ -550,12 +550,17 @@ func Render(text, newline, id, summary, subject, quote, body string) string {
 }
 
 // RemoveEntry deletes one note block (its `- NOTE-` row through its last
-// contiguous attribute row) from the source text.
+// attribute row) from the source text. Like ParseNotes, blank lines do not end
+// the block; trailing blank lines stay.
 func RemoveEntry(text, newline string, note *Note) string {
 	lines := strings.Split(strings.ReplaceAll(text, "\r\n", "\n"), "\n")
 	end := note.Line
-	for end < len(lines) && attrLineRE.MatchString(lines[end]) {
-		end++
+	for i := end; i < len(lines); i++ {
+		if attrLineRE.MatchString(lines[i]) {
+			end = i + 1
+		} else if strings.TrimSpace(lines[i]) != "" {
+			break
+		}
 	}
 	kept := append([]string{}, lines[:note.Line-1]...)
 	kept = append(kept, lines[end:]...)

package/engine/internal/overhaul/admit/run.go

@@ -25,6 +25,7 @@ import (
 	"unicode/utf8"
 
 	"github.com/devrites/devrites/internal/overhaul/ovio"
+	"github.com/devrites/devrites/internal/overhaul/packet"
 	"github.com/devrites/devrites/internal/overhaul/records"
 )
 
@@ -46,22 +47,15 @@ func Run(args []string, stdout, stderr io.Writer) int {
 	var code int
 	var err error
 	switch {
-	case len(args) >= 3 && args[0] == "receipt":
-		observed, hasObserved := "", false
-		for i, a := range args {
-			if a == "--observed" {
-				if i+1 >= len(args) {
-					fmt.Fprint(stderr, usage)
-					return 2
-				}
-				observed, hasObserved = args[i+1], true
-				break
-			}
+	case len(args) >= 3 && args[0] == "receipt" && (len(args) == 3 || len(args) == 5 && args[3] == "--observed"):
+		observed, hasObserved := "", len(args) == 5
+		if hasObserved {
+			observed = args[4]
 		}
 		code, err = receipt(args[1], args[2], observed, hasObserved, stdout)
 	case len(args) == 3 && args[0] == "packet":
 		code, err = packetAdmit(args[1], args[2], stdout)
-	case len(args) >= 3 && args[0] == "anchor":
+	case len(args) == 3 && args[0] == "anchor":
 		code, err = anchor(args[1], args[2], stdout, stderr)
 	default:
 		fmt.Fprint(stderr, usage)
@@ -228,6 +222,16 @@ func receipt(run, path, observed string, hasObserved bool, stdout io.Writer) (in
 			verdict(stdout, "DUPLICATE_OR_LATE", "attempt_status", x["status"])
 			return 3, nil
 		}
+		// Only the attempt's own receipt file counts: not a copy elsewhere (such
+		// as in the target repository) and not a symlink to one.
+		canon := filepath.Join(realpath(run), "receipts", packet.Name(map[string]any{"run_id": rj["run_id"],
+			"task_id": x["task_id"], "attempt_id": x["attempt_id"], "role": x["role"]})+".json")
+		if realpath(path) != canon {
+			why = append(why, "receipt must be the attempt's file <run>/receipts/<run_id>__<task_id>__<attempt_id>__<role>.json")
+		}
+		if r := ovio.Str(x["receipt"]); r != "" && realpath(join(run, r)) != canon {
+			why = append(why, "receipt differs from the dispatched attempt's receipt")
+		}
 		for _, k := range []string{"role", "lane", "snapshot"} {
 			if !eq(rc[k], x[k]) {
 				why = append(why, k+" differs from the dispatch packet")

package/engine/internal/overhaul/overhaul.go

@@ -25,6 +25,7 @@ const Usage = `usage: devrites-engine overhaul <tool> ...
   overhaul records stage <run>
   overhaul records publish <run>
   overhaul records validate <run>
+  overhaul records prune <run> [--keep K]
   overhaul admit receipt <run> <receipt.json> [--observed <paths.txt>]
   overhaul admit packet <run> <packet.json>
   overhaul admit anchor <tree> <proposals.json>

package/engine/internal/overhaul/records/check.go

@@ -13,6 +13,7 @@ import (
 	"strings"
 
 	"github.com/devrites/devrites/internal/overhaul/ovio"
+	"github.com/devrites/devrites/internal/overhaul/score"
 	"github.com/devrites/devrites/internal/overhaul/snapshot"
 )
 
@@ -65,6 +66,9 @@ var (
 	required     = []string{"run.json", "coverage.json", "findings.json", "evidence.json", "dispatch.json",
 		"approval.json", "cycles.json"}
 	channels = set("conversation", "host-structured-action")
+	// finishedVerdict is the readiness verdict each finished-repair outcome requires.
+	finishedVerdict = map[string]string{"READY_FOR_USER_REVIEW": "MEETS_TARGETS",
+		"COMPLETED_WITH_APPROVED_DEGRADATION": "MEETS_TARGETS_WITH_APPROVED_DEGRADATION"}
 )
 
 // Repr renders a decoded JSON value the way Python's repr() does, so rule
@@ -198,13 +202,8 @@ func BadPath(p any, repo string) string {
 	if path.Clean(s) != s || strings.Split(s, "/")[0] == ".." {
 		return "not normalized or escapes the repository"
 	}
-	for _, part := range strings.Split(s, "/") {
-		if part == ".git" {
-			return "names a directory or git metadata"
-		}
-	}
-	if strings.HasPrefix(s, snapshot.RunAreaDir) {
-		return "names the overhaul run area"
+	if why := reserved(s); why != "" {
+		return why
 	}
 	if isDir(join(repo, s)) {
 		return "names a directory or git metadata"
@@ -212,6 +211,30 @@ func BadPath(p any, repo string) string {
 	if !inside(repo, s) {
 		return "resolves outside the repository (symlink or traversal)"
 	}
+	// A symlink alias must not reach git metadata or the run area either.
+	root := realpath(repo)
+	full := realpath(join(root, s))
+	if why := reserved(filepath.ToSlash(strings.TrimPrefix(full, root+string(os.PathSeparator)))); why != "" {
+		return why
+	}
+	if area := realpath(join(root, snapshot.RunAreaDir)); strings.HasPrefix(strings.ToLower(full), strings.ToLower(area)+string(os.PathSeparator)) {
+		return "names the overhaul run area"
+	}
+	return ""
+}
+
+// reserved names why a repository-relative path is off limits: any .git
+// component or the run area, compared case-folded for case-insensitive filesystems.
+func reserved(rel string) string {
+	l := strings.ToLower(rel)
+	for _, part := range strings.Split(l, "/") {
+		if part == ".git" {
+			return "names a directory or git metadata"
+		}
+	}
+	if strings.HasPrefix(l, snapshot.RunAreaDir) {
+		return "names the overhaul run area"
+	}
 	return ""
 }
 
@@ -586,6 +609,27 @@ func Check(run, genDir, prevDir string) ([]string, error) {
 			add("run.json: readiness_verdict differs from scorecard.json")
 		}
 	}
+	// A finished repair claims readiness only on a complete, passing scorecard.
+	outcome := str(rj, "execution_outcome")
+	if want := finishedVerdict[outcome]; want != "" {
+		if !isFile(scp) {
+			add("run.json: %s needs scorecard.json", outcome)
+		} else if sc, err := ovio.LoadObject(scp); err != nil {
+			return nil, err
+		} else {
+			if !eq(sc["readiness_verdict"], want) || !eq(rj["readiness_verdict"], want) {
+				add("run.json: %s needs readiness_verdict %s in run.json and scorecard.json", outcome, want)
+			}
+			gates := ovio.Obj(sc["gates"])
+			for _, g := range score.GateIDs(!ovio.Truthy(rj["assessment_only"])) {
+				st := str(gates, g)
+				waived := g == "G-CONCURRENCY" && st == "WAIVED_OPERATIONAL" && want == "MEETS_TARGETS_WITH_APPROVED_DEGRADATION"
+				if st != "PASS" && st != "NOT_APPLICABLE" && !waived {
+					add("run.json: %s needs gate %s to pass in scorecard.json (got %s)", outcome, g, Repr(gates[g]))
+				}
+			}
+		}
+	}
 	if err := consistency(run, genDir, R, add); err != nil {
 		return nil, err
 	}
@@ -686,7 +730,7 @@ func Check(run, genDir, prevDir string) ([]string, error) {
 		if set("returned", "admitted", "rejected")[status] && !(str(x, "receipt") != "" && isFile(join(run, str(x, "receipt")))) {
 			add("attempt %s: receipt file missing", xid)
 		}
-		if set("dispatched", "running", "returned")[status] {
+		if !set("admitted", "rejected", "cancelled")[status] {
 			unsettled = append(unsettled, xid)
 		}
 		if !writers[str(x, "role")] {
@@ -721,7 +765,6 @@ func Check(run, genDir, prevDir string) ([]string, error) {
 			}
 		}
 	}
-	outcome := str(rj, "execution_outcome")
 	if outcome != "RUNNING" && len(unsettled) > 0 {
 		add("attempts must be admitted, rejected or cancelled before the run leaves RUNNING: %s", Repr(unsettled[:min(5, len(unsettled))]))
 	}

package/engine/internal/overhaul/render/run.go

@@ -530,6 +530,7 @@ type built struct {
 	laneCov        map[string][2]int // lane -> reviewed, eligible ranges
 	secs           []section
 	approve, stamp string
+	hasPlan        bool // run.json names a plan revision
 	finds          []map[string]any
 	lanes          []string
 	cards          map[string][]map[string]any // section anchor -> findings drawn as cards in HTML
@@ -787,7 +788,7 @@ func build(run, gen string) (*built, error) {
 	}
 	stamp := sf("overhaul-stamp run=%s generation=%s plan=%s", rj["run_id"],
 		strings.ReplaceAll(filepath.Base(strings.TrimRight(gen, "/")), ".tmp", ""), planStamp)
-	return &built{rj: rj, sc: sc, base: base, rubric: rubric, domains: domains, tasks: tasks, laneCov: laneCov, secs: S, approve: approve, stamp: stamp, finds: finds, lanes: lanes,
+	return &built{rj: rj, sc: sc, base: base, rubric: rubric, domains: domains, tasks: tasks, laneCov: laneCov, secs: S, approve: approve, stamp: stamp, hasPlan: len(pr) > 0, finds: finds, lanes: lanes,
 		cards: map[string][]map[string]any{"findings": confirmed, "opportunities": opps}, byF: byF}, nil
 }
 
@@ -816,7 +817,7 @@ func render(run, gen, kind, home string) (string, error) {
 	runID := pyStr(b.rj["run_id"])
 	if kind == "review" {
 		for _, s := range b.secs {
-			if s.anchor != "plan" || len(s.body) == 0 {
+			if s.anchor != "plan" || !b.hasPlan { // a zero-task plan still gets plan.md
 				continue
 			}
 			lines := append([]string{"<!-- " + b.stamp + " -->", "# Overhaul plan " + runID, ""}, mdTable(v, s.cols, s.body)...)

package/engine/internal/overhaul/snapshot/run.go

@@ -239,7 +239,7 @@ func dirty(root string, tracked []string) (map[string]bool, error) {
 		return set, nil
 	}
 	b, err := git(root, "-c", "diff.autoRefreshIndex=false", "diff", "--no-ext-diff", "--no-textconv", "--no-renames",
-		"--name-only", "-z", "HEAD")
+		"--relative", "--name-only", "-z", "HEAD") // --relative: same base as ls-files when root is a subdirectory
 	if err != nil {
 		return nil, err
 	}
@@ -465,7 +465,7 @@ func capture(root, out string, stdout io.Writer) error {
 	safe := []string{"--", "."}
 	for p, v := range st {
 		if v.Sensitive {
-			safe = append(safe, ":(top,exclude,literal)"+p)
+			safe = append(safe, ":(exclude,literal)"+p) // cwd-relative, like p, when root is a subdirectory
 		}
 	}
 	for _, o := range []struct {

package/engine/internal/parallel/git.go

@@ -108,18 +108,17 @@ func isAncestor(repo, ancestor, descendant string) (bool, error) {
 }
 
 func diffNames(repo, a, b string) ([]string, error) {
-	out, err := git(repo, "diff", "--name-only", a, b)
+	// --no-renames reports a rename's source as a deletion; -z keeps paths raw
+	// instead of C-quoted.
+	out, err := git(repo, "diff", "--name-only", "--no-renames", "-z", a, b)
 	if err != nil {
 		return nil, err
 	}
+	out = strings.TrimSuffix(out, "\x00")
 	if out == "" {
 		return nil, nil
 	}
-	lines := strings.Split(out, "\n")
-	for i := range lines {
-		lines[i] = strings.TrimSpace(lines[i])
-	}
-	return lines, nil
+	return strings.Split(out, "\x00"), nil
 }
 
 func headSHA(repo string) (string, error) {

package/engine/internal/parallel/ops.go

@@ -584,6 +584,9 @@ func cleanupLocked(repoRoot, slug string, force bool) ([]Salvage, error) {
 		inScratch := sl.WorktreePath != "" && ownedWorktreePath(repoRoot, lease.BatchID, sl)
 		owned := inScratch && createdWorktree(registered, sl.WorktreePath)
 		if sl.WorktreePath != "" && !owned {
+			// Never salvaged, so the batch sweep must not delete this slice's
+			// scratch entry either (e.g. a --root spelled through a symlink).
+			keptWorktrees[sl.ID] = true
 			if inScratch {
 				warnf("slice %s worktree_path %q is not a worktree git registered; leaving it untouched",
 					sl.ID, sl.WorktreePath)

package/engine/internal/parallel/pathdisjoint.go

@@ -67,21 +67,25 @@ func validateSlicePaths(paths []string, label, root string) ([]string, error) {
 		if err != nil {
 			return nil, fmt.Errorf("%s: %w", label, err)
 		}
+		// Comparisons fold case always: on a case-insensitive filesystem
+		// (macOS, Windows) .DEVRITES is the control tree and A.go is a.go; on a
+		// case-sensitive one a false overlap only serializes the slices.
+		folded := strings.ToLower(path)
 		// Parallel eligibility must reject workspace control metadata so slices
 		// cannot claim control-tree / SSOT files (docs: ".devrites/**").
-		if path == ".devrites" || strings.HasPrefix(path, ".devrites/") {
+		if folded == ".devrites" || strings.HasPrefix(folded, ".devrites/") {
 			return nil, fmt.Errorf("%s: path must not include .devrites: %q", label, path)
 		}
 		// Same for git internals: a transfer commit can never carry .git/**
 		// anyway, and inside a worktree .git is a file, so claiming it is
 		// pure footgun.
-		if path == ".git" || strings.HasPrefix(path, ".git/") {
+		if folded == ".git" || strings.HasPrefix(folded, ".git/") {
 			return nil, fmt.Errorf("%s: path must not include .git: %q", label, path)
 		}
-		if _, ok := seen[path]; ok {
+		if _, ok := seen[folded]; ok {
 			return nil, fmt.Errorf("%s: duplicate path %q", label, path)
 		}
-		seen[path] = struct{}{}
+		seen[folded] = struct{}{}
 		normalized = append(normalized, path)
 		if root != "" {
 			// Check every component, not just the leaf: a symlinked directory
@@ -122,6 +126,7 @@ func CheckPathDisjoint(slices []SlicePaths, root string) ([]string, error) {
 			return nil, err
 		}
 		for _, path := range paths {
+			path = strings.ToLower(path) // see validateSlicePaths: overlap folds case
 			owners[path] = append(owners[path], label)
 		}
 	}

package/engine/internal/release/release.go

@@ -145,15 +145,17 @@ func validTag(tag string) bool {
 }
 
 func platformBinaryName() (string, error) {
-	supported := (runtime.GOOS == "darwin" || runtime.GOOS == "linux") && (runtime.GOARCH == "amd64" || runtime.GOARCH == "arm64")
-	if runtime.GOOS == "windows" && runtime.GOARCH == "amd64" {
-		supported = true
-	}
-	if !supported {
-		return "", fmt.Errorf("no DevRites engine release for %s/%s", runtime.GOOS, runtime.GOARCH)
-	}
-	name := "devrites-" + runtime.GOOS + "-" + runtime.GOARCH
-	if runtime.GOOS == "windows" {
+	return binaryNameFor(runtime.GOOS, runtime.GOARCH)
+}
+
+// binaryNameFor names the release asset; CI publishes darwin, linux and
+// windows for both amd64 and arm64.
+func binaryNameFor(goos, goarch string) (string, error) {
+	if (goos != "darwin" && goos != "linux" && goos != "windows") || (goarch != "amd64" && goarch != "arm64") {
+		return "", fmt.Errorf("no DevRites engine release for %s/%s", goos, goarch)
+	}
+	name := "devrites-" + goos + "-" + goarch
+	if goos == "windows" {
 		name += ".exe"
 	}
 	return name, nil

package/engine/internal/safepath/safepath.go

@@ -1,6 +1,7 @@
 package safepath
 
 import (
+	"errors"
 	"os"
 	"path/filepath"
 )
@@ -28,9 +29,10 @@ func WithinResolved(candidate, parent string) bool {
 
 // ResolveExisting resolves symlinks in the longest existing path prefix, then
 // appends any missing tail without allowing it to change the resolved parent.
+// A dangling symlink is followed to its target: creating through it writes there.
 func ResolveExisting(filename string) (string, error) {
 	var tail []string
-	for {
+	for hops := 0; ; {
 		resolved, err := filepath.EvalSymlinks(filename)
 		if err == nil {
 			for i := len(tail) - 1; i >= 0; i-- {
@@ -41,6 +43,20 @@ func ResolveExisting(filename string) (string, error) {
 		if !os.IsNotExist(err) {
 			return "", err
 		}
+		if info, lerr := os.Lstat(filename); lerr == nil && info.Mode()&os.ModeSymlink != 0 {
+			target, rerr := os.Readlink(filename)
+			if rerr != nil {
+				return "", rerr
+			}
+			if hops++; hops > 255 {
+				return "", &os.PathError{Op: "resolve", Path: filename, Err: errors.New("too many symlinks")}
+			}
+			if !filepath.IsAbs(target) {
+				target = filepath.Join(filepath.Dir(filename), target)
+			}
+			filename = target
+			continue
+		}
 		parent := filepath.Dir(filename)
 		if parent == filename {
 			return "", err

package/engine/internal/state/budgets.go

@@ -78,17 +78,21 @@ func ArtifactLineBudget(name string) (int, bool) {
 
 // sanctionedRootFiles are workspace-root files the schema places there without a
 // line budget: conditional artifacts (`references.md`, `investigation-map.md`,
-// `dogfood.md`) and engine-owned machine files (the parallel lease, the metrics
-// ledger, the regression baseline). Anything else in the root is unsanctioned
-// placement — `packets/` and `history/` own by-reference packets and relocated
-// narrative (workspace-artifact-schema.md "Required by phase").
+// `dogfood.md`, `devex.md`) and engine-owned machine files (the parallel lease,
+// the metrics ledger, the regression baseline, the dispatch ledger, the drift
+// baseline). Anything else in the root is unsanctioned placement — `packets/`
+// and `history/` own by-reference packets and relocated narrative
+// (workspace-artifact-schema.md "Required by phase").
 var sanctionedRootFiles = map[string]bool{
 	"references.md":            true,
 	"investigation-map.md":     true,
 	"dogfood.md":               true,
+	"devex.md":                 true,
 	"parallel-lease.md":        true,
 	"metrics.jsonl":            true,
 	"regression-baseline.json": true,
+	"dispatch.json":            true,
+	"readiness-inputs.json":    true,
 }
 
 // SanctionedRootFile reports whether name is a legitimate workspace-root file:

package/engine/internal/state/feature.go

@@ -15,12 +15,14 @@ import (
 // ResolveRoot returns the .devrites directory to operate on. A non-empty
 // override (e.g. from DEVRITES_ROOT) may name either the project root or its
 // .devrites directory; otherwise the nearest ancestor .devrites is used.
+// Callers take Dir(root) as the project, so a symlinked .devrites (which
+// rootfacts proves resolves inside the project) keeps its project-side name.
 func ResolveRoot(override string) (string, error) {
 	facts, err := rootfacts.Resolve(override)
 	if err != nil {
 		return "", err
 	}
-	return facts.PhysicalRoot, nil
+	return filepath.Join(facts.PhysicalProject, devritespaths.DevritesRootName), nil
 }
 
 // featureDir is the canonical per-feature state directory under root.

package/engine/internal/state/observation.go

@@ -8,6 +8,7 @@ import (
 	"os"
 	"path"
 	"path/filepath"
+	"slices"
 	"sort"
 	"strings"
 
@@ -350,10 +351,12 @@ func observationWorkspaceOverrideValid(root, slug string) bool {
 	if raw == "" {
 		return true
 	}
-	if strings.TrimSpace(raw) != raw || filepath.Clean(raw) != raw {
+	if strings.TrimSpace(raw) != raw {
 		return false
 	}
-	if !filepath.IsAbs(raw) && !filepath.IsLocal(raw) {
+	// A ".." hop could route through a symlinked alias, so it is never
+	// cleaned away; "./" and trailing separators are harmless spellings.
+	if slices.Contains(strings.FieldsFunc(raw, func(r rune) bool { return r == '/' || r == filepath.Separator }), "..") {
 		return false
 	}
 	physicalRoot, err := filepath.EvalSymlinks(root)
@@ -364,16 +367,18 @@ func observationWorkspaceOverrideValid(root, slug string) bool {
 	if err != nil {
 		return false
 	}
-	override := raw
+	override := filepath.Clean(raw)
 	if !filepath.IsAbs(override) {
 		override = filepath.Join(filepath.Dir(physicalRoot), override)
 	}
-	override, err = filepath.Abs(override)
-	if err != nil {
+	// Only the selected root may be spelled through a symlink (/tmp versus
+	// /private/tmp); work/<slug> must match literally so an alias of the
+	// workspace itself never does.
+	if filepath.Base(override) != slug || filepath.Base(filepath.Dir(override)) != "work" {
 		return false
 	}
-	want := filepath.Join(physicalRoot, "work", slug)
-	return filepath.Clean(override) == filepath.Clean(want)
+	overrideRoot, err := filepath.EvalSymlinks(filepath.Dir(filepath.Dir(override)))
+	return err == nil && overrideRoot == physicalRoot
 }
 
 func observationInventory() []ArtifactPath {

package/engine/internal/state/taskgraph.go

@@ -3,16 +3,20 @@ package state
 import (
 	"fmt"
 	"regexp"
+	"slices"
 	"strings"
 	"unicode"
 
 	"github.com/devrites/devrites/internal/markdowntext"
 )
 
-// TaskSlice is one SLICE-### block parsed from tasks.md.
+// TaskSlice is one SLICE-### block parsed from tasks.md. Via maps a dependency
+// ID to the interface its `(via <text>)` suffix names; bare edges are absent.
 type TaskSlice struct {
-	ID           string
-	Dependencies []string
+	ID               string
+	Dependencies     []string
+	Via              map[string]string
+	ConsumesProduces string
 }
 
 // TaskGraphResult is the deterministic outcome of parsing a tasks.md slice graph.
@@ -26,8 +30,12 @@ type TaskGraphResult struct {
 var (
 	sliceHeaderRE  = regexp.MustCompile(`(?m)^##\s+(SLICE-\d+)\b`)
 	anyH2HeaderRE  = regexp.MustCompile(`(?m)^##\s`)
-	dependenciesRE = regexp.MustCompile(`(?m)^Dependencies:\s*(.+)\s*$`)
-	dependsOnRE    = regexp.MustCompile(`(?m)^depends_on:\s*(.+)\s*$`)
+	dependenciesRE = regexp.MustCompile(`(?m)^Dependencies:[ \t]*(.+)[ \t]*$`)
+	dependsOnRE    = regexp.MustCompile(`(?m)^depends_on:[ \t]*(.+)[ \t]*$`)
+	consumesRE     = regexp.MustCompile(`(?m)^Consumes / Produces:[ \t]*(.+)[ \t]*$`)
+	// viaSuffixRE matches a Dependencies `(via <text>)` suffix; group 2 is
+	// empty when the parenthetical is unclosed. Nested parentheses are unsupported.
+	viaSuffixRE    = regexp.MustCompile(`\([ \t]*via\b([^()]*)(\))?`)
 	sliceIDValidRE = regexp.MustCompile(`^SLICE-\d+$`)
 )
 
@@ -92,10 +100,10 @@ func ParseTaskGraph(tasksMarkdown []byte) TaskGraphResult {
 			end = headers[i+1][0]
 		}
 		block := text[start:end]
-		deps, problems := parseSliceGraph(id, block)
+		slice, problems := parseSliceGraph(id, block)
 		result.Problems = append(result.Problems, problems...)
-		result.Slices = append(result.Slices, TaskSlice{ID: id, Dependencies: deps})
-		for _, dep := range deps {
+		result.Slices = append(result.Slices, slice)
+		for _, dep := range slice.Dependencies {
 			if !known[dep] {
 				result.Unknown = append(result.Unknown, dep)
 				result.Problems = append(result.Problems, fmt.Sprintf("%s depends on unknown slice %s", id, dep))
@@ -121,14 +129,20 @@ func structuralTaskText(tasksMarkdown []byte) string {
 	return string(masked)
 }
 
-func parseSliceGraph(id, block string) ([]string, []string) {
+func parseSliceGraph(id, block string) (TaskSlice, []string) {
 	var problems []string
 	depsLine := firstLineValue(dependenciesRE, block)
 	mirrorLine := firstLineValue(dependsOnRE, block)
-	deps, malformed := parseIDList(depsLine)
-	for _, token := range malformed {
+	bare, via, malformed := splitDependencyVia(depsLine)
+	deps, malformedIDs := parseIDList(bare)
+	for _, token := range append(malformed, malformedIDs...) {
 		problems = append(problems, fmt.Sprintf("%s has malformed dependency %q", id, token))
 	}
+	for dep := range via {
+		if !slices.Contains(deps, dep) {
+			delete(via, dep) // its ID token is already reported malformed
+		}
+	}
 	mirror, mirrorMalformed := parseIDList(mirrorLine)
 	for _, token := range mirrorMalformed {
 		problems = append(problems, fmt.Sprintf("%s has malformed depends_on %q", id, token))
@@ -142,7 +156,48 @@ func parseSliceGraph(id, block string) ([]string, []string) {
 	if depsLine == "" {
 		deps = mirror
 	}
-	return deps, problems
+	return TaskSlice{ID: id, Dependencies: deps, Via: via, ConsumesProduces: firstLineValue(consumesRE, block)}, problems
+}
+
+// splitDependencyVia strips each `(via <text>)` suffix from a Dependencies
+// value, returning the bare ID list, the via text keyed by the ID it follows,
+// and any suffix that is empty, unclosed, or not directly after an ID.
+func splitDependencyVia(raw string) (string, map[string]string, []string) {
+	var bare strings.Builder
+	var via map[string]string
+	var malformed []string
+	last := 0
+	for _, m := range viaSuffixRE.FindAllStringSubmatchIndex(raw, -1) {
+		before := raw[last:m[0]]
+		bare.WriteString(before)
+		last = m[1]
+		text := strings.TrimSpace(raw[m[2]:m[3]])
+		dep := precedingSliceID(before)
+		if m[4] < 0 || text == "" || dep == "" {
+			malformed = append(malformed, strings.TrimSpace(raw[m[0]:m[1]]))
+			continue
+		}
+		if via == nil {
+			via = make(map[string]string)
+		}
+		if _, seen := via[dep]; !seen {
+			via[dep] = text
+		}
+	}
+	bare.WriteString(raw[last:])
+	return bare.String(), via, malformed
+}
+
+// precedingSliceID returns the SLICE-### token that ends s, separated from what
+// follows only by blanks, or "" when s ends in a separator or a non-ID token.
+func precedingSliceID(s string) string {
+	s = strings.TrimRight(s, " \t")
+	start := strings.LastIndexAny(s, ",; \t") + 1
+	id := strings.Trim(s[start:], "`'\"(){}[]")
+	if !sliceIDValidRE.MatchString(id) {
+		return ""
+	}
+	return id
 }
 
 func firstLineValue(re *regexp.Regexp, block string) string {

package/engine/internal/state/write.go

@@ -103,12 +103,18 @@ func WithFeatureLockRelease(root, slug string, fn func(release func()) error) er
 }
 
 // featureLockPath validates slug and creates the feature directory, returning
-// the lock file path inside it.
+// the lock file path inside it. A closed workspace (work/<slug> gone, archive/<slug>
+// present) is refused rather than resurrected by a late lock.
 func featureLockPath(root, slug string) (string, error) {
 	if !devritespaths.ValidSlug(slug) {
 		return "", fmt.Errorf("lock feature %q: not a feature slug", slug)
 	}
 	dir := featureDir(root, slug)
+	if _, err := os.Lstat(dir); errors.Is(err, fs.ErrNotExist) {
+		if _, archErr := os.Lstat(filepath.Join(root, "archive", slug)); archErr == nil {
+			return "", fmt.Errorf("lock feature %q: workspace is closed (archived)", slug)
+		}
+	}
 	if err := os.MkdirAll(dir, 0o755); err != nil {
 		return "", fmt.Errorf("lock feature %q: %w", slug, err)
 	}

package/engine/main.go

@@ -48,6 +48,8 @@ Usage:
   devrites-engine orient <slug>            Alias for observe summary
   devrites-engine next [slug]              Print the minimal remaining lifecycle path with advisory skips
   devrites-engine handoff [slug]           Emit the deterministic resume record (cursor, blocking gates, ledger, dead ends)
+  devrites-engine recall --paths <csv> [--limit n]
+                                         Point at archived features that touched these paths: decisions, constraints, findings (read-only)
   devrites-engine context [slug] (--phase <p> | --skill <name>) [--role <r>] [--slice <id>] [--trigger a,b]
                                          Emit one deduplicated read-set bundle for a phase, skill, or dispatch role
   devrites-engine metrics record <slug> --phase <p> --event <e> [--role r] [--bytes n] [--note s]
@@ -64,7 +66,7 @@ Usage:
   devrites-engine state resolve <qid> "<ans>"  Resolve an open question and update state atomically
   devrites-engine state merge-manifest <slug> [pred...]  Fold the recorded predecessor chain's manifests into the release candidate manifest
   devrites-engine state close <slug>       Archive a shipped feature and clear ACTIVE
-  devrites-engine migrate <slug> [--dry-run]  Normalize a pre-v5 workspace to the current schema
+  devrites-engine migrate <slug> [--dry-run] [--answer id=choice]  Normalize an older-schema workspace to the current schema
   devrites-engine secret-scan [--staged] [--stdin] [slug]  Scan exact staged blobs, stdin, or touched files; HIGH blocks
   devrites-engine open-visual <path-or-name> [--slug <slug>] [--no-open]
                                          Resolve a visual HTML file, optionally open it locally, print agent paths
@@ -134,6 +136,8 @@ func run(args []string, stdin io.Reader, stdout, stderr io.Writer) int {
 		return lib.RunNext(root, args[1:], stdout, stderr)
 	case "handoff":
 		return lib.RunHandoff(root, args[1:], stdout, stderr)
+	case "recall":
+		return lib.RunRecall(root, args[1:], stdout, stderr)
 	case "context":
 		return lib.RunContext(root, args[1:], stdout, stderr)
 	case "metrics":

package/pack/.claude/agents/_shared/composition-overhaul.md

@@ -1 +1,3 @@
 Do not invoke another agent. You are called by `/overhaul` and return your result to that orchestrator.
+
+Write your receipt (`schema` `overhaul.receipt/1`) to the packet's `receipt_path`, copying `run_id`, `task_id`, `attempt_id`, `lane` and `snapshot` verbatim from the packet and setting `role` to the unprefixed role name (`verifier`, not `overhaul-verifier`); follow `.claude/skills/overhaul/references/orchestration.md` § Receipts, since admission rejects any mismatch.