devrites 4.4.0 → 4.4.2

package/docs/engine/commands.md

@@ -12,13 +12,13 @@ workflow strategy.
 | `update [flags]` | Refresh an existing managed installation. |
 | `uninstall [flags]` | Remove managed artifacts while preserving runtime workspace state. |
 | `check candidate <slug>` | Validate the strict manifest and compute the content-bound project-candidate identity. |
-| `check readiness <slug>` | Check target-Phase files, open human gates from Clarify onward, and the current stable Build-input binding when applicable. |
+| `check readiness <slug>` | Check target-Phase files, open human gates from Clarify onward, the `tasks.md` slice graph when that artifact is required, and the current stable Build-input binding when applicable. |
 | `check readiness --emit-binding <slug>` | Render the exact stable Build-input binding for Vet to record after review. |
-| `check seal <slug>` | Check files required by target Phase `seal`, open human gates, the stable Build-input binding, and exact candidate bindings. |
-| `check path-disjoint` with optional `--root DIR` and optional `JSON-FILE` or `-` | Verify slice path sets are pairwise disjoint. |
-| `check task-graph <slug>` | Validate `tasks.md` slice dependency graph for cycles and unknown dependencies. |
+| `check seal <slug>` | Check files required by target Phase `seal`, open human gates, the `tasks.md` slice graph, the stable Build-input binding, and exact candidate bindings. |
+| `check path-disjoint [--root <dir>] [<json-file> | -]` | Verify slice path sets are pairwise disjoint. |
+| `check task-graph <slug>` | Validate `tasks.md` slice dependency graph for cycles, unknown deps, malformed tokens, duplicate IDs, missing `Dependencies`, and `depends_on` mismatch. |
 | `check skill-trust <path>` | Scan one skill/agent Markdown file for structural trust violations. |
-| `observe summary <slug>` | Emit sanitized JSON workspace summary from one retained observation. |
+| `observe summary <slug>` | Emit sanitized JSON workspace summary from one retained observation. `task_graph.ok` is true iff `task_graph.problems` is empty; `problems` lists cycle, unknown-dep, malformed-token, duplicate-id, and missing-`Dependencies` blockers. |
 | `state resolve <qid> "<answer>"` | Resolve an open question and update `questions.md` plus `state.md` atomically. |
 | `state close <slug>` | Archive a shipped workspace and clear matching `ACTIVE`. |
 | `secret-scan [--staged] [--stdin] [slug]` | Scan exact staged blobs, stdin, or touched regular files for credential material. |
@@ -36,8 +36,9 @@ not to the engine command namespace.
 The candidate gate validates and hashes path/state/type/mode/content identity;
 it does not infer scope from Git. The readiness gate checks target-Phase
 structure and applies open-question blocking only when that target is Clarify
-or later, plus the exact stable Build-input binding after Vet. The seal gate
-always targets Phase `seal`, repeats that binding, and checks exact candidate
+or later, plus the exact `tasks.md` slice graph when `tasks.md` is required,
+plus the exact stable Build-input binding after Vet. The seal gate
+always targets Phase `seal`, repeats that graph and binding, and checks exact candidate
 bindings in evidence, optional browser evidence, review, and seal. None judges
 the meaning of `CLEAR`/`READY` prose,
 parses reviewer narratives, infers acceptance coverage, counts assertions,

package/docs/engine/workspace-schema.md

@@ -166,11 +166,11 @@ The engine provides only:
 - `check candidate`: strict candidate-manifest validation and content-bound
   identity;
 - `check readiness`: phase-relative file completeness, open-human-gate check,
-  and the stable vetted Build-input binding whenever `eng-review.md` is
-  required;
-- `check seal`: final file completeness and open-human-gate checks, then the
-  readiness-binding recheck, then exact candidate bindings after that aggregate
-  gate passes;
+  the `tasks.md` slice graph when that artifact is required, and the stable
+  vetted Build-input binding whenever `eng-review.md` is required;
+- `check seal`: final file completeness and open-human-gate checks, the
+  `tasks.md` slice graph, then the readiness-binding recheck, then exact
+  candidate bindings after that aggregate gate passes;
 - atomic `state resolve` answer/drop/batch and transactional `state close`;
 - secret scanning, version reporting, and local install lifecycle primitives.
 

package/engine/internal/gate/gate.go

@@ -94,6 +94,15 @@ func checkObservation(kind Kind, observation *state.WorkspaceObservation) (*Resu
 			blocked = true
 		}
 	}
+	if len(missingFiles) == 0 && phaseRequiresTasks(policy) {
+		if fact, ok := observation.Fact("tasks.md"); ok && fact.State() == state.ArtifactPresent {
+			graph := state.ParseTaskGraph(fact.Bytes())
+			for _, problem := range graph.Problems {
+				stateProblems = append(stateProblems, "task-graph: "+problem)
+				blocked = true
+			}
+		}
+	}
 	if len(missingFiles) == 0 && phaseRequiresReadinessBinding(policy) {
 		expected, bindingErr := verifyReadinessBinding(observation)
 		if bindingErr != nil {

package/engine/internal/gate/gate_test.go

@@ -12,6 +12,114 @@ import (
 	"github.com/devrites/devrites/internal/testutil"
 )
 
+func TestCheckBlocksCyclicTaskGraphWhenTasksAreRequired(t *testing.T) {
+	root := t.TempDir()
+	workspace := writeReadinessFixture(t, root, "cyclic", "build")
+	testutil.WriteFile(t, filepath.Join(workspace, "tasks.md"), `# Tasks
+
+## SLICE-001 A
+Dependencies: SLICE-002
+
+## SLICE-002 B
+Dependencies: SLICE-001
+`)
+	binding := mustReadinessBinding(t, root, "cyclic")
+	testutil.AppendFile(t, filepath.Join(workspace, "eng-review.md"), "\n"+binding+"\n")
+
+	res, err := Check(Readiness, root, "cyclic")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !res.Blocked || res.ReasonID != reason.GateReadinessMissing {
+		t.Fatalf("blocked=%v reason=%q, want blocked missing", res.Blocked, res.ReasonID)
+	}
+	joined := strings.Join(res.StateProblems, "\n")
+	if !strings.Contains(joined, "task-graph: dependency cycle:") {
+		t.Fatalf("StateProblems=%q", joined)
+	}
+	if !strings.Contains(res.Render(), "result: blocked (state invariant)") {
+		t.Fatalf("Render()=\n%s", res.Render())
+	}
+}
+
+func TestCheckBlocksCyclicTaskGraphAtSeal(t *testing.T) {
+	root := t.TempDir()
+	writeCompleteGateFeature(t, root, "cyclic-seal", state.PhaseSeal, state.PhaseSeal, "none\n")
+	workspace := filepath.Join(root, "work", "cyclic-seal")
+	testutil.WriteFile(t, filepath.Join(workspace, "tasks.md"), `# Tasks
+
+## SLICE-001 A
+Dependencies: SLICE-002
+
+## SLICE-002 B
+Dependencies: SLICE-001
+`)
+	binding := mustReadinessBinding(t, root, "cyclic-seal")
+	testutil.AppendFile(t, filepath.Join(workspace, "eng-review.md"), "\n"+binding+"\n")
+
+	res, err := Check(Seal, root, "cyclic-seal")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !res.Blocked || res.ReasonID != reason.GateSealMissing {
+		t.Fatalf("blocked=%v reason=%q, want blocked %s", res.Blocked, res.ReasonID, reason.GateSealMissing)
+	}
+	joined := strings.Join(res.StateProblems, "\n")
+	if !strings.Contains(joined, "task-graph: dependency cycle:") {
+		t.Fatalf("StateProblems=%q", joined)
+	}
+	if !strings.Contains(res.Render(), "result: blocked (state invariant)") {
+		t.Fatalf("Render()=\n%s", res.Render())
+	}
+}
+
+func TestCheckBlocksMalformedTaskGraphInsteadOfDroppingTokens(t *testing.T) {
+	root := t.TempDir()
+	workspace := writeReadinessFixture(t, root, "malformed", "define")
+	testutil.WriteFile(t, filepath.Join(workspace, "tasks.md"), `# Tasks
+
+## SLICE-001 Ready
+Dependencies: none
+
+## SLICE-002 Next
+Dependencies: SLICE-001 and later
+`)
+
+	res, err := Check(Readiness, root, "malformed")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !res.Blocked {
+		t.Fatal("expected malformed dependency to block readiness")
+	}
+	joined := strings.Join(res.StateProblems, "\n")
+	if !strings.Contains(joined, `malformed dependency "and"`) || !strings.Contains(joined, `malformed dependency "later"`) {
+		t.Fatalf("StateProblems=%q", joined)
+	}
+}
+
+func TestCheckBlocksMissingDependenciesInsteadOfTreatingSliceAsIndependent(t *testing.T) {
+	root := t.TempDir()
+	workspace := writeReadinessFixture(t, root, "nodeps", "define")
+	testutil.WriteFile(t, filepath.Join(workspace, "tasks.md"), `# Tasks
+
+## SLICE-001 Ready
+Goal: looks complete without an ordering field
+`)
+
+	res, err := Check(Readiness, root, "nodeps")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !res.Blocked {
+		t.Fatal("expected missing Dependencies to block readiness")
+	}
+	joined := strings.Join(res.StateProblems, "\n")
+	if !strings.Contains(joined, "SLICE-001 is missing Dependencies") {
+		t.Fatalf("StateProblems=%q", joined)
+	}
+}
+
 func TestCheckAndRenderReadiness(t *testing.T) {
 	root := t.TempDir()
 	writeFeature(t, root, "alpha", map[string]string{
@@ -505,6 +613,8 @@ func writeCompleteGateFeature(t *testing.T, root, slug string, current, required
 		case "questions.md":
 			questionsRequired = true
 			content = questions
+		case "tasks.md":
+			content = testutil.CanonicalTasksMarkdown
 		}
 		testutil.WriteFile(t, filepath.Join(root, "work", slug, name), content)
 	}

package/engine/internal/gate/readiness_binding.go

@@ -148,6 +148,15 @@ func readinessDiagnosticError(diagnostic state.ArtifactDiagnostic) error {
 	return errors.New(prefix + repair)
 }
 
+func phaseRequiresTasks(policy state.PhasePolicy) bool {
+	for _, artifact := range policy.RequiredArtifacts {
+		if artifact == "tasks.md" {
+			return true
+		}
+	}
+	return false
+}
+
 func phaseRequiresReadinessBinding(policy state.PhasePolicy) bool {
 	for _, artifact := range policy.RequiredArtifacts {
 		if artifact == "eng-review.md" {

package/engine/internal/gate/readiness_binding_test.go

@@ -91,7 +91,7 @@ func TestReadinessBindingBindsOnlyStableBuildInputs(t *testing.T) {
 func TestReadinessBindingGoldenDigest(t *testing.T) {
 	root := t.TempDir()
 	writeReadinessFixture(t, root, "golden", "build")
-	const want = "Readiness inputs SHA-256: d84b9050bd8db742c6a379a966bd7457cde04a69d6811130817729776d976ebe"
+	const want = "Readiness inputs SHA-256: c4a073e85373f5fd9f9302c61b6772e766e4fa2a3da2ccc77bad23756c9f412d"
 	if got := mustReadinessBinding(t, root, "golden"); got != want {
 		t.Fatalf("ReadinessBinding()=%q, want %q", got, want)
 	}
@@ -374,7 +374,7 @@ func writeReadinessFixture(t *testing.T, root, slug, phase string) string {
 		"decision-coverage.md": "# Decision coverage\n\nCLEAR\n",
 		"architecture.md":      "# Architecture\n\nReady.\n",
 		"plan.md":              "# Plan\n\nReady.\n",
-		"tasks.md":             "# Tasks\n\nReady.\n",
+		"tasks.md":             testutil.CanonicalTasksMarkdown,
 		"traceability.md":      "# Traceability\n\nReady.\n",
 		"eng-review.md":        "# Engineering review\n\nREADY\n",
 		"test-plan.md":         "# Test plan\n\nReady.\n",

package/engine/internal/lib/observe_summary.go

@@ -7,21 +7,25 @@ import (
 	"github.com/devrites/devrites/internal/state"
 )
 
+// ObserveTaskGraph is the slice-graph subset of ObserveSummary.
+type ObserveTaskGraph struct {
+	SliceCount int      `json:"slice_count"`
+	Cycle      []string `json:"cycle,omitempty"`
+	Unknown    []string `json:"unknown_dependencies,omitempty"`
+	Problems   []string `json:"problems,omitempty"`
+	OK         bool     `json:"ok"`
+}
+
 // ObserveSummary is a sanitized, machine-readable workspace snapshot.
 type ObserveSummary struct {
-	Slug              string   `json:"slug"`
-	Phase             string   `json:"phase,omitempty"`
-	Status            string   `json:"status,omitempty"`
-	NextAction        string   `json:"next_action,omitempty"`
-	MissingSections   []string `json:"missing_sections,omitempty"`
-	MissingFiles      []string `json:"missing_files,omitempty"`
-	PrinciplesPresent bool     `json:"principles_present"`
-	TaskGraph         *struct {
-		SliceCount int      `json:"slice_count"`
-		Cycle      []string `json:"cycle,omitempty"`
-		Unknown    []string `json:"unknown_dependencies,omitempty"`
-		OK         bool     `json:"ok"`
-	} `json:"task_graph,omitempty"`
+	Slug              string            `json:"slug"`
+	Phase             string            `json:"phase,omitempty"`
+	Status            string            `json:"status,omitempty"`
+	NextAction        string            `json:"next_action,omitempty"`
+	MissingSections   []string          `json:"missing_sections,omitempty"`
+	MissingFiles      []string          `json:"missing_files,omitempty"`
+	PrinciplesPresent bool              `json:"principles_present"`
+	TaskGraph         *ObserveTaskGraph `json:"task_graph,omitempty"`
 }
 
 // ObserveSummaryFor builds a summary for one feature slug.
@@ -40,16 +44,12 @@ func ObserveSummaryFor(root, slug string) (ObserveSummary, error) {
 		MissingSections:   missingSectionNames(report.Missing),
 	}
 
-	if graph, graphErr := CheckTaskGraph(root, slug); graphErr == nil && len(graph.Slices) > 0 {
-		summary.TaskGraph = &struct {
-			SliceCount int      `json:"slice_count"`
-			Cycle      []string `json:"cycle,omitempty"`
-			Unknown    []string `json:"unknown_dependencies,omitempty"`
-			OK         bool     `json:"ok"`
-		}{
+	if graph, graphErr := CheckTaskGraph(root, slug); graphErr == nil && (len(graph.Slices) > 0 || len(graph.Problems) > 0) {
+		summary.TaskGraph = &ObserveTaskGraph{
 			SliceCount: len(graph.Slices),
-			Cycle:      graph.Cycle,
-			Unknown:    graph.Unknown,
+			Cycle:      append([]string(nil), graph.Cycle...),
+			Unknown:    append([]string(nil), graph.Unknown...),
+			Problems:   append([]string(nil), graph.Problems...),
 			OK:         len(graph.Problems) == 0,
 		}
 	}

package/engine/internal/lib/taskgraph.go

@@ -1,155 +1,16 @@
 package lib
 
-import (
-	"fmt"
-	"regexp"
-	"strings"
-)
+import "github.com/devrites/devrites/internal/state"
 
 // TaskSlice is one SLICE-### block parsed from tasks.md.
-type TaskSlice struct {
-	ID           string
-	Dependencies []string
-}
+type TaskSlice = state.TaskSlice
 
 // TaskGraphResult is the deterministic outcome of parsing a tasks.md slice graph.
-type TaskGraphResult struct {
-	Slices   []TaskSlice
-	Cycle    []string // empty when acyclic
-	Unknown  []string // dependency ids with no defining slice
-	Problems []string // human-readable blockers
-}
-
-var (
-	sliceHeaderRE  = regexp.MustCompile(`(?m)^##\s+(SLICE-\d+)\b`)
-	dependenciesRE = regexp.MustCompile(`(?m)^Dependencies:\s*(.+)\s*$`)
-	sliceIDValidRE = regexp.MustCompile(`^SLICE-\d+$`)
-)
+type TaskGraphResult = state.TaskGraphResult
 
 // ParseTaskGraph reads tasks.md content and validates the slice dependency DAG.
 func ParseTaskGraph(tasksMarkdown []byte) TaskGraphResult {
-	text := string(tasksMarkdown)
-	result := TaskGraphResult{}
-	if strings.TrimSpace(text) == "" {
-		result.Problems = append(result.Problems, "tasks.md is empty")
-		return result
-	}
-
-	headers := sliceHeaderRE.FindAllStringSubmatchIndex(text, -1)
-	if len(headers) == 0 {
-		result.Problems = append(result.Problems, "no SLICE-### sections found")
-		return result
-	}
-
-	known := make(map[string]bool)
-	for _, match := range headers {
-		id := text[match[2]:match[3]]
-		known[id] = true
-	}
-
-	for i, match := range headers {
-		id := text[match[2]:match[3]]
-		start := match[1]
-		end := len(text)
-		if i+1 < len(headers) {
-			end = headers[i+1][0]
-		}
-		block := text[start:end]
-		deps := parseSliceDependencies(block)
-		result.Slices = append(result.Slices, TaskSlice{ID: id, Dependencies: deps})
-		for _, dep := range deps {
-			if !known[dep] {
-				result.Unknown = append(result.Unknown, dep)
-				result.Problems = append(result.Problems, fmt.Sprintf("%s depends on unknown slice %s", id, dep))
-			}
-		}
-	}
-
-	if cycle := findTaskCycle(result.Slices); len(cycle) > 0 {
-		result.Cycle = cycle
-		result.Problems = append(result.Problems, "dependency cycle: "+strings.Join(cycle, " -> "))
-	}
-	return result
-}
-
-func parseSliceDependencies(block string) []string {
-	match := dependenciesRE.FindStringSubmatch(block)
-	if len(match) < 2 {
-		return nil
-	}
-	raw := strings.TrimSpace(match[1])
-	if raw == "" || strings.EqualFold(raw, "none") {
-		return nil
-	}
-	parts := strings.FieldsFunc(raw, func(r rune) bool {
-		return r == ',' || r == ';'
-	})
-	var deps []string
-	seen := make(map[string]bool)
-	for _, part := range parts {
-		id := strings.TrimSpace(part)
-		if id == "" {
-			continue
-		}
-		if !sliceIDValidRE.MatchString(id) {
-			continue
-		}
-		if seen[id] {
-			continue
-		}
-		seen[id] = true
-		deps = append(deps, id)
-	}
-	return deps
-}
-
-func findTaskCycle(slices []TaskSlice) []string {
-	graph := make(map[string][]string, len(slices))
-	for _, slice := range slices {
-		graph[slice.ID] = append([]string(nil), slice.Dependencies...)
-	}
-	visited := make(map[string]uint8, len(slices))
-	stack := make([]string, 0, len(slices))
-	var cycle []string
-
-	var visit func(id string) bool
-	visit = func(id string) bool {
-		switch visited[id] {
-		case 2:
-			return false
-		case 1:
-			for i := len(stack) - 1; i >= 0; i-- {
-				cycle = append(cycle, stack[i])
-				if stack[i] == id {
-					break
-				}
-			}
-			for i, j := 0, len(cycle)-1; i < j; i, j = i+1, j-1 {
-				cycle[i], cycle[j] = cycle[j], cycle[i]
-			}
-			return true
-		}
-		visited[id] = 1
-		stack = append(stack, id)
-		for _, dep := range graph[id] {
-			if visit(dep) {
-				return true
-			}
-		}
-		stack = stack[:len(stack)-1]
-		visited[id] = 2
-		return false
-	}
-
-	for _, slice := range slices {
-		if visited[slice.ID] == 0 {
-			cycle = nil
-			if visit(slice.ID) {
-				return cycle
-			}
-		}
-	}
-	return nil
+	return state.ParseTaskGraph(tasksMarkdown)
 }
 
 // CheckTaskGraph validates tasks.md for a feature workspace slug.

package/engine/internal/lib/taskgraph_test.go

@@ -1,6 +1,7 @@
 package lib
 
 import (
+	"encoding/json"
 	"os"
 	"path/filepath"
 	"strings"
@@ -52,6 +53,127 @@ Dependencies: SLICE-999
 	}
 }
 
+func TestParseTaskGraphRejectsMalformedDependencyTokens(t *testing.T) {
+	tasks := `# Tasks
+
+## SLICE-001 A
+Dependencies: none
+
+## SLICE-002 B
+Dependencies: SLICE-001 and slice-003
+`
+	graph := ParseTaskGraph([]byte(tasks))
+	if len(graph.Problems) == 0 {
+		t.Fatal("expected malformed dependency problem")
+	}
+	joined := strings.Join(graph.Problems, "\n")
+	if !strings.Contains(joined, `malformed dependency "and"`) || !strings.Contains(joined, `malformed dependency "slice-003"`) {
+		t.Fatalf("problems=%v", graph.Problems)
+	}
+}
+
+func TestParseTaskGraphAcceptsWhitespaceSeparatedDependencies(t *testing.T) {
+	tasks := `# Tasks
+
+## SLICE-001 A
+Dependencies: none
+
+## SLICE-002 B
+Dependencies: none
+
+## SLICE-003 C
+Dependencies: SLICE-001 SLICE-002
+`
+	graph := ParseTaskGraph([]byte(tasks))
+	if len(graph.Problems) != 0 {
+		t.Fatalf("problems=%v", graph.Problems)
+	}
+	if len(graph.Slices) != 3 || len(graph.Slices[2].Dependencies) != 2 {
+		t.Fatalf("slices=%+v", graph.Slices)
+	}
+}
+
+func TestParseTaskGraphRejectsDuplicateSliceIDs(t *testing.T) {
+	tasks := `# Tasks
+
+## SLICE-001 A
+Dependencies: none
+
+## SLICE-002 B
+Dependencies: SLICE-001
+
+## SLICE-001 Duplicate
+Dependencies: none
+`
+	graph := ParseTaskGraph([]byte(tasks))
+	joined := strings.Join(graph.Problems, "\n")
+	if !strings.Contains(joined, "duplicate slice id SLICE-001") {
+		t.Fatalf("problems=%v", graph.Problems)
+	}
+	if len(graph.Slices) != 2 {
+		t.Fatalf("slices=%d, want first-occurrence only", len(graph.Slices))
+	}
+}
+
+func TestParseTaskGraphRejectsDependsOnMismatch(t *testing.T) {
+	tasks := `# Tasks
+
+## SLICE-001 A
+Dependencies: none
+
+## SLICE-002 B
+Dependencies: SLICE-001
+depends_on: []
+`
+	graph := ParseTaskGraph([]byte(tasks))
+	joined := strings.Join(graph.Problems, "\n")
+	if !strings.Contains(joined, "SLICE-002 Dependencies and depends_on sets differ") {
+		t.Fatalf("problems=%v", graph.Problems)
+	}
+}
+
+func TestParseTaskGraphRejectsMissingDependencies(t *testing.T) {
+	tasks := `# Tasks
+
+## SLICE-001 A
+Goal: silent independent slice
+`
+	graph := ParseTaskGraph([]byte(tasks))
+	joined := strings.Join(graph.Problems, "\n")
+	if !strings.Contains(joined, "SLICE-001 is missing Dependencies") {
+		t.Fatalf("problems=%v", graph.Problems)
+	}
+}
+
+func TestParseTaskGraphAllowsDependsOnWithoutDependenciesLine(t *testing.T) {
+	tasks := `# Tasks
+
+## SLICE-001 A
+depends_on: []
+`
+	graph := ParseTaskGraph([]byte(tasks))
+	if len(graph.Problems) != 0 {
+		t.Fatalf("problems=%v", graph.Problems)
+	}
+}
+
+func TestParseTaskGraphAllowsMatchingDependsOnMirror(t *testing.T) {
+	tasks := `# Tasks
+
+## SLICE-001 A
+Dependencies: none
+depends_on: []
+
+## SLICE-002 B
+Dependencies: SLICE-001
+depends_on: [SLICE-001]
+`
+	graph := ParseTaskGraph([]byte(tasks))
+	if len(graph.Problems) != 0 {
+		t.Fatalf("problems=%v", graph.Problems)
+	}
+}
+
 func TestCheckTaskGraphWorkspace(t *testing.T) {
 	root := filepath.Join(t.TempDir(), ".devrites")
 	workspace := filepath.Join(root, "work", "feature")
@@ -126,6 +248,87 @@ func TestObserveSummaryForGolden(t *testing.T) {
 	if summary.Phase == "" {
 		t.Fatalf("summary=%+v", summary)
 	}
+	if summary.TaskGraph == nil || !summary.TaskGraph.OK || len(summary.TaskGraph.Problems) != 0 {
+		t.Fatalf("task_graph=%+v, want ok with no problems", summary.TaskGraph)
+	}
+}
+
+func TestObserveSummaryExposesTaskGraphProblems(t *testing.T) {
+	root := filepath.Join(t.TempDir(), ".devrites")
+	workspace := filepath.Join(root, "work", "blocked-graph")
+	if err := os.MkdirAll(workspace, 0o755); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(workspace, "state.md"), []byte("| phase | define |\n"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	body := `# Tasks
+
+## SLICE-001 Ready
+Dependencies: none
+
+## SLICE-002 Next
+Dependencies: SLICE-001 and later
+`
+	if err := os.WriteFile(filepath.Join(workspace, "tasks.md"), []byte(body), 0o644); err != nil {
+		t.Fatal(err)
+	}
+
+	summary, err := ObserveSummaryFor(root, "blocked-graph")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if summary.TaskGraph == nil {
+		t.Fatal("expected task_graph")
+	}
+	if summary.TaskGraph.OK {
+		t.Fatal("expected task_graph.ok=false")
+	}
+	joined := strings.Join(summary.TaskGraph.Problems, "\n")
+	if !strings.Contains(joined, `malformed dependency "and"`) || !strings.Contains(joined, `malformed dependency "later"`) {
+		t.Fatalf("problems=%v", summary.TaskGraph.Problems)
+	}
+	if len(summary.TaskGraph.Cycle) != 0 {
+		t.Fatalf("cycle=%v, want empty for a malformed-token failure", summary.TaskGraph.Cycle)
+	}
+
+	raw, err := json.Marshal(summary.TaskGraph)
+	if err != nil {
+		t.Fatal(err)
+	}
+	encoded := string(raw)
+	if !strings.Contains(encoded, `"ok":false`) || !strings.Contains(encoded, `"problems"`) {
+		t.Fatalf("json=%s", encoded)
+	}
+}
+
+func TestObserveSummaryExposesProblemsWhenNoSliceHeaders(t *testing.T) {
+	root := filepath.Join(t.TempDir(), ".devrites")
+	workspace := filepath.Join(root, "work", "bullet-list")
+	if err := os.MkdirAll(workspace, 0o755); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(workspace, "state.md"), []byte("| phase | define |\n"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(workspace, "tasks.md"), []byte("# Tasks\n\n- do the work\n"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+
+	summary, err := ObserveSummaryFor(root, "bullet-list")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if summary.TaskGraph == nil || summary.TaskGraph.OK {
+		t.Fatalf("task_graph=%+v, want problems with ok=false", summary.TaskGraph)
+	}
+	if summary.TaskGraph.SliceCount != 0 {
+		t.Fatalf("slice_count=%d", summary.TaskGraph.SliceCount)
+	}
+	joined := strings.Join(summary.TaskGraph.Problems, "\n")
+	if !strings.Contains(joined, "no SLICE-### sections found") {
+		t.Fatalf("problems=%v", summary.TaskGraph.Problems)
+	}
 }
 
 func copyDir(src, dst string) error {