devrites 2.6.0 → 3.0.0

package/engine/internal/lib/stuck.go

@@ -0,0 +1,206 @@
+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

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

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

@@ -0,0 +1,6 @@
+# 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

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

package/engine/internal/lib/testintegrity.go

@@ -0,0 +1,203 @@
+package lib
+
+import (
+	"fmt"
+	"io"
+	"os"
+	"os/exec"
+	"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 guards against reaching green by weakening tests instead of fixing
+// code. It diffs the test files against the slice's base tree (the reconcile
+// snapshot if present, else HEAD) and flags any test file that was deleted, gained
+// a skip/focus marker, or lost assertions. Read-only; the workspace is
+// <root>/features/<slug>.
+//
+//	0  clean, or skipped because this is not a git repo
+//	2  no active workspace / bad args
+//	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 := gitToplevel(cwd)
+	if gitRoot == "" {
+		fmt.Fprintln(stderr, "test-integrity: not a git repo — gate skipped, eyeball the test diff by hand.")
+		return 0
+	}
+
+	baseTree := ""
+	if b, err := os.ReadFile(filepath.Join(d, ".reconcile-base")); err == nil {
+		baseTree = strings.TrimSpace(string(b))
+	}
+	ref := baseTree
+	if ref == "" {
+		ref = "HEAD"
+	}
+
+	weak := 0
+	srcChanged, testChanged := 0, 0
+	var report strings.Builder
+	for _, f := range gitDiffNames(gitRoot, ref) {
+		if f == "" {
+			continue
+		}
+		if !isTestFile(f) {
+			if isSourceFile(f) {
+				srcChanged++
+			}
+			continue
+		}
+		testChanged++
+		old, ok := gitShow(gitRoot, ref+":"+f)
+		if !ok || old == "" {
+			continue // new test file — adding tests is never a weakening
+		}
+		if !isFile(filepath.Join(gitRoot, f)) {
+			weak++
+			fmt.Fprintf(&report, "  - %s: test file DELETED\n", f)
+			continue
+		}
+		newBytes, err := os.ReadFile(filepath.Join(gitRoot, f))
+		if err != nil {
+			continue
+		}
+		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)
+		}
+	}
+
+	// Verification-gap advisory: source changed but no test file did. Not a
+	// weakening and never a verdict on its own — a pointer to run the
+	// verification-gap trace (testing.md), since a green suite can pass identically
+	// with the change reverted. Printed on both the 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, "A test weakened to pass a gate is a Critical finding. Revert it; 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))
+}
+
+// gitShow returns the content of an object (e.g. "HEAD:path"), and false when it
+// does not exist at that ref.
+func gitShow(gitRoot, spec string) (string, bool) {
+	out, err := exec.Command("git", "-C", gitRoot, "show", spec).Output()
+	if err != nil {
+		return "", false
+	}
+	return string(out), true
+}

package/engine/internal/lib/testintegrity_test.go

@@ -0,0 +1,72 @@
+package lib
+
+import "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)
+		}
+	}
+}

package/engine/internal/lib/tickafk.go

@@ -0,0 +1,99 @@
+package lib
+
+import (
+	"fmt"
+	"io"
+	"os"
+	"regexp"
+	"strconv"
+	"strings"
+
+	"github.com/devrites/devrites/internal/fsutil"
+)
+
+// budgetField matches an "AFK slices remaining:" line and captures the value that
+// follows. The optional leading "- " tolerates state.md's markdown-bullet form.
+var budgetField = regexp.MustCompile(`^[[:space:]]*-?[[:space:]]*AFK slices remaining:[[:space:]]*`)
+
+// 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 == "" || !isFile(path) {
+		where := path
+		if where == "" {
+			where = "<unset>"
+		}
+		fmt.Fprintf(stderr, "tick-afk: state.md not found at %s\n", where)
+		return 5
+	}
+
+	data, _ := os.ReadFile(path)
+	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) {
+	for _, line := range lines {
+		loc := budgetField.FindStringIndex(line)
+		if loc == nil {
+			continue
+		}
+		value = line[loc[1]:]
+		if i := strings.IndexAny(value, spaceChars); i >= 0 {
+			value = value[:i]
+		}
+		return value, true
+	}
+	return "", false
+}
+
+// setBudget rewrites every budget line to the canonical bullet form with the new
+// count, passing all other lines through. The result is newline-terminated.
+func setBudget(lines []string, n int) []byte {
+	var b strings.Builder
+	for _, line := range lines {
+		if budgetField.MatchString(line) {
+			fmt.Fprintf(&b, "- AFK slices remaining: %d", n)
+		} else {
+			b.WriteString(line)
+		}
+		b.WriteByte('\n')
+	}
+	return []byte(b.String())
+}

package/engine/internal/lib/util.go

@@ -0,0 +1,68 @@
+package lib
+
+import (
+	"os/exec"
+	"path/filepath"
+	"strings"
+)
+
+// gitToplevel returns the absolute path of the git working tree containing dir,
+// or "" when dir is not inside a repository. The git-backed gates (test-integrity,
+// package-existence, reconcile) skip rather than block when it is empty.
+func gitToplevel(dir string) string {
+	out, err := exec.Command("git", "-C", dir, "rev-parse", "--show-toplevel").Output()
+	if err != nil {
+		return ""
+	}
+	return strings.TrimSpace(string(out))
+}
+
+// gitDiffNames lists the paths that differ, relative to gitRoot. With one ref it
+// diffs the working tree against that ref; with two it diffs the two tree objects.
+func gitDiffNames(gitRoot string, refs ...string) []string {
+	args := append([]string{"-C", gitRoot, "diff", "--name-only"}, refs...)
+	out, err := exec.Command("git", args...).Output()
+	if err != nil {
+		return nil
+	}
+	return splitLinesNoTrailing(out)
+}
+
+// stripASCIISpace removes every whitespace character from s (used to normalise an
+// ACTIVE pointer before comparing it to a slug).
+func stripASCIISpace(s string) string {
+	return strings.Map(func(r rune) rune {
+		if strings.ContainsRune(spaceChars, r) {
+			return -1
+		}
+		return r
+	}, s)
+}
+
+// isAllDigits reports whether s is a non-empty run of ASCII digits.
+func isAllDigits(s string) bool {
+	if s == "" {
+		return false
+	}
+	for _, r := range s {
+		if r < '0' || r > '9' {
+			return false
+		}
+	}
+	return true
+}
+
+// featureFile is the path to a leaf file inside a feature's directory:
+// <root>/features/<slug>/<name>.
+func featureFile(root, slug, name string) string {
+	return filepath.Join(featureDir(root, slug), name)
+}
+
+// slugOrActive returns the slug named in args[0], falling back to the active
+// feature when none is given.
+func slugOrActive(root string, args []string) string {
+	if slug := argAt(args, 0); slug != "" {
+		return slug
+	}
+	return activeSlug(root)
+}