devrites 6.1.2 → 6.1.3

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`.
 
+## [6.1.3](https://github.com/ViktorsBaikers/DevRites/compare/v6.1.2...v6.1.3) (2026-10-16)
+
+### Changed
+
+* **devrites:** apply plan bundles in the engine and overlap phase work ([#109](https://github.com/ViktorsBaikers/DevRites/issues/109)) ([4394b0a](https://github.com/ViktorsBaikers/DevRites/commit/4394b0af21677da279be0ca5c359af728e482fd9))
+
 ## [6.1.2](https://github.com/ViktorsBaikers/DevRites/compare/v6.1.1...v6.1.2) (2026-10-16)
 
 ### Fixed

package/README.md

@@ -31,7 +31,7 @@ history can't lose it. After you clear the conversation, switch hosts, or hand
 the feature to another engineer, the next session reads the same plan,
 decisions, and evidence before it continues.
 
-**Status:** [`v6.1.2`](https://github.com/ViktorsBaikers/DevRites/releases/tag/v6.1.2): see [`CHANGELOG.md`](CHANGELOG.md) for release notes.
+**Status:** [`v6.1.3`](https://github.com/ViktorsBaikers/DevRites/releases/tag/v6.1.3): see [`CHANGELOG.md`](CHANGELOG.md) for release notes.
 
 This is the latest published release; `main` may contain unreleased work.
 

package/docs/command-map.md

@@ -44,7 +44,7 @@ The Go surface is intentionally closed and deterministic:
 | Candidate and deterministic checks | `check candidate`, `check readiness [--emit-binding]`, `check seal`, `check slice <slug> <SLICE-ID>`, `check task-graph`, `check regression <slug> [--update]`, `check drift <slug> [--record]`, `check windows <slug>`, `check dup`, `check path-disjoint`, `parallel select`, `check skill-trust`, `check indexes`, `detect commands [--root <dir>] [--json]` | Candidate validates/hashes the strict project manifest; readiness checks phase files, the required `tasks.md` slice graph, or emits the vetted Build-input binding; seal checks final files/open gates, that graph and binding, then exact candidate bindings. `check slice` preflights one slice before wright dispatch — contract present, exact Writer allowlist paths, `Satisfies` AC ids resolvable, bounded scope — so a malformed slice fails before a writer context is spent. `check indexes` reports install manifest and optional code-index directory presence as JSON. `parallel select` returns the greedy path-disjoint subset ≤ cap from the supplied ready slices. `check regression` compares current workspace progress against the durable `regression-baseline.json` high-water mark and `--update` ratchets it at a checkpoint, so a lost slice, unchecked criterion, or reopened question fails closed instead of passing silently. `check windows` scans the feature diff for newly introduced deferral markers (TODO/FIXME/skipped test/stub idioms) and fails when any lacks a `windows.md` waiver row — silent deferrals block the seal. `check dup` reports advisory near-duplicate clusters that survive renaming (normalized token shingles, transitive clusters, distance-boosted rank, `*`-marked diff overlap, stable content hashes, `.devrites/dup-ignore` dismissal ledger) — leads for reviewer triage, never a gate. `check drift` attributes readiness-input drift to the exact artifact: `--record` snapshots per-input SHA-256 digests into `readiness-inputs.json` under the feature lock, and a later compare names each `changed`/`missing`/`added` input (falling back to the aggregate `eng-review.md` binding plus mtime candidates when no baseline exists) so a stale-binding repair starts at the right file — advisory, never a gate. `detect commands` resolves the repository's own test/lint/vet/build commands (Makefile targets, then `package.json` scripts, then language-manifest fallbacks, plus the lockfile-derived package manager) so `gates.md` `CHECK` lines and proof steps cite real wiring instead of invented commands — read-only, no installs, no execution. |
 | Workspace observation | `observe summary`, `orient`, `observe slice <slug> <SLICE-ID>`, `next`, `handoff` | JSON workspace snapshot for agents (cursor, task graph, `artifact_budgets`, `bulk_files`); `orient` is an alias for `observe summary`. `observe slice` prints one `SLICE-###` section of `tasks.md` so Build reads a slice, not the file. `next` prints the minimal remaining lifecycle path plus advisory skips (e.g. clarify at zero open questions). `handoff` emits the deterministic resume record (cursor, `awaiting_human`, blocking question gates, ledger reduction with unmet/stale ids, dead ends, read-next order) — the `/rite-handoff` spine and compaction-fallback entry. |
 | Context packets, dispatch waves, metrics, claims, notes | `context [slug] (--phase <p> \| --skill <name>) [--role <r>] [--trigger a,b]`, `dispatch <slug> <open\|start\|seal\|return\|status\|abandon>`, `metrics record`, `metrics summary`, `claim <add\|release\|list\|check>`, `note <add\|list\|check\|rm>` | `context` emits one deduplicated read-set bundle per phase/role/skill from each skill's `loads:` manifest — a dispatch target reads it instead of selecting files; `--skill` works without a workspace when `--out` is given. `dispatch` owns the launch-wave barrier (seal needs a handle per role; return needs seal) and auto-records dispatch/return metrics. `metrics` owns the append-only `metrics.jsonl` ledger. `claim` owns the append-only `.devrites/claims.jsonl` ledger — advisory, session-scoped file claims with TTL so concurrent same-tree sessions see each other's write intent before edits collide (conflict exits 3; never a substitute for one-writer-per-worktree). `note` owns the anchored `notes.md` ledger — notes bound to verbatim code quotes, regraded `exact`/`moved`/`stale`/`ambiguous`/`lost` as the code drifts; `check seal` refuses non-`exact` anchors. `check diff-scope` is the mechanical changed-paths ⊆ allowlist gate run before reviewer dispatch. |
-| Atomic workspace state | `state resolve`, `state merge-manifest`, `state close`, `migrate [--dry-run] [--answer id=choice]` | Go owns answer/drop/batch resolution, the recorded predecessor-chain manifest union for a release milestone, transactional close, and fail-closed v5 schema normalization. |
+| Atomic workspace state | `state resolve`, `state merge-manifest`, `state apply-bundle <slug> <bundle.json>... [--dry-run]`, `state close`, `migrate [--dry-run] [--answer id=choice]` | Go owns answer/drop/batch resolution, the recorded predecessor-chain manifest union for a release milestone, the all-or-nothing apply of plan-drafter hunk bundles (base-hash pins, unique non-overlapping anchors, no lost IDs, no new task-graph or budget defect, no appended dated delta section), transactional close, and fail-closed v5 schema normalization. |
 | Acceptance ledger | `gates scaffold`, `gates status`, `gates run [--timeout N]`, `gates reverify [--timeout N]`, `gates lint [--strict]`, `gates attest <id> <note>`, `gates abandon <id> <why>` | Go owns the `gates.md` ledger: per-outcome gates whose runnable `CHECK`/`CWD` must exactly match a `test-plan.md` Build-entry preflight row, evidence bound to the gate definition digest (stale = unmet), `ABANDON:` handoffs, and oracle lint. Readiness/seal require a parse-clean, all-met ledger whenever `gates.md` is a required artifact. |
 | Security | `secret-scan` | `/rite-ship`, safe hooks, or an operator scans staged blobs, stdin, or touched files. |
 | Install/operator | `install`, `update`, `uninstall`, `version` | Direct update acquires latest; npm/bootstrap may supply local candidates; the engine performs manifest-owned local changes. |

package/engine/commands.go

@@ -34,7 +34,7 @@ func rootModeFor(command string, args []string) rootMode {
 		return rootLenient
 	case "state":
 		switch subcommand {
-		case "resolve", "merge-manifest", "close":
+		case "resolve", "merge-manifest", "apply-bundle", "close":
 			return rootStrict
 		}
 		return rootUnused

package/engine/help.go

@@ -30,7 +30,7 @@ const (
   check dup [slug] [--all|--worktree|--staged|--base <ref>]
 `
 
-	stateUsage = `usage: devrites-engine state <resolve|merge-manifest|close> ...
+	stateUsage = `usage: devrites-engine state <resolve|merge-manifest|apply-bundle|close> ...
 
   state resolve <qid> "<answer>"
   state resolve --drop <qid> ["<reason>"]
@@ -39,6 +39,7 @@ const (
   state resolve --human --drop <qid> ["<reason>"]
   state resolve --human --batch <file>
   state merge-manifest <slug> [<predecessor>...]
+  state apply-bundle <slug> <bundle.json>... [--dry-run]
   state close <slug>
 `
 
@@ -86,6 +87,7 @@ const (
 	dupUsageLine        = "usage: devrites-engine check dup [slug] [--all|--worktree|--staged|--base <ref>] [--min-lines n] [--threshold f] [--ignore-file <path>] [--limit n] [--exclude <csv>] [--phase p] [--cwd <dir>]"
 	resolveUsage        = `usage: devrites-engine state resolve <qid> "<answer>"  |  state resolve --drop <qid> ["<reason>"]  |  state resolve --batch <file>  |  state resolve --human <qid> "<answer>"  |  state resolve --human --drop <qid> ["<reason>"]  |  state resolve --human --batch <file>`
 	mergeManifestUsage  = "usage: devrites-engine state merge-manifest <slug> [<predecessor>...]"
+	applyBundleUsage    = "usage: devrites-engine state apply-bundle <slug> <bundle.json>... [--dry-run]"
 	closeUsage          = "usage: devrites-engine state close <slug>"
 	observeSliceUsage   = "usage: devrites-engine observe slice <slug> <SLICE-ID>"
 	observeSummaryUsage = "usage: devrites-engine observe summary [slug]"
@@ -286,6 +288,8 @@ func helpState(rest []string) string {
 		return resolveUsage
 	case "merge-manifest":
 		return mergeManifestUsage
+	case "apply-bundle":
+		return applyBundleUsage
 	case "close":
 		return closeUsage
 	default:

package/engine/internal/acceptance/cli.go

@@ -248,9 +248,19 @@ func cmdRun(root string, args []string, reverify bool, stdout, stderr io.Writer)
 		return ExitBlocked
 	}
 
-	lockErr := state.WithFeatureLock(root, slug, func() error {
-		text, err := ReadLedgerFile(ledgerPath)
-		if err != nil {
+	// The gates lock serializes check execution; the feature lock is held only
+	// to read inputs and per writeback, so dispatch and other workspace writers
+	// are not blocked for the whole (often minutes-long) run.
+	featureLock := func(fn func() error) error { return state.WithFeatureLock(root, slug, fn) }
+	lockErr := state.WithLock(ledgerPath+".lock", func() error {
+		var text string
+		var approved []ApprovedCommand
+		if err := featureLock(func() error {
+			var err error
+			text, err = ReadLedgerFile(ledgerPath)
+			approved = loadTestPlan(testPlanPath)
+			return err
+		}); err != nil {
 			return err
 		}
 		doc := ParseLedger(text)
@@ -260,8 +270,7 @@ func cmdRun(root string, args []string, reverify bool, stdout, stderr io.Writer)
 			}
 			return nil
 		}
-		approved := loadTestPlan(testPlanPath)
-		for _, result := range RunGates(context.Background(), project, ledgerPath, doc, approved, reverify, timeout) {
+		for _, result := range RunGates(context.Background(), project, ledgerPath, doc, approved, reverify, timeout, featureLock) {
 			switch {
 			case !result.Ran:
 				fmt.Fprintf(stdout, "gate %s: skipped (%s)\n", result.ID, result.Detail)

package/engine/internal/acceptance/run.go

@@ -65,9 +65,19 @@ func ReadLedgerFile(ledgerPath string) (string, error) {
 // Each pass writes definition-bound evidence; each failure clears the box and
 // restores EVIDENCE: pending.
 //
-// The caller holds the feature lock across this call.
-func RunGates(ctx context.Context, root, ledgerPath string, doc *Document, approved []ApprovedCommand, reverify bool, timeout time.Duration) []GateResult {
+// Gates sharing one CHECK and CWD execute once per call; each matches its own
+// EXPECT against that shared output. writeLock, when non-nil, wraps every
+// ledger writeback so the caller need not hold the feature lock while checks
+// execute; writeResult re-verifies the gate's oracle before it writes.
+func RunGates(ctx context.Context, root, ledgerPath string, doc *Document, approved []ApprovedCommand, reverify bool, timeout time.Duration, writeLock func(func() error) error) []GateResult {
 	var results []GateResult
+	outcomes := map[string]RunOutcome{}
+	write := func(gate *Gate, evidence string, checked bool) error {
+		if writeLock == nil {
+			return writeResult(ledgerPath, gate, evidence, checked)
+		}
+		return writeLock(func() error { return writeResult(ledgerPath, gate, evidence, checked) })
+	}
 	for _, gate := range doc.Gates {
 		if _, abandoned := doc.Abandoned[gate.ID]; abandoned {
 			results = append(results, GateResult{ID: gate.ID, Detail: "abandoned; handoff required"})
@@ -94,17 +104,22 @@ func RunGates(ctx context.Context, root, ledgerPath string, doc *Document, appro
 		if gate.Cwd != "" {
 			cwd = filepath.Join(root, filepath.FromSlash(gate.Cwd))
 		}
-		outcome := Execute(ctx, gate.Check, cwd, timeout)
+		key := gate.Check + "\x00" + cwd
+		outcome, ran := outcomes[key]
+		if !ran {
+			outcome = Execute(ctx, gate.Check, cwd, timeout)
+			outcomes[key] = outcome
+		}
 		if outcome.Err == nil && outcome.ExitCode == 0 && expectation.Matches(outcome.Output) {
 			evidence := FormatEvidence(gate, OutputDigest(outcome.Output), outcome.OutputBytes, time.Now().UTC().Format(time.RFC3339))
-			writeErr := writeResult(ledgerPath, gate, evidence, true)
+			writeErr := write(gate, evidence, true)
 			results = append(results, GateResult{
 				ID: gate.ID, Ran: true, Passed: true,
 				Discarded: errors.Is(writeErr, ErrOracleMoved), WriteErr: writeErr,
 				Detail: resultDetail(writeErr, "pass"),
 			})
 		} else {
-			writeErr := writeResult(ledgerPath, gate, "pending", false)
+			writeErr := write(gate, "pending", false)
 			results = append(results, GateResult{
 				ID: gate.ID, Ran: true,
 				Discarded: errors.Is(writeErr, ErrOracleMoved), WriteErr: writeErr,

package/engine/internal/lib/apply_bundle.go

@@ -0,0 +1,474 @@
+package lib
+
+import (
+	"crypto/sha256"
+	"encoding/hex"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"io/fs"
+	"os"
+	"path/filepath"
+	"regexp"
+	"slices"
+	"sort"
+	"strings"
+
+	"github.com/devrites/devrites/internal/devritespaths"
+	"github.com/devrites/devrites/internal/fsutil"
+	"github.com/devrites/devrites/internal/state"
+)
+
+// maxBundleBytes bounds one drafter bundle read. A bundle carries hunks for a
+// handful of planning artifacts, each capped at state.MaxArtifactBytes.
+const maxBundleBytes = 8 << 20
+
+// trackedIDRE matches the workspace ID families whose silent disappearance is
+// a planning defect: an AC, slice, or horizon item never vanishes unrecorded.
+var trackedIDRE = regexp.MustCompile(`\b(?:AC|REQ|HZN|SLICE|PF|INV|DEC|PROH|EDGE|DRIFT|ASM|Q|EVID)-\d+(?:-[A-Z][A-Z0-9]*)*\b`)
+
+// datedHeadingRE finds a dated section heading. In the current-state planning
+// artifacts it marks an appended repair delta that leaves the superseded clause
+// beside its replacement, growing the file and the next review's surface.
+var datedHeadingRE = regexp.MustCompile(`(?m)^#{2,4}\s.*\b\d{4}-\d{2}-\d{2}\b`)
+
+var currentStatePlanning = map[string]bool{
+	"architecture.md": true, "plan.md": true, "tasks.md": true, "test-plan.md": true, "traceability.md": true,
+}
+
+// candidateBundle is the plan-drafter's candidate_files result. Unknown fields
+// (acceptance_map, technical_decisions, ...) are the root's to reconcile and
+// are ignored here.
+type candidateBundle struct {
+	BaseHashes     map[string]string `json:"base_hashes"`
+	CandidateFiles []candidateFile   `json:"candidate_files"`
+	RetiredIDs     []string          `json:"retired_ids"`
+}
+
+type candidateFile struct {
+	Path      string          `json:"path"`
+	Operation string          `json:"operation"`
+	Content   *string         `json:"content"`
+	Hunks     []candidateHunk `json:"hunks"`
+}
+
+type candidateHunk struct {
+	ID      string `json:"id"`
+	OldText string `json:"old_text"`
+	NewText string `json:"new_text"`
+}
+
+// bundleTarget is every requested change to one workspace file, merged across
+// bundles so anchor-disjoint drafter clusters apply against one shared base.
+type bundleTarget struct {
+	rel      string
+	op       string // create | replace | patch
+	content  string
+	hunks    []candidateHunk
+	pins     []string // base hashes named by each bundle that touches rel
+	before   []byte
+	existed  bool
+	after    []byte
+	hunkSeen int
+}
+
+// RunApplyBundle implements `devrites-engine state apply-bundle <slug>
+// <bundle.json>... [--dry-run]`. It replaces the root's hand fold of drafter
+// hunks: every bundle is validated against the current bytes (base hash pin,
+// unique non-overlapping old_text, no lost tracked ID, no new task-graph
+// problem, no new material budget overshoot) and then all files are written,
+// or none are. Several bundles combine when their hunks are disjoint.
+//
+// Exit codes:
+//
+//	0  applied (or dry-run clean)
+//	2  usage error
+//	3  blocked: a bundle failed validation; nothing was written
+//	1  internal/IO error
+func RunApplyBundle(root string, args []string, stdout, stderr io.Writer) int {
+	dryRun := false
+	var positional []string
+	for _, arg := range args {
+		if arg == "--dry-run" {
+			dryRun = true
+			continue
+		}
+		if strings.HasPrefix(arg, "-") {
+			fmt.Fprintln(stderr, "usage: devrites-engine state apply-bundle <slug> <bundle.json>... [--dry-run]")
+			return 2
+		}
+		positional = append(positional, arg)
+	}
+	if len(positional) < 2 {
+		fmt.Fprintln(stderr, "usage: devrites-engine state apply-bundle <slug> <bundle.json>... [--dry-run]")
+		return 2
+	}
+	slug := positional[0]
+	workspace, err := devritespaths.ExistingFeatureDirChecked(root, slug)
+	if err != nil {
+		fmt.Fprintf(stderr, "apply-bundle: BLOCKED: workspace for %s: %v\n", slug, err)
+		return 3
+	}
+	if err := state.RequireWorkspaceSchema(root, slug); err != nil {
+		fmt.Fprintf(stderr, "apply-bundle: BLOCKED: %v\n", err)
+		return 3
+	}
+	bundles := make([]candidateBundle, 0, len(positional)-1)
+	for _, name := range positional[1:] {
+		bundle, err := readCandidateBundle(name)
+		if err != nil {
+			fmt.Fprintf(stderr, "apply-bundle: BLOCKED: bundle %s: %v\n", name, err)
+			return 3
+		}
+		bundles = append(bundles, bundle)
+	}
+
+	code := 0
+	if err := state.WithFeatureLock(root, slug, func() error {
+		code = applyBundlesLocked(slug, workspace, bundles, dryRun, stdout, stderr)
+		return nil
+	}); err != nil {
+		fmt.Fprintf(stderr, "apply-bundle: %v\n", err)
+		return 1
+	}
+	return code
+}
+
+func readCandidateBundle(name string) (candidateBundle, error) {
+	var bundle candidateBundle
+	raw, err := readBoundedRegularFile(name, maxBundleBytes)
+	if err != nil {
+		return bundle, err
+	}
+	if err := json.Unmarshal(raw, &bundle); err != nil {
+		return bundle, fmt.Errorf("not a JSON candidate bundle: %w", err)
+	}
+	if len(bundle.CandidateFiles) == 0 {
+		return bundle, errors.New("candidate_files is empty")
+	}
+	return bundle, nil
+}
+
+func applyBundlesLocked(slug, workspace string, bundles []candidateBundle, dryRun bool, stdout, stderr io.Writer) int {
+	ws, err := os.OpenRoot(workspace)
+	if err != nil {
+		fmt.Fprintf(stderr, "apply-bundle: %v\n", err)
+		return 1
+	}
+	defer func() { _ = ws.Close() }()
+
+	targets, retired, problems := collectBundleTargets(slug, bundles)
+	if len(problems) == 0 {
+		problems = materializeTargets(ws, targets)
+	}
+	if len(problems) == 0 {
+		problems = checkBundleResult(targets, retired)
+	}
+	if len(problems) > 0 {
+		for _, problem := range problems {
+			fmt.Fprintf(stderr, "apply-bundle: BLOCKED: %s\n", problem)
+		}
+		fmt.Fprintln(stderr, "apply-bundle: nothing written")
+		return 3
+	}
+
+	hunks := 0
+	for _, target := range targets {
+		hunks += len(target.hunks)
+		lines := state.CountLines(target.after)
+		budget := ""
+		if limit, ok := state.ArtifactLineBudget(filepath.Base(target.rel)); ok {
+			budget = fmt.Sprintf("/%d", limit)
+		}
+		fmt.Fprintf(stdout, "apply-bundle: %s %s %d hunk(s) sha256 %s -> %s lines %d%s\n",
+			target.rel, target.op, len(target.hunks), shortHash(target.before, target.existed), shortHash(target.after, true), lines, budget)
+	}
+	if dryRun {
+		fmt.Fprintf(stdout, "apply-bundle: dry-run clean: %d file(s), %d hunk(s); nothing written\n", len(targets), hunks)
+		return 0
+	}
+	if err := writeBundleTargets(ws, targets); err != nil {
+		fmt.Fprintf(stderr, "apply-bundle: %v\n", err)
+		return 1
+	}
+	fmt.Fprintf(stdout, "apply-bundle: applied %d file(s), %d hunk(s)\n", len(targets), hunks)
+	return 0
+}
+
+// collectBundleTargets merges every bundle's candidate files by workspace path.
+// One path takes either one create/replace or any number of patch entries.
+func collectBundleTargets(slug string, bundles []candidateBundle) ([]*bundleTarget, map[string]bool, []string) {
+	var problems []string
+	byRel := map[string]*bundleTarget{}
+	retired := map[string]bool{}
+	prefix := ".devrites/work/" + slug + "/"
+	for bi, bundle := range bundles {
+		for _, id := range bundle.RetiredIDs {
+			retired[strings.TrimSpace(id)] = true
+		}
+		pins := map[string]string{}
+		for path, hash := range bundle.BaseHashes {
+			pins[strings.TrimPrefix(filepath.ToSlash(path), prefix)] = strings.ToLower(strings.TrimPrefix(strings.TrimSpace(hash), "sha256:"))
+		}
+		for _, file := range bundle.CandidateFiles {
+			rel := strings.TrimPrefix(filepath.ToSlash(file.Path), prefix)
+			where := fmt.Sprintf("bundle %d %s", bi+1, file.Path)
+			if !filepath.IsLocal(filepath.FromSlash(rel)) || !strings.HasSuffix(rel, ".md") {
+				problems = append(problems, where+": path must be a Markdown file inside the "+slug+" workspace")
+				continue
+			}
+			op := strings.ToLower(strings.TrimSpace(file.Operation))
+			switch op {
+			case "create", "replace":
+				if file.Content == nil {
+					problems = append(problems, where+": "+op+" needs content")
+					continue
+				}
+			case "patch":
+				if len(file.Hunks) == 0 {
+					problems = append(problems, where+": patch needs hunks")
+					continue
+				}
+			default:
+				problems = append(problems, fmt.Sprintf("%s: unknown operation %q", where, file.Operation))
+				continue
+			}
+			target, seen := byRel[rel]
+			if !seen {
+				target = &bundleTarget{rel: rel, op: op}
+				byRel[rel] = target
+			} else if op != "patch" || target.op != "patch" {
+				problems = append(problems, where+": conflicts with another candidate for the same file (only patch hunks combine)")
+				continue
+			}
+			if op != "create" {
+				pin, ok := pins[rel]
+				if !ok {
+					problems = append(problems, where+": base_hashes has no pin for this file")
+					continue
+				}
+				target.pins = append(target.pins, pin)
+			}
+			if file.Content != nil {
+				target.content = *file.Content
+			}
+			target.hunks = append(target.hunks, file.Hunks...)
+		}
+	}
+	targets := make([]*bundleTarget, 0, len(byRel))
+	for _, target := range byRel {
+		targets = append(targets, target)
+	}
+	sort.Slice(targets, func(i, j int) bool { return targets[i].rel < targets[j].rel })
+	return targets, retired, problems
+}
+
+// materializeTargets reads each file's current bytes, verifies its pins, and
+// computes the after bytes.
+func materializeTargets(ws *os.Root, targets []*bundleTarget) []string {
+	var problems []string
+	for _, target := range targets {
+		before, existed, err := readBundleFile(ws, target.rel)
+		if err != nil {
+			problems = append(problems, fmt.Sprintf("%s: %v", target.rel, err))
+			continue
+		}
+		target.before, target.existed = before, existed
+		if target.op == "create" {
+			if existed {
+				problems = append(problems, target.rel+": create target already exists")
+				continue
+			}
+			target.after = []byte(target.content)
+			continue
+		}
+		if !existed {
+			problems = append(problems, target.rel+": "+target.op+" target does not exist")
+			continue
+		}
+		current := sha256Hex(before)
+		for _, pin := range target.pins {
+			if pin != current {
+				problems = append(problems, fmt.Sprintf("%s: stale base: pinned %s, current %s", target.rel, abbrev(pin), abbrev(current)))
+				break
+			}
+		}
+		if target.op == "replace" {
+			target.after = []byte(target.content)
+			continue
+		}
+		after, hunkProblems := applyHunks(string(before), target.hunks)
+		for _, problem := range hunkProblems {
+			problems = append(problems, target.rel+": "+problem)
+		}
+		target.after = []byte(after)
+	}
+	return problems
+}
+
+// applyHunks replaces each hunk's old_text, which must occur exactly once in
+// base and must not overlap another hunk's span.
+func applyHunks(base string, hunks []candidateHunk) (string, []string) {
+	type span struct {
+		start, end int
+		hunk       candidateHunk
+	}
+	var problems []string
+	spans := make([]span, 0, len(hunks))
+	for i, hunk := range hunks {
+		name := hunk.ID
+		if name == "" {
+			name = fmt.Sprintf("#%d", i+1)
+		}
+		hunk.ID = name
+		if hunk.OldText == "" {
+			problems = append(problems, "hunk "+name+": empty old_text")
+			continue
+		}
+		start := strings.Index(base, hunk.OldText)
+		if start < 0 {
+			problems = append(problems, "hunk "+name+": old_text not found (stale anchor)")
+			continue
+		}
+		// Search from start+1 so an overlapping second occurrence also counts.
+		if strings.Contains(base[start+1:], hunk.OldText) {
+			problems = append(problems, "hunk "+name+": old_text occurs more than once (non-unique anchor)")
+			continue
+		}
+		spans = append(spans, span{start, start + len(hunk.OldText), hunk})
+	}
+	sort.Slice(spans, func(i, j int) bool { return spans[i].start < spans[j].start })
+	for i := 1; i < len(spans); i++ {
+		if spans[i].start < spans[i-1].end {
+			problems = append(problems, fmt.Sprintf("hunks %s and %s overlap", spans[i-1].hunk.ID, spans[i].hunk.ID))
+		}
+	}
+	if len(problems) > 0 {
+		return base, problems
+	}
+	var out strings.Builder
+	last := 0
+	for _, s := range spans {
+		out.WriteString(base[last:s.start])
+		out.WriteString(s.hunk.NewText)
+		last = s.end
+	}
+	out.WriteString(base[last:])
+	return out.String(), nil
+}
+
+// checkBundleResult rejects an outcome the root would otherwise discover only
+// at Vet: a tracked ID that vanished from every touched file without being
+// listed in retired_ids, a new tasks.md graph problem, or a budgeted artifact
+// that grew into material overshoot without a `Budget override:` line.
+func checkBundleResult(targets []*bundleTarget, retired map[string]bool) []string {
+	var problems []string
+	beforeIDs, afterIDs := map[string]bool{}, map[string]bool{}
+	for _, target := range targets {
+		for _, id := range trackedIDRE.FindAllString(string(target.before), -1) {
+			beforeIDs[id] = true
+		}
+		for _, id := range trackedIDRE.FindAllString(string(target.after), -1) {
+			afterIDs[id] = true
+		}
+	}
+	var lost []string
+	for id := range beforeIDs {
+		if !afterIDs[id] && !retired[id] {
+			lost = append(lost, id)
+		}
+	}
+	if len(lost) > 0 {
+		slices.Sort(lost)
+		problems = append(problems, "IDs vanished from every touched file (list them in retired_ids if intended): "+strings.Join(lost, ", "))
+	}
+
+	for _, target := range targets {
+		name := filepath.Base(target.rel)
+		if name == "tasks.md" && filepath.Dir(target.rel) == "." {
+			old := map[string]bool{}
+			if target.existed {
+				for _, p := range state.ParseTaskGraph(target.before).Problems {
+					old[p] = true
+				}
+			}
+			for _, p := range state.ParseTaskGraph(target.after).Problems {
+				if !old[p] {
+					problems = append(problems, "tasks.md: "+p)
+				}
+			}
+		}
+		if filepath.Dir(target.rel) == "." && currentStatePlanning[name] &&
+			len(datedHeadingRE.FindAllIndex(target.after, -1)) > len(datedHeadingRE.FindAllIndex(target.before, -1)) {
+			problems = append(problems, target.rel+": adds a dated delta section; rewrite the owning clause in place (rationale to decisions.md, closed narrative to history/)")
+		}
+		if filepath.Dir(target.rel) != "." || !state.ArtifactBudgetGateApplies(name) {
+			continue
+		}
+		after, _ := state.ArtifactBudget(name, target.after)
+		before, _ := state.ArtifactBudget(name, target.before)
+		grew := !target.existed || after.Lines > before.Lines || after.Bytes > before.Bytes
+		if after.Material && !after.Override && grew {
+			problems = append(problems, fmt.Sprintf("%s: %d lines / %d bytes is a material overshoot of its %d-line budget; split or relocate instead of growing it",
+				target.rel, after.Lines, after.Bytes, after.LineBudget))
+		}
+	}
+	return problems
+}
+
+// writeBundleTargets writes every target atomically and, if one write fails,
+// restores the files already written so the workspace never holds half a
+// bundle.
+func writeBundleTargets(ws *os.Root, targets []*bundleTarget) error {
+	for i, target := range targets {
+		if err := fsutil.WriteFileAtomicIn(ws, filepath.FromSlash(target.rel), target.after, 0o644); err != nil {
+			for _, done := range targets[:i] {
+				if done.existed {
+					_ = fsutil.WriteFileAtomicIn(ws, filepath.FromSlash(done.rel), done.before, 0o644)
+				} else {
+					_ = ws.Remove(filepath.FromSlash(done.rel))
+				}
+			}
+			return fmt.Errorf("write %s: %w (earlier files restored)", target.rel, err)
+		}
+	}
+	return nil
+}
+
+func readBundleFile(ws *os.Root, rel string) ([]byte, bool, error) {
+	info, err := ws.Lstat(filepath.FromSlash(rel))
+	if errors.Is(err, fs.ErrNotExist) {
+		return nil, false, nil
+	}
+	if err != nil {
+		return nil, false, err
+	}
+	if !info.Mode().IsRegular() {
+		return nil, false, errors.New("not a regular file")
+	}
+	if info.Size() > state.MaxArtifactBytes {
+		return nil, false, fmt.Errorf("exceeds the %d-byte artifact cap", state.MaxArtifactBytes)
+	}
+	raw, err := ws.ReadFile(filepath.FromSlash(rel))
+	return raw, true, err
+}
+
+func sha256Hex(raw []byte) string {
+	sum := sha256.Sum256(raw)
+	return hex.EncodeToString(sum[:])
+}
+
+func shortHash(raw []byte, exists bool) string {
+	if !exists {
+		return "(new)"
+	}
+	return abbrev(sha256Hex(raw))
+}
+
+func abbrev(hash string) string {
+	if len(hash) > 12 {
+		return hash[:12]
+	}
+	return hash
+}

package/engine/internal/lib/diffscope.go

@@ -177,7 +177,7 @@ func (o diffScopeOpts) changedPaths() ([]string, error) {
 
 // engineMachineFiles are the feature-root files the engine itself writes:
 // the dispatch ledger, metrics ledger, drift and regression baselines, the
-// parallel lease, and the feature lock.
+// parallel lease, the feature lock, and the gate-execution lock.
 var engineMachineFiles = map[string]bool{
 	"dispatch.json":        true,
 	MetricsFile:            true,
@@ -185,6 +185,7 @@ var engineMachineFiles = map[string]bool{
 	regressionBaselineFile: true,
 	"parallel-lease.md":    true,
 	".lock":                true,
+	"gates.md.lock":        true,
 }
 
 // engineMachineFile reports whether rel, relative to the .devrites tree, is

package/engine/main.go

@@ -65,6 +65,8 @@ Usage:
   devrites-engine gates <subcommand> <slug>  Machine-checked gates.md ledger: scaffold/status/run/reverify/lint/attest/abandon
   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 apply-bundle <slug> <bundle.json>... [--dry-run]
+                                         Validate and apply plan-drafter hunk bundles atomically
   devrites-engine state close <slug>       Archive a shipped feature and clear ACTIVE
   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
@@ -237,6 +239,8 @@ func cmdState(root string, args []string, stdout, stderr io.Writer) int {
 		return lib.Resolve(root, args[1:], stdout, stderr)
 	case "merge-manifest":
 		return lib.RunMergeManifest(root, args[1:], stdout, stderr)
+	case "apply-bundle":
+		return lib.RunApplyBundle(root, args[1:], stdout, stderr)
 	case "close":
 		return lib.CloseOut(root, args[1:], stdout, stderr)
 	default: