devrites 3.2.28 → 4.0.0

package/engine/commands.go

@@ -1,17 +1,12 @@
 package main
 
 import (
-	"encoding/json"
 	"errors"
-	"fmt"
-	"io"
 	"os"
 	"path/filepath"
 	"strings"
 
 	"github.com/devrites/devrites/internal/devritespaths"
-	"github.com/devrites/devrites/internal/doctor"
-	"github.com/devrites/devrites/internal/migrate"
 	"github.com/devrites/devrites/internal/rootfacts"
 	"github.com/devrites/devrites/internal/state"
 )
@@ -31,102 +26,24 @@ const (
 func rootModeFor(command string, args []string) rootMode {
 	subcommand := firstRootOperand(args)
 	switch command {
-	case "first-task", "spec-dedupe", "evidence-fresh", "coverage",
-		"doubt-coverage", "budget", "preamble", "progress",
-		"build-readiness", "readiness-digest", "analyze", "mutation-gate",
-		"test-integrity", "review-integrity",
-		"archive-search", "config", "reviewers", "outside-voice", "docs-stale",
-		"secret-scan", "lanes", "overrides":
+	case "secret-scan":
 		return rootLenient
-	case "clarify-return", "reconcile", "close-out", "forge":
-		return rootStrict
-	case "resolve":
-		if subcommand == "next-qid" {
-			return rootLenient
-		}
-		return rootStrict
-	case "footprint", "stuck":
-		if subcommand == "log" {
-			return rootStrict
-		}
-		return rootLenient
-	case "recovery":
-		if subcommand == "record" || subcommand == "clear" {
-			return rootStrict
-		}
-		return rootLenient
-	case "decisions":
-		if subcommand == "index" {
-			return rootStrict
-		}
-		return rootLenient
-	case "ledger":
-		if subcommand == "sync" {
-			return rootStrict
-		}
-		return rootLenient
-	case "learnings":
-		if subcommand == "add" {
-			return rootStrict
-		}
-		return rootLenient
-	case "timeline":
-		if subcommand == "log" || subcommand == "purge" {
-			return rootStrict
-		}
-		return rootLenient
-	case "health":
-		if subcommand == "" || subcommand == "run" || subcommand == "check" || subcommand == "record" {
-			return rootStrict
-		}
-		return rootLenient
-	case "review-fingerprints":
-		if hasRootFlag(args, "--write") {
-			return rootStrict
-		}
-		return rootLenient
-	case "reviewer-stats":
-		if subcommand == "record" {
-			return rootStrict
-		}
-		return rootLenient
-	case "extensions":
-		if subcommand == "sync" {
-			return rootStrict
-		}
-		return rootLenient
-	case "context":
-		if subcommand == "sync" {
-			return rootStrict
-		}
-		return rootLenient
-	case "runbook":
-		if subcommand == "run" || subcommand == "resume" {
+	case "state":
+		switch subcommand {
+		case "resolve", "close":
 			return rootStrict
 		}
-		return rootLenient
+		return rootUnused
 	default:
 		return rootUnused
 	}
 }
 
 func firstRootOperand(args []string) string {
-	for _, arg := range args {
-		if arg == "--json" {
-			continue
-		}
-		return strings.ToLower(strings.TrimSpace(arg))
-	}
-	return ""
-}
-
-func hasRootFlag(args []string, flag string) bool {
-	for _, arg := range args {
-		if arg == flag {
-			return true
-		}
+	if len(args) == 0 {
+		return ""
 	}
-	return false
+	return strings.ToLower(strings.TrimSpace(args[0]))
 }
 
 // resolveRootFor resolves exactly once per command invocation. Strict commands
@@ -173,170 +90,3 @@ func fallbackRoot() string {
 	}
 	return filepath.Join(cwd, devritespaths.DevritesRootName)
 }
-
-func readFile(path string) string {
-	raw, err := os.ReadFile(path)
-	if err != nil {
-		return ""
-	}
-	return string(raw)
-}
-
-func gitDir(projectDir string) string {
-	path := filepath.Join(projectDir, ".git")
-	if info, err := os.Stat(path); err == nil && info.IsDir() {
-		return path
-	}
-	line := strings.TrimSpace(readFile(path))
-	if target, ok := strings.CutPrefix(line, "gitdir:"); ok {
-		target = strings.TrimSpace(target)
-		if filepath.IsAbs(target) {
-			return target
-		}
-		return filepath.Clean(filepath.Join(projectDir, target))
-	}
-	return path
-}
-
-func gitOperation(projectDir, resolvedGitDir string) string {
-	dir := resolvedGitDir
-	if dir == "" {
-		dir = gitDir(projectDir)
-	}
-	if _, err := os.Stat(filepath.Join(dir, "MERGE_HEAD")); err == nil {
-		return "merge"
-	}
-	for _, name := range []string{"rebase-merge", "rebase-apply"} {
-		if info, err := os.Stat(filepath.Join(dir, name)); err == nil && info.IsDir() {
-			return "rebase"
-		}
-	}
-	return ""
-}
-
-// cmdDoctor reports canonical root facts and the binary, pack, and state schema
-// versions. It exits nonzero for an unsafe root or newer state schema. Missing
-// optional data and warnings remain diagnostic.
-func cmdDoctor(args []string, stdout, stderr io.Writer) int {
-	if len(args) > 1 || len(args) == 1 && args[0] != "--verbose" {
-		fmt.Fprintln(stderr, "usage: devrites-engine doctor [--verbose]")
-		return exitUsage
-	}
-	facts, resolveErr := rootfacts.Resolve(os.Getenv("DEVRITES_ROOT"))
-	if resolveErr != nil && len(facts.Hazards) == 0 {
-		fmt.Fprintf(stderr, "devrites: %v\n", resolveErr)
-		return exitUsage
-	}
-	root := facts.PhysicalRoot
-	projectDir := facts.PhysicalProject
-	report, err := doctor.DiagnoseFacts(facts)
-	if err != nil {
-		fmt.Fprintf(stderr, "devrites: %v\n", err)
-		return exitUsage
-	}
-	fmt.Fprint(stdout, report.Render())
-	if op := gitOperation(projectDir, facts.Git.Dir); op != "" {
-		fmt.Fprintf(stdout, "git-state: %s in progress: resolve with .claude/skills/devrites-lib/reference/standards/git-workflow.md#merge-conflict-recovery\n", op)
-	}
-	if root != "" {
-		for _, warning := range extensionProvenanceWarnings(root) {
-			fmt.Fprintf(stdout, "warning: %s\n", warning)
-		}
-	}
-	if root != "" {
-		slug := strings.TrimSpace(readFile(filepath.Join(root, "ACTIVE")))
-		if snap, err := state.Snapshot(root, slug); err == nil {
-			fmt.Fprintln(stdout)
-			fmt.Fprintln(stdout, "readiness-dashboard:")
-			fmt.Fprintf(stdout, "  active: %s (%s, %s)\n", snap.Slug, snap.Phase, snap.RunMode)
-			fmt.Fprintf(stdout, "  evidence: %s\n", snap.Evidence.Status)
-			fmt.Fprintf(stdout, "  drift: %s\n", snap.Drift.Status)
-			fmt.Fprintf(stdout, "  review: %s\n", snap.Review.Status)
-			fmt.Fprintf(stdout, "  harness: %s: %s\n", snap.Harness.Status, snap.Harness.Detail)
-			fmt.Fprintf(stdout, "  extensions: %s (%d)\n", snap.Extensions.Status, snap.Extensions.Count)
-			fmt.Fprintf(stdout, "  worktree: %s (%d changed)\n", snap.DirtyWorkspace.Status, snap.DirtyWorkspace.Changed)
-			fmt.Fprintln(stdout, "  capabilities:")
-			for _, cap := range snap.Capabilities {
-				fmt.Fprintf(stdout, "    - %s: %s · used by %s · fallback: %s · risk: %s\n", cap.Name, cap.Status, cap.UsedBy, cap.Fallback, cap.Risk)
-			}
-		}
-	}
-	if report.Refuse {
-		return exitBlocked
-	}
-	return exitOK
-}
-
-// cmdMigrate normalizes workspaces to the current schema. It is idempotent
-// (a second run is a no-op) and backs up the pre-migration state first.
-func extensionProvenanceWarnings(root string) []string {
-	dir := filepath.Join(root, "extensions")
-	entries, err := os.ReadDir(dir)
-	if err != nil {
-		return nil
-	}
-	var warnings []string
-	for _, entry := range entries {
-		if !entry.IsDir() || strings.HasPrefix(entry.Name(), ".") {
-			continue
-		}
-		edir := filepath.Join(dir, entry.Name())
-		hasArtifact := readFile(filepath.Join(edir, "skill", "SKILL.md")) != "" || readFile(filepath.Join(edir, "agent.md")) != "" || readFile(filepath.Join(edir, "component.yaml")) != ""
-		if hasArtifact && readFile(filepath.Join(edir, "provenance.json")) == "" {
-			warnings = append(warnings, fmt.Sprintf("extension %s has no provenance.json", entry.Name()))
-		}
-	}
-	return warnings
-}
-
-func cmdMigrate(args []string, stdout, stderr io.Writer) int {
-	if len(args) != 0 {
-		fmt.Fprintln(stderr, "usage: devrites-engine migrate")
-		return exitUsage
-	}
-	root, err := state.ResolveRoot(os.Getenv("DEVRITES_ROOT"))
-	if err != nil {
-		fmt.Fprintf(stderr, "devrites: %v\n", err)
-		return exitUsage
-	}
-	result, err := migrate.Run(root)
-	if err != nil {
-		fmt.Fprintf(stderr, "devrites: migrate failed: %v\n", err)
-		return 1
-	}
-	if result.Skipped {
-		fmt.Fprintln(stdout, "migrate: already up to date (no workspace normalization needed)")
-		return exitOK
-	}
-	fmt.Fprintf(stdout, "migrated %d feature(s): %v\n", len(result.Migrated), result.Migrated)
-	fmt.Fprintf(stdout, "backup: %s\n", result.BackupDir)
-	return exitOK
-}
-
-func cmdSnapshot(args []string, stdout, stderr io.Writer) int {
-	if len(args) > 1 {
-		fmt.Fprintln(stderr, "usage: devrites-engine snapshot [slug]")
-		return exitUsage
-	}
-	root, err := state.ResolveRoot(os.Getenv("DEVRITES_ROOT"))
-	if err != nil {
-		fmt.Fprintf(stderr, "devrites: %v\n", err)
-		return exitUsage
-	}
-	slug := ""
-	if len(args) == 1 {
-		slug = args[0]
-	}
-	snapshot, err := state.Snapshot(root, slug)
-	if err != nil {
-		fmt.Fprintf(stderr, "devrites: %v\n", err)
-		return exitUsage
-	}
-	data, err := json.MarshalIndent(snapshot, "", "  ")
-	if err != nil {
-		fmt.Fprintf(stderr, "devrites: cannot render snapshot JSON: %v\n", err)
-		return exitUsage
-	}
-	_, _ = stdout.Write(append(data, '\n'))
-	return exitOK
-}

package/engine/harnessmatrix_test.go

@@ -2,58 +2,45 @@ package main
 
 import (
 	"bytes"
-	"os"
-	"path/filepath"
 	"strings"
 	"testing"
-
-	"github.com/devrites/devrites/internal/harness"
 )
 
-func TestHarnessMatrixRender(t *testing.T) {
-	var out, errb bytes.Buffer
-	if code := cmdHarnessMatrix(nil, &out, &errb); code != exitOK {
-		t.Fatalf("render exit %d", code)
+func TestHarnessMatrixCommandIsRemoved(t *testing.T) {
+	var stdout, stderr bytes.Buffer
+	if code := run([]string{"harness-matrix"}, strings.NewReader(""), &stdout, &stderr); code != exitUsage {
+		t.Fatalf("run(harness-matrix) = %d, want %d", code, exitUsage)
 	}
-	if !strings.Contains(out.String(), harness.MatrixBeginMarker) {
-		t.Error("rendered block missing begin marker")
+	if stdout.Len() != 0 {
+		t.Fatalf("stdout = %q, want no success output", stdout.String())
 	}
-}
-
-func TestHarnessMatrixCheckInSync(t *testing.T) {
-	dir := t.TempDir()
-	doc := filepath.Join(dir, "m.md")
-	body := "# heading\n\n" + harness.RenderMatrix() + "\n\ntrailing prose\n"
-	if err := os.WriteFile(doc, []byte(body), 0o644); err != nil {
-		t.Fatal(err)
+	if !strings.Contains(stderr.String(), `unknown command "harness-matrix"`) {
+		t.Fatalf("stderr = %q, want unknown-command diagnostic", stderr.String())
+	}
+	if !strings.Contains(stderr.String(), "Usage:") {
+		t.Fatalf("stderr = %q, want help after unknown-command diagnostic", stderr.String())
 	}
-	var out, errb bytes.Buffer
-	if code := cmdHarnessMatrix([]string{"--check", doc}, &out, &errb); code != exitOK {
-		t.Fatalf("in-sync doc should pass, got %d: %s", code, errb.String())
+	if strings.Contains(stderr.String(), "\n  devrites-engine harness-matrix ") {
+		t.Fatalf("usage still advertises harness-matrix:\n%s", stderr.String())
 	}
 }
 
-func TestHarnessMatrixCheckDrift(t *testing.T) {
-	dir := t.TempDir()
-	doc := filepath.Join(dir, "m.md")
-	drifted := strings.Replace(harness.RenderMatrix(), "Native", "MADE-UP", 1)
-	if err := os.WriteFile(doc, []byte(drifted), 0o644); err != nil {
-		t.Fatal(err)
+func TestHarnessMatrixCheckCommandIsRemoved(t *testing.T) {
+	var stdout, stderr bytes.Buffer
+	args := []string{"harness-matrix", "--check", "docs/harness-compliance.md"}
+	if code := run(args, strings.NewReader(""), &stdout, &stderr); code != exitUsage {
+		t.Fatalf("run(%q) = %d, want %d", args, code, exitUsage)
 	}
-	var out, errb bytes.Buffer
-	if code := cmdHarnessMatrix([]string{"--check", doc}, &out, &errb); code != exitBlocked {
-		t.Fatalf("drifted doc should block (exit 3), got %d", code)
+	if stdout.Len() != 0 {
+		t.Fatalf("stdout = %q, want no success output", stdout.String())
 	}
-}
-
-func TestHarnessMatrixCheckMissingMarkers(t *testing.T) {
-	dir := t.TempDir()
-	doc := filepath.Join(dir, "m.md")
-	if err := os.WriteFile(doc, []byte("no markers here"), 0o644); err != nil {
-		t.Fatal(err)
-	}
-	var out, errb bytes.Buffer
-	if code := cmdHarnessMatrix([]string{"--check", doc}, &out, &errb); code != exitBlocked {
-		t.Fatalf("missing markers should block, got %d", code)
+	if !strings.Contains(stderr.String(), `unknown command "harness-matrix"`) {
+		t.Fatalf("stderr = %q, want unknown-command diagnostic", stderr.String())
+	}
+	if !strings.Contains(stderr.String(), "Usage:") {
+		t.Fatalf("stderr = %q, want help after unknown-command diagnostic", stderr.String())
+	}
+	if strings.Contains(stderr.String(), "\n  devrites-engine harness-matrix ") {
+		t.Fatalf("usage still advertises harness-matrix:\n%s", stderr.String())
 	}
 }

package/engine/internal/devritespaths/paths.go

@@ -66,7 +66,7 @@ func WorkspaceOverrideChecked(root, slug string) (string, error) {
 		return r == '/' || r == '\\'
 	})
 	canonicalWorkspace := relErr == nil && len(parts) == 2 &&
-		(parts[0] == "work" || parts[0] == "features")
+		parts[0] == "work"
 	if sameRoot || !canonicalWorkspace || !validSlug(filepath.Base(path)) {
 		return "", fmt.Errorf("DRV-WORKSPACE-INVALID: DEVRITES_WORKSPACE %q is not a feature workspace; run `unset DEVRITES_WORKSPACE`", raw)
 	}
@@ -76,25 +76,16 @@ func WorkspaceOverrideChecked(root, slug string) (string, error) {
 	return path, nil
 }
 
-// FeatureDir is the per-feature workspace directory under root. work/ is
-// canonical; features/ remains readable as a compatibility alias.
+// FeatureDir is the canonical per-feature workspace directory under root.
 func FeatureDir(root, slug string) string {
 	if ws := WorkspaceOverride(root, slug); ws != "" {
 		return ws
 	}
-	work := filepath.Join(root, "work", slug)
-	if isDir(work) {
-		return work
-	}
-	features := filepath.Join(root, "features", slug)
-	if isDir(features) {
-		return features
-	}
-	return work
+	return filepath.Join(root, "work", slug)
 }
 
 // ExistingFeatureDirChecked resolves an existing canonical feature workspace
-// without following a work/<slug> or features/<slug> symlink. Mutating
+// without following a work/<slug> symlink. Mutating
 // control-plane commands use this instead of FeatureDir so an attacker cannot
 // redirect archive/removal operations outside the selected DevRites root.
 func ExistingFeatureDirChecked(root, slug string) (string, error) {
@@ -106,17 +97,15 @@ func ExistingFeatureDirChecked(root, slug string) (string, error) {
 	} else if ws != "" {
 		return ws, nil
 	}
-	for _, parent := range []string{"work", "features"} {
-		candidate := filepath.Join(root, parent, slug)
-		resolved, err := checkedCanonicalDir(root, candidate, parent, slug)
-		if err == nil {
-			return resolved, nil
-		}
-		if !errors.Is(err, os.ErrNotExist) {
-			return "", err
-		}
+	candidate := filepath.Join(root, "work", slug)
+	resolved, err := checkedCanonicalDir(root, candidate, "work", slug)
+	if err == nil {
+		return resolved, nil
 	}
-	return "", os.ErrNotExist
+	if errors.Is(err, os.ErrNotExist) {
+		return "", os.ErrNotExist
+	}
+	return "", err
 }
 
 // ArchiveDirChecked resolves (or safely prepares) the canonical archive
@@ -199,11 +188,6 @@ func ActiveSlug(root string) (string, error) {
 	return slug, nil
 }
 
-func isDir(path string) bool {
-	info, err := os.Stat(path)
-	return err == nil && info.IsDir()
-}
-
 func validSlug(slug string) bool {
 	return slug != "" && slug != "." && slug != ".." &&
 		filepath.Base(slug) == slug &&

package/engine/internal/fsutil/copy.go

@@ -5,8 +5,16 @@ import (
 	"io/fs"
 	"os"
 	"path/filepath"
+	"runtime"
 )
 
+// PermissionsMatch compares POSIX permission bits where the platform exposes
+// them. Windows os.FileMode synthesizes 0666/0777 from file attributes, so its
+// inherited ACL remains the security boundary instead.
+func PermissionsMatch(mode, want fs.FileMode) bool {
+	return runtime.GOOS == "windows" || mode.Perm() == want.Perm()
+}
+
 // WriteFileAtomic writes path by first writing a sibling temp file and then
 // renaming it into place.
 func WriteFileAtomic(path string, data []byte, perm fs.FileMode) error {