devrites 4.1.0 → 4.3.0

package/engine/internal/state/status.go

@@ -6,78 +6,119 @@ import (
 )
 
 // Report is the computed completeness status of a feature at its current phase.
-// It embeds the loaded Feature (Slug, Phase, Present) and adds the phase-relative
-// required set and the missing sections.
 type Report struct {
-	*Feature
-	Required      map[Section]bool
-	Missing       []Section // legacy required-but-empty sections, in Sections order
-	RequiredFiles map[string]bool
-	MissingFiles  []string // required-but-empty workspace files, in lifecycle order
+	Slug              string
+	Phase             Phase
+	Status            string
+	NextAction        string
+	PrinciplesPresent bool
+	Required          map[Section]bool
+	Missing           []Section // required-but-empty sections, in policy order
+	RequiredFiles     map[string]bool
+	MissingFiles      []string // required-but-empty workspace files, in lifecycle order
+	present           map[Section]bool
+	diagnostics       []ArtifactDiagnostic
 }
 
-// Status computes the status report for feature <slug> under root by reading
-// the files directly. It reports completeness relative to the feature's current
-// phase only.
+// Status computes phase-relative completeness from one retained workspace observation.
 func Status(root, slug string) (*Report, error) {
-	f, err := LoadFeature(root, slug)
+	return statusWithCallback(root, slug, nil)
+}
+
+func statusWithCallback(root, slug string, callback observationCallback) (*Report, error) {
+	observation, err := observeWorkspace(root, slug, callback)
+	if err != nil {
+		return nil, err
+	}
+	phase, err := observation.DeclaredPhase()
 	if err != nil {
 		return nil, fmt.Errorf("compute status: %w", err)
 	}
-	return NewReport(f), nil
+	policy, _ := PolicyFor(phase)
+	return newObservationReport(observation, phase, policy), nil
 }
 
-// NewReport computes the phase-relative required set and missing sections for a
-// loaded Feature.
-func NewReport(f *Feature) *Report {
-	required := make(map[Section]bool)
-	for _, s := range RequiredSections(f.Phase) {
-		required[s] = true
+func observationCursorFields(observation *WorkspaceObservation) (status, nextAction string, principlesPresent bool) {
+	if fact, ok := observation.Fact(".devrites/principles.md"); ok && fact.State() == ArtifactPresent {
+		principlesPresent = true
+	}
+	fact, ok := observation.Fact(LedgerFile)
+	if !ok || fact.State() != ArtifactPresent {
+		return "", "", principlesPresent
 	}
-	requiredFiles := make(map[string]bool)
-	for _, name := range RequiredWorkspaceFiles(f.Phase) {
-		requiredFiles[name] = true
+	lines := strings.Split(string(fact.Bytes()), "\n")
+	if value, ok := CursorField(lines, CursorStatus); ok {
+		status = value
+	}
+	if value, ok := CursorField(lines, CursorNextAction); ok {
+		nextAction = value
+	}
+	return status, nextAction, principlesPresent
+}
+
+func newObservationReport(observation *WorkspaceObservation, phase Phase, policy PhasePolicy) *Report {
+	present := observationSectionPresence(observation)
+	required := requiredSections(policy)
+	requiredFiles := requiredArtifactSet(policy)
+	missingArtifacts, diagnostics := observation.Missing(policy.RequiredArtifacts)
+	missingFiles := make([]string, len(missingArtifacts))
+	for i, artifact := range missingArtifacts {
+		missingFiles[i] = string(artifact)
 	}
-	missingFiles := MissingWorkspaceFiles(f, f.Phase)
+	status, nextAction, principlesPresent := observationCursorFields(observation)
 	return &Report{
-		Feature:       f,
-		Required:      required,
-		Missing:       MissingFor(f, f.Phase),
-		RequiredFiles: requiredFiles,
-		MissingFiles:  missingFiles,
+		Slug:              observation.Slug(),
+		Phase:             phase,
+		Status:            status,
+		NextAction:        nextAction,
+		PrinciplesPresent: principlesPresent,
+		Required:          required,
+		Missing:           missingObservationSections(present, policy.RequiredSections),
+		RequiredFiles:     requiredFiles,
+		MissingFiles:      missingFiles,
+		present:           present,
+		diagnostics:       diagnostics,
 	}
 }
 
-// MissingFor returns the sections required to complete phase p that the feature
-// does not yet have real content for, in canonical Sections order. Gates use it
-// to check completeness against a phase other than the feature's current one
-// (e.g. seal always checks the full seal-phase set), so its result is
-// independent of f.Phase.
-func MissingFor(f *Feature, p Phase) []Section {
-	required := make(map[Section]bool)
-	for _, s := range RequiredSections(p) {
-		required[s] = true
+func observationSectionPresence(observation *WorkspaceObservation) map[Section]bool {
+	present := make(map[Section]bool, len(Sections))
+	for _, section := range Sections {
+		for _, name := range sectionFiles[section] {
+			fact, ok := observation.Fact(ArtifactPath(name))
+			if ok && fact.State() == ArtifactPresent {
+				present[section] = true
+				break
+			}
+		}
 	}
+	return present
+}
+
+func missingObservationSections(present map[Section]bool, required []Section) []Section {
 	var missing []Section
-	for _, s := range Sections {
-		if required[s] && !f.Present[s] {
-			missing = append(missing, s)
+	for _, section := range required {
+		if !present[section] {
+			missing = append(missing, section)
 		}
 	}
 	return missing
 }
 
-// MissingWorkspaceFiles returns the concrete lifecycle artifacts required for
-// p that do not contain real content. It is the authoritative runtime
-// completeness view; Section completeness remains only a compact legacy view.
-func MissingWorkspaceFiles(f *Feature, p Phase) []string {
-	var missing []string
-	for _, name := range RequiredWorkspaceFiles(p) {
-		if !f.PresentFiles[name] {
-			missing = append(missing, name)
-		}
+func requiredSections(policy PhasePolicy) map[Section]bool {
+	required := make(map[Section]bool, len(policy.RequiredSections))
+	for _, section := range policy.RequiredSections {
+		required[section] = true
 	}
-	return missing
+	return required
+}
+
+func requiredArtifactSet(policy PhasePolicy) map[string]bool {
+	required := make(map[string]bool, len(policy.RequiredArtifacts))
+	for _, artifact := range policy.RequiredArtifacts {
+		required[string(artifact)] = true
+	}
+	return required
 }
 
 // Complete reports whether every concrete canonical-workspace file required by
@@ -92,19 +133,22 @@ func (r *Report) Render() string {
 	var b strings.Builder
 	fmt.Fprintf(&b, "feature: %s\n", r.Slug)
 	fmt.Fprintf(&b, "phase: %s\n", r.Phase)
-	for _, s := range Sections {
+	for _, section := range Sections {
 		state := "empty"
-		if r.Present[s] {
+		if r.present[section] {
 			state = "present"
 		}
 		mark := ""
-		if r.Required[s] {
+		if r.Required[section] {
 			mark = "required"
 		}
-		line := fmt.Sprintf("  %-10s %-8s %s", s, state, mark)
+		line := fmt.Sprintf("  %-10s %-8s %s", section, state, mark)
 		b.WriteString(strings.TrimRight(line, " "))
 		b.WriteByte('\n')
 	}
+	for _, diagnostic := range r.diagnostics {
+		fmt.Fprintf(&b, "artifact: %s: %s (%s)\n", diagnostic.Path, diagnostic.State, diagnostic.Code)
+	}
 	if r.Complete() {
 		b.WriteString("result: complete\n")
 	} else {

package/engine/main.go

@@ -10,6 +10,7 @@ import (
 	"github.com/devrites/devrites/internal/gate"
 	"github.com/devrites/devrites/internal/install"
 	"github.com/devrites/devrites/internal/lib"
+	"github.com/devrites/devrites/internal/parallel"
 	"github.com/devrites/devrites/internal/state"
 	"github.com/devrites/devrites/internal/version"
 )
@@ -24,6 +25,12 @@ Usage:
   devrites-engine check readiness <slug>   Check required files and the stable Build-input binding
   devrites-engine check readiness --emit-binding <slug>  Emit the stable Build-input binding for Vet
   devrites-engine check seal <slug>        Recheck the Build-input binding, final files, and evidence freshness
+  devrites-engine check path-disjoint [--root <dir>] [<json-file>|-]
+                                         Verify slice path sets are pairwise disjoint
+  devrites-engine check task-graph <slug>  Validate tasks.md slice dependency graph
+  devrites-engine check skill-trust <path> Scan one skill/agent Markdown for trust violations
+  devrites-engine observe summary <slug>   Emit sanitized JSON workspace summary
+  devrites-engine parallel <subcommand>   Deterministic parallel worktree lease/create/integrate/cleanup
   devrites-engine state resolve <qid> "<ans>"  Resolve an open question and update state atomically
   devrites-engine state close <slug>       Archive a shipped feature and clear ACTIVE
   devrites-engine secret-scan [--staged] [--stdin] [slug]  Scan exact staged blobs, stdin, or touched files; HIGH blocks
@@ -71,7 +78,11 @@ func run(args []string, stdin io.Reader, stdout, stderr io.Writer) int {
 	case "uninstall":
 		return install.Run(args[1:], stdout, stderr, install.ModeUninstall)
 	case "check":
-		return cmdCheck(args[1:], stdout, stderr)
+		return cmdCheck(root, args[1:], stdin, stdout, stderr)
+	case "parallel":
+		return parallel.Run("parallel", args[1:], stdin, stdout, stderr)
+	case "observe":
+		return cmdObserve(root, args[1:], stdout, stderr)
 	case "state":
 		return cmdState(root, args[1:], stdout, stderr)
 	case "secret-scan":
@@ -88,9 +99,9 @@ func run(args []string, stdin io.Reader, stdout, stderr io.Writer) int {
 	}
 }
 
-func cmdCheck(args []string, stdout, stderr io.Writer) int {
+func cmdCheck(root string, args []string, stdin io.Reader, stdout, stderr io.Writer) int {
 	if len(args) == 0 {
-		fmt.Fprintln(stderr, "usage: devrites-engine check <candidate|readiness|seal> ...")
+		fmt.Fprintln(stderr, "usage: devrites-engine check <candidate|readiness|seal|path-disjoint|task-graph|skill-trust> ...")
 		return exitUsage
 	}
 	sub, rest := args[0], args[1:]
@@ -99,6 +110,12 @@ func cmdCheck(args []string, stdout, stderr io.Writer) int {
 		return cmdCandidate(rest, stdout, stderr)
 	case "readiness", "seal":
 		return cmdGate(gate.Kind(sub), rest, stdout, stderr)
+	case "path-disjoint":
+		return parallel.Run("path-disjoint", rest, stdin, stdout, stderr)
+	case "task-graph":
+		return cmdTaskGraph(root, rest, stdout, stderr)
+	case "skill-trust":
+		return cmdSkillTrust(rest, stdout, stderr)
 	default:
 		fmt.Fprintf(stderr, "devrites: unknown check %q\n", sub)
 		return exitUsage
@@ -185,3 +202,55 @@ func cmdGate(kind gate.Kind, args []string, stdout, stderr io.Writer) int {
 	fmt.Fprint(stdout, result.Render())
 	return exitOK
 }
+
+func cmdTaskGraph(root string, args []string, stdout, stderr io.Writer) int {
+	if len(args) != 1 {
+		fmt.Fprintln(stderr, "usage: devrites-engine check task-graph <slug>")
+		return exitUsage
+	}
+	if root == "" {
+		var err error
+		root, err = state.ResolveRoot(os.Getenv("DEVRITES_ROOT"))
+		if err != nil {
+			fmt.Fprintf(stderr, "devrites: %v\n", err)
+			return exitUsage
+		}
+	}
+	return lib.RunTaskGraphCheck(root, args[0], stdout, stderr)
+}
+
+func cmdSkillTrust(args []string, stdout, stderr io.Writer) int {
+	if len(args) != 1 {
+		fmt.Fprintln(stderr, "usage: devrites-engine check skill-trust <path>")
+		return exitUsage
+	}
+	return lib.RunSkillTrustCheck(args[0], stdout, stderr)
+}
+
+func cmdObserve(root string, args []string, stdout, stderr io.Writer) int {
+	if len(args) == 0 {
+		fmt.Fprintln(stderr, "usage: devrites-engine observe summary <slug>")
+		return exitUsage
+	}
+	if args[0] != "summary" {
+		fmt.Fprintf(stderr, "devrites: unknown observe command %q\n", args[0])
+		return exitUsage
+	}
+	if root == "" {
+		var err error
+		root, err = state.ResolveRoot(os.Getenv("DEVRITES_ROOT"))
+		if err != nil {
+			fmt.Fprintf(stderr, "devrites: %v\n", err)
+			return exitUsage
+		}
+	}
+	slug, code, err := lib.ActiveSlug(root, args[1:])
+	if err != nil {
+		fmt.Fprintf(stderr, "observe: %v\n", err)
+		if code == 0 {
+			code = exitUsage
+		}
+		return code
+	}
+	return lib.RunObserveSummary(root, slug, stdout, stderr)
+}

package/engine/root_routing_test.go

@@ -126,7 +126,7 @@ func TestNestedCommandFamilyUsageListsOnlyRetainedCommands(t *testing.T) {
 		want    string
 		removed []string
 	}{
-		{args: []string{"check"}, want: "check <candidate|readiness|seal>", removed: []string{"spec"}},
+		{args: []string{"check"}, want: "check <candidate|readiness|seal|path-disjoint|task-graph|skill-trust>", removed: []string{"spec"}},
 		{args: []string{"state"}, want: "state <resolve|close>", removed: []string{"clarify", "tick-afk", "recovery"}},
 	} {
 		t.Run(test.args[0], func(t *testing.T) {

package/engine/tests/adr_0004_required_by_phase_test.go

@@ -13,31 +13,34 @@ import (
 )
 
 func TestADR0004RequiredSectionsAreAdditiveDownTheArc(t *testing.T) {
-	phaseArc := state.LifecyclePhases()
-	for _, p := range phaseArc {
-		if !state.KnownPhase(p) {
-			t.Fatalf("phase %q in the arc is not a known phase", p)
+	policies := state.PhasePolicies()
+	for _, policy := range policies {
+		lookedUp, ok := state.PolicyFor(policy.Target)
+		if !ok || lookedUp.Target != policy.Target {
+			t.Fatalf("phase %q in the arc is not a known phase", policy.Target)
 		}
 	}
 
 	// Each phase's required set must contain everything the previous phase
 	// required: completeness only accumulates, never regresses.
-	for i := 1; i < len(phaseArc); i++ {
-		prev := asSet(state.RequiredSections(phaseArc[i-1]))
-		cur := asSet(state.RequiredSections(phaseArc[i]))
-		for s := range prev {
-			if !cur[s] {
+	for i := 1; i < len(policies); i++ {
+		previous := asSet(policies[i-1].RequiredSections)
+		current := asSet(policies[i].RequiredSections)
+		for section := range previous {
+			if !current[section] {
 				t.Errorf("phase %q dropped section %q that %q required: arc must be additive",
-					phaseArc[i], s, phaseArc[i-1])
+					policies[i].Target, section, policies[i-1].Target)
 			}
 		}
 	}
 
 	// Anchors: framing requires nothing; seal requires the full section set.
-	if got := state.RequiredSections(state.PhaseFrame); len(got) != 0 {
-		t.Errorf("frame requires %v, want none", got)
+	frame, _ := state.PolicyFor(state.PhaseFrame)
+	if len(frame.RequiredSections) != 0 {
+		t.Errorf("frame requires %v, want none", frame.RequiredSections)
 	}
-	if got, want := len(state.RequiredSections(state.PhaseSeal)), len(state.Sections); got != want {
+	seal, _ := state.PolicyFor(state.PhaseSeal)
+	if got, want := len(seal.RequiredSections), len(state.Sections); got != want {
 		t.Errorf("seal requires %d sections, want the full set of %d", got, want)
 	}
 }

package/engine/tests/adr_0011_define_plan_test.go

@@ -7,24 +7,26 @@ import (
 )
 
 func TestADR0011DefineAndPlanHaveDistinctTransitionRights(t *testing.T) {
-	if got := state.ResumeVerb(state.PhaseDefine); got != "define" {
-		t.Fatalf("define resumes %q, want define", got)
+	define, ok := state.PolicyFor(state.PhaseDefine)
+	if !ok || define.ResumeVerb != "define" {
+		t.Fatalf("define policy=(%+v,%v), want resume verb define", define, ok)
 	}
-	if got := state.ResumeVerb(state.PhasePlan); got != "vet" {
-		t.Fatalf("plan resumes %q, want vet", got)
+	plan, ok := state.PolicyFor(state.PhasePlan)
+	if !ok || plan.ResumeVerb != "vet" {
+		t.Fatalf("plan policy=(%+v,%v), want resume verb vet", plan, ok)
 	}
-	if got, ok := state.PhaseForName("planning"); ok || got != "" {
-		t.Fatalf("planning alias=(%q,%v), want speculative alias rejected", got, ok)
+	if policy, ok := state.PolicyFor(state.Phase("planning")); ok {
+		t.Fatalf("planning alias=(%+v,true), want speculative alias rejected", policy)
 	}
 
 	rights := map[string]state.Phase{}
-	for _, phase := range state.WorkflowPhases() {
-		if phase.TransitionRight == "" {
-			t.Fatalf("phase %q has no transition right", phase.ID)
+	for _, policy := range state.PhasePolicies() {
+		if policy.TransitionRight == "" {
+			t.Fatalf("phase %q has no transition right", policy.Target)
 		}
-		if prior := rights[phase.TransitionRight]; prior != "" {
-			t.Fatalf("phases %q and %q share transition right %q", prior, phase.ID, phase.TransitionRight)
+		if prior := rights[policy.TransitionRight]; prior != "" {
+			t.Fatalf("phases %q and %q share transition right %q", prior, policy.Target, policy.TransitionRight)
 		}
-		rights[phase.TransitionRight] = phase.ID
+		rights[policy.TransitionRight] = policy.Target
 	}
 }