devrites 3.2.28 → 4.0.0

package/engine/internal/lib/stuck.go

@@ -1,206 +0,0 @@
-package lib
-
-import (
-	"crypto/sha1" // #nosec G505 -- non-cryptographic tool-call fingerprint; must match `sha1sum` output
-	"encoding/hex"
-	"fmt"
-	"io"
-	"os"
-	"path/filepath"
-	"regexp"
-	"strconv"
-	"strings"
-	"time"
-)
-
-// awkNumRe recognises an awk "numeric string" (optional surrounding blanks, sign,
-// int/float/exponent): the class that makes a comparison numeric. awkLeadNumRe
-// captures the leading numeric prefix strtod would convert (so "4x" → 4).
-var (
-	awkNumRe     = regexp.MustCompile(`^[ \t\n]*[+-]?([0-9]+\.?[0-9]*|\.[0-9]+)([eE][+-]?[0-9]+)?[ \t\n]*$`)
-	awkLeadNumRe = regexp.MustCompile(`^[+-]?([0-9]+\.?[0-9]*|\.[0-9]+)([eE][+-]?[0-9]+)?`)
-)
-
-// awkNum returns a token's numeric value (strtod-style leading-number coercion,
-// 0 when there is none) and whether the whole token is a numeric string.
-func awkNum(s string) (val float64, isNumericString bool) {
-	isNumericString = awkNumRe.MatchString(s)
-	if m := awkLeadNumRe.FindString(strings.TrimLeft(s, " \t\n")); m != "" {
-		val, _ = strconv.ParseFloat(m, 64)
-	}
-	return val, isNumericString
-}
-
-// sameWindow reports whether the last `win` actions are identical, reproducing
-// awk's `for (i=NR-win+1; i<=NR; i++)` loop over the numeric window value: a
-// non-integer window never matches (fractional array indices are empty), and a
-// window ≤ 0 makes the loop empty so `same` stays true.
-func sameWindow(h []string, winVal float64) bool {
-	n := len(h)
-	w := int(winVal)
-	if float64(w) != winVal {
-		return false
-	}
-	if w <= 0 {
-		return true
-	}
-	if w > n {
-		return false // guarded (the too-few check catches this for numeric windows)
-	}
-	for i := n - w; i < n; i++ {
-		if h[i] != h[n-1] {
-			return false
-		}
-	}
-	return true
-}
-
-// Stuck is the unattended-build loop detector.
-// `log` appends one (tool,target) action record; `check` flags the semantic-repeat
-// patterns that mean the agent is burning tokens in a loop: the same action
-// repeating, an A<->B ping-pong, or one action dominating the recent window.
-// Matching is by (tool,target) sha1, timestamps ignored. root is the .devrites
-// directory; the log lives at <root>/features/<slug>/action.log.
-//
-//	0  ok: not stuck (or logging, or no workspace: never fail the caller on log)
-//	2  bad args
-//	3  STUCK: the recent window is a loop
-func Stuck(root string, args []string, stdout, stderr io.Writer) int {
-	cmd := argAt(args, 0)
-	slug := argAt(args, 1)
-	if cmd == "" || slug == "" {
-		fmt.Fprintln(stderr, "usage: devrites-engine stuck log|check <slug> [...]")
-		return 2
-	}
-	dir := featureDir(root, slug)
-	logPath := filepath.Join(dir, "action.log")
-
-	switch cmd {
-	case "log":
-		tool := argAt(args, 2)
-		target := argAt(args, 3)
-		if tool == "" {
-			fmt.Fprintln(stderr, "usage: devrites-engine stuck log <slug> <tool> [target]")
-			return 2
-		}
-		if !isDir(dir) {
-			return 0 // no workspace: never fail the caller
-		}
-		record := fmt.Sprintf("%d %s %s\n", time.Now().Unix(), tool, sha1Hex(tool+"|"+target))
-		f, err := os.OpenFile(logPath, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0o644)
-		if err != nil {
-			return 0
-		}
-		defer f.Close()
-		_, _ = f.WriteString(record)
-		return 0
-
-	case "check":
-		rawWin := "4" // bash `win="${3:-4}"`
-		if w := argAt(args, 2); w != "" {
-			rawWin = w
-		}
-		data, err := os.ReadFile(logPath)
-		if err != nil {
-			fmt.Fprintln(stdout, "stuck: no actions logged: not stuck.")
-			return 0
-		}
-		return checkStuck(actionHashes(data), rawWin, stdout)
-
-	default:
-		fmt.Fprintln(stderr, "usage: devrites-engine stuck log|check <slug> [...]")
-		return 2
-	}
-}
-
-// actionHashes returns the 3rd (sha1) field of every record line, mirroring the
-// awk `h[NR]=$3` (an empty string for a line with fewer than three fields).
-func actionHashes(data []byte) []string {
-	lines := splitLinesNoTrailing(data)
-	hashes := make([]string, len(lines))
-	for i, line := range lines {
-		if fields := strings.Fields(line); len(fields) >= 3 {
-			hashes[i] = fields[2]
-		}
-	}
-	return hashes
-}
-
-// checkStuck evaluates the hash column for identical-repeat,
-// A<->B ping-pong (last 6), and one-action-dominates (≥6 of last 8). The window
-// arg is handled with awk-compatible semantics (see awkNum / sameWindow) because
-// the prior shell helper passed it verbatim to `awk -v win=`.
-func checkStuck(h []string, rawWin string, stdout io.Writer) int {
-	n := len(h)
-	winVal, isNumericString := awkNum(rawWin)
-
-	// `NR < win`: a numeric comparison when the token is a numeric string, else a
-	// string comparison of str(NR) against the raw token: awk's comparison rule.
-	tooFew := false
-	if isNumericString {
-		tooFew = float64(n) < winVal
-	} else {
-		tooFew = strconv.Itoa(n) < rawWin
-	}
-	if tooFew {
-		fmt.Fprintf(stdout, "stuck: only %d action(s): not stuck.\n", n)
-		return 0
-	}
-	// The last `win` actions are identical. The message echoes the raw token, as
-	// awk prints the `win` variable verbatim (so "04"/"+4" render unchanged).
-	if sameWindow(h, winVal) {
-		fmt.Fprintf(stdout, "stuck: last %s actions identical: STUCK.\n", rawWin)
-		return 3
-	}
-	// A<->B ping-pong over the last 6 actions.
-	if n >= 6 {
-		pp := true
-		for i := n - 6; i < n; i++ {
-			expect := h[n-2]
-			if (n-1-i)%2 == 0 {
-				expect = h[n-1]
-			}
-			if h[i] != expect {
-				pp = false
-				break
-			}
-		}
-		if pp && h[n-1] != h[n-2] {
-			fmt.Fprintln(stdout, "stuck: A<->B ping-pong over last 6: STUCK.")
-			return 3
-		}
-	}
-	// One action dominates the last 8.
-	if n >= 8 {
-		counts := map[string]int{}
-		for i := n - 8; i < n; i++ {
-			counts[h[i]]++
-		}
-		top := 0
-		for _, c := range counts {
-			if c > top {
-				top = c
-			}
-		}
-		if top >= 6 {
-			fmt.Fprintf(stdout, "stuck: one action %d/8 of recent window: STUCK.\n", top)
-			return 3
-		}
-	}
-	fmt.Fprintln(stdout, "stuck: recent window varied: not stuck.")
-	return 0
-}
-
-// sha1Hex returns the lowercase hex sha1 of s, matching `sha1sum`/`shasum`.
-func sha1Hex(s string) string {
-	sum := sha1.Sum([]byte(s)) // #nosec G401 -- dedup fingerprint, not a security boundary; persisted records depend on sha1
-	return hex.EncodeToString(sum[:])
-}
-
-// argAt returns args[i] or "": the Go analogue of bash's ${N:-} positional reads.
-func argAt(args []string, i int) string {
-	if i < len(args) {
-		return args[i]
-	}
-	return ""
-}

package/engine/internal/lib/templates/conventions_drift.tmpl

@@ -1,6 +0,0 @@
-
-## convention-drift: {{.Key}}
-- slice: {{.Slug}}
-- contradicted_by: {{.Evidence}}
-- now: {{.State}}
-- at: {{.When}}

package/engine/internal/lib/templates/conventions_ledger_header.md

@@ -1,6 +0,0 @@
-# DevRites conventions ledger
-
-Conventions proven by sealed slices on this project. **Local, gitignored, advisory.**
-The confidence band is earned: it reflects how many independent sealed slices corroborated
-the convention. It is not a model's guess. A high band is still untrusted data; a fresh
-observation of the live code always wins over a stale entry here.

package/engine/internal/lib/templates/conventions_orient_header.txt

@@ -1 +0,0 @@
-# Conventions ledger: proven priors (live code always overrides)

package/engine/internal/lib/testintegrity.go

@@ -1,199 +0,0 @@
-package lib
-
-import (
-	"fmt"
-	"io"
-	"os"
-	"path/filepath"
-	"regexp"
-	"strings"
-)
-
-// skipMarkers matches a test that has been muted: a skip/focus/ignore marker
-// across the common test frameworks. assertMarkers matches an assertion. Both are
-// counted per file to detect a test being weakened rather than fixed.
-var (
-	skipMarkers   = regexp.MustCompile(`(\bit|\bdescribe|\btest|\bcontext)\.skip|\bxit\b|\bxdescribe\b|\.only\b|@pytest\.mark\.skip|@unittest\.skip|\bpytest\.skip\b|t\.Skip\(|#\[ignore\]|@Ignore\b|@Disabled\b|\bfdescribe\b|\bfit\(`)
-	assertMarkers = regexp.MustCompile(`assert|expect\(|\.should\b|\brequire\.|EXPECT_|ASSERT_|XCTAssert|t\.Error|t\.Fatal`)
-)
-
-// TestIntegrity detects tests that were weakened instead of fixing the code. It
-// compares test files in the retained reconcile tree with the current tree, or
-// uses HEAD as the base outside a slice lifecycle. It does not modify the
-// workspace at <root>/features/<slug>.
-//
-//	0  clean, or skipped because this is not a git repo
-//	2  no active workspace, bad args, or missing/corrupt baseline state
-//	3  WEAKENED: a test was deleted, skipped, or de-asserted since the base
-func TestIntegrity(root string, args []string, stdout, stderr io.Writer) int {
-	// Accept both `test-integrity [slug]` and the `check [slug]` alias; a leading
-	// dash is treated as "no slug".
-	slug := ""
-	switch first := argAt(args, 0); {
-	case first == "check":
-		slug = argAt(args, 1)
-	case first == "" || strings.HasPrefix(first, "-"):
-		slug = ""
-	default:
-		slug = first
-	}
-	if slug == "" {
-		slug = activeSlug(root)
-	}
-	if slug == "" {
-		fmt.Fprintln(stderr, "test-integrity: no active workspace (pass a slug or set .devrites/ACTIVE).")
-		return 2
-	}
-
-	d := featureDir(root, slug)
-	if !isDir(d) {
-		fmt.Fprintf(stderr, "test-integrity: no workspace at %s.\n", d)
-		return 2
-	}
-
-	cwd, _ := os.Getwd()
-	gitRoot, err := gitToplevel(cwd)
-	if err != nil {
-		fmt.Fprintf(stderr, "test-integrity: cannot resolve git worktree: %v\n", err)
-		return 2
-	}
-
-	trees, err := captureSliceTreeRange(gitRoot, root, d)
-	if err != nil {
-		fmt.Fprintf(stderr, "test-integrity: cannot capture slice range: %v\n", err)
-		return 2
-	}
-	defer trees.cleanup()
-	changedPaths, err := changedTreePaths(gitRoot, trees.env, trees.base, trees.current)
-	if err != nil {
-		fmt.Fprintf(stderr, "test-integrity: cannot compare slice trees: %v\n", err)
-		return 2
-	}
-
-	weak := 0
-	srcChanged, testChanged := 0, 0
-	var report strings.Builder
-	for _, f := range changedPaths {
-		if f == "" {
-			continue
-		}
-		if !isTestFile(f) {
-			if isSourceFile(f) {
-				srcChanged++
-			}
-			continue
-		}
-		testChanged++
-		oldBytes, oldExists, err := treeFileContent(gitRoot, trees.env, trees.base, f)
-		if err != nil {
-			fmt.Fprintf(stderr, "test-integrity: cannot read baseline %s: %v\n", f, err)
-			return 2
-		}
-		if !oldExists || len(oldBytes) == 0 {
-			continue // new test file: adding tests is never a weakening
-		}
-		newBytes, newExists, err := treeFileContent(gitRoot, trees.env, trees.current, f)
-		if err != nil {
-			fmt.Fprintf(stderr, "test-integrity: cannot read current %s: %v\n", f, err)
-			return 2
-		}
-		if !newExists {
-			weak++
-			fmt.Fprintf(&report, "  - %s: test file DELETED\n", f)
-			continue
-		}
-		old := string(oldBytes)
-		now := string(newBytes)
-		oldSkips, newSkips := countMatches(skipMarkers, old), countMatches(skipMarkers, now)
-		oldAsserts, newAsserts := countMatches(assertMarkers, old), countMatches(assertMarkers, now)
-		switch {
-		case newSkips > oldSkips:
-			weak++
-			fmt.Fprintf(&report, "  - %s: skip/focus markers added (%d→%d)\n", f, oldSkips, newSkips)
-		case newAsserts < oldAsserts:
-			weak++
-			fmt.Fprintf(&report, "  - %s: assertions dropped (%d→%d)\n", f, oldAsserts, newAsserts)
-		}
-	}
-
-	// When source changes without a test change, print the verification-gap
-	// advisory from testing.md. This is not a weakening verdict and appears on
-	// both clean and weakened paths.
-	gapAdvisory := ""
-	if srcChanged > 0 && testChanged == 0 {
-		gapAdvisory = fmt.Sprintf("test-integrity: advisory: %d source file(s) changed, 0 test file(s) touched; "+
-			"run the verification-gap trace (testing.md) to confirm each changed behavior is asserted.", srcChanged)
-	}
-
-	if weak > 0 {
-		fmt.Fprintf(stderr, "test-integrity: WEAKENED: %d test file(s) lost coverage since the slice base:\n", weak)
-		fmt.Fprint(stderr, report.String())
-		fmt.Fprintln(stderr, "Weakening a test to pass the gate is a Critical finding. Restore the test, then fix the code or raise a blocking question.")
-		if gapAdvisory != "" {
-			fmt.Fprintln(stderr, gapAdvisory)
-		}
-		return 3
-	}
-	fmt.Fprintln(stdout, "test-integrity: OK: no test deleted, skipped, or de-asserted since the base.")
-	if gapAdvisory != "" {
-		fmt.Fprintln(stdout, gapAdvisory)
-	}
-	return 0
-}
-
-// isSourceFile recognises a path as project source worth pairing with a test:
-// a code file that is not itself a test. It filters out the common non-code
-// changes (docs, config, lockfiles) so the verification-gap advisory keys on
-// behavior-bearing edits, not a README or a manifest bump.
-func isSourceFile(f string) bool {
-	ext := filepath.Ext(f)
-	switch ext {
-	case ".go", ".js", ".jsx", ".ts", ".tsx", ".py", ".rb", ".rs", ".java", ".kt",
-		".c", ".h", ".cc", ".cpp", ".hpp", ".cs", ".php", ".swift", ".scala", ".m", ".mm":
-		return true
-	default:
-		return false
-	}
-}
-
-// testDirSegments are directory names that mark everything beneath them as test
-// code, across the common ecosystems (JS/TS, Python, Go, Rust, JUnit).
-var testDirSegments = map[string]bool{
-	"test": true, "tests": true, "spec": true, "specs": true,
-	"__tests__": true, "__test__": true,
-}
-
-// isTestFile recognises a path as a test by its filename/directory conventions.
-// Markers must land on a basename or a whole path segment: matching "test" or
-// "spec" as a bare substring would classify ordinary source ("internal/latest/",
-// "internal/respect/") as tests, deleting them would then trip the WEAKENED gate,
-// and they would never count toward the verification-gap advisory.
-func isTestFile(f string) bool {
-	f = filepath.ToSlash(f)
-	base := filepath.Base(f)
-
-	for _, marker := range []string{
-		"_test.", ".test.", "_tests.", ".tests.",
-		"_spec.", ".spec.", "_specs.", ".specs.",
-		"Test.", "Tests.", "Spec.", "Specs.",
-	} {
-		if strings.Contains(base, marker) {
-			return true
-		}
-	}
-	if strings.HasPrefix(base, "test_") || strings.HasPrefix(base, "spec_") {
-		return true
-	}
-
-	for _, seg := range strings.Split(filepath.ToSlash(filepath.Dir(f)), "/") {
-		if testDirSegments[seg] {
-			return true
-		}
-	}
-	return false
-}
-
-// countMatches counts the non-overlapping matches of re in text.
-func countMatches(re *regexp.Regexp, text string) int {
-	return len(re.FindAllStringIndex(text, -1))
-}

package/engine/internal/lib/testintegrity_test.go

@@ -1,149 +0,0 @@
-package lib
-
-import (
-	"bytes"
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-)
-
-func TestIsTestFileClassifiesTests(t *testing.T) {
-	cases := []struct {
-		path string
-		want bool
-	}{
-		// Test files, by basename marker.
-		{"internal/lib/reconcile_test.go", true},
-		{"src/parser.test.ts", true},
-		{"src/parser.spec.tsx", true},
-		{"src/parser_spec.rb", true},
-		{"lib/thing.tests.js", true},
-		{"java/com/acme/OrderTest.java", true},
-		{"java/com/acme/OrderTests.java", true},
-		{"csharp/OrderSpec.cs", true},
-		{"test_parser.py", true},
-		{"python/pkg/test_parser.py", true},
-		{"ruby/spec_helper.rb", true},
-
-		// Test files, by directory segment.
-		{"tests/integration/flow.go", true},
-		{"src/__tests__/button.tsx", true},
-		{"crate/test/harness.rs", true},
-		{"app/spec/models/user_spec.rb", true},
-		{"api/specs/contract.py", true},
-
-		// Regression: ordinary source whose path merely *contains* "test" or
-		// "spec" as a substring must not be classified as a test. Misclassifying
-		// these trips the WEAKENED gate when they are deleted, and hides them
-		// from the verification-gap advisory when they change.
-		{"internal/latest/handler.go", false},
-		{"internal/respect/config.go", false},
-		{"internal/contest/rules.go", false},
-		{"pkg/digest/sha.go", false},
-		{"src/greatest_hits.ts", false},
-		{"src/special.tsx", false},
-		{"cmd/protest.go", false},
-		{"internal/attestation/verify.go", false},
-
-		// Ordinary source with no marker at all.
-		{"internal/lib/reconcile.go", false},
-		{"README.md", false},
-	}
-
-	for _, tc := range cases {
-		if got := isTestFile(tc.path); got != tc.want {
-			t.Errorf("isTestFile(%q) = %v, want %v", tc.path, got, tc.want)
-		}
-	}
-}
-
-func TestIsSourceFileRecognisesCode(t *testing.T) {
-	cases := []struct {
-		path string
-		want bool
-	}{
-		{"internal/lib/reconcile.go", true},
-		{"src/app.tsx", true},
-		{"pkg/mod.rs", true},
-		{"README.md", false},
-		{"package-lock.json", false},
-		{"config.yaml", false},
-	}
-	for _, tc := range cases {
-		if got := isSourceFile(tc.path); got != tc.want {
-			t.Errorf("isSourceFile(%q) = %v, want %v", tc.path, got, tc.want)
-		}
-	}
-}
-
-func TestIntegrityFailsClosedWhenGitIsUnavailable(t *testing.T) {
-	newGitRepo(t)
-	root := workspace(t, "feat")
-	t.Setenv("PATH", t.TempDir())
-
-	var stdout, stderr bytes.Buffer
-	code := TestIntegrity(root, []string{"feat"}, &stdout, &stderr)
-	if code != 2 {
-		t.Fatalf("test-integrity = %d, want 2\nstdout: %s\nstderr: %s", code, stdout.String(), stderr.String())
-	}
-	if !strings.Contains(stderr.String(), "cannot resolve git worktree") {
-		t.Fatalf("missing fail-closed diagnostic: %s", stderr.String())
-	}
-}
-
-func TestIntegrityDetectsDeletionFromDirtySliceBaseline(t *testing.T) {
-	gitRoot := newGitRepo(t)
-	root := workspace(t, "feat")
-	testPath := "tests/preexisting_test.go"
-	writeFile(t, filepath.Join(gitRoot, testPath), "package tests\n\nfunc TestBaseline(t *testing.T) { t.Fatal(\"assert\") }\n")
-	writeWrightAllowlist(t, root, "feat", testPath)
-	if code, out := runReconcile(t, root, "snapshot", "feat"); code != 0 {
-		t.Fatalf("snapshot = %d, want 0\n%s", code, out)
-	}
-	if err := os.Remove(filepath.Join(gitRoot, testPath)); err != nil {
-		t.Fatal(err)
-	}
-	if code, out := runReconcile(t, root, "check", "feat"); code != 0 {
-		t.Fatalf("reconcile check = %d, want 0\n%s", code, out)
-	}
-
-	var stdout, stderr bytes.Buffer
-	code := TestIntegrity(root, []string{"feat"}, &stdout, &stderr)
-	if code != 3 {
-		t.Fatalf("test-integrity = %d, want 3\nstdout: %s\nstderr: %s", code, stdout.String(), stderr.String())
-	}
-	if !strings.Contains(stderr.String(), testPath+": test file DELETED") {
-		t.Fatalf("deleted dirty-baseline test missing from finding:\n%s", stderr.String())
-	}
-}
-
-func TestIntegrityFailsClosedOnPartialReconcileBaseline(t *testing.T) {
-	newGitRepo(t)
-	root := workspace(t, "feat")
-	writeFile(t, filepath.Join(featureDir(root, "feat"), reconcileBaseName), "deadbeef\n")
-
-	var stdout, stderr bytes.Buffer
-	code := TestIntegrity(root, []string{"feat"}, &stdout, &stderr)
-	if code != 2 {
-		t.Fatalf("test-integrity = %d, want 2\nstdout: %s\nstderr: %s", code, stdout.String(), stderr.String())
-	}
-	if !strings.Contains(stderr.String(), "partial lifecycle") {
-		t.Fatalf("missing fail-closed lifecycle diagnostic:\n%s", stderr.String())
-	}
-}
-
-func TestIntegrityAdvisesWhenSourceChangesWithoutTests(t *testing.T) {
-	gitRoot := newGitRepo(t)
-	root := workspace(t, "feat")
-	writeFile(t, filepath.Join(gitRoot, "src", "feature.go"), "package src\n")
-
-	var stdout, stderr bytes.Buffer
-	code := TestIntegrity(root, []string{"feat"}, &stdout, &stderr)
-	if code != 0 {
-		t.Fatalf("test-integrity = %d, want 0\nstdout: %s\nstderr: %s", code, stdout.String(), stderr.String())
-	}
-	if !strings.Contains(stdout.String(), "source file(s) changed, 0 test file(s) touched") {
-		t.Fatalf("missing verification-gap advisory:\n%s", stdout.String())
-	}
-}

package/engine/internal/lib/tickafk.go

@@ -1,86 +0,0 @@
-package lib
-
-import (
-	"fmt"
-	"io"
-	"os"
-	"strconv"
-	"strings"
-
-	"github.com/devrites/devrites/internal/fsutil"
-	"github.com/devrites/devrites/internal/state"
-)
-
-// TickAfk spends one slice from a run's AFK budget: it reads the "AFK slices
-// remaining" count from the state.md at args[0], decrements it, and writes the
-// file back. /rite-build calls it after building a slice unattended.
-//
-// It operates on a state.md path (not a feature slug) so a caller can point it at
-// any workspace. Exit codes:
-//
-//	0  a slice was spent and budget remains, or no budget is set (nothing to do)
-//	3  the budget is now exhausted: the caller must stop and hand back to a human
-//	5  the file is missing, or the field holds a non-numeric value
-func TickAfk(args []string, stdout, stderr io.Writer) int {
-	path := argAt(args, 0)
-	if path == "" {
-		where := path
-		if where == "" {
-			where = "<unset>"
-		}
-		fmt.Fprintf(stderr, "tick-afk: state.md not found at %s\n", where)
-		return 5
-	}
-
-	data, err := os.ReadFile(path)
-	if err != nil {
-		fmt.Fprintf(stderr, "tick-afk: read state.md at %s: %v\n", path, err)
-		return 5
-	}
-	lines := splitLinesNoTrailing(data)
-
-	remaining, found := readBudget(lines)
-	if !found || remaining == "none" {
-		fmt.Fprintf(stdout, "tick-afk: no \"AFK slices remaining\" budget set in %s: no-op\n", path)
-		return 0
-	}
-	if !isAllDigits(remaining) {
-		fmt.Fprintf(stderr, "tick-afk: \"AFK slices remaining\" is not a number (%s) in %s\n", remaining, path)
-		return 5
-	}
-
-	n, _ := strconv.Atoi(remaining)
-	if n--; n < 0 {
-		n = 0
-	}
-
-	if err := fsutil.WriteFileAtomic(path, setBudget(lines, n), 0o644); err != nil {
-		fmt.Fprintf(stderr, "tick-afk: %v\n", err)
-		return 5
-	}
-	fmt.Fprintln(stdout, n)
-
-	if n <= 0 {
-		return 3
-	}
-	return 0
-}
-
-// readBudget returns the current "AFK slices remaining" value: the first blank-
-// delimited token after the field, and whether the field is present at all.
-func readBudget(lines []string) (value string, found bool) {
-	value, found = state.CursorField(lines, state.CursorAFKSlicesRemaining)
-	if !found {
-		return "", false
-	}
-	if i := strings.IndexAny(value, spaceChars); i >= 0 {
-		value = value[:i]
-	}
-	return value, true
-}
-
-// setBudget preserves the cursor's canonical-table or legacy-bullet format.
-func setBudget(lines []string, n int) []byte {
-	updated, _ := state.SetCursorField(lines, state.CursorAFKSlicesRemaining, strconv.Itoa(n))
-	return []byte(strings.Join(updated, "\n") + "\n")
-}