devrites 3.2.27 → 4.0.0

package/engine/internal/migrate/migrate.go

@@ -1,279 +0,0 @@
-// Package migrate normalizes .devrites workspaces in place. work/<slug> is the
-// canonical layout; features/<slug> remains readable as a compatibility alias.
-// The normalizer adds canonical files without deleting aliases. It is idempotent
-// and backs up the pre-migration state before touching anything, so a botched
-// upgrade never strands work.
-package migrate
-
-import (
-	"fmt"
-	"os"
-	"path/filepath"
-	"slices"
-	"sort"
-	"strconv"
-	"strings"
-	"time"
-
-	"github.com/devrites/devrites/internal/fsutil"
-	"github.com/devrites/devrites/internal/state"
-)
-
-// Result reports what a migration did. Skipped is true when there was nothing to
-// migrate (a no-op re-run); Migrated lists the slugs upgraded this run; BackupDir
-// is the pre-migration snapshot (empty when Skipped).
-type Result struct {
-	Skipped   bool
-	Migrated  []string
-	BackupDir string
-}
-
-type normalizationTarget struct {
-	slug string
-	dir  string
-}
-
-// Run normalizes the workspace at root. If no feature directory needs additive
-// files, it returns Skipped without writing or backing up anything (idempotent).
-// Otherwise it snapshots the state, then writes missing canonical files.
-func Run(root string) (*Result, error) {
-	targets, err := featureDirsNeedingNormalization(root)
-	if err != nil {
-		return nil, fmt.Errorf("scan workspace: %w", err)
-	}
-	if len(targets) == 0 {
-		return &Result{Skipped: true}, nil
-	}
-
-	backup, err := backupWorkspace(root)
-	if err != nil {
-		return nil, fmt.Errorf("backup workspace: %w", err)
-	}
-	migrated := make([]string, 0, len(targets))
-	for _, target := range targets {
-		if err := normalizeFeatureDir(target.dir, target.slug); err != nil {
-			return nil, fmt.Errorf("normalize %q: %w", target.slug, err)
-		}
-		migrated = append(migrated, target.slug)
-	}
-	sort.Strings(migrated)
-	return &Result{Migrated: slices.Compact(migrated), BackupDir: backup}, nil
-}
-
-func featureDirsNeedingNormalization(root string) ([]normalizationTarget, error) {
-	var targets []normalizationTarget
-	for _, layout := range []string{"work", "features"} {
-		base := filepath.Join(root, layout)
-		entries, err := os.ReadDir(base)
-		if os.IsNotExist(err) {
-			continue
-		}
-		if err != nil {
-			return nil, fmt.Errorf("list feature dirs: %w", err)
-		}
-		for _, e := range entries {
-			if !e.IsDir() {
-				continue
-			}
-			dir := filepath.Join(base, e.Name())
-			if needsNormalizeFeature(dir) {
-				targets = append(targets, normalizationTarget{slug: e.Name(), dir: dir})
-			}
-		}
-	}
-	sort.Slice(targets, func(i, j int) bool {
-		if targets[i].slug != targets[j].slug {
-			return targets[i].slug < targets[j].slug
-		}
-		return targets[i].dir < targets[j].dir
-	})
-	return targets, nil
-}
-
-func needsNormalizeFeature(dir string) bool {
-	if !regularFileExists(filepath.Join(dir, state.WorkspaceMapFile)) {
-		return true
-	}
-	if version := declaredSchemaVersion(dir); version < state.SchemaVersion {
-		return true
-	}
-	return regularFileExists(filepath.Join(dir, "proof.md")) && !regularFileExists(filepath.Join(dir, state.EvidenceFile)) ||
-		regularFileExists(filepath.Join(dir, "status.md")) && !regularFileExists(filepath.Join(dir, state.LedgerFile))
-}
-
-func regularFileExists(path string) bool {
-	info, err := os.Stat(path)
-	return err == nil && info.Mode().IsRegular()
-}
-
-func normalizeFeatureDir(dir, slug string) error {
-	for _, alias := range state.WorkspaceMapFiles()[1:] {
-		if err := copyAliasFile(dir, alias, state.WorkspaceMapFile); err != nil {
-			return fmt.Errorf("copy %s to %s: %w", alias, state.WorkspaceMapFile, err)
-		}
-	}
-	if !regularFileExists(filepath.Join(dir, state.WorkspaceMapFile)) {
-		phase := derivePhase(filepath.Join(dir, state.LedgerFile))
-		if err := state.AtomicWrite(filepath.Join(dir, state.WorkspaceMapFile), []byte(workspaceIndex(slug, phase)), 0o644); err != nil {
-			return fmt.Errorf("write workspace index: %w", err)
-		}
-	}
-	phase := derivePhase(filepath.Join(dir, state.LedgerFile))
-	if err := upgradeWorkspaceMapSchema(filepath.Join(dir, state.WorkspaceMapFile), slug, phase); err != nil {
-		return fmt.Errorf("upgrade workspace schema: %w", err)
-	}
-	if err := copyAliasFile(dir, "proof.md", state.EvidenceFile); err != nil {
-		return fmt.Errorf("copy proof.md to evidence.md: %w", err)
-	}
-	return copyAliasFile(dir, "status.md", state.LedgerFile)
-}
-
-func declaredSchemaVersion(dir string) int {
-	for _, name := range state.WorkspaceMapFiles() {
-		raw, err := os.ReadFile(filepath.Join(dir, name))
-		if err != nil {
-			continue
-		}
-		lines := strings.Split(string(raw), "\n")
-		if len(lines) == 0 || strings.TrimSpace(lines[0]) != "---" {
-			return 0
-		}
-		for _, line := range lines[1:] {
-			if strings.TrimSpace(line) == "---" {
-				break
-			}
-			key, value, ok := strings.Cut(line, ":")
-			if ok && strings.TrimSpace(key) == "schemaVersion" {
-				version, _ := strconv.Atoi(strings.TrimSpace(value))
-				return version
-			}
-		}
-		return 0
-	}
-	return 0
-}
-
-// upgradeWorkspaceMapSchema advances only the compatibility declaration. It
-// never creates decision coverage, readiness, or proof artifacts: those must be
-// earned by their owning phases.
-func upgradeWorkspaceMapSchema(path, slug string, phase state.Phase) error {
-	raw, err := os.ReadFile(path)
-	if err != nil {
-		return err
-	}
-	version := declaredSchemaVersion(filepath.Dir(path))
-	if version > state.SchemaVersion {
-		return fmt.Errorf("schemaVersion %d is newer than this engine supports (%d)", version, state.SchemaVersion)
-	}
-	if version == state.SchemaVersion {
-		return nil
-	}
-
-	text := string(raw)
-	if !strings.HasPrefix(text, "---\n") {
-		prefix := fmt.Sprintf("---\nslug: %s\nphase: %s\nschemaVersion: %d\n---\n\n", slug, phase, state.SchemaVersion)
-		return state.AtomicWrite(path, []byte(prefix+text), 0o644)
-	}
-
-	lines := strings.Split(text, "\n")
-	end := -1
-	schemaLine := -1
-	for i := 1; i < len(lines); i++ {
-		if strings.TrimSpace(lines[i]) == "---" {
-			end = i
-			break
-		}
-		key, _, ok := strings.Cut(lines[i], ":")
-		if ok && strings.TrimSpace(key) == "schemaVersion" {
-			schemaLine = i
-		}
-	}
-	if end < 0 {
-		return fmt.Errorf("workspace map has an unclosed frontmatter block")
-	}
-	value := fmt.Sprintf("schemaVersion: %d", state.SchemaVersion)
-	if schemaLine >= 0 {
-		lines[schemaLine] = value
-	} else {
-		lines = append(lines[:end], append([]string{value}, lines[end:]...)...)
-	}
-	return state.AtomicWrite(path, []byte(strings.Join(lines, "\n")), 0o644)
-}
-
-func copyAliasFile(dir, alias, canonical string) error {
-	src := filepath.Join(dir, alias)
-	dst := filepath.Join(dir, canonical)
-	if !regularFileExists(src) || regularFileExists(dst) {
-		return nil
-	}
-	data, err := os.ReadFile(src)
-	if err != nil {
-		return fmt.Errorf("read alias file: %w", err)
-	}
-	return state.AtomicWrite(dst, data, 0o644)
-}
-
-// workspaceIndex renders the compact map used by a normalized workspace.
-func workspaceIndex(slug string, phase state.Phase) string {
-	return fmt.Sprintf(`---
-slug: %s
-title: %s
-phase: %s
-schemaVersion: %d
----
-
-Normalized by DevRites migration.
-`, slug, slug, phase, state.SchemaVersion)
-}
-
-// derivePhase reads state.md in either canonical cursor-table or legacy form and
-// maps its recorded phase/status onto the current lifecycle. An unreadable or
-// unrecognised state defaults to build: the safe middle of the arc, from which
-// the completeness gates re-derive what's missing.
-func derivePhase(statePath string) state.Phase {
-	raw, err := os.ReadFile(statePath)
-	if err != nil {
-		return state.PhaseBuild
-	}
-	lines := strings.Split(string(raw), "\n")
-	for _, key := range []string{state.CursorPhase, state.CursorStatus} {
-		if value, found := state.CursorField(lines, key); found {
-			if p, ok := mapLegacyPhase(value); ok {
-				return p
-			}
-		}
-	}
-	return state.PhaseBuild
-}
-
-// mapLegacyPhase maps a current or legacy phase/status word onto the lifecycle.
-func mapLegacyPhase(word string) (state.Phase, bool) {
-	word = strings.ToLower(strings.TrimSpace(word))
-	// Take the first token, so a legacy "done" status with trailing notes still maps to "done".
-	if i := strings.IndexAny(word, " \t—-"); i > 0 {
-		word = word[:i]
-	}
-	return state.PhaseForName(word)
-}
-
-// backupWorkspace snapshots mutable state (work/, features/, and the ACTIVE pointer) into
-// a timestamped, gitignored backup directory under root before any change.
-func backupWorkspace(root string) (string, error) {
-	backup := filepath.Join(root, fmt.Sprintf(".migrate-backup-%d", time.Now().UnixNano()))
-	if err := fsutil.CopyTree(filepath.Join(root, "work"), filepath.Join(backup, "work")); err != nil {
-		return "", fmt.Errorf("copy work tree: %w", err)
-	}
-	if err := fsutil.CopyTree(filepath.Join(root, "features"), filepath.Join(backup, "features")); err != nil {
-		return "", fmt.Errorf("copy features tree: %w", err)
-	}
-	// The ACTIVE pointer is a single small file; copy it if present.
-	if data, err := os.ReadFile(filepath.Join(root, "ACTIVE")); err == nil {
-		if err := os.MkdirAll(backup, 0o755); err != nil {
-			return "", fmt.Errorf("create backup dir: %w", err)
-		}
-		if err := os.WriteFile(filepath.Join(backup, "ACTIVE"), data, 0o644); err != nil {
-			return "", fmt.Errorf("copy ACTIVE pointer: %w", err)
-		}
-	}
-	return backup, nil
-}

package/engine/internal/migrate/migrate_test.go

@@ -1,157 +0,0 @@
-package migrate
-
-import (
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-
-	"github.com/devrites/devrites/internal/state"
-	"github.com/devrites/devrites/internal/testutil"
-)
-
-func TestRunNormalizesCanonicalWorkLayout(t *testing.T) {
-	root := t.TempDir()
-	testutil.WriteFile(t, filepath.Join(root, "ACTIVE"), "alpha\n")
-	testutil.WriteFile(t, filepath.Join(root, "work/alpha/spec.md"), "spec\n")
-	testutil.WriteFile(t, filepath.Join(root, "work/alpha/plan.md"), "plan\n")
-	testutil.WriteFile(t, filepath.Join(root, "work/alpha/evidence.md"), "proof\n")
-	testutil.WriteFile(t, filepath.Join(root, "work/alpha/state.md"), "status: done - shipped\n")
-	testutil.WriteFile(t, filepath.Join(root, "work/alpha/review.md"), "review\n")
-
-	res, err := Run(root)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if res.Skipped {
-		t.Fatalf("Run skipped=true, want migration")
-	}
-	if got := strings.Join(res.Migrated, ","); got != "alpha" {
-		t.Fatalf("Run migrated=%q, want alpha", got)
-	}
-	if res.BackupDir == "" {
-		t.Fatalf("Run backup dir empty")
-	}
-
-	assertFile(t, root, "work/alpha/spec.md", "spec\n")
-	assertFile(t, root, "work/alpha/evidence.md", "proof\n")
-	assertFile(t, root, "work/alpha/state.md", "status: done - shipped\n")
-	assertFileContains(t, root, "work/alpha/README.md", "phase: done")
-	assertFileContains(t, root, "work/alpha/README.md", "schemaVersion: 2")
-	assertMissing(t, root, "work/alpha/proof.md")
-	assertMissing(t, root, "work/alpha/status.md")
-	assertFile(t, root, "work/alpha/review.md", "review\n")
-
-	f, err := state.LoadFeature(root, "alpha")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if f.Phase != state.PhaseDone {
-		t.Fatalf("migrated phase=%q, want %q", f.Phase, state.PhaseDone)
-	}
-	assertFile(t, res.BackupDir, "ACTIVE", "alpha\n")
-
-	again, err := Run(root)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !again.Skipped {
-		t.Fatalf("second Run skipped=false, migrated=%v", again.Migrated)
-	}
-}
-
-func TestRunNormalizesLiveFeatureAliases(t *testing.T) {
-	root := t.TempDir()
-	testutil.WriteFile(t, filepath.Join(root, "features/beta/feature.md"), "# Beta\n")
-	testutil.WriteFile(t, filepath.Join(root, "features/beta/status.md"), "- Phase: prove\n")
-	testutil.WriteFile(t, filepath.Join(root, "features/beta/proof.md"), "evidence\n")
-
-	res, err := Run(root)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if got := strings.Join(res.Migrated, ","); got != "beta" {
-		t.Fatalf("Run normalized=%q, want beta", got)
-	}
-	assertFileContains(t, root, "features/beta/README.md", "schemaVersion: 2")
-	assertFileContains(t, root, "features/beta/README.md", "# Beta")
-	assertFile(t, root, "features/beta/state.md", "- Phase: prove\n")
-	assertFile(t, root, "features/beta/evidence.md", "evidence\n")
-	assertFile(t, root, "features/beta/status.md", "- Phase: prove\n")
-	assertFile(t, root, "features/beta/proof.md", "evidence\n")
-
-	f, err := state.LoadFeature(root, "beta")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if f.Phase != state.PhaseProve {
-		t.Fatalf("normalized phase=%q, want %q", f.Phase, state.PhaseProve)
-	}
-}
-
-func TestRunUpgradesV1DeclarationWithoutFabricatingReadiness(t *testing.T) {
-	root := t.TempDir()
-	testutil.WriteFile(t, filepath.Join(root, "work/old/README.md"), "---\nphase: vet\nschemaVersion: 1\n---\n\nOld workspace.\n")
-	testutil.WriteFile(t, filepath.Join(root, "work/old/state.md"), "| phase | vet |\n")
-
-	result, err := Run(root)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if result.Skipped || strings.Join(result.Migrated, ",") != "old" {
-		t.Fatalf("result=%+v, want old migrated", result)
-	}
-	assertFileContains(t, root, "work/old/README.md", "schemaVersion: 2")
-	for _, name := range []string{"decision-coverage.md", "eng-review.md", "test-plan.md"} {
-		assertMissing(t, root, filepath.Join("work/old", name))
-	}
-}
-
-func TestMapLegacyPhase(t *testing.T) {
-	for _, phase := range state.LifecyclePhases() {
-		got, ok := mapLegacyPhase(string(phase))
-		if !ok || got != phase {
-			t.Fatalf("mapLegacyPhase(%q)=(%q,%v), want canonical phase", phase, got, ok)
-		}
-	}
-
-	for _, tc := range []struct {
-		word string
-		want state.Phase
-		ok   bool
-	}{
-		{word: "specced", want: state.PhaseSpec, ok: true},
-		{word: "clarified", want: state.PhaseClarify, ok: true},
-		{word: "in-progress", want: state.PhaseBuild, ok: true},
-		{word: "reviewing", want: state.PhaseReview, ok: true},
-		{word: "done - shipped", want: state.PhaseDone, ok: true},
-		{word: "done — shipped", want: state.PhaseDone, ok: true},
-		{word: "mystery"},
-	} {
-		got, ok := mapLegacyPhase(tc.word)
-		if got != tc.want || ok != tc.ok {
-			t.Fatalf("mapLegacyPhase(%q)=(%q,%v), want (%q,%v)", tc.word, got, ok, tc.want, tc.ok)
-		}
-	}
-}
-
-func assertFile(t *testing.T, root, rel, want string) {
-	t.Helper()
-	if got := testutil.ReadFile(t, filepath.Join(root, rel)); got != want {
-		t.Fatalf("%s=%q, want %q", rel, got, want)
-	}
-}
-
-func assertFileContains(t *testing.T, root, rel, want string) {
-	t.Helper()
-	if got := testutil.ReadFile(t, filepath.Join(root, rel)); !strings.Contains(got, want) {
-		t.Fatalf("%s=%q, want it to contain %q", rel, got, want)
-	}
-}
-
-func assertMissing(t *testing.T, root, rel string) {
-	t.Helper()
-	if _, err := os.Stat(filepath.Join(root, rel)); !os.IsNotExist(err) {
-		t.Fatalf("%s exists or stat failed with %v, want missing", rel, err)
-	}
-}

package/engine/internal/orient/firstrun.go

@@ -1,50 +0,0 @@
-package orient
-
-import (
-	"os"
-	"path/filepath"
-
-	"github.com/devrites/devrites/internal/lib"
-)
-
-// FirstRunFile names the marker, under the .devrites root, that records that the
-// one-time blank-slate orientation has been shown. It is runtime state like
-// ACTIVE: preserved on uninstall, so a reinstall never re-nags.
-const FirstRunFile = ".first-run-shown"
-
-// firstRunNudges maps each first-task token to the single orientation line shown
-// on the first-ever session with no active feature. A token missing here (or a
-// future new token) stays silent: the nudge is an enhancement, never a
-// dependency, and prose is owned here rather than in the classifier.
-var firstRunNudges = map[string]string{
-	"greenfield":           "Greenfield project: start with /rite-spec <feature> to spec the first feature.",
-	"brownfield-unadopted": "Existing codebase with no DevRites history: start with /rite-adopt to onboard it.",
-	"dirty-worktree":       "Uncommitted changes in the worktree: /rite-frame the work in flight, or /rite-quick for a small fix.",
-	"branch-ahead":         "Branch is ahead of its upstream: /rite-review then /rite-ship the unshipped work.",
-	"clean-default":        "No active feature: /rite-spec <feature> starts the next one; /rite shows the menu.",
-}
-
-// FirstRunDigest returns the one-time blank-slate orientation for a workspace
-// with no active feature. It fires at most once per project: the marker is
-// written before the text is returned, and a marker that cannot be written
-// keeps the digest silent so a broken filesystem never turns into a per-session
-// nag. Fail-open throughout: every non-happy path is ("", false).
-func FirstRunDigest(root string) (text string, has bool) {
-	marker := filepath.Join(root, FirstRunFile)
-	if _, err := os.Stat(marker); err == nil {
-		return "", false
-	}
-	nudge, ok := firstRunNudges[lib.FirstTaskToken(root)]
-	if !ok {
-		return "", false
-	}
-	f, err := os.OpenFile(marker, os.O_CREATE|os.O_EXCL|os.O_WRONLY, 0o644)
-	if err != nil {
-		return "", false // marker unwritable (or raced): silent rather than nagging
-	}
-	if err := f.Close(); err != nil {
-		return "", false
-	}
-	return "DevRites is installed but no feature is active. " + nudge +
-		"\n(One-time orientation; /rite shows the full menu.)", true
-}

package/engine/internal/orient/firstrun_test.go

@@ -1,72 +0,0 @@
-package orient
-
-import (
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-)
-
-func newBlankRoot(t *testing.T) string {
-	t.Helper()
-	root := filepath.Join(t.TempDir(), ".devrites")
-	if err := os.MkdirAll(root, 0o755); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.WriteFile(filepath.Join(root, ActiveFile), nil, 0o644); err != nil {
-		t.Fatal(err)
-	}
-	return root
-}
-
-func TestFirstRunDigestGreenfieldNudgesOnce(t *testing.T) {
-	root := newBlankRoot(t)
-	text, has := FirstRunDigest(root)
-	if !has {
-		t.Fatal("first call: want a nudge, got silence")
-	}
-	if !strings.Contains(text, "/rite-spec") {
-		t.Fatalf("greenfield nudge should point at /rite-spec, got %q", text)
-	}
-	if _, err := os.Stat(filepath.Join(root, FirstRunFile)); err != nil {
-		t.Fatalf("marker not written: %v", err)
-	}
-	if _, has = FirstRunDigest(root); has {
-		t.Fatal("second call: want silence, marker should suppress")
-	}
-}
-
-func TestFirstRunDigestBrownfieldPointsAtAdopt(t *testing.T) {
-	root := newBlankRoot(t)
-	project := filepath.Dir(root)
-	if err := os.WriteFile(filepath.Join(project, "package.json"), []byte("{}"), 0o644); err != nil {
-		t.Fatal(err)
-	}
-	text, has := FirstRunDigest(root)
-	if !has {
-		t.Fatal("want a nudge, got silence")
-	}
-	if !strings.Contains(text, "/rite-adopt") {
-		t.Fatalf("brownfield nudge should point at /rite-adopt, got %q", text)
-	}
-}
-
-func TestFirstRunDigestActiveFeatureStaysSilent(t *testing.T) {
-	root := newBlankRoot(t)
-	if err := os.WriteFile(filepath.Join(root, ActiveFile), []byte("some-feature\n"), 0o644); err != nil {
-		t.Fatal(err)
-	}
-	if _, has := FirstRunDigest(root); has {
-		t.Fatal("active feature: first-run nudge must stay silent")
-	}
-	if _, err := os.Stat(filepath.Join(root, FirstRunFile)); !os.IsNotExist(err) {
-		t.Fatalf("active feature must not consume the first-run marker, stat err = %v", err)
-	}
-}
-
-func TestFirstRunDigestUnwritableMarkerStaysSilent(t *testing.T) {
-	root := filepath.Join(t.TempDir(), "missing", ".devrites")
-	if _, has := FirstRunDigest(root); has {
-		t.Fatal("unwritable marker: want silence, never a per-session nag")
-	}
-}

package/engine/internal/orient/orient.go

@@ -1,69 +0,0 @@
-// Package orient builds the SessionStart orientation digest injected at the top
-// of a session, so the model knows a DevRites workflow is in flight and where it
-// stands. It reads workspace state from files and makes zero model or network calls. It is silent
-// when there is nothing to say, mirroring the legacy devrites-orient.sh: an
-// enhancement, never a dependency.
-package orient
-
-import (
-	"fmt"
-	"strings"
-
-	"github.com/devrites/devrites/internal/devritespaths"
-	"github.com/devrites/devrites/internal/lib"
-	"github.com/devrites/devrites/internal/state"
-)
-
-// ActiveFile names the pointer file, under the .devrites root, that records the
-// slug of the feature currently being worked. An absent or empty pointer means
-// no feature is active and orientation stays silent.
-const ActiveFile = "ACTIVE"
-
-// Digest returns the orientation text for the workspace at root and whether
-// there is anything to say. It returns ("", false, nil): silent, not an error:
-// when no feature is active or the active pointer is stale, so a session is never
-// disrupted by a missing or half-set-up workspace.
-func Digest(root string) (text string, has bool, err error) {
-	slug, err := ActiveSlug(root)
-	if err != nil {
-		return "", false, fmt.Errorf("orient digest: %w", err)
-	}
-	if slug == "" {
-		return "", false, nil
-	}
-
-	// A stale pointer (names a feature that no longer exists) stays silent
-	// rather than erroring: orientation must never be a session dependency.
-	report, err := state.Status(root, slug)
-	if err != nil {
-		return "", false, nil
-	}
-
-	var b strings.Builder
-	fmt.Fprintf(&b, "DevRites workflow active: feature %q at phase %q.\n\n", report.Slug, report.Phase)
-	b.WriteString(report.Render())
-
-	// Surface only the high-confidence, human-promoted learnings, capped so a
-	// growing ledger never bloats the session. Bounds come from
-	// DEVRITES_LEARNING_CONFIDENCE_THRESHOLD / DEVRITES_MAX_INJECTED_LEARNINGS.
-	if picks := lib.TopLearnings(root, lib.InjectMax(), lib.InjectThreshold()); len(picks) > 0 {
-		b.WriteString("\n\nHigh-confidence learnings (untrusted prior: live code always wins):\n")
-		for _, p := range picks {
-			b.WriteString(p)
-			b.WriteByte('\n')
-		}
-	}
-
-	b.WriteString("\nThis is the current state; the next host-specific DevRites command (/rite-* in Claude Code, $rite-* in Codex) will re-run its own step-0 preamble.")
-	return b.String(), true, nil
-}
-
-// ActiveSlug reads and trims the active-feature pointer. A missing pointer file
-// is not an error: it yields the empty slug (no active feature).
-func ActiveSlug(root string) (string, error) {
-	return devritespaths.ActiveSlug(root)
-}
-
-// ResolveRoot is a thin re-export so hook callers can fail open on a
-// non-DevRites directory without importing state directly.
-var ResolveRoot = state.ResolveRoot

package/engine/internal/orient/orient_test.go

@@ -1,25 +0,0 @@
-package orient
-
-import (
-	"os"
-	"path/filepath"
-	"testing"
-)
-
-func TestActiveSlugHonorsExplicitWorkspace(t *testing.T) {
-	root := filepath.Join(t.TempDir(), ".devrites")
-	if err := os.MkdirAll(root, 0o755); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.WriteFile(filepath.Join(root, ActiveFile), []byte("other\n"), 0o644); err != nil {
-		t.Fatal(err)
-	}
-	t.Setenv("DEVRITES_WORKSPACE", filepath.Join(root, "work", "explicit"))
-	slug, err := ActiveSlug(root)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if slug != "explicit" {
-		t.Fatalf("ActiveSlug = %q, want explicit", slug)
-	}
-}