devrites 7.3.1 → 7.3.2

package/engine/internal/lib/final_prerequisites.go

@@ -0,0 +1,137 @@
+package lib
+
+import (
+	"fmt"
+	"time"
+
+	"github.com/devrites/devrites/internal/acceptance"
+	"github.com/devrites/devrites/internal/state"
+)
+
+// CheckFinalPrerequisites validates retained dispatch settlement and runnable gate
+// origins without executing proof. The caller must hold the feature lock through
+// this check and any final mutation. A missing ledger cannot certify settlement.
+func CheckFinalPrerequisites(root, slug string) error {
+	ledger, _, err := loadDispatch(root, slug)
+	if err != nil {
+		return fmt.Errorf("review dispatch: %w", err)
+	}
+	reviewers := 0
+	for _, name := range sortedKeys(ledger.Waves) {
+		wave := ledger.Waves[name]
+		if wave.State == "abandoned" && (isWrightWave(wave) || wave.Claim != "") && wave.TerminalAt == "" {
+			for _, account := range wave.Roles {
+				if _, _, err := settledReviewer(account); err != nil {
+					return fmt.Errorf("review dispatch wave %q has no confirmed terminal writer account; confirm host termination with abandon --release", name)
+				}
+			}
+		}
+		for _, role := range sortedKeys(wave.Roles) {
+			if isReviewerRole(role) {
+				reviewers++
+			}
+			if wave.Phase == "" {
+				return fmt.Errorf("review dispatch wave %q has no phase", name)
+			}
+			account := wave.Roles[role]
+			switch wave.State {
+			case "complete":
+				if _, _, err := settledReviewer(account); err != nil {
+					return fmt.Errorf("review dispatch wave %q role %q: %w", name, role, err)
+				}
+			case "abandoned":
+				if !isReviewerRole(role) && roleBase(role) != "proof-runner" {
+					if wave.TerminalAt != "" {
+						continue
+					}
+					if isWrightWave(wave) || wave.Claim != "" {
+						if _, _, err := settledReviewer(account); err == nil {
+							continue
+						}
+					}
+				}
+				if !reconciledReviewer(ledger, wave, role, account) {
+					return fmt.Errorf("review dispatch wave %q role %q is abandoned; retain a fresh settled account with the same phase, role and slice subject", name, role)
+				}
+			default:
+				return fmt.Errorf("review dispatch wave %q role %q is not settled (state %s)", name, role, wave.State)
+			}
+		}
+	}
+	if reviewers == 0 {
+		return fmt.Errorf("review dispatch has no retained reviewer accounts; restore the native dispatch ledger")
+	}
+	return acceptance.CheckRetainedOrigins(root, slug)
+}
+
+func settledReviewer(account *dispatchRole) (time.Time, time.Time, error) {
+	if account == nil || account.Handle == "" || !account.Returned {
+		return time.Time{}, time.Time{}, fmt.Errorf("missing reviewer start identity or return")
+	}
+	start, startErr := time.Parse(time.RFC3339, account.StartedAt)
+	end, endErr := time.Parse(time.RFC3339, account.ReturnedAt)
+	if startErr != nil || endErr != nil || end.Before(start) {
+		return time.Time{}, time.Time{}, fmt.Errorf("invalid reviewer start/return timestamps")
+	}
+	return start, end, nil
+}
+
+func reconciledReviewer(ledger *dispatchFile, abandoned *dispatchWave, role string, account *dispatchRole) bool {
+	if account == nil {
+		return false
+	}
+	var boundary time.Time
+	if account.Handle != "" {
+		var err error
+		boundary, err = time.Parse(time.RFC3339Nano, account.StartedAt)
+		if err != nil {
+			return false
+		}
+		if account.ReturnedAt != "" {
+			returned, err := time.Parse(time.RFC3339Nano, account.ReturnedAt)
+			if err != nil || returned.Before(boundary) {
+				return false
+			}
+			boundary = returned
+		}
+	} else if account.StartedAt != "" || account.Returned || account.ReturnedAt != "" {
+		return false
+	}
+	if abandoned.AbandonedAt != "" {
+		stamp, err := time.Parse(time.RFC3339Nano, abandoned.AbandonedAt)
+		if err != nil || stamp.Before(boundary) {
+			return false
+		}
+		boundary = stamp
+	}
+	// A never-started legacy launch needs an explicit native abandonment first.
+	if boundary.IsZero() {
+		return false
+	}
+	for _, wave := range ledger.Waves {
+		if wave.State != "complete" || state.CanonicalPhase(wave.Phase) != state.CanonicalPhase(abandoned.Phase) || !sameSliceSubject(wave.Slices, abandoned.Slices) {
+			continue
+		}
+		replacement := wave.Roles[role]
+		start, _, err := settledReviewer(replacement)
+		// Equal or older starts cannot prove a fresh replacement.
+		if err == nil && replacement.Handle != account.Handle && start.After(boundary) {
+			return true
+		}
+	}
+	return false
+}
+
+func sameSliceSubject(a, b []string) bool {
+	for _, id := range a {
+		if !containsSlice(b, id) {
+			return false
+		}
+	}
+	for _, id := range b {
+		if !containsSlice(a, id) {
+			return false
+		}
+	}
+	return true
+}

package/engine/internal/lib/manifest_union.go

@@ -7,6 +7,7 @@ import (
 	"os"
 	"path/filepath"
 	"sort"
+	"strconv"
 	"strings"
 
 	"github.com/devrites/devrites/internal/devritespaths"
@@ -134,9 +135,9 @@ func mergeManifestLocked(root, slug, workspace string, args []string, stdout, st
 	return 0
 }
 
-// explicitManifests parses the caller-ordered predecessor list. When the
-// workspace carries a sequence_parent cursor, the last predecessor must be the
-// recorded parent; a mismatch means the list does not describe this chain.
+// explicitManifests parses the caller-ordered predecessor list. A numbered
+// workspace or one recording a parent requires the complete recorded chain;
+// legacy workspaces without cursors retain caller-supplied ordering.
 func explicitManifests(root, slug string, predecessors []string) ([][]candidateRow, error) {
 	seen := make(map[string]struct{}, len(predecessors))
 	for _, pred := range predecessors {
@@ -148,8 +149,31 @@ func explicitManifests(root, slug string, predecessors []string) ([][]candidateR
 		}
 		seen[pred] = struct{}{}
 	}
-	if parent := sequenceParent(root, slug); parent != "" && parent != predecessors[len(predecessors)-1] {
-		return nil, fmt.Errorf("%s records sequence_parent %q; pass the full ordered predecessor list ending with it (or no list to walk the recorded chain)", slug, parent)
+	dir, err := devritespaths.ExistingFeatureDirChecked(root, slug)
+	if err != nil {
+		return nil, err
+	}
+	raw, err := readBoundedRegularFile(filepath.Join(dir, "state.md"), maxCandidateManifestBytes)
+	if err != nil {
+		return nil, fmt.Errorf("%s state.md: %w", slug, err)
+	}
+	lines := strings.Split(string(raw), "\n")
+	parent, _ := state.CursorField(lines, state.CursorSequenceParent)
+	_, numbered := state.CursorField(lines, state.CursorSequencePosition)
+	if parent != "" || numbered {
+		chain, manifests, err := walkSequenceChain(root, slug, dir)
+		if err != nil {
+			return nil, err
+		}
+		if len(chain) != len(predecessors) {
+			return nil, fmt.Errorf("%s requires the complete ordered sequence_parent chain", slug)
+		}
+		for i, pred := range predecessors {
+			if pred != chain[i] {
+				return nil, fmt.Errorf("%s requires the complete ordered sequence_parent chain", slug)
+			}
+		}
+		return manifests, nil
 	}
 	manifests := make([][]candidateRow, 0, len(predecessors))
 	for _, pred := range predecessors {
@@ -162,26 +186,52 @@ func explicitManifests(root, slug string, predecessors []string) ([][]candidateR
 	return manifests, nil
 }
 
-// walkSequenceChain follows the target workspace's sequence_parent links to the
-// chain head, returning predecessors oldest-first with their manifests. Every
-// link must resolve to a live or archived workspace carrying the cursor field;
-// a broken link refuses the merge rather than producing a partial union.
+// walkSequenceChain follows sequence_parent links, returning predecessors
+// oldest-first. Numbered chains must descend consecutively to position 1;
+// fully unnumbered legacy chains may end at any parentless workspace. Broken
+// links or mixed numbering refuse the merge instead of producing a partial union.
 func walkSequenceChain(root, slug, workspace string) ([]string, [][]candidateRow, error) {
 	visited := map[string]struct{}{slug: {}}
 	chain := []string{}
 	manifests := [][]candidateRow{}
 	dir := workspace
+	numbered := false
+	var expectedPosition uint64
 	for {
 		raw, err := readBoundedRegularFile(filepath.Join(dir, "state.md"), maxCandidateManifestBytes)
 		if err != nil {
 			return nil, nil, fmt.Errorf("%s state.md: %w", filepath.Base(dir), err)
 		}
-		parent, _ := state.CursorField(strings.Split(string(raw), "\n"), state.CursorSequenceParent)
+		lines := strings.Split(string(raw), "\n")
+		parent, _ := state.CursorField(lines, state.CursorSequenceParent)
+		positionText, hasPosition := state.CursorField(lines, state.CursorSequencePosition)
+		if len(chain) == 0 {
+			numbered = hasPosition
+		}
+		if hasPosition != numbered {
+			return nil, nil, fmt.Errorf("%s mixes numbered and unnumbered sequence positions", filepath.Base(dir))
+		}
+		if numbered {
+			position, err := strconv.ParseUint(positionText, 10, 64)
+			if err != nil || position == 0 || strconv.FormatUint(position, 10) != positionText {
+				return nil, nil, fmt.Errorf("%s sequence_position %q must be a positive canonical decimal", filepath.Base(dir), positionText)
+			}
+			if len(chain) > 0 && position != expectedPosition {
+				return nil, nil, fmt.Errorf("%s sequence_position %d; expected %d", filepath.Base(dir), position, expectedPosition)
+			}
+			if parent == "" && position != 1 {
+				return nil, nil, fmt.Errorf("%s sequence_position %d has no sequence_parent; only position 1 may end the chain", filepath.Base(dir), position)
+			}
+			if parent != "" && position == 1 {
+				return nil, nil, fmt.Errorf("%s sequence_position 1 must not have a sequence_parent", filepath.Base(dir))
+			}
+			expectedPosition = position - 1
+		}
 		if parent == "" {
 			break
 		}
 		if len(chain) == maxSequenceChain {
-			return nil, nil, fmt.Errorf("sequence chain longer than %d; pass an explicit ordered predecessor list", maxSequenceChain)
+			return nil, nil, fmt.Errorf("sequence chain longer than %d", maxSequenceChain)
 		}
 		if _, dup := visited[parent]; dup {
 			return nil, nil, fmt.Errorf("sequence_parent cycle at %q", parent)
@@ -201,7 +251,7 @@ func walkSequenceChain(root, slug, workspace string) ([]string, [][]candidateRow
 		chain = append(chain, parent)
 		manifests = append(manifests, rows)
 	}
-	if len(chain) == 0 {
+	if len(chain) == 0 && !numbered {
 		return nil, nil, fmt.Errorf("%s has no sequence_parent; pass an explicit ordered predecessor list", slug)
 	}
 	for i, j := 0, len(chain)-1; i < j; i, j = i+1, j-1 {
@@ -211,19 +261,6 @@ func walkSequenceChain(root, slug, workspace string) ([]string, [][]candidateRow
 	return chain, manifests, nil
 }
 
-func sequenceParent(root, slug string) string {
-	dir, err := devritespaths.ExistingFeatureDirChecked(root, slug)
-	if err != nil {
-		return ""
-	}
-	raw, err := readBoundedRegularFile(filepath.Join(dir, "state.md"), maxCandidateManifestBytes)
-	if err != nil {
-		return ""
-	}
-	parent, _ := state.CursorField(strings.Split(string(raw), "\n"), state.CursorSequenceParent)
-	return parent
-}
-
 // VerifyReleaseUnion enforces the release-milestone contract at the candidate
 // and seal gates: a workspace whose cursor declares `sequence_role: release`
 // must carry a candidate manifest covering every predecessor in its recorded

package/engine/internal/lib/next.go

@@ -16,11 +16,11 @@ import (
 	"github.com/devrites/devrites/internal/workflow"
 )
 
-// RunNext prints the minimal remaining lifecycle path: the first phase whose
-// required artifacts are not all present, plus advisory skips for phases whose
-// remaining work is vacuous (e.g. clarify with zero open questions). Advisory
-// only — the rite still owns the decision to advance — except the root-edit
-// tripwire, which exits 3 while an unattributed product edit is in the tree.
+// RunNext prints the minimal remaining lifecycle path using artifact presence
+// where it proves completion, retaining phases that add no required artifact.
+// Advisory only — the rite still owns the decision to advance — except the
+// root-edit tripwire, which exits 3 while an unattributed product edit is in the
+// tree. Observation never records lifecycle metrics.
 func RunNext(root string, args []string, stdout, stderr io.Writer) int {
 	slug, code, err := ActiveSlug(root, args)
 	if err != nil {
@@ -55,6 +55,7 @@ func RunNext(root string, args []string, stdout, stderr io.Writer) int {
 		return 2
 	}
 
+	fmt.Fprintf(stdout, "source: %s\n", slug)
 	fmt.Fprintf(stdout, "current: %s\n", report.Phase)
 	if report.Complete() {
 		fmt.Fprintln(stdout, "current-status: complete")
@@ -69,7 +70,6 @@ func RunNext(root string, args []string, stdout, stderr io.Writer) int {
 		fmt.Fprintf(stdout, "blocked: tree baseline: %v\n", err)
 		exit = 3
 	} else if len(flagged) > 0 {
-		recordUnattributed(root, slug, string(report.Phase), flagged)
 		fmt.Fprintf(stdout, "blocked: %s\n", unattributedMessage(slug, flagged))
 		exit = 3
 	}
@@ -94,7 +94,7 @@ func RunNext(root string, args []string, stdout, stderr io.Writer) int {
 		}
 		var missing []string
 		if i == currentIdx {
-			if report.Complete() {
+			if report.Complete() && (currentIdx == 0 || addsArtifact(policies[currentIdx-1], policy) || policy.Target == state.PhaseConverge) {
 				continue
 			}
 			missing = report.MissingFiles
@@ -114,7 +114,7 @@ func RunNext(root string, args []string, stdout, stderr io.Writer) int {
 			}
 		}
 		fmt.Fprintf(stdout, "next-phase: %s\n", policy.Target)
-		fmt.Fprintf(stdout, "next-command: %s\n", renderNextCommand(policy))
+		fmt.Fprintf(stdout, "next-command: %s\n", renderNextCommand(policy, slug))
 		if policy.BlocksOpenQuestions && openQuestions > 0 && policy.Target != state.PhaseClarify {
 			fmt.Fprintf(stdout, "blocked: %d open question(s) gate this phase\n", openQuestions)
 		}
@@ -153,12 +153,12 @@ func printPlanBatch(stdout io.Writer, root, slug string) {
 	fmt.Fprintf(stdout, "select-command: %s\n", planSelectCommand(filepath.Dir(root), slug, capN))
 }
 
-func renderNextCommand(policy state.PhasePolicy) string {
+func renderNextCommand(policy state.PhasePolicy, slug string) string {
 	verb := policy.ResumeVerb
 	if verb == "" {
 		return "(no resume command)"
 	}
-	return workflow.ForVerb(verb).Claude
+	return workflow.ForVerb(verb).SourceInvocation(slug)
 }
 
 func printSkips(stdout io.Writer, skips []string) {

package/engine/internal/lib/packet.go

@@ -1,6 +1,7 @@
 package lib
 
 import (
+	"crypto/sha256"
 	"errors"
 	"fmt"
 	"io"
@@ -25,11 +26,14 @@ check, and each --checks gates.md gate's CHECK, which must be an approved
 test-plan.md Build-entry preflight row; a native-worktree pilot keeps its own
 contract. A reviewer
 role (*-reviewer, *-auditor, test-analyst) writes packets/<w>.<role>.md with
-its Outcome/Counts return head. Read first names the role's context bundle
-(run context first; --recheck names the build --recheck bundle) and
-packets/<w>.diff when candidate freeze wrote one; Candidate copies
-packets/<w>.sha256 verbatim, or only its header rows when the per-file rows
-would overflow the packet (required at review and seal). --focus (relative
+its Outcome/Counts return head. Read first names an immutable wave/role copy
+of the role's context bundle, bound by its actual SHA256 in the packet
+(run context first; --recheck copies the build --recheck bundle), and
+packets/<w>.diff when candidate freeze wrote one. The context path names the
+selected workspace, including authorized overrides outside the project.
+Candidate copies packets/<w>.sha256 verbatim, or only its header rows when the per-file rows
+would overflow the packet (required at review and seal). A wave/role cannot
+be re-rendered with a different context read-set. --focus (relative
 to the workspace) holds one "- <ID> <path:line> <text>" row per line, text up
 to 240 characters, and any other non-blank line is refused: open findings
 for a reviewer, defects and quoted carry-forward constraints for a wright,
@@ -108,13 +112,22 @@ func renderPacketLocked(root, slug, workspace, wave, phase, role, slice, checks,
 	}
 	rel := workspaceRel(root, workspace)
 	bundle := "ctx/" + bundleName(contextOpts{phase: phase, role: role, slice: slice, recheck: recheck})
-	if info, err := os.Stat(filepath.Join(workspace, filepath.FromSlash(bundle))); err != nil || !info.Mode().IsRegular() {
+	context, err := (&contextSources{dir: workspace}).read(bundle)
+	if errors.Is(err, os.ErrNotExist) {
 		scope := recheck
 		if slice != "" {
 			scope = " --slice " + slice + recheck
 		}
 		return fail(fmt.Errorf("%s/%s is missing; run devrites-engine context %s --phase %s --role %s%s first", rel, bundle, slug, phase, role, scope))
 	}
+	if err != nil {
+		return fail(err)
+	}
+	if len(context) == 0 {
+		return fail(fmt.Errorf("%s/%s is empty; run context first", rel, bundle))
+	}
+	contextName := wave + "." + role + ".context.bundle.md"
+	contextPath := rel + "/packets/" + contextName
 	candidate, partial, err := frozenCandidate(workspace, wave)
 	if err != nil {
 		return fail(err)
@@ -135,10 +148,11 @@ func renderPacketLocked(root, slug, workspace, wave, phase, role, slice, checks,
 	} else {
 		b.WriteString("Authority: read-only reviewer. Edit nothing and ask the user nothing; judge the candidate against the bundle sources.\n")
 	}
-	fmt.Fprintf(&b, "\nRead first:\n- %s/%s\n", rel, bundle)
+	fmt.Fprintf(&b, "\nRead first:\n- %s\n", contextPath)
 	if candidate != "" {
 		fmt.Fprintf(&b, "- %s/packets/%s.diff\n", rel, wave)
 	}
+	fmt.Fprintf(&b, "\nContext binding:\ncontext %x %s\n", sha256.Sum256(context), contextPath)
 	if wright {
 		raw, err := readWorkspaceArtifact(root, slug, "tasks.md")
 		if err != nil {
@@ -199,7 +213,14 @@ func renderPacketLocked(root, slug, workspace, wave, phase, role, slice, checks,
 		name = wave + ".contract.md"
 	}
 	out := filepath.Join(workspace, "packets", name)
-	if err := os.MkdirAll(filepath.Dir(out), 0o755); err != nil {
+	if prior, err := readBoundedRegularFile(out, maxContractBytes); err == nil {
+		if err := lintPacketContexts(root, slug, prior); err != nil {
+			return fail(fmt.Errorf("existing packet context: %w", err))
+		}
+	} else if !errors.Is(err, os.ErrNotExist) {
+		return fail(err)
+	}
+	if err := retainPacketContext(workspace, contextName, context); err != nil {
 		return fail(err)
 	}
 	// Lint a sibling draft so a refused re-render keeps the packet already on disk.
@@ -231,6 +252,9 @@ func renderPacketLocked(root, slug, workspace, wave, phase, role, slice, checks,
 // contract also gets the gates.md `RUN: writer` precheck lint.
 func lintRenderedPacket(root, slug, path, role string, wright, finalPhase bool) error {
 	if wright {
+		if err := lintPacketDiffs(root, slug, path, false); err != nil {
+			return err
+		}
 		return lintWrightContractFor(root, slug, path)
 	}
 	if err := lintReviewerWavePacket(path, []string{role}); err != nil {

package/engine/internal/lib/packet_integrity.go

@@ -8,7 +8,10 @@ import (
 	"io"
 	"os"
 	"path/filepath"
+	"regexp"
 	"strings"
+
+	"github.com/devrites/devrites/internal/devritespaths"
 )
 
 // Binary patches can exceed the candidate's raw-byte bound; stream verification.
@@ -85,13 +88,21 @@ func verifyFrozenDiff(name, expected string) error {
 
 func resolvePacketDiff(root, slug, name string) (string, error) {
 	clean := filepath.Clean(filepath.FromSlash(name))
+	workspace, err := devritespaths.ExistingFeatureDirChecked(root, slug)
+	if err != nil {
+		return "", err
+	}
+	if rel, ok := strings.CutPrefix(name, workspaceRel(root, workspace)+"/"); ok && clean == filepath.FromSlash(name) {
+		name = rel
+		clean = filepath.Clean(filepath.FromSlash(name))
+	}
 	if clean == ".." || strings.HasPrefix(clean, ".."+string(filepath.Separator)) || clean != filepath.FromSlash(name) {
 		return "", fmt.Errorf("unsafe frozen candidate diff path %q", name)
 	}
-	dirs := []string{projectDir(root), featureDir(root, slug)}
+	dirs := []string{projectDir(root), workspace}
 	// Freeze's checksum rows use this workspace-relative namespace, never a product packets/ directory.
 	if strings.HasPrefix(name, "packets/") {
-		dirs = []string{featureDir(root, slug)}
+		dirs = []string{workspace}
 	}
 	if filepath.IsAbs(name) {
 		parent, err := filepath.EvalSymlinks(filepath.Dir(name))
@@ -120,12 +131,193 @@ func resolvePacketDiff(root, slug, name string) (string, error) {
 	return "", fmt.Errorf("frozen candidate diff %q does not exist", name)
 }
 
+var packetContextPathRE = regexp.MustCompile(`(?:[A-Za-z]:/)?[A-Za-z0-9_./@+-]+\.bundle\.md\b`)
+
+type packetContextRef struct {
+	dir  string
+	name string
+}
+
+// Preserve the leaf spelling below the workspace when an ancestor has an OS alias.
+func packetContextWorkspaceRelative(workspace, name string) (string, error) {
+	if rel, err := filepath.Rel(workspace, name); err == nil && filepath.IsLocal(rel) {
+		return rel, nil
+	}
+	selected, err := os.Stat(workspace)
+	if err != nil {
+		return "", err
+	}
+	for parent := filepath.Dir(name); ; parent = filepath.Dir(parent) {
+		info, err := os.Stat(parent)
+		if err != nil {
+			return "", err
+		}
+		if os.SameFile(selected, info) {
+			return filepath.Rel(parent, name)
+		}
+		if parent == filepath.Dir(parent) {
+			return "", nil
+		}
+	}
+}
+
+func resolvePacketContext(root, slug, name string) (packetContextRef, error) {
+	workspace, err := devritespaths.ExistingFeatureDirChecked(root, slug)
+	if err != nil {
+		return packetContextRef{}, err
+	}
+	workspace, err = filepath.Abs(workspace)
+	if err != nil {
+		return packetContextRef{}, err
+	}
+	clean := filepath.Clean(filepath.FromSlash(name))
+	if clean != filepath.FromSlash(name) {
+		return packetContextRef{}, fmt.Errorf("unsafe packet context path %q", name)
+	}
+	dirs := []string{projectDir(root), workspace}
+	// Only the selected workspace's exact namespace may contain leading "..".
+	if rel, ok := strings.CutPrefix(name, workspaceRel(root, workspace)+"/"); ok {
+		dirs, clean = []string{workspace}, filepath.FromSlash(rel)
+	} else if filepath.IsAbs(clean) {
+		rel, err := packetContextWorkspaceRelative(workspace, clean)
+		if err != nil {
+			return packetContextRef{}, err
+		}
+		if rel != "" {
+			dirs, clean = []string{workspace}, rel
+		} else {
+			// Absolute manual bundles remain supported, but not foreign workspaces.
+			physicalParent, err := filepath.EvalSymlinks(filepath.Dir(clean))
+			if err != nil {
+				return packetContextRef{}, err
+			}
+			physical := filepath.Join(physicalParent, filepath.Base(clean))
+			for _, work := range []string{filepath.Dir(workspace), filepath.Join(root, "work")} {
+				absoluteWork, err := filepath.Abs(work)
+				if err != nil {
+					return packetContextRef{}, err
+				}
+				absoluteWork, err = filepath.EvalSymlinks(absoluteWork)
+				if err != nil {
+					return packetContextRef{}, err
+				}
+				if rel, err := filepath.Rel(absoluteWork, physical); err == nil && filepath.IsLocal(rel) {
+					return packetContextRef{}, fmt.Errorf("foreign packet context path %q", name)
+				}
+			}
+			dirs, clean = []string{filepath.Dir(clean)}, filepath.Base(clean)
+		}
+	} else if strings.HasPrefix(name, "ctx/") || strings.HasPrefix(name, "packets/") {
+		dirs = []string{workspace}
+	} else {
+		work := filepath.ToSlash(workspaceRel(root, filepath.Dir(workspace))) + "/"
+		if strings.HasPrefix(name, work) {
+			return packetContextRef{}, fmt.Errorf("foreign packet context path %q", name)
+		}
+	}
+	if !filepath.IsLocal(clean) {
+		return packetContextRef{}, fmt.Errorf("unsafe packet context path %q", name)
+	}
+	for _, dir := range dirs {
+		if err := contextParents(dir, clean); err != nil {
+			return packetContextRef{}, err
+		}
+		ws, err := os.OpenRoot(dir)
+		if err != nil {
+			return packetContextRef{}, err
+		}
+		info, err := ws.Lstat(clean)
+		closeErr := ws.Close()
+		if err != nil && !errors.Is(err, os.ErrNotExist) {
+			return packetContextRef{}, err
+		}
+		if closeErr != nil {
+			return packetContextRef{}, closeErr
+		}
+		if errors.Is(err, os.ErrNotExist) {
+			continue
+		}
+		if !info.Mode().IsRegular() {
+			return packetContextRef{}, errors.New("packet context is not a regular file")
+		}
+		absoluteDir, err := filepath.Abs(dir)
+		if err != nil {
+			return packetContextRef{}, err
+		}
+		return packetContextRef{dir: absoluteDir, name: clean}, nil
+	}
+	return packetContextRef{}, fmt.Errorf("packet context %q does not exist", name)
+}
+
+func lintPacketContexts(root, slug string, raw []byte) error {
+	bound := make(map[string]string)
+	var names []string
+	for _, line := range strings.Split(string(raw), "\n") {
+		fields := strings.Fields(line)
+		if len(fields) > 0 && fields[0] == "context" {
+			if len(fields) < 3 || len(fields[1]) != sha256.Size*2 {
+				return errors.New("malformed context checksum; use context <SHA256> <path.bundle.md>")
+			}
+			if _, err := hex.DecodeString(fields[1]); err != nil {
+				return errors.New("malformed context SHA256 checksum")
+			}
+			entry := strings.TrimSpace(strings.TrimPrefix(strings.TrimSpace(line), "context"))
+			name := strings.TrimSpace(entry[len(fields[1]):])
+			ref, err := resolvePacketContext(root, slug, name)
+			if err != nil {
+				return err
+			}
+			path := filepath.Join(ref.dir, ref.name)
+			digest := strings.ToLower(fields[1])
+			if prior, ok := bound[path]; ok && prior != digest {
+				return fmt.Errorf("conflicting context checksums for %s", name)
+			}
+			body, err := readContextArtifact(ref.dir, ref.name)
+			if err != nil {
+				return fmt.Errorf("packet context %s: %w", name, err)
+			}
+			if len(body) == 0 || fmt.Sprintf("%x", sha256.Sum256(body)) != digest {
+				return fmt.Errorf("packet context %s SHA256 mismatch; render the intended read-set under a new wave", name)
+			}
+			bound[path] = digest
+			continue
+		}
+		if len(fields) >= 3 && fields[0] == "file" {
+			if fields[1] == "absent" {
+				continue
+			}
+			if digest, err := hex.DecodeString(fields[1]); err == nil && len(digest) == sha256.Size {
+				continue
+			}
+		}
+		if name, ok := strings.CutPrefix(strings.TrimSpace(line), "- "); ok && strings.HasSuffix(name, ".bundle.md") {
+			names = append(names, name)
+			continue
+		}
+		names = append(names, packetContextPathRE.FindAllString(line, -1)...)
+	}
+	for _, name := range names {
+		ref, err := resolvePacketContext(root, slug, name)
+		if err != nil {
+			return err
+		}
+		path := filepath.Join(ref.dir, ref.name)
+		if _, ok := bound[path]; !ok {
+			return fmt.Errorf("unbound packet context %s; add context <SHA256> %s to the packet", name, name)
+		}
+	}
+	return nil
+}
+
 // Caller may already hold the feature lock (dispatch); never acquire it here.
 func lintPacketDiffs(root, slug, packet string, required bool) error {
 	raw, err := readBoundedRegularFile(packet, maxContractBytes)
 	if err != nil {
 		return fmt.Errorf("reviewer packet %s: %w", packet, err)
 	}
+	if err := lintPacketContexts(root, slug, raw); err != nil {
+		return err
+	}
 	bindings, err := frozenDiffBindings(raw)
 	if err != nil {
 		return err