devrites 3.0.1 → 3.0.3

package/engine/internal/state/cursor.go

@@ -0,0 +1,119 @@
+package state
+
+import (
+	"sort"
+	"strings"
+	"unicode"
+)
+
+// Canonical cursor keys. Callers use these constants so schema spelling changes
+// remain local to the cursor package; normalizeCursorKey still accepts legacy
+// presentation aliases at the text boundary.
+const (
+	CursorPhase              = "phase"
+	CursorStatus             = "status"
+	CursorNextAction         = "next_action"
+	CursorQuestionID         = "question_id"
+	CursorActiveSlice        = "active_slice"
+	CursorAFKSlicesRemaining = "afk_slices_remaining"
+)
+
+var cursorKeyAliases = map[string]string{
+	"nextstep": CursorNextAction,
+	"qid":      CursorQuestionID,
+}
+
+// CursorKeyAlias is the generated-manifest view of a compatibility key.
+type CursorKeyAlias struct {
+	Alias     string `json:"alias"`
+	Canonical string `json:"canonical"`
+}
+
+// CursorKeyAliases returns compatibility keys in deterministic order.
+func CursorKeyAliases() []CursorKeyAlias {
+	aliases := make([]string, 0, len(cursorKeyAliases))
+	for alias := range cursorKeyAliases {
+		aliases = append(aliases, alias)
+	}
+	sort.Strings(aliases)
+	out := make([]CursorKeyAlias, 0, len(aliases))
+	for _, alias := range aliases {
+		out = append(out, CursorKeyAlias{Alias: alias, Canonical: cursorKeyAliases[alias]})
+	}
+	return out
+}
+
+type cursorLineKind uint8
+
+const (
+	cursorLineUnknown cursorLineKind = iota
+	cursorLineLegacy
+	cursorLineTable
+)
+
+// CursorField reads a state.md field from either the canonical | key | value |
+// cursor table or the legacy "- Key: value" form.
+func CursorField(lines []string, key string) (string, bool) {
+	want := normalizeCursorKey(key)
+	for _, line := range lines {
+		gotKey, value, _, ok := parseCursorLine(line)
+		if ok && normalizeCursorKey(gotKey) == want {
+			return value, true
+		}
+	}
+	return "", false
+}
+
+// SetCursorField replaces an existing state.md field without changing whether
+// the file uses the canonical table or legacy bullet form.
+func SetCursorField(lines []string, key, value string) ([]string, bool) {
+	want := normalizeCursorKey(key)
+	out := append([]string(nil), lines...)
+	for i, line := range out {
+		gotKey, _, kind, ok := parseCursorLine(line)
+		if !ok || normalizeCursorKey(gotKey) != want {
+			continue
+		}
+		switch kind {
+		case cursorLineTable:
+			indent := line[:len(line)-len(strings.TrimLeft(line, " \t"))]
+			out[i] = indent + "| " + strings.TrimSpace(gotKey) + " | " + value + " |"
+		case cursorLineLegacy:
+			colon := strings.IndexByte(line, ':')
+			out[i] = line[:colon+1] + " " + value
+		}
+		return out, true
+	}
+	return out, false
+}
+
+func parseCursorLine(line string) (key, value string, kind cursorLineKind, ok bool) {
+	trimmed := strings.TrimSpace(line)
+	if len(trimmed) >= 2 && trimmed[0] == '|' && trimmed[len(trimmed)-1] == '|' {
+		cells := strings.Split(trimmed[1:len(trimmed)-1], "|")
+		if len(cells) >= 2 {
+			return strings.TrimSpace(cells[0]), strings.TrimSpace(cells[1]), cursorLineTable, true
+		}
+	}
+
+	trimmed = strings.TrimLeft(trimmed, "-*+ \t")
+	key, value, ok = strings.Cut(trimmed, ":")
+	if !ok || strings.TrimSpace(key) == "" {
+		return "", "", cursorLineUnknown, false
+	}
+	return strings.TrimSpace(key), strings.TrimSpace(value), cursorLineLegacy, true
+}
+
+func normalizeCursorKey(key string) string {
+	var b strings.Builder
+	for _, r := range strings.ToLower(key) {
+		if unicode.IsLetter(r) || unicode.IsDigit(r) {
+			b.WriteRune(r)
+		}
+	}
+	normalized := b.String()
+	if canonical, ok := cursorKeyAliases[normalized]; ok {
+		return normalizeCursorKey(canonical)
+	}
+	return normalized
+}

package/engine/internal/state/cursor_test.go

@@ -0,0 +1,58 @@
+package state
+
+import "testing"
+
+func TestCursorFieldReadsCanonicalTableAndLegacyLines(t *testing.T) {
+	table := []string{
+		"| Key | Value |",
+		"| --- | --- |",
+		"| phase | temper |",
+		"| status | awaiting_human |",
+		"| next_action | /rite-define |",
+	}
+	legacy := []string{
+		"- Phase: build",
+		"- Status: running",
+		"- Next step: /rite-prove",
+	}
+
+	for _, tc := range []struct {
+		name  string
+		lines []string
+		key   string
+		want  string
+	}{
+		{"table phase", table, "phase", "temper"},
+		{"table status", table, "status", "awaiting_human"},
+		{"table next alias", table, "Next step", "/rite-define"},
+		{"legacy phase", legacy, "phase", "build"},
+		{"legacy next alias", legacy, "next_action", "/rite-prove"},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			got, ok := CursorField(tc.lines, tc.key)
+			if !ok || got != tc.want {
+				t.Fatalf("CursorField(%q) = %q, %v; want %q, true", tc.key, got, ok, tc.want)
+			}
+		})
+	}
+}
+
+func TestSetCursorFieldPreservesCanonicalAndLegacyFormats(t *testing.T) {
+	for _, tc := range []struct {
+		name  string
+		lines []string
+		key   string
+		value string
+		want  string
+	}{
+		{"table", []string{"| status | awaiting_human |"}, "status", "running", "| status | running |"},
+		{"legacy", []string{"- AFK slices remaining: 2"}, "afk_slices_remaining", "1", "- AFK slices remaining: 1"},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			got, ok := SetCursorField(tc.lines, tc.key, tc.value)
+			if !ok || len(got) != 1 || got[0] != tc.want {
+				t.Fatalf("SetCursorField() = %v, %v; want [%q], true", got, ok, tc.want)
+			}
+		})
+	}
+}

package/engine/internal/state/feature.go

@@ -108,27 +108,11 @@ func regularFileExists(path string) bool {
 	return err == nil && info.Mode().IsRegular()
 }
 
-// CandidateFiles returns the paths that make up feature <slug>: its feature.md
-// manifest plus every file that can satisfy a section (canonical names and the
-// transitional aliases), in a stable order. Not all need exist; callers that
-// fingerprint the feature stat and hash the ones that do, so including the alias
-// names means a change to either the canonical or the alias file is detected.
-func CandidateFiles(root, slug string) []string {
-	dir := featureDir(root, slug)
-	files := []string{filepath.Join(dir, "feature.md")}
-	for _, s := range Sections {
-		for _, name := range sectionFiles[s] {
-			files = append(files, filepath.Join(dir, name))
-		}
-	}
-	return files
-}
-
-// LoadFeature reads feature <slug> under root. The phase comes from the manifest
-// (feature.md) frontmatter when present, otherwise from the working-state ledger
-// (state.md, a "- Phase: <p>" line) the live pack writes. A feature with neither a
-// manifest nor a ledger does not exist. Section content is read from the canonical
-// section files or their transitional aliases (see sectionFiles).
+// LoadFeature reads feature <slug> under root. The phase comes from the live
+// working-state ledger when it declares one, otherwise from feature.md
+// frontmatter. A feature with neither a manifest nor a ledger does not exist.
+// Section content is read from the canonical section files or their transitional
+// aliases (see sectionFiles).
 func LoadFeature(root, slug string) (*Feature, error) {
 	dir := featureDir(root, slug)
 
@@ -142,7 +126,7 @@ func LoadFeature(root, slug string) (*Feature, error) {
 		return nil, fmt.Errorf("feature %q not found", slug)
 	}
 
-	var phase Phase
+	var manifestPhase Phase
 	if hasManifest {
 		fm, _ := splitFrontmatter(manifest)
 		if v := strings.TrimSpace(fm["schemaVersion"]); v != "" {
@@ -154,12 +138,16 @@ func LoadFeature(root, slug string) (*Feature, error) {
 				return nil, fmt.Errorf("feature %q: schemaVersion %d is newer than this engine supports (%d); upgrade devrites", slug, n, SchemaVersion)
 			}
 		}
-		phase = Phase(strings.TrimSpace(fm["phase"]))
+		manifestPhase = Phase(strings.TrimSpace(fm["phase"]))
 	}
-	// Ledger fallback: only when the manifest did not declare a phase, so a manifest
-	// with an explicit-but-unknown phase still surfaces as that error below.
-	if phase == "" {
-		phase = PhaseFromLedger(filepath.Join(dir, LedgerFile))
+
+	// state.md is the mutable runtime cursor, so it must win over the manifest,
+	// which migration and compatibility flows may leave stale. Preserve an
+	// explicitly unknown ledger value so the validation below reports it rather
+	// than silently falling back to feature.md.
+	phase, ledgerDeclared := declaredPhaseFromLedger(filepath.Join(dir, LedgerFile))
+	if !ledgerDeclared {
+		phase = manifestPhase
 	}
 	if phase == "" {
 		return nil, fmt.Errorf("feature %q: no phase in feature.md frontmatter or %s ledger", slug, LedgerFile)
@@ -186,31 +174,20 @@ func sectionPresentAny(dir string, s Section) bool {
 	return false
 }
 
-// PhaseFromLedger reads a phase from the working-state ledger: the value of a
-// "- Phase: <p>" line (leading list markers tolerated), taking the first token
-// and accepting it only if it is a phase the engine understands. Returns "" when
-// the file is absent or declares no recognized phase. Unlike migrate's tolerant
-// legacy mapping, this accepts only canonical phase words — the live pack's form.
-func PhaseFromLedger(path string) Phase {
+func declaredPhaseFromLedger(path string) (Phase, bool) {
 	raw, err := os.ReadFile(path)
 	if err != nil {
-		return ""
+		return "", false
 	}
-	for _, line := range strings.Split(string(raw), "\n") {
-		t := strings.TrimLeft(strings.TrimSpace(line), "-*+ \t")
-		key, val, ok := strings.Cut(t, ":")
-		if !ok || !strings.EqualFold(strings.TrimSpace(key), "phase") {
-			continue
-		}
-		word := strings.ToLower(strings.TrimSpace(val))
-		if i := strings.IndexAny(word, " \t"); i > 0 {
-			word = word[:i]
-		}
-		if p := Phase(word); KnownPhase(p) {
-			return p
-		}
+	value, ok := CursorField(strings.Split(string(raw), "\n"), CursorPhase)
+	if !ok {
+		return "", false
+	}
+	word := strings.ToLower(strings.TrimSpace(value))
+	if i := strings.IndexAny(word, " \t"); i > 0 {
+		word = word[:i]
 	}
-	return ""
+	return Phase(word), true
 }
 
 // ReadDeclaredSchemaVersion returns the schemaVersion declared in a feature's

package/engine/internal/state/schema.go

@@ -1,5 +1,7 @@
 package state
 
+//go:generate go run ./cmd/workflowmanifest -out workflow_manifest.json
+
 // SchemaVersion is the .devrites state-schema version this engine understands.
 // A feature.md may declare its own schemaVersion in frontmatter; the engine
 // refuses a version newer than this (see LoadFeature) and otherwise reads the
@@ -46,48 +48,173 @@ var sectionFiles = map[Section][]string{
 }
 
 // LedgerFile is the working-state ledger the live pack writes. It carries the
-// phase (as a "- Phase: <p>" line) when no feature.md manifest declares one, and
-// it satisfies the status section.
+// phase in its canonical cursor table (legacy "- Phase: <p>" remains readable)
+// when no feature.md manifest declares one, and it satisfies the status section.
 const LedgerFile = "state.md"
 
 // Phase is a workflow state. The order mirrors the rite-* arc.
 type Phase string
 
 const (
-	PhaseFrame Phase = "frame" // problem framing
-	PhaseSpec  Phase = "spec"  // specification
-	PhasePlan  Phase = "plan"  // planning
-	PhaseBuild Phase = "build" // implementation
-	PhaseProve Phase = "prove" // proof / testing
-	PhaseVet   Phase = "vet"   // review
-	PhaseSeal  Phase = "seal"  // completeness seal
-	PhaseShip  Phase = "ship"  // shipping
+	PhaseFrame    Phase = "frame"    // problem framing
+	PhaseSpec     Phase = "spec"     // specification
+	PhaseTemper   Phase = "temper"   // strategic specification review
+	PhaseDefine   Phase = "define"   // plan definition
+	PhasePlan     Phase = "plan"     // approved plan
+	PhaseVet      Phase = "vet"      // pre-build engineering review
+	PhaseBuild    Phase = "build"    // implementation
+	PhaseConverge Phase = "converge" // post-build gap closure
+	PhaseProve    Phase = "prove"    // proof / testing
+	PhasePolish   Phase = "polish"   // quality pass
+	PhaseReview   Phase = "review"   // post-proof review
+	PhaseSeal     Phase = "seal"     // completeness seal
+	PhaseShip     Phase = "ship"     // shipping
+	PhaseDone     Phase = "done"     // archived completion
+)
+
+// phaseDefinition is the single source of truth for lifecycle order and
+// phase-specific behavior. Workflow topology is versioned application logic,
+// rather than deploy-time configuration, so keeping it typed and ordered makes
+// additions compile-visible and lets every consumer derive the same arc.
+type phaseDefinition struct {
+	phase               Phase
+	resumeVerb          string
+	required            []Section
+	aliases             []string
+	workspaceRequired   []string
+	proofRequired       bool
+	blocksOpenQuestions bool
+	shippable           bool
+}
+
+var (
+	sectionsSpec     = []Section{SectionSpec}
+	sectionsPlan     = []Section{SectionSpec, SectionPlan}
+	sectionsBuild    = []Section{SectionSpec, SectionPlan, SectionDecisions, SectionTasks}
+	sectionsProof    = []Section{SectionSpec, SectionPlan, SectionDecisions, SectionTasks, SectionProof}
+	sectionsComplete = []Section{SectionSpec, SectionPlan, SectionDecisions, SectionTasks, SectionProof, SectionStatus}
+
+	workspaceFrame = []string{"state.md"}
+	workspaceSpec  = []string{"brief.md", "spec.md", "state.md", "decisions.md", "assumptions.md", "questions.md"}
+	workspacePlan  = []string{"brief.md", "spec.md", "architecture.md", "plan.md", "tasks.md", "traceability.md", "state.md", "decisions.md", "assumptions.md", "questions.md"}
+	workspaceProof = append(append([]string(nil), workspacePlan...), "evidence.md", "touched-files.md")
 )
 
-// requiredByPhase lists the sections that must have real content to complete a
-// phase. Completeness is phase-relative: a section not yet required (e.g. proof
-// during the spec phase) never blocks. The set is additive down the arc.
-var requiredByPhase = map[Phase][]Section{
-	PhaseFrame: {},
-	PhaseSpec:  {SectionSpec},
-	PhasePlan:  {SectionSpec, SectionPlan},
-	PhaseBuild: {SectionSpec, SectionPlan, SectionDecisions, SectionTasks},
-	PhaseProve: {SectionSpec, SectionPlan, SectionDecisions, SectionTasks, SectionProof},
-	PhaseVet:   {SectionSpec, SectionPlan, SectionDecisions, SectionTasks, SectionProof},
-	PhaseSeal:  {SectionSpec, SectionPlan, SectionDecisions, SectionTasks, SectionProof, SectionStatus},
-	PhaseShip:  {SectionSpec, SectionPlan, SectionDecisions, SectionTasks, SectionProof, SectionStatus},
+// Completeness is phase-relative: a section not yet required (e.g. proof during
+// spec) never blocks. Requirements are additive down the arc. Plan resumes at
+// define because plan is the artifact state produced by rite-define; done has no
+// resume command.
+var phaseDefinitions = []phaseDefinition{
+	{phase: PhaseFrame, resumeVerb: "frame", workspaceRequired: workspaceFrame},
+	{phase: PhaseSpec, resumeVerb: "spec", required: sectionsSpec, aliases: []string{"specced", "specifying"}, workspaceRequired: workspaceSpec},
+	{phase: PhaseTemper, resumeVerb: "temper", required: sectionsSpec, aliases: []string{"tempered", "tempering"}, workspaceRequired: workspaceSpec},
+	{phase: PhaseDefine, resumeVerb: "define", required: sectionsPlan, aliases: []string{"defined", "defining"}, workspaceRequired: workspacePlan, blocksOpenQuestions: true},
+	{phase: PhasePlan, resumeVerb: "define", required: sectionsPlan, aliases: []string{"planned", "planning"}, workspaceRequired: workspacePlan, blocksOpenQuestions: true},
+	{phase: PhaseVet, resumeVerb: "vet", required: sectionsBuild, aliases: []string{"vetted", "vetting"}, workspaceRequired: workspacePlan, blocksOpenQuestions: true},
+	{phase: PhaseBuild, resumeVerb: "build", required: sectionsBuild, aliases: []string{"building", "wip", "in", "in-progress"}, workspaceRequired: workspacePlan, blocksOpenQuestions: true},
+	{phase: PhaseConverge, resumeVerb: "converge", required: sectionsBuild, aliases: []string{"converged", "converging"}, workspaceRequired: workspacePlan, blocksOpenQuestions: true},
+	{phase: PhaseProve, resumeVerb: "prove", required: sectionsProof, aliases: []string{"proving", "proven", "testing"}, workspaceRequired: workspaceProof, proofRequired: true, blocksOpenQuestions: true},
+	{phase: PhasePolish, resumeVerb: "polish", required: sectionsProof, aliases: []string{"polished", "polishing"}, workspaceRequired: workspaceProof, proofRequired: true, blocksOpenQuestions: true},
+	{phase: PhaseReview, resumeVerb: "review", required: sectionsProof, aliases: []string{"reviewed", "reviewing"}, workspaceRequired: workspaceProof, proofRequired: true, blocksOpenQuestions: true},
+	{phase: PhaseSeal, resumeVerb: "seal", required: sectionsComplete, aliases: []string{"sealed", "sealing"}, workspaceRequired: workspaceProof, proofRequired: true, blocksOpenQuestions: true, shippable: true},
+	{phase: PhaseShip, resumeVerb: "ship", required: sectionsComplete, aliases: []string{"shipped", "shipping"}, workspaceRequired: workspaceProof, proofRequired: true, blocksOpenQuestions: true, shippable: true},
+	{phase: PhaseDone, required: sectionsComplete, aliases: []string{"closed", "complete", "completed"}, workspaceRequired: workspaceProof, proofRequired: true, blocksOpenQuestions: true, shippable: true},
+}
+
+// WorkflowPhase is the read-only cross-format view used to generate the compact
+// manifest consumed by non-Go release tooling.
+type WorkflowPhase struct {
+	ID                  Phase    `json:"id"`
+	ResumeVerb          string   `json:"resumeVerb,omitempty"`
+	Aliases             []string `json:"aliases,omitempty"`
+	WorkspaceRequired   []string `json:"workspaceRequired"`
+	ProofRequired       bool     `json:"proofRequired,omitempty"`
+	BlocksOpenQuestions bool     `json:"blocksOpenQuestions,omitempty"`
+	Shippable           bool     `json:"shippable,omitempty"`
+}
+
+// WorkflowPhases returns copied metadata suitable for deterministic generation.
+func WorkflowPhases() []WorkflowPhase {
+	out := make([]WorkflowPhase, 0, len(phaseDefinitions))
+	for _, definition := range phaseDefinitions {
+		out = append(out, WorkflowPhase{
+			ID:                  definition.phase,
+			ResumeVerb:          definition.resumeVerb,
+			Aliases:             append([]string(nil), definition.aliases...),
+			WorkspaceRequired:   append([]string(nil), definition.workspaceRequired...),
+			ProofRequired:       definition.proofRequired,
+			BlocksOpenQuestions: definition.blocksOpenQuestions,
+			Shippable:           definition.shippable,
+		})
+	}
+	return out
+}
+
+// LifecyclePhases returns the ordered lifecycle. The returned slice is a copy,
+// so callers cannot mutate the registry.
+func LifecyclePhases() []Phase {
+	phases := make([]Phase, len(phaseDefinitions))
+	for i, definition := range phaseDefinitions {
+		phases[i] = definition.phase
+	}
+	return phases
+}
+
+func definitionFor(p Phase) (phaseDefinition, bool) {
+	for _, definition := range phaseDefinitions {
+		if definition.phase == p {
+			return definition, true
+		}
+	}
+	return phaseDefinition{}, false
 }
 
 // KnownPhase reports whether p is a phase the engine understands.
 func KnownPhase(p Phase) bool {
-	_, ok := requiredByPhase[p]
+	_, ok := definitionFor(p)
 	return ok
 }
 
+// ResumeVerb returns the public rite verb that resumes p. Terminal and unknown
+// phases return an empty string.
+func ResumeVerb(p Phase) string {
+	definition, ok := definitionFor(p)
+	if !ok {
+		return ""
+	}
+	return definition.resumeVerb
+}
+
+// ShippablePhase reports whether p is allowed to claim a sealed/shipped result.
+func ShippablePhase(p Phase) bool {
+	definition, ok := definitionFor(p)
+	return ok && definition.shippable
+}
+
+// PhaseForName resolves a canonical phase ID or compatibility alias. Callers
+// should normalize surrounding syntax before querying it.
+func PhaseForName(name string) (Phase, bool) {
+	for _, definition := range phaseDefinitions {
+		if string(definition.phase) == name {
+			return definition.phase, true
+		}
+		for _, alias := range definition.aliases {
+			if alias == name {
+				return definition.phase, true
+			}
+		}
+	}
+	return "", false
+}
+
 // RequiredSections returns the sections required to complete the given phase,
 // in canonical Sections order.
 func RequiredSections(p Phase) []Section {
-	want := requiredByPhase[p]
+	definition, ok := definitionFor(p)
+	if !ok {
+		return nil
+	}
+	want := definition.required
 	set := make(map[Section]bool, len(want))
 	for _, s := range want {
 		set[s] = true

package/engine/internal/state/snapshot.go

@@ -23,6 +23,7 @@ var (
 	snapshotSliceStateRe   = regexp.MustCompile(`[[:space:]]+(built|pending)[[:space:]]*$`)
 	snapshotSliceSepRe     = regexp.MustCompile(`[[:space:]]+[^[:alnum:][:space:]]+[[:space:]]*$`)
 	snapshotSliceCheckedRe = regexp.MustCompile(`\[[xX]\]`)
+	snapshotSliceHeadingRe = regexp.MustCompile(`(?m)^##[[:space:]]+(SLICE-[0-9]{3})(?:[[:space:]]+.*)?$`)
 	snapshotTouchedPathRe  = regexp.MustCompile("`([^`]+)`")
 )
 
@@ -121,7 +122,7 @@ func Snapshot(root, slug string) (*WorkspaceSnapshot, error) {
 	}
 
 	workDir := featureDir(root, report.Slug)
-	next := workflow.ForPhase(string(report.Phase))
+	next := nextCommand(workDir, report.Phase)
 	snap := &WorkspaceSnapshot{
 		SchemaVersion:  WorkspaceSnapshotSchema,
 		Slug:           report.Slug,
@@ -152,7 +153,7 @@ func Snapshot(root, slug string) (*WorkspaceSnapshot, error) {
 	if snap.RunMode == "AFK" && len(snap.MissingSections) > 0 {
 		snap.Warnings = append(snap.Warnings, "AFK workspace has missing required sections")
 	}
-	if snap.Evidence.Status == "missing" && (report.Phase == PhaseProve || report.Phase == PhaseSeal || report.Phase == PhaseShip) {
+	if report.Required[SectionProof] && snap.Evidence.Status != "fresh" {
 		snap.Warnings = append(snap.Warnings, "proof phase requires fresh evidence")
 	}
 	if snap.Drift.Open > 0 {
@@ -161,6 +162,17 @@ func Snapshot(root, slug string) (*WorkspaceSnapshot, error) {
 	return snap, nil
 }
 
+func nextCommand(workDir string, phase Phase) workflow.Command {
+	if raw, err := os.ReadFile(filepath.Join(workDir, LedgerFile)); err == nil {
+		if action, ok := CursorField(strings.Split(string(raw), "\n"), CursorNextAction); ok {
+			if command := workflow.ForAction(action); command.Verb != "" {
+				return command
+			}
+		}
+	}
+	return workflow.ForVerb(ResumeVerb(phase))
+}
+
 func readActiveSlug(root string) string {
 	if ws := devritespaths.WorkspaceOverride(root, ""); ws != "" {
 		return filepath.Base(ws)
@@ -180,6 +192,22 @@ func runMode(root string) string {
 }
 
 func currentSlice(workDir string) *SliceSnapshot {
+	if rawState, err := os.ReadFile(filepath.Join(workDir, LedgerFile)); err == nil {
+		if active, ok := CursorField(strings.Split(string(rawState), "\n"), CursorActiveSlice); ok {
+			fields := strings.Fields(active)
+			if len(fields) > 0 {
+				active = fields[0]
+				if rawTasks, taskErr := os.ReadFile(filepath.Join(workDir, "tasks.md")); taskErr == nil {
+					matches := snapshotSliceHeadingRe.FindAllStringSubmatch(string(rawTasks), -1)
+					for i, match := range matches {
+						if match[1] == active {
+							return &SliceSnapshot{Index: i + 1, Total: len(matches), Name: active, State: "pending"}
+						}
+					}
+				}
+			}
+		}
+	}
 	for _, name := range []string{"state.md", "tasks.md"} {
 		raw, err := os.ReadFile(filepath.Join(workDir, name))
 		if err != nil {
@@ -260,6 +288,9 @@ func driftSummary(workDir string) DriftSnapshot {
 			continue
 		}
 		open := countOpenMarkers(string(raw))
+		if name == "questions.md" {
+			open = countOpenQuestions(string(raw))
+		}
 		if open > 0 {
 			return DriftSnapshot{Status: "open", Open: open}
 		}
@@ -267,11 +298,37 @@ func driftSummary(workDir string) DriftSnapshot {
 	return DriftSnapshot{Status: "clear"}
 }
 
+func countOpenQuestions(text string) int {
+	open := 0
+	inQuestion := false
+	status := ""
+	finalize := func() {
+		if inQuestion && status == "open" {
+			open++
+		}
+	}
+	for _, line := range strings.Split(text, "\n") {
+		lower := strings.ToLower(strings.TrimSpace(line))
+		switch {
+		case strings.HasPrefix(lower, "## q-"):
+			finalize()
+			inQuestion, status = true, ""
+		case inQuestion && strings.HasPrefix(lower, "status:"):
+			status = strings.TrimSpace(strings.TrimPrefix(lower, "status:"))
+		case inQuestion && strings.HasPrefix(lower, "## "):
+			finalize()
+			inQuestion = false
+		}
+	}
+	finalize()
+	return open
+}
+
 func countOpenMarkers(text string) int {
 	open := 0
 	for _, line := range strings.Split(text, "\n") {
 		l := strings.ToLower(strings.TrimSpace(line))
-		if strings.Contains(l, "status: open") || strings.Contains(l, "- [ ]") || strings.Contains(l, "gate: blocking") {
+		if strings.Contains(l, "status: open") || strings.Contains(l, "- [ ]") {
 			open++
 		}
 	}