diff --git a/.sdd/graph/2026/07/20-113534-s-tac-ufs.md b/.sdd/graph/2026/07/20-113534-s-tac-ufs.md
new file mode 100644
index 00000000..22a0c80b
--- /dev/null
+++ b/.sdd/graph/2026/07/20-113534-s-tac-ufs.md
@@ -0,0 +1,20 @@
+---
+type: signal
+layer: tactical
+kind: done
+refs:
+    - id: 20260719-190740-d-tac-ptn
+      kind: addresses
+      desc: delivers the plan's metadata, authoring, inspection, and derived-read slice
+participants:
+    - Christopher
+confidence: high
+topics:
+    - engine/base-facts
+    - implementation/engine
+    - type-system/kinds
+    - reliability/testing
+summary: Slice 1 of the derived base-fact index plan ships in commit 60adf47, delivering strict nested metadata, serialization and validation, propagation from engine capture through CLI and show, and a pure current-project read restricted to active indexed facts with deterministic ordering and no supersession inheritance. Three independent reviews drove fail-loud malformed enrollment, centralized validation, strict YAML shape, removable optional state, value isolation, and stronger ordering coverage; focused tests, vet, diff checks, and targeted lint are green. This intermediate done signal addresses the plan without closing it.
+---
+
+Slice 1 of the derived base-fact index plan ships strict metadata and the pure derived read in commit 60adf47. The slice adds exact nested fact-index serialization and validation, carries the value through engine capture, application, command, CLI, and show surfaces, and derives only active indexed facts from the current project's merged graph with deterministic ordering and no supersession inheritance. Three independent reviews covered architecture, acceptance-criteria fidelity, and adversarial risk; their findings drove fail-loud malformed enrollment, centralized validation, strict YAML shape, removable optional state, value isolation, and stronger ordering coverage. Focused tests, vet, diff checks, and targeted lint are green. This is an intermediate completion record and does not close the plan.
diff --git a/.sdd/graph/wip/20260719-191635-christopher.md b/.sdd/graph/wip/20260719-191635-christopher.md
new file mode 100644
index 00000000..66be02f6
--- /dev/null
+++ b/.sdd/graph/wip/20260719-191635-christopher.md
@@ -0,0 +1,7 @@
+---
+entry: 20260719-190740-d-tac-ptn
+participant: Christopher
+exclusive: true
+---
+
+Implement derived base-fact index plan slice by slice
diff --git a/application/session_runtime_test.go b/application/session_runtime_test.go
index fff8b401..5c513bcb 100644
--- a/application/session_runtime_test.go
+++ b/application/session_runtime_test.go
@@ -4,12 +4,15 @@ import (
 	"context"
 	"encoding/json"
 	"errors"
+	"os"
+	"path/filepath"
 	"strings"
 	"sync"
 	"testing"
 	"time"
 
 	sdd "github.com/networkteam/sdd/application"
+	"github.com/networkteam/sdd/internal/model"
 	localadapter "github.com/networkteam/sdd/local"
 )
 
@@ -390,7 +393,8 @@ func TestPreparedTransitionRejectsEmptyTargetAndStructuredDivergence(t *testing.
 }
 
 func TestCreateEntryResolvesConcreteDefaultWithoutCWDAndReleasesAroundLLM(t *testing.T) {
-	graph, err := localadapter.NewFilesystemGraphStore(localadapter.FilesystemGraphStoreOptions{Project: "example", GraphDir: t.TempDir()})
+	graphDir := t.TempDir()
+	graph, err := localadapter.NewFilesystemGraphStore(localadapter.FilesystemGraphStoreOptions{Project: "example", GraphDir: graphDir})
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -432,7 +436,8 @@ func TestCreateEntryResolvesConcreteDefaultWithoutCWDAndReleasesAroundLLM(t *tes
 	binding := openBinding(t, sessions, identity.Subject, "create-default")
 	t.Chdir(t.TempDir())
 	created, err := application.CreateEntry(t.Context(), identity, "example", binding, sdd.EntryDraft{
-		Kind: "gap", Layer: "tactical", Body: "Concrete target resolution must remain independent of the process working directory.", Confidence: "high",
+		Kind: "fact", Layer: "tactical", Body: "Concrete target resolution must remain independent of the process working directory.", Confidence: "high",
+		Topics: []string{"implementation/engine"}, Index: &sdd.FactIndex{Title: "Concrete target resolution", Topic: "implementation/engine"},
 	})
 	if err != nil || created.EntryID == "" {
 		t.Fatalf("CreateEntry = %+v, %v", created, err)
@@ -450,6 +455,17 @@ func TestCreateEntryResolvesConcreteDefaultWithoutCWDAndReleasesAroundLLM(t *tes
 	if !sessionHasEvent(stored.Events, "mutation_intent", `"Target":{"project":"example","branch":"main"}`) {
 		t.Fatalf("ordinary capture did not persist its concrete default target: %+v", stored.Events)
 	}
+	rel, err := model.IDToRelPath(created.EntryID)
+	if err != nil {
+		t.Fatal(err)
+	}
+	written, err := os.ReadFile(filepath.Join(graphDir, rel))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !strings.Contains(string(written), "index:\n    title: Concrete target resolution\n    topic: implementation/engine\n") {
+		t.Fatalf("written entry missing nested index:\n%s", written)
+	}
 }
 
 func TestPreparedRevalidationToleratesJSONRoundTripScalarTypes(t *testing.T) {
diff --git a/application/workflow_registry.go b/application/workflow_registry.go
index 5f67b6d7..93e253f9 100644
--- a/application/workflow_registry.go
+++ b/application/workflow_registry.go
@@ -53,6 +53,15 @@ func (w *WorkflowSession) registerWorkflowQueries(registry *engine.Registry) err
 	}); err != nil {
 		return err
 	}
+	if err := registry.RegisterQuery(engine.Query{
+		Doc:       engine.FuncDoc{Name: "factIndex", Doc: "Active indexed facts from the current project graph, ordered for session discovery."},
+		ServeSafe: true,
+		Fn: func(ctx *engine.Context, _ map[string]any) (any, error) {
+			return ctx.Graph.IndexedFacts()
+		},
+	}); err != nil {
+		return err
+	}
 	if err := registry.RegisterQuery(engine.Query{
 		Doc:       engine.FuncDoc{Name: "viewLayout", Doc: "Rendered `sdd view` pipeline result. Arg layout: the full pipeline syntax; may be a Go template over the store. Optional arg maxBytes: cap the rendered result on a line boundary (0 = uncapped), for a framing lane that must stay bounded."},
 		ServeSafe: true,
@@ -130,7 +139,7 @@ func (w *WorkflowSession) registerWorkflowWrites(registry *engine.Registry) erro
 	if err := registry.RegisterCommand(engine.Command{
 		Doc: engine.FuncDoc{
 			Name: "newEntry", Doc: "Creates the entry from the capture state fields (pre-flight inside; staged attachments materialized from handles; a recorded override skips pre-flight, durably logged).",
-			Reads: []string{"body", "entryKind", "layer", "refs", "topics", "confidence", "intent", "attachments", "participants", "supersedes", "closes", "preflightOverride"}, Writes: []string{"entryId", "findings"},
+			Reads: []string{"body", "entryKind", "layer", "refs", "topics", "index", "confidence", "intent", "attachments", "participants", "supersedes", "closes", "preflightOverride"}, Writes: []string{"entryId", "findings"},
 		},
 		MutatesGraph: true,
 		Fn:           w.runWorkflowNewEntry,
@@ -241,6 +250,13 @@ func (w *WorkflowSession) runWorkflowNewEntry(ctx *engine.Context) error {
 	}
 	draft.Confidence, _ = workflowStoreString(ctx.Store, "confidence")
 	draft.Intent, _ = workflowStoreString(ctx.Store, "intent")
+	if value, ok := ctx.Store.Get("index"); ok {
+		index, valid := value.(engine.FactIndex)
+		if !valid {
+			return fmt.Errorf("newEntry: index has invalid stored type")
+		}
+		draft.Index = &FactIndex{Title: index.Title, Topic: index.Topic}
+	}
 	if override, ok := ctx.Store.Get("preflightOverride"); ok {
 		draft.SkipPreflight, _ = override.(bool)
 	}
diff --git a/application/workflow_target_graph_test.go b/application/workflow_target_graph_test.go
index c5e64934..a42e9062 100644
--- a/application/workflow_target_graph_test.go
+++ b/application/workflow_target_graph_test.go
@@ -2,6 +2,7 @@ package application
 
 import (
 	"context"
+	"strings"
 	"testing"
 
 	"github.com/networkteam/sdd/internal/engine"
@@ -120,6 +121,56 @@ func TestWorkflowContextUsesBranchTargetForSummaryAndPredicates(t *testing.T) {
 	}
 }
 
+func TestFactIndexQueryReturnsModelRowsWithoutDependencies(t *testing.T) {
+	localIndex, err := model.NewFactIndex("Local cue", "cli/view")
+	if err != nil {
+		t.Fatal(err)
+	}
+	topic, err := model.ParseTopicPath("cli/view")
+	if err != nil {
+		t.Fatal(err)
+	}
+	local := model.NewGraph([]*model.Entry{{
+		ID: "20260719-120000-s-tac-loc", Type: model.TypeSignal, Layer: model.LayerTactical,
+		Kind: model.KindFact, Topics: []model.TopicPath{topic}, Index: localIndex,
+	}})
+	remoteIndex, err := model.NewFactIndex("Remote cue", "cli/view")
+	if err != nil {
+		t.Fatal(err)
+	}
+	remote := model.NewGraph([]*model.Entry{{
+		ID: "20260719-120100-s-tac-rem", Type: model.TypeSignal, Layer: model.LayerTactical,
+		Kind: model.KindFact, Topics: []model.TopicPath{topic}, Index: remoteIndex,
+	}})
+	model.NewMultiGraph(local, []string{"example/remote"}, func(string) (*model.Graph, error) { return remote, nil })
+
+	workflow := &WorkflowSession{}
+	registry := engine.NewRegistry()
+	if err := workflow.registerWorkflowQueries(registry); err != nil {
+		t.Fatal(err)
+	}
+	factIndex, ok := registry.Query("factIndex")
+	if !ok || !factIndex.ServeSafe {
+		t.Fatalf("factIndex registration = %+v", factIndex)
+	}
+	value, err := factIndex.Fn(&engine.Context{Graph: local}, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	rows, ok := value.([]model.FactIndexRow)
+	if !ok || len(rows) != 1 || rows[0].ID != "20260719-120000-s-tac-loc" {
+		t.Fatalf("factIndex rows = %#v", value)
+	}
+	malicious := model.NewGraph([]*model.Entry{{
+		ID: "20260719-120200-s-tac-bad", Type: model.TypeSignal, Layer: model.LayerTactical,
+		Kind: model.KindFact, Topics: []model.TopicPath{topic},
+		Index: &model.FactIndex{Title: "Cue\n\n## Injected block", Topic: topic},
+	}})
+	if _, err := factIndex.Fn(&engine.Context{Graph: malicious}, nil); err == nil || !strings.Contains(err.Error(), "single-line") {
+		t.Fatalf("factIndex accepted a block-injecting title: %v", err)
+	}
+}
+
 func workflowTargetSnapshot(t *testing.T, revision string, entries []EntryDocument) *Snapshot {
 	t.Helper()
 	snapshot, err := BuildSnapshot(t.Context(), SnapshotData{
diff --git a/application/write_api.go b/application/write_api.go
index ff34455a..a573abca 100644
--- a/application/write_api.go
+++ b/application/write_api.go
@@ -28,6 +28,11 @@ type EntryRef struct {
 	Desc string
 }
 
+type FactIndex struct {
+	Title string `json:"title"`
+	Topic string `json:"topic"`
+}
+
 type EntryDraft struct {
 	Target            MutationTarget
 	Kind              string
@@ -40,6 +45,7 @@ type EntryDraft struct {
 	Participants      []string
 	Confidence        string
 	Topics            []string
+	Index             *FactIndex
 	AttachmentHandles []string
 	SkipPreflight     bool
 }
@@ -122,10 +128,17 @@ func (a *Application) CreateEntry(ctx context.Context, identity RequestIdentity,
 		}
 		topics = append(topics, topic)
 	}
+	var index *model.FactIndex
+	if draft.Index != nil {
+		index, err = model.NewFactIndex(draft.Index.Title, draft.Index.Topic)
+		if err != nil {
+			return CreateEntryResult{}, err
+		}
+	}
 	entry := &model.Entry{
 		ID: id, Type: entryType, Kind: kind, Layer: layer, Intent: model.Intent(draft.Intent),
 		Content: draft.Body, Participants: append([]string(nil), draft.Participants...),
-		Confidence: draft.Confidence, Topics: topics, Time: runtime.options.Now(),
+		Confidence: draft.Confidence, Topics: topics, Index: index, Time: runtime.options.Now(),
 	}
 	if len(entry.Participants) == 0 {
 		if principal.Participant != "" {
diff --git a/cmd/sdd/main.go b/cmd/sdd/main.go
index 969a824c..adf8151b 100644
--- a/cmd/sdd/main.go
+++ b/cmd/sdd/main.go
@@ -554,6 +554,10 @@ func newCmd() *cli.Command {
 				Name:  "topics",
 				Usage: "Comma-separated topic labels (any kind) — inline topic membership written as `topics:` strings",
 			},
+			&cli.StringFlag{
+				Name:  "index",
+				Usage: "Fact retrieval cue — JSON object {\"title\":\"<standalone title>\",\"topic\":\"<topic also in --topics>\"}",
+			},
 			&cli.StringSliceFlag{
 				Name:  "topic",
 				Usage: "Topic cluster (kind: annotation only) — JSON object {\"label\":\"path\",\"members\":[\"id\",...]}; repeatable. A plain string in --topics works too for whole-refs membership.",
@@ -700,6 +704,10 @@ func newCmd() *cli.Command {
 			if err != nil {
 				return err
 			}
+			factIndex, err := parseFactIndexFlag(cmd.String("index"))
+			if err != nil {
+				return err
+			}
 			refs, err := parseRefFlags(cmd.StringSlice("refs"))
 			if err != nil {
 				return err
@@ -725,6 +733,7 @@ func newCmd() *cli.Command {
 				Class:            strings.TrimSpace(cmd.String("class")),
 				Actor:            strings.TrimSpace(cmd.String("actor")),
 				TopicLabels:      splitCSV(cmd.String("topics")),
+				Index:            factIndex,
 				AnnotationTopics: annotationTopics,
 				FocusActors:      focusActors,
 				FocusWhen:        focusWhen,
@@ -2203,6 +2212,30 @@ func parseWhenFlag(s string) (*model.FocusWhen, error) {
 	return &w, nil
 }
 
+func parseFactIndexFlag(s string) (*model.FactIndex, error) {
+	s = strings.TrimSpace(s)
+	if s == "" {
+		return nil, nil
+	}
+	decoder := json.NewDecoder(strings.NewReader(s))
+	decoder.DisallowUnknownFields()
+	var raw struct {
+		Title string `json:"title"`
+		Topic string `json:"topic"`
+	}
+	if err := decoder.Decode(&raw); err != nil {
+		return nil, fmt.Errorf("--index: invalid JSON object: %w", err)
+	}
+	if err := decoder.Decode(&struct{}{}); err != io.EOF {
+		return nil, fmt.Errorf("--index: expected one JSON object")
+	}
+	index, err := model.NewFactIndex(raw.Title, raw.Topic)
+	if err != nil {
+		return nil, fmt.Errorf("--index: %w", err)
+	}
+	return index, nil
+}
+
 // parseInvolvementFlags parses each --involvement JSON value into a
 // model.Involvement, preserving the actors-omitted vs explicit-empty
 // distinction (the latter declares pull-available involvement).
diff --git a/cmd/sdd/main_test.go b/cmd/sdd/main_test.go
index a0e3094b..74ae4e80 100644
--- a/cmd/sdd/main_test.go
+++ b/cmd/sdd/main_test.go
@@ -390,6 +390,28 @@ func TestParseRefFlags_UnknownKindRejectedAtCapture(t *testing.T) {
 	}
 }
 
+func TestParseFactIndexFlag(t *testing.T) {
+	index, err := parseFactIndexFlag(`{"title":"How to compose graph views","topic":"cli/view"}`)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if index.Title != "How to compose graph views" || index.Topic.String() != "cli/view" {
+		t.Fatalf("index = %+v", index)
+	}
+	for _, input := range []string{
+		`{"title":"Missing topic"}`,
+		`{"title":" ","topic":"cli/view"}`,
+		`{"title":"Title","topic":"cli view"}`,
+		`{"title":"Title\n## Injected","topic":"cli/view"}`,
+		`{"title":"Title","topic":"cli/view","extra":true}`,
+		`{"title":"Title","topic":"cli/view"} {}`,
+	} {
+		if _, err := parseFactIndexFlag(input); err == nil {
+			t.Errorf("parseFactIndexFlag(%q) accepted invalid object", input)
+		}
+	}
+}
+
 func TestParseRefFlags_EmptyInput(t *testing.T) {
 	got, err := parseRefFlags(nil)
 	if err != nil {
diff --git a/internal/basefacts/basefacts.go b/internal/basefacts/basefacts.go
index ea3ee22b..52c6a1eb 100644
--- a/internal/basefacts/basefacts.go
+++ b/internal/basefacts/basefacts.go
@@ -50,6 +50,9 @@ func build(id, frontmatter, body string) (*model.Entry, error) {
 	if entry.Type != model.TypeSignal || entry.Kind != model.KindFact {
 		return nil, fmt.Errorf("base fact %s is %s %s — base facts ship as kind: fact signals", id, entry.Type, entry.Kind)
 	}
+	if err := entry.Index.ValidateForEntry(entry.Kind, entry.Topics); err != nil {
+		return nil, fmt.Errorf("base fact %s index: %w", id, err)
+	}
 	entry.Embedded = true
 	return entry, nil
 }
@@ -70,6 +73,9 @@ confidence: high
 topics:
     - engine/base-facts
     - cli/view
+index:
+    title: 'How to compose graph views (view tool): layout grammar, filters, ranking, quoting, and examples'
+    topic: cli/view
 summary: >-
     The view layout language composes graph views from a colon-chained
     pipeline — filters, then ranking, paging, and transforms, ending in a
@@ -78,15 +84,6 @@ summary: >-
     quoting rule for multi-word, date, and duration arguments.
 `
 
-// viewGrammarBody renders the fact's body: a short neutral orientation line
-// followed by the host-neutral grammar-and-vocabulary reference generated
-// from the live executor vocabulary. Nothing here names a host command, so
-// the fact stays host-neutral (d-cpt-476).
 func viewGrammarBody(vocab viewlayout.Vocabulary) string {
-	return "Reference for the view layout language — the grammar for composing graph " +
-		"views by pipeline. Pull it when building or debugging a layout: it lists " +
-		"every filter, rank algorithm, transform, render terminator, and macro the " +
-		"executor accepts, and the quoting rule that trips up unquoted multi-word, " +
-		"date, and duration arguments.\n\n" +
-		viewlayout.ReferenceBody(vocab)
+	return viewlayout.Markdown(vocab)
 }
diff --git a/internal/basefacts/basefacts_test.go b/internal/basefacts/basefacts_test.go
index 3b77fcff..bf47e819 100644
--- a/internal/basefacts/basefacts_test.go
+++ b/internal/basefacts/basefacts_test.go
@@ -10,7 +10,7 @@ import (
 
 func testVocabulary() viewlayout.Vocabulary {
 	return viewlayout.Vocabulary{
-		Functions:  []string{"active", "kind", "rank", "n", "as-list"},
+		Functions:  []string{"active", "indexed", "kind", "rank", "n", "as-list"},
 		Renders:    []string{"as-list"},
 		Algorithms: []string{"heat"},
 		Decays:     []string{"exp-14d"},
@@ -43,10 +43,12 @@ func TestEntriesShipViewGrammarFact(t *testing.T) {
 	if len(fact.Refs) != 0 {
 		t.Errorf("base fact carries refs %v, want none", fact.Refs)
 	}
+	const title = "How to compose graph views (view tool): layout grammar, filters, ranking, quoting, and examples"
+	if fact.Index == nil || fact.Index.Title != title || fact.Index.Topic.String() != "cli/view" {
+		t.Errorf("fact index = %+v", fact.Index)
+	}
 }
 
-// The body is generated from the supplied vocabulary and must stay host-
-// neutral (d-cpt-476): no fact may name the sdd CLI or a command to run.
 func TestViewGrammarBodyIsGeneratedAndHostNeutral(t *testing.T) {
 	entries, err := Entries(testVocabulary())
 	if err != nil {
@@ -54,23 +56,29 @@ func TestViewGrammarBodyIsGeneratedAndHostNeutral(t *testing.T) {
 	}
 	body := entries[0].Content
 
-	for _, want := range []string{"active", "heat", "exp-14d", "top(N)", "Grammar:"} {
+	for _, want := range []string{"# How to compose graph views", "## Grammar", "```text", "| Category | Syntax | Meaning |", "active", "heat", "exp-14d", "top(N)", "active:indexed:as-list"} {
 		if !strings.Contains(body, want) {
 			t.Errorf("generated body missing live-vocabulary token %q", want)
 		}
 	}
-	for _, host := range []string{"sdd view", "Usage:", "--layout"} {
+	for _, host := range []string{"sdd view", "Usage:", "--layout", "MCP", "debugging"} {
 		if strings.Contains(body, host) {
 			t.Errorf("base fact body contains host-specific reference %q", host)
 		}
 	}
 }
 
-// A base fact that is not a kind: fact signal is a build mistake and must
-// fail construction rather than reach a graph.
 func TestBuildRejectsNonFact(t *testing.T) {
 	_, err := build("20260101-000000-d-cpt-xxx", "type: decision\nlayer: conceptual\nkind: directive\nconfidence: low\nintent: guiding\n", "body")
 	if err == nil {
 		t.Fatal("build accepted a non-fact base entry, want error")
 	}
 }
+
+func TestBuildRejectsInvalidFactIndexEnrollment(t *testing.T) {
+	frontmatter := "type: signal\nlayer: process\nkind: fact\ntopics: [cli/view]\nindex: {title: Reference, topic: agent/ux}\n"
+	_, err := build("20260101-000000-s-prc-idx", frontmatter, "body")
+	if err == nil || !strings.Contains(err.Error(), "must also appear in topics") {
+		t.Fatalf("build error = %v", err)
+	}
+}
diff --git a/internal/baseprocedures/baseprocedures_test.go b/internal/baseprocedures/baseprocedures_test.go
index 85090300..eea82a66 100644
--- a/internal/baseprocedures/baseprocedures_test.go
+++ b/internal/baseprocedures/baseprocedures_test.go
@@ -110,3 +110,26 @@ func TestEntries_EmbeddedSetLoads(t *testing.T) {
 		t.Errorf("embedded set must ship the capture procedure, got canonicals %v", canonicals)
 	}
 }
+
+func TestCaptureCarriesFactIndexThroughPlaybackAndWrite(t *testing.T) {
+	entries, err := Entries()
+	if err != nil {
+		t.Fatal(err)
+	}
+	var capture string
+	for _, entry := range entries {
+		if entry.Canonical == "capture" {
+			capture = entry.Content
+		}
+	}
+	for _, want := range []string{
+		"{{if .index}}- index:",
+		"title: {{.index.Title}}",
+		"topic: {{.index.Topic}}",
+		"optionally enrolls a `fact` in the retrieval index",
+	} {
+		if !strings.Contains(capture, want) {
+			t.Errorf("capture procedure missing %q", want)
+		}
+	}
+}
diff --git a/internal/baseprocedures/entries/20260703-094500-d-prc-cap.md b/internal/baseprocedures/entries/20260703-094500-d-prc-cap.md
index 91d6a7c9..71f8daa5 100644
--- a/internal/baseprocedures/entries/20260703-094500-d-prc-cap.md
+++ b/internal/baseprocedures/entries/20260703-094500-d-prc-cap.md
@@ -23,6 +23,7 @@ state:
     layer: {type: layer, desc: strategic | conceptual | tactical | operational | process}
     refs: {type: list<ref>, desc: "each {id, kind, desc?}; kind chosen from what the body asserts"}
     topics: {type: list<label>, desc: reuse existing labels; a new label deliberately starts a cluster}
+    index: {type: fact-index, optional: true, desc: fact-only retrieval cue with standalone title and a topic also present in topics}
     confidence: {type: confidence, desc: honest — high / medium / low}
     intent: {type: intent, optional: true, desc: required when entryKind is directive}
     attachments: {type: list<attachment-handle>, optional: true, desc: staged handles carrying the dialogue's full record}
@@ -31,7 +32,7 @@ state:
     correctedSummary: {type: text, optional: true, desc: replacement summary when the generated one drifted}
 steps:
     - id: assemble
-      collect: [body, entryKind, layer, refs, topics, confidence, "intent?", "attachments?", widenReport]
+      collect: [body, entryKind, layer, refs, topics, "index?", confidence, "intent?", "attachments?", widenReport]
       inject:
           - {fn: viewLayout, args: {layout: "active:as-counts"}}
       transitions:
@@ -43,7 +44,7 @@ steps:
       chooser: user
       options:
           - {choice: confirm, call: confirmPlayback, to: write}
-          - {choice: adjust, collect: ["body?", "refs?", "topics?", "confidence?", "intent?"], to: assemble}
+          - {choice: adjust, collect: ["body?", "refs?", "topics?", "index?", "confidence?", "intent?"], to: assemble}
           - {choice: abort, to: end(abandoned)}
     - id: write
       guard: playbackConfirmed
@@ -56,7 +57,7 @@ steps:
       chooser: user
       render: findings
       options:
-          - {choice: revise, collect: ["body?", "refs?", "topics?"], to: assemble}
+          - {choice: revise, collect: ["body?", "refs?", "topics?", "index?"], to: assemble}
           - {choice: override, call: recordOverride, to: write}
           - {choice: abort, to: end(abandoned)}
     - id: verifySummary
@@ -100,6 +101,8 @@ A ref may point across a repo boundary, written as `<repo-id>:<entry-id>`. Resol
 
 Pick an existing label when one fits; a new label deliberately starts a cluster. Prefer hierarchical paths (`family/member`) for label families.
 
+**Index** (`index`) optionally enrolls a `fact` in the retrieval index as `{title, topic}`. The title must stand alone as a retrieval cue, and the topic must also appear in `topics`. Omit it for every other kind.
+
 **Confidence** (`confidence`) is honest: high — strong conviction · medium — reasonable but unvalidated · low — hypothesis.
 
 **Intent** (`intent`) is required when the kind is directive and is never derivable: `pending` — demands follow-up (the default posture) · `guiding` — standing context that shapes later decisions without ever completing · `settled` — born terminal; the body must justify why no follow-up is needed.
@@ -115,6 +118,10 @@ Present the draft to the user for verification. This is the verification contrac
 - kind: {{.entryKind}} · layer: {{.layer}}{{if .intent}} · intent: {{.intent}}{{end}} · confidence: {{.confidence}}
 - refs:{{range .refs}} {{.ID}} ({{.Kind}}){{if .Desc}} — {{.Desc}}{{end}};{{end}}
 - topics:{{range .topics}} {{.}}{{end}}
+{{if .index}}- index:
+    title: {{.index.Title}}
+    topic: {{.index.Topic}}
+{{end}}
 - target branch: {{if .captureBranch}}{{.captureBranch}}{{else}}the project's configured default branch{{end}}{{if .supersedes}}
 - supersedes: {{.supersedes}}{{end}}{{if .closes}}
 - closes:{{range .closes}} {{.}}{{end}}{{end}}{{if .attachments}}
diff --git a/internal/baseprocedures/entries/20260704-100000-d-prc-dlg.md b/internal/baseprocedures/entries/20260704-100000-d-prc-dlg.md
index 34fc49a4..aab3e33c 100644
--- a/internal/baseprocedures/entries/20260704-100000-d-prc-dlg.md
+++ b/internal/baseprocedures/entries/20260704-100000-d-prc-dlg.md
@@ -20,6 +20,7 @@ steps:
       inject:
           - {fn: sessionInfo}
           - {fn: procedureList}
+          - {fn: factIndex}
       options:
           - {choice: conclude, to: wrap}
     - id: wrap
@@ -49,6 +50,11 @@ Your session framing — local participant, configured language, search modes, a
 {{if .sessionInfo.recovery}}{{.sessionInfo.recovery}}
 {{end}}
 
+{{if .factIndex}}**Reference facts available before composing or guessing.** Pull the relevant fact in full first:
+{{range .factIndex}}- `{{.ID}}` — {{.Title}}
+{{end}}
+{{end}}
+
 **The graph, in short.** An append-only record of the project's thinking. Two entry types: a signal records something noticed (kinds: gap, fact, question, insight, done, actor, annotation) and a decision records something committed to (kinds: directive, activity, plan, contract, aspiration, role, focus, procedure). Layers name thinking depth: strategic (why), conceptual (approach), tactical (structures and trade-offs), operational (steps), process (how we work). One loop drives everything: a signal meets dialogue and becomes a decision; completed work lands as a done signal that closes the commitment and feeds the next loop. Entries are immutable — status is derived from the graph, and retiring an entry means adding a closing or superseding entry, never editing. Summaries are pointers, not facts: before asserting what the graph holds — in dialogue as much as before capture — search from several angles and read the promising entries in full (`show`); both `search` and `show` reach the local graph and, when the query selects them, its connected dependencies.
 
 **How the dialogue feels.** Be a colleague thinking alongside the user, not a report writer. Keep turns short; ask one question at a time and wait. Use plain, outcome-focused words — tool names, step ids, schema fields, and graph mechanics stay out of the conversation ("I'll record this as a decision", never the tool call that does it). Structured technical detail belongs in exactly one place: playback of a proposed entry, where the user verifies the fields verbatim. Cite entries by short ID in conversation (`d-tac-ry0`); pass full IDs to tools — and to turn a short ID into its full form, resolve it with `show`, which accepts an unambiguous short or unprefixed ID and resolves it across the local graph and its declared dependencies (so a foreign entry's bare ID resolves too, expanding to full `<repo-id>:<entry-id>` form), never by reading graph files (reads are free, so do this up front; file paths don't exist for a remote graph). This resolve-first step is also how a bare ID becomes a move anchor: resolve it with `show`, then anchor on the full ID — anchor fields take the resolved form, not a bare one. Anything generated for other people carries no SDD vocabulary at all. Frame SDD activity by what it does for the user — the answer is recorded, the decision is searchable — not by your procedure.
diff --git a/internal/command/new_entry.go b/internal/command/new_entry.go
index 6dc0f3be..49b2b499 100644
--- a/internal/command/new_entry.go
+++ b/internal/command/new_entry.go
@@ -68,6 +68,7 @@ type NewEntryCmd struct {
 	// parsing into TopicPath happens during BuildEntry so the command
 	// surface stays simple.
 	TopicLabels []string
+	Index       *model.FactIndex
 
 	// AnnotationTopics carries the topic assignments for a kind: annotation
 	// entry. Each --topic flag at the CLI parses into one entry here. The
@@ -157,6 +158,19 @@ func (c *NewEntryCmd) Validate() error {
 	case c.Class != "" && c.Class != string(model.ProcedureClassMove) && c.Class != string(model.ProcedureClassShell):
 		return fmt.Errorf("invalid class %q (expected move or shell)", c.Class)
 	}
+	if c.Index != nil {
+		topics := make([]model.TopicPath, 0, len(c.TopicLabels))
+		for _, label := range c.TopicLabels {
+			topic, err := model.ParseTopicPath(label)
+			if err != nil {
+				return fmt.Errorf("topics: %w", err)
+			}
+			topics = append(topics, topic)
+		}
+		if err := c.Index.ValidateForEntry(effectiveKind, topics); err != nil {
+			return err
+		}
+	}
 	return nil
 }
 
@@ -179,6 +193,7 @@ func (c *NewEntryCmd) BuildEntry(id string) (*model.Entry, error) {
 		Aliases:      c.Aliases,
 		Class:        model.ProcedureClass(c.Class),
 		Actor:        c.Actor,
+		Index:        c.Index,
 		FocusActors:  c.FocusActors,
 		FocusWhen:    c.FocusWhen,
 		Involvement:  c.Involvement,
diff --git a/internal/command/new_entry_test.go b/internal/command/new_entry_test.go
index a605c071..d1d164e6 100644
--- a/internal/command/new_entry_test.go
+++ b/internal/command/new_entry_test.go
@@ -168,6 +168,37 @@ func TestBuildEntry_MapsIntent(t *testing.T) {
 	}
 }
 
+func TestNewEntryCmdFactIndex(t *testing.T) {
+	index, err := model.NewFactIndex("How to compose graph views", "cli/view")
+	if err != nil {
+		t.Fatal(err)
+	}
+	cmd := &command.NewEntryCmd{
+		Type: model.TypeSignal, Layer: model.LayerTactical, Kind: model.KindFact,
+		TopicLabels: []string{"cli/view"}, Index: index,
+	}
+	if err := cmd.Validate(); err != nil {
+		t.Fatalf("Validate: %v", err)
+	}
+	entry, err := cmd.BuildEntry("20260719-120000-s-tac-idx")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if entry.Index != index || entry.Index.Title != "How to compose graph views" {
+		t.Fatalf("entry.Index = %+v", entry.Index)
+	}
+
+	cmd.Kind = model.KindInsight
+	if err := cmd.Validate(); err == nil {
+		t.Fatal("Validate accepted index on non-fact")
+	}
+	cmd.Kind = model.KindFact
+	cmd.TopicLabels = []string{"agent/ux"}
+	if err := cmd.Validate(); err == nil {
+		t.Fatal("Validate accepted index topic absent from topics")
+	}
+}
+
 func TestBuildEntry_ResolvesAttachmentPaths(t *testing.T) {
 	cmd := &command.NewEntryCmd{
 		Type:        model.TypeDecision,
diff --git a/internal/engine/engine_test.go b/internal/engine/engine_test.go
index 54198e89..29c19469 100644
--- a/internal/engine/engine_test.go
+++ b/internal/engine/engine_test.go
@@ -244,6 +244,64 @@ func TestCapture_OneShotHappyPath(t *testing.T) {
 	}
 }
 
+func TestCapture_FactIndexSetThenClearSurvivesReplay(t *testing.T) {
+	env := newFixtureEnv(t)
+	var log strings.Builder
+	env.session.sink = NewWriterSink(&log)
+
+	sv, err := env.session.Start(env.spec, nil, "")
+	if err != nil {
+		t.Fatal(err)
+	}
+	draft := fullDraft()
+	draft["entryKind"] = "fact"
+	draft["index"] = map[string]any{"title": "How to compose graph views", "topic": "cli/ux"}
+	sv, err = env.session.Report(sv.Instance, draft)
+	if err != nil {
+		t.Fatal(err)
+	}
+	const playback = "- index:\n    title: How to compose graph views\n    topic: cli/ux"
+	if !strings.Contains(sv.Instructions, playback) {
+		t.Fatalf("playback missing nested fact index:\n%s", sv.Instructions)
+	}
+	index, ok := env.session.instances[sv.Instance].Store.Get("index")
+	if !ok || index != (FactIndex{Title: "How to compose graph views", Topic: "cli/ux"}) {
+		t.Fatalf("stored index = %#v", index)
+	}
+	sv, err = env.session.Answer(sv.Instance, "playback", "adjust", map[string]any{"index": nil}, "remove the index")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if strings.Contains(sv.Instructions, "- index:") {
+		t.Fatalf("playback retained cleared fact index:\n%s", sv.Instructions)
+	}
+
+	events, err := ReadEvents(strings.NewReader(log.String()))
+	if err != nil {
+		t.Fatal(err)
+	}
+	replayedEnv := newFixtureEnv(t)
+	replayed, err := replayedEnv.engine.ReplaySession("s_test", "christopher", events,
+		func(string) (*Spec, error) { return replayedEnv.spec, nil }, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	instance, ok := replayed.Instance(sv.Instance)
+	if !ok {
+		t.Fatal("replayed capture instance missing")
+	}
+	if index, ok := instance.Store.Get("index"); ok {
+		t.Fatalf("replayed index = %#v, want cleared", index)
+	}
+	replayedServe, err := replayed.Serve(sv.Instance)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if strings.Contains(replayedServe.Instructions, "- index:") {
+		t.Fatalf("replayed playback retained cleared fact index:\n%s", replayedServe.Instructions)
+	}
+}
+
 func TestCapture_StallNamesExactlyWhatIsMissing(t *testing.T) {
 	env := newFixtureEnv(t)
 	sv, err := env.session.Start(env.spec, nil, "")
diff --git a/internal/engine/schema.go b/internal/engine/schema.go
index 41bd2430..0c9178ae 100644
--- a/internal/engine/schema.go
+++ b/internal/engine/schema.go
@@ -21,7 +21,7 @@ func (s *Spec) ReportSchemaForStep(step *Step) map[string]any {
 		if !ok {
 			return // load validation rejects undeclared collect names
 		}
-		properties[name] = schemaForType(decl.Type, decl.Desc)
+		properties[name] = schemaForState(decl)
 	}
 
 	if step != nil {
@@ -68,7 +68,7 @@ func (s *Spec) AnswerSchemaForStep(step *Step) map[string]any {
 				continue
 			}
 			if decl, ok := s.State[cf.Name]; ok {
-				fieldProps[cf.Name] = schemaForType(decl.Type, decl.Desc)
+				fieldProps[cf.Name] = schemaForState(decl)
 			}
 		}
 	}
@@ -110,6 +110,17 @@ func (s *Spec) AnswerSchemaForStep(step *Step) map[string]any {
 	}
 }
 
+func schemaForState(decl VarDecl) map[string]any {
+	schema := schemaForType(decl.Type, "")
+	if decl.Optional {
+		schema = map[string]any{"anyOf": []any{schema, map[string]any{"type": "null"}}}
+	}
+	if decl.Desc != "" {
+		schema["description"] = decl.Desc
+	}
+	return schema
+}
+
 // schemaForType maps a domain type to its JSON Schema fragment. Validation
 // on arrival is VarType.ValidateValue — the schema is the advertised
 // contract, the store write is the enforcement.
@@ -168,6 +179,16 @@ func schemaForType(t VarType, desc string) map[string]any {
 		schema = map[string]any{"type": "string", "enum": []any{"high", "medium", "low"}}
 	case TypeIntent:
 		schema = map[string]any{"type": "string", "enum": []any{"pending", "guiding", "settled"}}
+	case TypeFactIndex:
+		schema = map[string]any{
+			"type": "object",
+			"properties": map[string]any{
+				"title": map[string]any{"type": "string", "minLength": 1},
+				"topic": map[string]any{"type": "string", "minLength": 1},
+			},
+			"required":             []string{"title", "topic"},
+			"additionalProperties": false,
+		}
 	case TypePreflightFindings:
 		schema = map[string]any{
 			"type": "array",
diff --git a/internal/engine/schema_test.go b/internal/engine/schema_test.go
index 2e64fe83..b354d39d 100644
--- a/internal/engine/schema_test.go
+++ b/internal/engine/schema_test.go
@@ -59,4 +59,46 @@ func TestReportSchemaForStep(t *testing.T) {
 	if schema["additionalProperties"] != false {
 		t.Error("undeclared fields must be rejected by the schema")
 	}
+
+	index, _ := props["index"].(map[string]any)
+	indexObject := nullableObjectBranch(t, index)
+	if indexObject["additionalProperties"] != false {
+		t.Fatalf("index object schema = %#v", indexObject)
+	}
+	indexProps, _ := indexObject["properties"].(map[string]any)
+	if len(indexProps) != 2 || indexProps["title"] == nil || indexProps["topic"] == nil {
+		t.Fatalf("index properties = %#v", indexProps)
+	}
+	if required, _ := indexObject["required"].([]string); len(required) != 2 {
+		t.Fatalf("index required = %#v", indexObject["required"])
+	}
+
+	answer := env.spec.AnswerSchemaForStep(env.spec.StepByID["playback"])
+	answerProps, _ := answer["properties"].(map[string]any)
+	fields, _ := answerProps["fields"].(map[string]any)
+	fieldProps, _ := fields["properties"].(map[string]any)
+	nullableObjectBranch(t, fieldProps["index"].(map[string]any))
+}
+
+func nullableObjectBranch(t *testing.T, schema map[string]any) map[string]any {
+	t.Helper()
+	branches, _ := schema["anyOf"].([]any)
+	if len(branches) != 2 {
+		t.Fatalf("nullable schema = %#v", schema)
+	}
+	var object map[string]any
+	var hasNull bool
+	for _, branch := range branches {
+		candidate, _ := branch.(map[string]any)
+		switch candidate["type"] {
+		case "object":
+			object = candidate
+		case "null":
+			hasNull = true
+		}
+	}
+	if object == nil || !hasNull {
+		t.Fatalf("nullable schema = %#v", schema)
+	}
+	return object
 }
diff --git a/internal/engine/store.go b/internal/engine/store.go
index e7e5cbbe..92fe0069 100644
--- a/internal/engine/store.go
+++ b/internal/engine/store.go
@@ -129,6 +129,14 @@ func (s *Store) WriteState(fields map[string]any) ([]string, error) {
 			}
 			return nil, fmt.Errorf("field %q is not declared in state — reports can only write declared state fields", name)
 		}
+		if raw == nil {
+			if !decl.Optional {
+				return nil, fmt.Errorf("field %q is required and cannot be cleared", name)
+			}
+			delete(s.values, name)
+			written = append(written, name)
+			continue
+		}
 		v, err := decl.Type.ValidateValue(raw)
 		if err != nil {
 			return nil, fmt.Errorf("field %q: %w", name, err)
diff --git a/internal/engine/store_test.go b/internal/engine/store_test.go
new file mode 100644
index 00000000..1cd04682
--- /dev/null
+++ b/internal/engine/store_test.go
@@ -0,0 +1,32 @@
+package engine
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestWriteStateClearsOnlyOptionalFields(t *testing.T) {
+	env := newFixtureEnv(t)
+	store := NewStore(env.spec)
+	if _, err := store.WriteState(map[string]any{
+		"index": map[string]any{"title": "View grammar", "topic": "cli/ux"},
+	}); err != nil {
+		t.Fatal(err)
+	}
+	if _, ok := store.Get("index"); !ok {
+		t.Fatal("optional index was not stored")
+	}
+	written, err := store.WriteState(map[string]any{"index": nil})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(written) != 1 || written[0] != "index" {
+		t.Fatalf("cleared fields = %v", written)
+	}
+	if _, ok := store.Get("index"); ok {
+		t.Fatal("optional index was not cleared")
+	}
+	if _, err := store.WriteState(map[string]any{"body": nil}); err == nil || !strings.Contains(err.Error(), "cannot be cleared") {
+		t.Fatalf("required-field clear error = %v", err)
+	}
+}
diff --git a/internal/engine/types.go b/internal/engine/types.go
index 04cef20b..607319ea 100644
--- a/internal/engine/types.go
+++ b/internal/engine/types.go
@@ -35,6 +35,7 @@ const (
 	TypeConfidence        BaseType = "confidence"
 	TypeIntent            BaseType = "intent"
 	TypeAttachmentHandle  BaseType = "attachment-handle"
+	TypeFactIndex         BaseType = "fact-index"
 	TypePreflightFindings BaseType = "preflight-findings"
 )
 
@@ -50,6 +51,7 @@ var baseTypes = map[BaseType]bool{
 	TypeConfidence:        true,
 	TypeIntent:            true,
 	TypeAttachmentHandle:  true,
+	TypeFactIndex:         true,
 	TypePreflightFindings: true,
 }
 
@@ -217,6 +219,34 @@ func validateBaseValue(base BaseType, v any) (any, error) {
 		}
 		return s, nil
 
+	case TypeFactIndex:
+		m, ok := v.(map[string]any)
+		if !ok {
+			if index, typed := v.(FactIndex); typed {
+				m = map[string]any{"title": index.Title, "topic": index.Topic}
+				ok = true
+			}
+		}
+		if !ok {
+			return nil, fmt.Errorf("expected fact-index object {title, topic}")
+		}
+		if len(m) != 2 {
+			return nil, fmt.Errorf("expected fact-index object with exactly title and topic")
+		}
+		title, titleOK := m["title"].(string)
+		topic, topicOK := m["topic"].(string)
+		if !titleOK {
+			return nil, fmt.Errorf("fact-index title must be a string")
+		}
+		if !topicOK {
+			return nil, fmt.Errorf("fact-index topic must be a string")
+		}
+		index, err := model.NewFactIndex(title, topic)
+		if err != nil {
+			return nil, fmt.Errorf("fact-index: %w", err)
+		}
+		return FactIndex{Title: index.Title, Topic: index.Topic.String()}, nil
+
 	case TypePreflightFindings:
 		// Engine-written by the write gate; accept the typed form and the
 		// replay/JSON form. Validation is shape-only — severity vocabulary is
@@ -262,6 +292,11 @@ type Ref struct {
 	Desc string `json:"desc,omitempty"`
 }
 
+type FactIndex struct {
+	Title string `json:"title"`
+	Topic string `json:"topic"`
+}
+
 func refFromMap(m map[string]any) (Ref, error) {
 	id, _ := m["id"].(string)
 	kind, _ := m["kind"].(string)
diff --git a/internal/engine/types_test.go b/internal/engine/types_test.go
index 72830e4b..931abf7e 100644
--- a/internal/engine/types_test.go
+++ b/internal/engine/types_test.go
@@ -74,6 +74,11 @@ func TestValidateValue(t *testing.T) {
 		{name: "intent ok", typ: "intent", value: "guiding"},
 		{name: "intent unknown", typ: "intent", value: "someday", wantErr: "pending|guiding|settled"},
 		{name: "attachment handle ok", typ: "attachment-handle", value: "att_1"},
+		{name: "fact index ok", typ: "fact-index", value: map[string]any{"title": "View grammar", "topic": "cli/view"}},
+		{name: "fact index partial", typ: "fact-index", value: map[string]any{"title": "View grammar"}, wantErr: "exactly title and topic"},
+		{name: "fact index extra", typ: "fact-index", value: map[string]any{"title": "View grammar", "topic": "cli/view", "extra": true}, wantErr: "exactly title and topic"},
+		{name: "fact index blank title", typ: "fact-index", value: map[string]any{"title": " ", "topic": "cli/view"}, wantErr: "trimmed, non-empty"},
+		{name: "fact index bad topic", typ: "fact-index", value: map[string]any{"title": "View grammar", "topic": "cli view"}, wantErr: "invalid character"},
 		{name: "list ok", typ: "list<label>", value: []any{"cli/ux", "type-system"}},
 		{name: "list element invalid", typ: "list<label>", value: []any{"ok", ""}, wantErr: "item 1"},
 		{name: "list not list", typ: "list<label>", value: "cli/ux", wantErr: "expected a list"},
@@ -98,6 +103,23 @@ func TestValidateValue(t *testing.T) {
 	}
 }
 
+func TestValidateValueNormalizesFactIndex(t *testing.T) {
+	value, err := (VarType{Base: TypeFactIndex}).ValidateValue(map[string]any{"title": "View grammar", "topic": "cli/view"})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if value != (FactIndex{Title: "View grammar", Topic: "cli/view"}) {
+		t.Fatalf("value = %#v", value)
+	}
+}
+
+func TestValidateValueRejectsMultilineFactIndexTitle(t *testing.T) {
+	_, err := (VarType{Base: TypeFactIndex}).ValidateValue(map[string]any{"title": "View grammar\n## Injected", "topic": "cli/view"})
+	if err == nil || !strings.Contains(err.Error(), "single-line") {
+		t.Fatalf("ValidateValue error = %v", err)
+	}
+}
+
 func TestValidateValueNormalizesLayer(t *testing.T) {
 	vt, _ := ParseVarType("layer")
 	v, err := vt.ValidateValue("tac")
diff --git a/internal/engine/userdialogue_test.go b/internal/engine/userdialogue_test.go
index 40c98ee0..b1c43282 100644
--- a/internal/engine/userdialogue_test.go
+++ b/internal/engine/userdialogue_test.go
@@ -20,6 +20,10 @@ type shellEnv struct {
 }
 
 func newShellEnv(t *testing.T) *shellEnv {
+	return newShellEnvWithFacts(t, []model.FactIndexRow{{ID: "20260717-110000-s-prc-vwg", Title: "How to compose graph views"}})
+}
+
+func newShellEnvWithFacts(t *testing.T, facts []model.FactIndexRow) *shellEnv {
 	t.Helper()
 	env := &shellEnv{quiescent: true}
 
@@ -39,6 +43,12 @@ func newShellEnv(t *testing.T) *shellEnv {
 			return "- capture — record a signal or decision.\n- engage — anchor on an entry.", nil
 		},
 	})
+	mustRegisterQuery(reg, Query{
+		Doc: FuncDoc{Name: "factIndex", Doc: "fake fact index"},
+		Fn: func(_ *Context, _ map[string]any) (any, error) {
+			return facts, nil
+		},
+	})
 	// The shell declares its framing lanes as viewLayout injects; the MCP shell
 	// registers the real query in production. Stub it (serve-safe, like the real
 	// one) so the base entry loads.
@@ -73,6 +83,33 @@ func newShellEnv(t *testing.T) *shellEnv {
 	return env
 }
 
+func TestUserDialogueOpeningRendersFactPointersFromData(t *testing.T) {
+	const id = "20991231-235959-s-prc-xyz"
+	env := newShellEnvWithFacts(t, []model.FactIndexRow{{ID: id, Title: "Standalone retrieval cue"}})
+	serve, err := env.session.Start(env.spec, nil, "")
+	if err != nil {
+		t.Fatal(err)
+	}
+	want := "- `" + id + "` — Standalone retrieval cue"
+	if !strings.Contains(serve.Instructions, want) || !strings.Contains(serve.Instructions, "Pull the relevant fact in full first") {
+		t.Fatalf("opening fact index missing %q:\n%s", want, serve.Instructions)
+	}
+	if strings.Contains(env.spec.Units["open"], id) {
+		t.Fatal("opening unit hard-codes a fact ID")
+	}
+}
+
+func TestUserDialogueOpeningOmitsEmptyFactIndex(t *testing.T) {
+	env := newShellEnvWithFacts(t, nil)
+	serve, err := env.session.Start(env.spec, nil, "")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if strings.Contains(serve.Instructions, "Reference facts available") {
+		t.Fatalf("empty fact index rendered a block:\n%s", serve.Instructions)
+	}
+}
+
 func TestUserDialogue_OpeningServeAndQuietConclude(t *testing.T) {
 	env := newShellEnv(t)
 
diff --git a/internal/finders/graph_test.go b/internal/finders/graph_test.go
index 8910ac6e..f58dc0bb 100644
--- a/internal/finders/graph_test.go
+++ b/internal/finders/graph_test.go
@@ -111,8 +111,7 @@ func TestLoadGraphMergesBaseFact(t *testing.T) {
 	if !fact.Embedded {
 		t.Error("base fact is not marked Embedded")
 	}
-	// Body is generated from the executor vocabulary, not hand-written.
-	if !strings.Contains(fact.Content, "Grammar:") {
+	if !strings.Contains(fact.Content, "## Grammar") {
 		t.Error("base fact body missing generated grammar reference")
 	}
 }
diff --git a/internal/finders/section_spec.go b/internal/finders/section_spec.go
index 2f799a2c..1c37f129 100644
--- a/internal/finders/section_spec.go
+++ b/internal/finders/section_spec.go
@@ -40,6 +40,7 @@ type sectionSpec struct {
 	participantFilters [][]string
 	sinceCutoff        *time.Time // pointer so we can distinguish "no since()" from "since(0d)"
 	topicPrefix        model.TopicPath
+	indexed            bool
 	untagged           bool      // untagged: keep only entries whose effective topic set is empty
 	idFilter           []string  // id(<id>,...): keep only the listed entries (raw IDs, resolved at apply time)
 	rank               *rankSpec // last-write-wins per d-tac-uww §2
@@ -122,6 +123,8 @@ func (s *sectionSpec) rejectGraphPrimitivesForWip() error {
 		return fmt.Errorf("source(wip) does not support since(); slice 8 surfaces every active marker")
 	case !s.topicPrefix.IsZero():
 		return fmt.Errorf("source(wip) does not support topic() filters; markers do not carry topics")
+	case s.indexed:
+		return fmt.Errorf("source(wip) does not support indexed; markers are not graph entries")
 	case s.rank != nil:
 		return fmt.Errorf("source(wip) does not support rank(); markers are surfaced in chronological order")
 	case s.pageN >= 0:
diff --git a/internal/finders/view.go b/internal/finders/view.go
index e541c74f..462076e6 100644
--- a/internal/finders/view.go
+++ b/internal/finders/view.go
@@ -110,7 +110,7 @@ var renderFunctions = map[string]model.RenderShape{
 
 // knownFunctions lists every function name the executor recognizes. Used
 // in the unknown-function error message so users see what's available.
-var knownFunctions = []string{"source", "active", "kind", "intent", "type", "layer", "since", "topic", "participant", "untagged", "id", "not", "n", "rank", "group", "expand", "name", "name-prefix", "stalled", "brief", "as-list", "as-grouped", "as-counts", "as-focus-block", "as-participants-block", "as-wip-list"}
+var knownFunctions = []string{"source", "active", "indexed", "kind", "intent", "type", "layer", "since", "topic", "participant", "untagged", "id", "not", "n", "rank", "group", "expand", "name", "name-prefix", "stalled", "brief", "as-list", "as-grouped", "as-counts", "as-focus-block", "as-participants-block", "as-wip-list"}
 
 // ViewFunctionNames returns the function names accepted by the layout
 // executor. Reference surfaces use this instead of maintaining their own
@@ -240,6 +240,9 @@ func executeSection(g *model.Graph, wipMarkers []*model.WIPMarker, section model
 	// post-Graph.Filter() narrowings doesn't affect the result; chosen
 	// here to keep cheaper structural checks before time/topic walks.
 	entries := g.Filter(spec.filter)
+	if spec.indexed {
+		entries = model.FilterIndexed(entries)
+	}
 	for _, kinds := range spec.kindFilters {
 		entries = filterByKinds(entries, kinds)
 	}
@@ -385,6 +388,12 @@ func parseSectionFunction(spec *sectionSpec, fn model.Function) error {
 		}
 		spec.filter.OpenOnly = true
 
+	case fn.Name == "indexed":
+		if len(fn.Args) > 0 {
+			return fmt.Errorf("indexed takes no arguments")
+		}
+		spec.indexed = true
+
 	case fn.Name == "kind":
 		kinds, err := parseKindArgs(fn.Args)
 		if err != nil {
diff --git a/internal/finders/view_indexed_test.go b/internal/finders/view_indexed_test.go
new file mode 100644
index 00000000..ffe1f42c
--- /dev/null
+++ b/internal/finders/view_indexed_test.go
@@ -0,0 +1,88 @@
+package finders
+
+import (
+	"reflect"
+	"sort"
+	"strings"
+	"testing"
+
+	"github.com/networkteam/sdd/internal/model"
+	"github.com/networkteam/sdd/internal/query"
+)
+
+func withFactIndex(title, topic string) entryOpt {
+	return func(entry *model.Entry) {
+		index, err := model.NewFactIndex(title, topic)
+		if err != nil {
+			panic(err)
+		}
+		entry.Index = index
+	}
+}
+
+func TestViewIndexedIsStructuralAndComposes(t *testing.T) {
+	old := entry("20260101-100000-s-tac-old", withKind(model.KindFact), withTopics("cli/view"), withFactIndex("Old", "cli/view"))
+	closer := entry("20260101-110000-s-tac-cls", withKind(model.KindDone), withCloses(old.ID))
+	first := entry("20260101-120000-s-tac-one", withKind(model.KindFact), withTopics("cli/view"), withFactIndex("First", "cli/view"))
+	second := entry("20260101-130000-s-tac-two", withKind(model.KindFact), withTopics("cli/view"), withFactIndex("Second", "cli/view"))
+	other := entry("20260101-140000-s-tac-oth", withKind(model.KindFact), withTopics("agent/ux"), withFactIndex("Other", "agent/ux"))
+	unindexed := entry("20260101-150000-s-tac-off", withKind(model.KindFact), withTopics("cli/view"))
+	graph := model.NewGraph([]*model.Entry{old, closer, first, second, other, unindexed})
+	finder := New(Options{})
+
+	result, err := finder.View(query.ViewQuery{Graph: graph, Layout: mustParseLayout(t, "indexed:as-list")})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if got, want := idsOf(result.Sections[0].Data.(model.FlatList).Entries), []string{old.ID, first.ID, second.ID, other.ID}; !reflect.DeepEqual(got, want) {
+		t.Fatalf("indexed population = %v, want %v", got, want)
+	}
+
+	result, err = finder.View(query.ViewQuery{Graph: graph, Layout: mustParseLayout(t, `active:indexed:topic("cli/view"):rank(by(date)):n(1):brief:as-list`)})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if got := idsOf(result.Sections[0].Data.(model.FlatList).Entries); !reflect.DeepEqual(got, []string{second.ID}) {
+		t.Fatalf("composed indexed population = %v", got)
+	}
+
+	for _, layout := range []string{"indexed:group(by(layer)):as-grouped", "active:indexed:as-counts"} {
+		if _, err := finder.View(query.ViewQuery{Graph: graph, Layout: mustParseLayout(t, layout)}); err != nil {
+			t.Errorf("%s: %v", layout, err)
+		}
+	}
+}
+
+func TestActiveIndexedMatchesDerivedFactIndex(t *testing.T) {
+	active := entry("20260101-100000-s-tac-act", withKind(model.KindFact), withTopics("cli/view"), withFactIndex("Active", "cli/view"))
+	second := entry("20260101-090000-s-tac-two", withKind(model.KindFact), withTopics("agent/ux"), withFactIndex("Second", "agent/ux"))
+	retired := entry("20260101-110000-s-tac-ret", withKind(model.KindFact), withTopics("cli/view"), withFactIndex("Retired", "cli/view"))
+	successor := entry("20260101-120000-s-tac-new", withKind(model.KindFact), withSupersedes(retired.ID))
+	graph := model.NewGraph([]*model.Entry{active, second, retired, successor})
+
+	result, err := New(Options{}).View(query.ViewQuery{Graph: graph, Layout: mustParseLayout(t, "active:indexed:as-list")})
+	if err != nil {
+		t.Fatal(err)
+	}
+	rows, err := graph.IndexedFacts()
+	if err != nil {
+		t.Fatal(err)
+	}
+	want := make([]string, len(rows))
+	for i, row := range rows {
+		want[i] = row.ID
+	}
+	got := idsOf(result.Sections[0].Data.(model.FlatList).Entries)
+	sort.Strings(got)
+	sort.Strings(want)
+	if !reflect.DeepEqual(got, want) {
+		t.Fatalf("active:indexed IDs = %v, derived index IDs = %v", got, want)
+	}
+}
+
+func TestViewIndexedRejectsArguments(t *testing.T) {
+	_, err := New(Options{}).View(query.ViewQuery{Graph: model.NewGraph(nil), Layout: mustParseLayout(t, "indexed(topic):as-list")})
+	if err == nil || !strings.Contains(err.Error(), "indexed takes no arguments") {
+		t.Fatalf("indexed argument error = %v", err)
+	}
+}
diff --git a/internal/finders/view_reference_examples_test.go b/internal/finders/view_reference_examples_test.go
new file mode 100644
index 00000000..4b612148
--- /dev/null
+++ b/internal/finders/view_reference_examples_test.go
@@ -0,0 +1,42 @@
+package finders
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/networkteam/sdd/internal/model"
+	"github.com/networkteam/sdd/internal/query"
+	"github.com/networkteam/sdd/internal/viewlayout"
+)
+
+func TestViewReferenceExamplesExecute(t *testing.T) {
+	graph := model.NewGraph(nil)
+	for _, example := range viewlayout.ExampleSpecs() {
+		t.Run(example, func(t *testing.T) {
+			layout, err := query.ParseLayout(example)
+			if err != nil {
+				t.Fatal(err)
+			}
+			layout, err = query.ExpandMacros(layout)
+			if err != nil {
+				t.Fatal(err)
+			}
+			_, err = New(Options{}).View(query.ViewQuery{Graph: graph, Layout: layout, WIPMarkers: []*model.WIPMarker{}})
+			if err != nil {
+				t.Fatal(err)
+			}
+		})
+	}
+}
+
+func TestMarkdownReferenceCoversLiveViewVocabulary(t *testing.T) {
+	vocabulary := LiveViewVocabulary()
+	markdown := viewlayout.Markdown(vocabulary)
+	for _, names := range [][]string{vocabulary.Functions, vocabulary.Algorithms, vocabulary.Decays, vocabulary.Macros} {
+		for _, name := range names {
+			if !strings.Contains(markdown, name) {
+				t.Errorf("Markdown reference omits live name %q", name)
+			}
+		}
+	}
+}
diff --git a/internal/finders/view_slice8_test.go b/internal/finders/view_slice8_test.go
index afb63e3c..fbd46a08 100644
--- a/internal/finders/view_slice8_test.go
+++ b/internal/finders/view_slice8_test.go
@@ -85,6 +85,7 @@ func TestView_SourceWip_RejectsGraphFilters(t *testing.T) {
 		{"layer", "source(wip):layer(tac):as-wip-list", "graph filters"},
 		{"since", "source(wip):since(\"7d\"):as-wip-list", "since()"},
 		{"topic", "source(wip):topic(catch-up-scaling):as-wip-list", "topic() filters"},
+		{"indexed", "source(wip):indexed:as-wip-list", "indexed"},
 		{"rank", "source(wip):rank(heat):as-wip-list", "rank()"},
 		{"n", "source(wip):n(5):as-wip-list", "n()"},
 		{"group", "source(wip):group(by(kind)):as-wip-list", "group()"},
diff --git a/internal/handlers/handler_index_test.go b/internal/handlers/handler_index_test.go
index 4fcbb4dc..ffbf8b77 100644
--- a/internal/handlers/handler_index_test.go
+++ b/internal/handlers/handler_index_test.go
@@ -147,8 +147,9 @@ func TestIndexHandler_Build(t *testing.T) {
 	if got := withoutEmbedded(t, indexed); len(got) != 2 {
 		t.Errorf("expected 2 project entries indexed, got %d (%v)", len(got), got)
 	}
-	if emb.calls != 1 {
-		t.Errorf("expected 1 cross-entry batched embed call, got %d", emb.calls)
+	wantCalls := (emb.totalInputs + emb.BatchSize() - 1) / emb.BatchSize()
+	if emb.calls != wantCalls {
+		t.Errorf("batched embed calls = %d, want %d for %d inputs", emb.calls, wantCalls, emb.totalInputs)
 	}
 	// Each project entry: 1 summary + 1 body = 2 chunks.
 	for _, id := range withoutEmbedded(t, indexed) {
@@ -201,13 +202,17 @@ func TestIndexHandler_BuildFiresOnBatchStart(t *testing.T) {
 		t.Fatalf("Build: %v", err)
 	}
 
-	// Both entries' chunks fit one batch, so OnBatchStart fires once carrying
-	// both entry IDs — before the single embed round-trip.
-	if len(batches) != 1 {
-		t.Fatalf("expected 1 batch, got %d (%v)", len(batches), batches)
+	if len(batches) != emb.calls {
+		t.Fatalf("batch callbacks = %d, embed calls = %d", len(batches), emb.calls)
 	}
-	if got := withoutEmbedded(t, batches[0]); len(got) != 2 {
-		t.Errorf("batch carried %d project entry IDs, want 2 (%v)", len(got), batches[0])
+	var batchedIDs []string
+	var announcedChunks int
+	for i, ids := range batches {
+		batchedIDs = append(batchedIDs, ids...)
+		announcedChunks += batchChunks[i]
+	}
+	if got := withoutEmbedded(t, batchedIDs); len(got) != 2 {
+		t.Errorf("batches carried %d project entry IDs, want 2 (%v)", len(got), batchedIDs)
 	}
 	// The planned total is the chunk sum, and it must equal both the batch's
 	// announced chunk count and the chunks reported as entries complete — the
@@ -216,8 +221,8 @@ func TestIndexHandler_BuildFiresOnBatchStart(t *testing.T) {
 	if plannedChunks <= 0 {
 		t.Errorf("OnPlanned reported %d chunks, want > 0", plannedChunks)
 	}
-	if batchChunks[0] != plannedChunks {
-		t.Errorf("batch chunk count %d != planned total %d", batchChunks[0], plannedChunks)
+	if announcedChunks != plannedChunks {
+		t.Errorf("announced batch chunks %d != planned total %d", announcedChunks, plannedChunks)
 	}
 	if indexedChunks != plannedChunks {
 		t.Errorf("indexed chunks %d != planned total %d", indexedChunks, plannedChunks)
@@ -285,8 +290,8 @@ func TestIndexHandler_BuildForceReindexes(t *testing.T) {
 	if err := h.Build(context.Background(), &command.BuildIndexCmd{Force: true}); err != nil {
 		t.Fatalf("forced Build: %v", err)
 	}
-	if emb.calls != firstCalls+1 {
-		t.Errorf("Force=true should re-call embedder; got %d additional calls", emb.calls-firstCalls)
+	if emb.calls != firstCalls*2 {
+		t.Errorf("Force=true should repeat every embed batch; got %d additional calls, want %d", emb.calls-firstCalls, firstCalls)
 	}
 }
 
diff --git a/internal/model/entry.go b/internal/model/entry.go
index f7d1b12a..bedfed00 100644
--- a/internal/model/entry.go
+++ b/internal/model/entry.go
@@ -263,6 +263,7 @@ type Entry struct {
 	// Warnings rather than failing the parse, matching how other shape rules
 	// are handled.
 	Topics []TopicPath
+	Index  *FactIndex
 	// AnnotationTopics carries the topic assignments declared by a
 	// kind: annotation entry. Each item is either a plain label (Members nil
 	// — applies to all of the annotation's Refs) or a label with explicit
@@ -400,6 +401,7 @@ type frontmatter struct {
 	Class        string            `yaml:"class,omitempty"`
 	Actor        string            `yaml:"actor,omitempty"`
 	Topics       []AnnotationTopic `yaml:"topics,omitempty"`
+	Index        *FactIndex        `yaml:"index,omitempty"`
 	FocusActors  []string          `yaml:"actors,omitempty"`
 	FocusWhen    *FocusWhen        `yaml:"when,omitempty"`
 	Involvement  []involvementYAML `yaml:"involvement,omitempty"`
@@ -461,6 +463,7 @@ func ParseEntry(filename, content string) (*Entry, error) {
 		Aliases:      fm.Aliases,
 		Class:        ProcedureClass(fm.Class),
 		Actor:        fm.Actor,
+		Index:        fm.Index,
 		FocusActors:  fm.FocusActors,
 		FocusWhen:    fm.FocusWhen,
 		Preflight:    fm.Preflight,
@@ -672,6 +675,7 @@ func FormatFrontmatter(e *Entry) string {
 		Aliases:      e.Aliases,
 		Class:        string(e.Class),
 		Actor:        e.Actor,
+		Index:        e.Index,
 		FocusActors:  e.FocusActors,
 		FocusWhen:    e.FocusWhen,
 		Preflight:    e.Preflight,
diff --git a/internal/model/fact_index.go b/internal/model/fact_index.go
new file mode 100644
index 00000000..98da4622
--- /dev/null
+++ b/internal/model/fact_index.go
@@ -0,0 +1,153 @@
+package model
+
+import (
+	"fmt"
+	"sort"
+	"strings"
+
+	"gopkg.in/yaml.v3"
+)
+
+type FactIndex struct {
+	Title string
+	Topic TopicPath
+
+	topicRaw string
+}
+
+func NewFactIndex(title, topic string) (*FactIndex, error) {
+	index := &FactIndex{Title: title, topicRaw: topic}
+	parsed, err := ParseTopicPath(topic)
+	if err == nil {
+		index.Topic = parsed
+	}
+	if err := index.Validate(); err != nil {
+		return nil, err
+	}
+	return index, nil
+}
+
+func (i *FactIndex) Validate() error {
+	if i == nil {
+		return nil
+	}
+	if i.Title == "" || strings.TrimSpace(i.Title) != i.Title {
+		return fmt.Errorf("index.title must be a trimmed, non-empty string")
+	}
+	if strings.ContainsAny(i.Title, "\r\n") {
+		return fmt.Errorf("index.title must be a single-line string")
+	}
+	topic := i.Topic.String()
+	if topic == "" {
+		topic = i.topicRaw
+	}
+	if topic == "" {
+		return fmt.Errorf("index.topic must be a valid, non-empty topic path")
+	}
+	if _, err := ParseTopicPath(topic); err != nil {
+		return fmt.Errorf("index.topic: %w", err)
+	}
+	return nil
+}
+
+func (i *FactIndex) ValidateForEntry(kind Kind, topics []TopicPath) error {
+	if i == nil {
+		return nil
+	}
+	if err := i.Validate(); err != nil {
+		return err
+	}
+	if kind != KindFact {
+		return fmt.Errorf("index is only valid on kind: fact")
+	}
+	for _, topic := range topics {
+		if i.Topic.Equal(topic) {
+			return nil
+		}
+	}
+	return fmt.Errorf("index.topic %q must also appear in topics", i.Topic.String())
+}
+
+func (i *FactIndex) UnmarshalYAML(node *yaml.Node) error {
+	if node.Kind != yaml.MappingNode {
+		return fmt.Errorf("index must be a mapping with title and topic")
+	}
+	values := map[string]string{}
+	for offset := 0; offset < len(node.Content); offset += 2 {
+		key, value := node.Content[offset], node.Content[offset+1]
+		if key.Kind != yaml.ScalarNode || (key.Value != "title" && key.Value != "topic") {
+			return fmt.Errorf("index contains unknown field %q", key.Value)
+		}
+		if _, exists := values[key.Value]; exists {
+			return fmt.Errorf("index contains duplicate field %q", key.Value)
+		}
+		if value.Kind != yaml.ScalarNode || value.Tag != "!!str" {
+			return fmt.Errorf("index.%s must be a string", key.Value)
+		}
+		values[key.Value] = value.Value
+	}
+	i.Title = values["title"]
+	i.topicRaw = values["topic"]
+	if topic, err := ParseTopicPath(i.topicRaw); err == nil {
+		i.Topic = topic
+	}
+	return nil
+}
+
+func (i FactIndex) MarshalYAML() (any, error) {
+	topic := i.Topic.String()
+	if topic == "" {
+		topic = i.topicRaw
+	}
+	return struct {
+		Title string `yaml:"title"`
+		Topic string `yaml:"topic"`
+	}{Title: i.Title, Topic: topic}, nil
+}
+
+type FactIndexRow struct {
+	ID    string
+	Title string
+	Topic TopicPath
+}
+
+// FilterIndexed selects entries by index metadata alone.
+func FilterIndexed(entries []*Entry) []*Entry {
+	result := make([]*Entry, 0, len(entries))
+	for _, entry := range entries {
+		if entry.Index != nil {
+			result = append(result, entry)
+		}
+	}
+	return result
+}
+
+func (g *Graph) IndexedFacts() ([]FactIndexRow, error) {
+	var rows []FactIndexRow
+	for _, entry := range g.Entries {
+		if entry.Index == nil {
+			continue
+		}
+		status := g.DerivedStatus(entry).Kind
+		if status != StatusOpen && status != StatusActive {
+			continue
+		}
+		if err := entry.Index.ValidateForEntry(entry.Kind, entry.Topics); err != nil {
+			return nil, fmt.Errorf("entry %s index: %w", entry.ID, err)
+		}
+		rows = append(rows, FactIndexRow{
+			ID: entry.ID, Title: entry.Index.Title,
+			Topic: TopicPath{Components: append([]string(nil), entry.Index.Topic.Components...)},
+		})
+	}
+	sort.Slice(rows, func(a, b int) bool {
+		if left, right := rows[a].Topic.FoldKey(), rows[b].Topic.FoldKey(); left != right {
+			return left < right
+		}
+		if left, right := caseFoldKey(rows[a].Title), caseFoldKey(rows[b].Title); left != right {
+			return left < right
+		}
+		return rows[a].ID < rows[b].ID
+	})
+	return rows, nil
+}
diff --git a/internal/model/fact_index_test.go b/internal/model/fact_index_test.go
new file mode 100644
index 00000000..5afce081
--- /dev/null
+++ b/internal/model/fact_index_test.go
@@ -0,0 +1,263 @@
+package model
+
+import (
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func indexedFact(t *testing.T, id, title, topic string) *Entry {
+	t.Helper()
+	index, err := NewFactIndex(title, topic)
+	if err != nil {
+		t.Fatal(err)
+	}
+	path, err := ParseTopicPath(topic)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return &Entry{ID: id, Type: TypeSignal, Layer: LayerTactical, Kind: KindFact, Topics: []TopicPath{path}, Index: index}
+}
+
+func TestFactIndexYAMLRoundTrip(t *testing.T) {
+	const source = `---
+type: signal
+layer: tactical
+kind: fact
+topics:
+    - cli/view
+index:
+    title: How to compose graph views
+    topic: cli/view
+---
+
+Reference body.
+`
+	entry, err := ParseEntry("20260719-120000-s-tac-idx.md", source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if entry.Index == nil || entry.Index.Title != "How to compose graph views" || entry.Index.Topic.String() != "cli/view" {
+		t.Fatalf("index = %+v", entry.Index)
+	}
+	formatted := FormatFrontmatter(entry)
+	if !strings.Contains(formatted, "index:\n    title: How to compose graph views\n    topic: cli/view\n") {
+		t.Fatalf("nested index missing from frontmatter:\n%s", formatted)
+	}
+	roundTrip, err := ParseEntry(entry.ID+".md", formatted+"\n"+entry.Content)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if roundTrip.Index == nil || roundTrip.Index.Title != entry.Index.Title || !roundTrip.Index.Topic.Equal(entry.Index.Topic) {
+		t.Fatalf("round-trip index = %+v, want %+v", roundTrip.Index, entry.Index)
+	}
+}
+
+func TestFactIndexYAMLRejectsNonExactMappings(t *testing.T) {
+	tests := []struct {
+		name  string
+		index string
+		want  string
+	}{
+		{name: "scalar", index: `index: cue`, want: "must be a mapping"},
+		{name: "sequence", index: "index: [title, topic]", want: "must be a mapping"},
+		{name: "unknown field", index: "index: {title: Cue, topic: cli/view, extra: value}", want: `unknown field "extra"`},
+		{name: "duplicate field", index: "index: {title: Cue, title: Other, topic: cli/view}", want: `duplicate field "title"`},
+		{name: "non-string", index: "index: {title: 12, topic: cli/view}", want: "index.title must be a string"},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			_, err := ParseEntry("20260719-120000-s-tac-bad.md", "---\ntype: signal\nlayer: tactical\nkind: fact\ntopics: [cli/view]\n"+tt.index+"\n---\nbody")
+			if err == nil || !strings.Contains(err.Error(), tt.want) {
+				t.Fatalf("ParseEntry error = %v, want %q", err, tt.want)
+			}
+		})
+	}
+}
+
+func TestValidateEntryFactIndex(t *testing.T) {
+	topic, _ := ParseTopicPath("cli/view")
+	other, _ := ParseTopicPath("engine/base-facts")
+	tests := []struct {
+		name  string
+		entry *Entry
+		want  string
+	}{
+		{
+			name: "non-fact",
+			entry: &Entry{ID: "20260719-120000-s-tac-non", Type: TypeSignal, Layer: LayerTactical, Kind: KindInsight,
+				Topics: []TopicPath{topic}, Index: &FactIndex{Title: "Title", Topic: topic}},
+			want: "only valid on kind: fact",
+		},
+		{
+			name: "blank title",
+			entry: &Entry{ID: "20260719-120001-s-tac-ttl", Type: TypeSignal, Layer: LayerTactical, Kind: KindFact,
+				Topics: []TopicPath{topic}, Index: &FactIndex{Title: " ", Topic: topic}},
+			want: "trimmed, non-empty",
+		},
+		{
+			name: "multiline title",
+			entry: &Entry{ID: "20260719-120005-s-tac-lin", Type: TypeSignal, Layer: LayerTactical, Kind: KindFact,
+				Topics: []TopicPath{topic}, Index: &FactIndex{Title: "Title\n## Injected", Topic: topic}},
+			want: "single-line",
+		},
+		{
+			name: "missing topic",
+			entry: &Entry{ID: "20260719-120002-s-tac-top", Type: TypeSignal, Layer: LayerTactical, Kind: KindFact,
+				Topics: []TopicPath{topic}, Index: &FactIndex{Title: "Title"}},
+			want: "valid, non-empty topic path",
+		},
+		{
+			name: "malformed topic value",
+			entry: &Entry{ID: "20260719-120004-s-tac-raw", Type: TypeSignal, Layer: LayerTactical, Kind: KindFact,
+				Topics: []TopicPath{topic}, Index: &FactIndex{Title: "Title", Topic: TopicPath{Components: []string{"cli view"}}}},
+			want: "invalid character",
+		},
+		{
+			name: "topic not enrolled",
+			entry: &Entry{ID: "20260719-120003-s-tac-mem", Type: TypeSignal, Layer: LayerTactical, Kind: KindFact,
+				Topics: []TopicPath{other}, Index: &FactIndex{Title: "Title", Topic: topic}},
+			want: "must also appear in topics",
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			graph := NewGraph([]*Entry{tt.entry})
+			var found bool
+			for _, warning := range graph.ByID[tt.entry.ID].Warnings {
+				if warning.Field == "index" && strings.Contains(warning.Message, tt.want) {
+					found = true
+				}
+			}
+			if !found {
+				t.Fatalf("warnings = %+v, want index warning containing %q", tt.entry.Warnings, tt.want)
+			}
+		})
+	}
+}
+
+func TestNewFactIndexRejectsLineBreaks(t *testing.T) {
+	for _, title := range []string{"First\nSecond", "First\rSecond"} {
+		if _, err := NewFactIndex(title, "cli/view"); err == nil || !strings.Contains(err.Error(), "single-line") {
+			t.Fatalf("NewFactIndex(%q) error = %v", title, err)
+		}
+	}
+}
+
+func TestParseEntryInvalidFactIndexTopicFailsValidation(t *testing.T) {
+	entry, err := ParseEntry("20260719-120000-s-tac-bad.md", `---
+type: signal
+layer: tactical
+kind: fact
+topics: [cli/view]
+index: {title: Reference, topic: "cli view"}
+---
+body`)
+	if err != nil {
+		t.Fatal(err)
+	}
+	graph := NewGraph([]*Entry{entry})
+	if len(graph.ByID[entry.ID].Warnings) == 0 || !strings.Contains(graph.ByID[entry.ID].Warnings[0].Message, "invalid character") {
+		t.Fatalf("warnings = %+v", graph.ByID[entry.ID].Warnings)
+	}
+}
+
+func TestIndexedFactsLifecycleOrderingAndNoInheritance(t *testing.T) {
+	old := indexedFact(t, "20260719-100000-s-tac-old", "Old", "cli/view")
+	successor := indexedFact(t, "20260719-100100-s-tac-new", "beta", "cli/view")
+	successor.Supersedes = []string{old.ID}
+	closed := indexedFact(t, "20260719-100200-s-tac-cls", "Closed", "agent/ux")
+	closer := &Entry{ID: "20260719-100300-d-tac-dec", Type: TypeDecision, Layer: LayerTactical, Kind: KindDirective, Intent: IntentPending, Closes: []string{closed.ID}}
+	alphaLater := indexedFact(t, "20260719-100500-s-tac-a02", "Alpha", "cli/view")
+	alphaEarlier := indexedFact(t, "20260719-100400-s-tac-a01", "alpha", "cli/view")
+	graph := NewGraph([]*Entry{old, successor, closed, closer, alphaLater, alphaEarlier})
+
+	rows, err := graph.IndexedFacts()
+	if err != nil {
+		t.Fatal(err)
+	}
+	got := make([]string, len(rows))
+	for i, row := range rows {
+		got[i] = row.ID
+	}
+	want := []string{alphaEarlier.ID, alphaLater.ID, successor.ID}
+	if !reflect.DeepEqual(got, want) {
+		t.Fatalf("IndexedFacts IDs = %v, want %v", got, want)
+	}
+
+	unindexedSuccessor := &Entry{ID: "20260719-100600-s-tac-off", Type: TypeSignal, Layer: LayerTactical, Kind: KindFact, Supersedes: []string{successor.ID}}
+	graph = NewGraph(append(graph.Entries, unindexedSuccessor))
+	rows, err = graph.IndexedFacts()
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, row := range rows {
+		if row.ID == successor.ID || row.ID == unindexedSuccessor.ID {
+			t.Fatalf("index metadata inherited across supersession: %+v", rows)
+		}
+	}
+}
+
+func TestIndexedFactsOrderingAndValueIsolation(t *testing.T) {
+	agent := indexedFact(t, "20260719-101000-s-tac-top", "Later title", "agent/ux")
+	sigma := indexedFact(t, "20260719-101001-s-tac-sig", "Σ", "cli/view")
+	finalSigma := indexedFact(t, "20260719-101002-s-tac-fin", "ς", "cli/view")
+	graph := NewGraph([]*Entry{finalSigma, sigma, agent})
+
+	rows, err := graph.IndexedFacts()
+	if err != nil {
+		t.Fatal(err)
+	}
+	got := []string{rows[0].ID, rows[1].ID, rows[2].ID}
+	want := []string{agent.ID, sigma.ID, finalSigma.ID}
+	if !reflect.DeepEqual(got, want) {
+		t.Fatalf("IndexedFacts IDs = %v, want %v", got, want)
+	}
+	rows[0].Topic.Components[0] = "mutated"
+	if agent.Index.Topic.String() != "agent/ux" {
+		t.Fatalf("derived row mutated entry topic to %q", agent.Index.Topic.String())
+	}
+}
+
+func TestIndexedFactsFailsOnActiveMalformedEnrollment(t *testing.T) {
+	topic, _ := ParseTopicPath("cli/view")
+	malformed := &Entry{
+		ID: "20260719-102000-s-tac-bad", Type: TypeSignal, Layer: LayerTactical, Kind: KindInsight,
+		Topics: []TopicPath{topic}, Index: &FactIndex{Title: "Invalid enrollment", Topic: topic},
+	}
+	graph := NewGraph([]*Entry{malformed})
+	_, err := graph.IndexedFacts()
+	if err == nil || !strings.Contains(err.Error(), malformed.ID) || !strings.Contains(err.Error(), "only valid on kind: fact") {
+		t.Fatalf("IndexedFacts error = %v", err)
+	}
+}
+
+func TestFilterIndexedSelectsMetadataWithoutLifecycleSemantics(t *testing.T) {
+	indexed := indexedFact(t, "20260719-102100-s-tac-idx", "Indexed", "cli/view")
+	plain := &Entry{ID: "20260719-102200-s-tac-off", Type: TypeSignal, Layer: LayerTactical, Kind: KindFact}
+	if got := FilterIndexed([]*Entry{plain, indexed}); len(got) != 1 || got[0] != indexed {
+		t.Fatalf("FilterIndexed = %+v", got)
+	}
+}
+
+func TestIndexedFactsUsesDiskOverrideAndExcludesDependencies(t *testing.T) {
+	const id = "20260719-110000-s-tac-ovr"
+	embedded := indexedFact(t, id, "Embedded", "cli/view")
+	embedded.Embedded = true
+	retained := indexedFact(t, "20260719-110050-s-tac-base", "Retained base fact", "engine/base-facts")
+	retained.Embedded = true
+	disk := &Entry{ID: id, Type: TypeSignal, Layer: LayerTactical, Kind: KindFact}
+	local := NewGraph(MergeEmbedded([]*Entry{disk}, map[string]bool{id: true}, []*Entry{embedded, retained}))
+	remote := NewGraph([]*Entry{indexedFact(t, "20260719-110100-s-tac-rem", "Remote", "cli/view")})
+	NewMultiGraph(local, []string{"example.com/team/remote"}, func(string) (*Graph, error) { return remote, nil })
+	if member, err := local.MemberGraph("example.com/team/remote"); err != nil || member == nil {
+		t.Fatalf("loading dependency: member=%v err=%v", member, err)
+	}
+	rows, err := local.IndexedFacts()
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(rows) != 1 || rows[0].ID != retained.ID {
+		t.Fatalf("IndexedFacts = %+v, want retained embedded fact only", rows)
+	}
+}
diff --git a/internal/model/graph.go b/internal/model/graph.go
index 0e825d9f..472fef8d 100644
--- a/internal/model/graph.go
+++ b/internal/model/graph.go
@@ -914,10 +914,17 @@ func ValidateEntry(e *Entry, g *Graph) {
 	validateAnnotationFrontmatter(e)
 	validateFocusFrontmatter(e, g)
 	validateInlineTopics(e)
+	validateFactIndex(e)
 	validateDoneSignalRefs(e)
 	validateAttachmentLinks(e)
 }
 
+func validateFactIndex(e *Entry) {
+	if err := e.Index.ValidateForEntry(e.Kind, e.Topics); err != nil {
+		e.Warnings = append(e.Warnings, Warning{Field: "index", Message: err.Error()})
+	}
+}
+
 // validateRefs checks the refs field with kind awareness. Cross-repo refs
 // are validated syntactically only — both portions must be well-formed, but
 // the target is never dangling-checked against the local graph (resolution
diff --git a/internal/model/topic_path.go b/internal/model/topic_path.go
index 7a8c079f..ee049adb 100644
--- a/internal/model/topic_path.go
+++ b/internal/model/topic_path.go
@@ -99,17 +99,28 @@ func (t TopicPath) HasPrefix(prefix TopicPath) bool {
 	return true
 }
 
-// FoldKey returns a comparable lower-case key for use as a map key when
-// deduplicating paths case-insensitively. The original casing is lost in
-// the key but preserved on the source TopicPath value.
+// FoldKey returns a comparable key for case-insensitive path deduplication.
 func (t TopicPath) FoldKey() string {
 	parts := make([]string, len(t.Components))
 	for i, c := range t.Components {
-		parts[i] = strings.ToLower(c)
+		parts[i] = caseFoldKey(c)
 	}
 	return strings.Join(parts, "/")
 }
 
+// caseFoldKey returns one representative for each strings.EqualFold class.
+func caseFoldKey(s string) string {
+	return strings.Map(func(r rune) rune {
+		canonical := r
+		for folded := unicode.SimpleFold(r); folded != r; folded = unicode.SimpleFold(folded) {
+			if folded < canonical {
+				canonical = folded
+			}
+		}
+		return canonical
+	}, s)
+}
+
 // CanonicalizeTopicPaths walks paths in order and returns a deduplicated
 // slice where the first-seen casing of each fold-key wins. Used by display
 // rendering and by graph traversal merging inline topics with annotation
diff --git a/internal/model/topic_path_test.go b/internal/model/topic_path_test.go
index a9811bc7..5b5d3095 100644
--- a/internal/model/topic_path_test.go
+++ b/internal/model/topic_path_test.go
@@ -107,6 +107,20 @@ func TestTopicPath_Equal(t *testing.T) {
 	}
 }
 
+func TestTopicPathFoldKeyMatchesEqualFold(t *testing.T) {
+	sigma, err := ParseTopicPath("Σ")
+	if err != nil {
+		t.Fatal(err)
+	}
+	finalSigma, err := ParseTopicPath("ς")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !sigma.Equal(finalSigma) || sigma.FoldKey() != finalSigma.FoldKey() {
+		t.Fatalf("equal-fold paths have keys %q and %q", sigma.FoldKey(), finalSigma.FoldKey())
+	}
+}
+
 func TestTopicPath_HasPrefix(t *testing.T) {
 	cases := []struct {
 		path, prefix string
diff --git a/internal/presenters/show.go b/internal/presenters/show.go
index 8139fb0f..a2c9e457 100644
--- a/internal/presenters/show.go
+++ b/internal/presenters/show.go
@@ -86,24 +86,25 @@ func primaryDisplayID(g query.ShowGroup) string {
 // output order. Summary renders last (and only with --with-summary) so the
 // long opt-in text never pushes the scannable fields down.
 type showEnvelope struct {
-	ID           string      `yaml:"id"`
-	Type         string      `yaml:"type"`
-	Kind         string      `yaml:"kind,omitempty"`
-	Layer        string      `yaml:"layer"`
-	Confidence   string      `yaml:"confidence,omitempty"`
-	Intent       string      `yaml:"intent,omitempty"`
-	Participants []string    `yaml:"participants,omitempty"`
-	Canonical    string      `yaml:"canonical,omitempty"`
-	Aliases      []string    `yaml:"aliases,omitempty"`
-	Actor        string      `yaml:"actor,omitempty"`
-	Topics       []string    `yaml:"topics,omitempty"`
-	Refs         []model.Ref `yaml:"refs,omitempty"`
-	Closes       []string    `yaml:"closes,omitempty"`
-	Supersedes   []string    `yaml:"supersedes,omitempty"`
-	Attachments  []string    `yaml:"attachments,omitempty"`
-	Status       string      `yaml:"status,omitempty"`
-	Time         string      `yaml:"time"`
-	Summary      string      `yaml:"summary,omitempty"`
+	ID           string           `yaml:"id"`
+	Type         string           `yaml:"type"`
+	Kind         string           `yaml:"kind,omitempty"`
+	Layer        string           `yaml:"layer"`
+	Confidence   string           `yaml:"confidence,omitempty"`
+	Intent       string           `yaml:"intent,omitempty"`
+	Participants []string         `yaml:"participants,omitempty"`
+	Canonical    string           `yaml:"canonical,omitempty"`
+	Aliases      []string         `yaml:"aliases,omitempty"`
+	Actor        string           `yaml:"actor,omitempty"`
+	Topics       []string         `yaml:"topics,omitempty"`
+	Index        *model.FactIndex `yaml:"index,omitempty"`
+	Refs         []model.Ref      `yaml:"refs,omitempty"`
+	Closes       []string         `yaml:"closes,omitempty"`
+	Supersedes   []string         `yaml:"supersedes,omitempty"`
+	Attachments  []string         `yaml:"attachments,omitempty"`
+	Status       string           `yaml:"status,omitempty"`
+	Time         string           `yaml:"time"`
+	Summary      string           `yaml:"summary,omitempty"`
 }
 
 func writeEnvelope(w io.Writer, g query.ShowGroup, opts ShowOptions) {
@@ -120,6 +121,7 @@ func writeEnvelope(w io.Writer, g query.ShowGroup, opts ShowOptions) {
 		Aliases:      e.Aliases,
 		Actor:        e.Actor,
 		Topics:       topicLabels(g.PrimaryTopics),
+		Index:        e.Index,
 		Refs:         e.Refs,
 		Closes:       e.Closes,
 		Supersedes:   e.Supersedes,
diff --git a/internal/presenters/show_test.go b/internal/presenters/show_test.go
index f6e00b82..f8d948b1 100644
--- a/internal/presenters/show_test.go
+++ b/internal/presenters/show_test.go
@@ -297,6 +297,22 @@ func TestRenderShow_SummaryShownWithFlag(t *testing.T) {
 	}
 }
 
+func TestRenderShow_NestedFactIndex(t *testing.T) {
+	index, err := model.NewFactIndex("How to compose graph views", "cli/view")
+	if err != nil {
+		t.Fatal(err)
+	}
+	topic, _ := model.ParseTopicPath("cli/view")
+	e := entry("20260719-120000-s-tac-idx", withKind(model.KindFact), withContent("Reference body."))
+	e.Topics = []model.TopicPath{topic}
+	e.Index = index
+	g := model.NewGraph([]*model.Entry{e})
+	out := renderShow(t, g, []string{e.ID})
+	if !contains(out, "index:\n    title: How to compose graph views\n    topic: cli/view\n") {
+		t.Fatalf("show output missing nested index:\n%s", out)
+	}
+}
+
 func TestRenderShowStyled_ColorDisabled(t *testing.T) {
 	// Writing to a non-TTY buffer downsamples to Ascii through the colorprofile
 	// writer, so the styled output arrives color-free — we assert on its plain
diff --git a/internal/viewlayout/reference.go b/internal/viewlayout/reference.go
index 070edfce..12fda4e5 100644
--- a/internal/viewlayout/reference.go
+++ b/internal/viewlayout/reference.go
@@ -1,6 +1,3 @@
-// Package viewlayout renders the user-facing reference for the composable
-// view layout language. Callers supply the live executor vocabularies so CLI,
-// MCP, and embedded reference surfaces share names instead of copying them.
 package viewlayout
 
 import (
@@ -9,8 +6,7 @@ import (
 	"strings"
 )
 
-// Vocabulary is the live layout vocabulary exposed by the packages that
-// execute each part of the language.
+// Vocabulary lists names accepted by the live view executors.
 type Vocabulary struct {
 	Functions  []string
 	Renders    []string
@@ -19,15 +15,27 @@ type Vocabulary struct {
 	Macros     []string
 }
 
-type item struct {
+type referenceItem struct {
 	category    string
 	syntax      string
 	description string
 }
 
-var functionReference = map[string]item{
+type referenceSection struct {
+	title string
+	items []referenceItem
+}
+
+type referenceModel struct {
+	sections []referenceSection
+	grammar  []string
+	examples []string
+}
+
+var functionReference = map[string]referenceItem{
 	"source":      {"Sources", "source(graph|wip)", "Select graph entries (default) or active WIP markers."},
 	"active":      {"Filters", "active", "Keep entries that are neither closed nor superseded."},
+	"indexed":     {"Filters", "indexed", "Keep entries that carry fact-index metadata; lifecycle state is unchanged."},
 	"kind":        {"Filters", "kind(K[, K2, ...])", "Keep entries matching any listed kind; repeated calls intersect."},
 	"intent":      {"Filters", "intent(I[, I2, ...])", "Keep directives with pending, guiding, or settled intent."},
 	"type":        {"Filters", "type(T)", "Keep decisions/signals; accepts d, s, decision, or signal."},
@@ -78,127 +86,181 @@ var decayReference = map[string]string{
 }
 
 var macroReference = map[string]string{
-	"top":          "top(N) — active entries ranked by heat",
-	"topic":        "topic(L) — one topic neighborhood ranked by heat",
-	"focus":        "focus — active focuses with involvement state",
-	"decisions":    "decisions — active decisions grouped by kind",
-	"signals":      "signals — active gaps and questions grouped by kind",
-	"insights":     "insights — recent active insights by date",
-	"done":         "done — recent done signals by date",
-	"aspirations":  "aspirations — active aspirations",
-	"contracts":    "contracts — active contracts",
-	"participants": "participants — active actors with bound roles",
-	"wip":          "wip — active WIP markers",
+	"top":          "active entries ranked by heat",
+	"topic":        "one topic neighborhood ranked by heat",
+	"focus":        "active focuses with involvement state",
+	"decisions":    "active decisions grouped by kind",
+	"signals":      "active gaps and questions grouped by kind",
+	"insights":     "recent active insights by date",
+	"done":         "recent done signals by date",
+	"aspirations":  "active aspirations",
+	"contracts":    "active contracts",
+	"participants": "active actors with bound roles",
+	"wip":          "active WIP markers",
+}
+
+var macroSyntax = map[string]string{
+	"top": "top(N)", "topic": "topic(L)", "focus": "focus", "decisions": "decisions",
+	"signals": "signals", "insights": "insights", "done": "done", "aspirations": "aspirations",
+	"contracts": "contracts", "participants": "participants", "wip": "wip",
 }
 
 var categoryOrder = []string{"Sources", "Filters", "Rank", "Page", "Aggregate", "Transform", "Output", "Other primitives"}
 
-// Reference renders the complete CLI-shaped layout reference around the
-// host-neutral vocabulary body.
-func Reference(v Vocabulary) string {
-	var b strings.Builder
-	b.WriteString("Usage: sdd view --layout=<spec>\n\n")
-	b.WriteString(ReferenceBody(v))
-	b.WriteString("\nExamples:\n")
-	b.WriteString("  sdd view --layout='top(20)'\n")
-	b.WriteString("  sdd view --layout='active:kind(plan):rank(heat(exp-14d)):n(10):as-list'\n")
-	b.WriteString("  sdd view --layout='topic(\"infrastructure/cli\"):rank(by(date)):n(20):as-list'\n")
-	b.WriteString("  sdd view --layout='active:participant(\"Jonathan Philipp\"):as-list'\n")
-	b.WriteString("  sdd view --layout='decisions,signals,participants'\n")
-	b.WriteString("  sdd view --layout='top(20):not(kind(contract,aspiration))'\n")
-	b.WriteString("  sdd view --layout='wip'\n")
-	return b.String()
+var referenceGrammar = []string{
+	`layout  := section ("," section)*`,
+	`section := function (":" function)*`,
+	`function := name ("(" arguments? ")")?`,
+}
+
+var referenceExamples = []string{
+	"top(20)",
+	"active:indexed:as-list",
+	"active:kind(plan):rank(heat(exp-14d)):n(10):as-list",
+	`topic("infrastructure/cli"):rank(by(date)):n(20):as-list`,
+	`active:participant("Jonathan Philipp"):as-list`,
+	"decisions,signals,participants",
+	"top(20):not(kind(contract,aspiration))",
+	"wip",
 }
 
-// ReferenceBody renders the host-neutral grammar and categorized vocabulary.
-// Every live name is emitted even when descriptive metadata has not caught up,
-// making a newly added primitive discoverable instead of silently absent.
-func ReferenceBody(v Vocabulary) string {
+// ExampleSpecs returns the shared reference examples.
+func ExampleSpecs() []string {
+	return slices.Clone(referenceExamples)
+}
+
+func buildReference(v Vocabulary) referenceModel {
 	renders := make(map[string]struct{}, len(v.Renders))
 	for _, name := range v.Renders {
 		renders[name] = struct{}{}
 	}
-
-	byCategory := make(map[string][]string)
+	byCategory := make(map[string][]referenceItem)
 	for _, name := range v.Functions {
 		if _, isRender := renders[name]; isRender {
 			continue
 		}
-		ref, ok := functionReference[name]
+		item, ok := functionReference[name]
 		if !ok {
-			ref = item{category: "Other primitives", syntax: name, description: "See executor validation for accepted arguments."}
+			item = referenceItem{category: "Other primitives", syntax: name, description: "See executor validation for accepted arguments."}
 		}
-		byCategory[ref.category] = append(byCategory[ref.category], name)
+		byCategory[item.category] = append(byCategory[item.category], item)
 	}
 
-	var b strings.Builder
-	b.WriteString("Compose colon-chained functions into a section; separate multiple sections with commas.\n")
-	b.WriteString("Every section ends in a render function. Filters intersect; rank, page, name, and\n")
-	b.WriteString("render modifiers use the last call of their kind. No whitespace is allowed outside\n")
-	b.WriteString("quoted strings. Quote multi-word names, dates, durations, and topic paths.\n\n")
-	b.WriteString("Grammar:\n")
-	b.WriteString("  layout  := section (\",\" section)*\n")
-	b.WriteString("  section := function (\":\" function)*\n")
-	b.WriteString("  function := name (\"(\" arguments? \")\")?\n\n")
-	b.WriteString("Implemented pipeline vocabulary:\n")
-
+	model := referenceModel{grammar: slices.Clone(referenceGrammar), examples: slices.Clone(referenceExamples)}
 	for _, category := range categoryOrder {
-		names := byCategory[category]
-		if len(names) == 0 {
-			continue
-		}
-		fmt.Fprintf(&b, "\n  %s:\n", category)
-		for _, name := range names {
-			ref := functionReference[name]
-			if ref.syntax == "" {
-				ref.syntax = name
-			}
-			fmt.Fprintf(&b, "    %-30s %s\n", ref.syntax, ref.description)
+		if items := byCategory[category]; len(items) > 0 {
+			model.sections = append(model.sections, referenceSection{title: category, items: items})
 		}
 	}
+	model.sections = append(model.sections,
+		referenceSection{title: "Render (required terminator)", items: namedItems(v.Renders, renderReference, "Executor-defined render shape.")},
+		referenceSection{title: "Rank algorithms", items: namedItems(v.Algorithms, algorithmReference, "Executor-defined ranking algorithm.")},
+		referenceSection{title: "Decays", items: namedItems(v.Decays, decayReference, "Model-defined decay function.")},
+		referenceSection{title: "Macros (recognized at section start; later modifiers override defaults)", items: macroItems(v.Macros)},
+	)
+	return model
+}
 
-	b.WriteString("\n  Render (required terminator):\n")
-	for _, name := range v.Renders {
-		description := renderReference[name]
+func macroItems(names []string) []referenceItem {
+	items := make([]referenceItem, 0, len(names))
+	for _, name := range names {
+		syntax := macroSyntax[name]
+		if syntax == "" {
+			syntax = name
+		}
+		description := macroReference[name]
 		if description == "" {
-			description = "Executor-defined render shape."
+			description = "Query-defined macro."
 		}
-		fmt.Fprintf(&b, "    %-30s %s\n", name, description)
+		items = append(items, referenceItem{syntax: syntax, description: description})
 	}
+	return items
+}
 
-	b.WriteString("\n  Rank algorithms:\n")
-	for _, name := range v.Algorithms {
-		description := algorithmReference[name]
+func namedItems(names []string, descriptions map[string]string, fallback string) []referenceItem {
+	items := make([]referenceItem, 0, len(names))
+	for _, name := range names {
+		description := descriptions[name]
 		if description == "" {
-			description = "Executor-defined ranking algorithm."
+			description = fallback
 		}
-		fmt.Fprintf(&b, "    %-30s %s\n", name, description)
+		items = append(items, referenceItem{syntax: name, description: description})
+	}
+	return items
+}
+
+// Reference renders the terminal layout reference.
+func Reference(v Vocabulary) string {
+	model := buildReference(v)
+	var b strings.Builder
+	b.WriteString("Usage: sdd view --layout=<spec>\n\n")
+	b.WriteString(referenceBody(model))
+	b.WriteString("\nExamples:\n")
+	for _, example := range model.examples {
+		fmt.Fprintf(&b, "  sdd view --layout='%s'\n", example)
 	}
+	return b.String()
+}
 
-	b.WriteString("\n  Decays:\n")
-	for _, name := range v.Decays {
-		description := decayReference[name]
-		if description == "" {
-			description = "Model-defined decay function."
+func referenceBody(model referenceModel) string {
+	var b strings.Builder
+	b.WriteString("Compose colon-chained functions into a section; separate multiple sections with commas.\n")
+	b.WriteString("Every section ends in a render function. Filters intersect; rank, page, name, and\n")
+	b.WriteString("render modifiers use the last call of their kind. No whitespace is allowed outside\n")
+	b.WriteString("quoted strings. Quote multi-word names, dates, durations, and topic paths.\n\n")
+	b.WriteString("Grammar:\n")
+	for _, line := range model.grammar {
+		fmt.Fprintf(&b, "  %s\n", line)
+	}
+	b.WriteString("\nImplemented pipeline vocabulary:\n")
+	for _, section := range model.sections {
+		if len(section.items) == 0 {
+			continue
+		}
+		fmt.Fprintf(&b, "\n  %s:\n", section.title)
+		for _, item := range section.items {
+			if strings.HasPrefix(section.title, "Macros ") {
+				fmt.Fprintf(&b, "    %s — %s\n", item.syntax, item.description)
+			} else {
+				fmt.Fprintf(&b, "    %-30s %s\n", item.syntax, item.description)
+			}
 		}
-		fmt.Fprintf(&b, "    %-30s %s\n", name, description)
 	}
+	return b.String()
+}
 
-	b.WriteString("\n  Macros (recognized at section start; later modifiers override defaults):\n")
-	for _, name := range v.Macros {
-		description := macroReference[name]
-		if description == "" {
-			description = name + " — query-defined macro"
+// Markdown renders the host-neutral layout reference.
+func Markdown(v Vocabulary) string {
+	model := buildReference(v)
+	var b strings.Builder
+	b.WriteString("# How to compose graph views\n\n")
+	b.WriteString("Compose colon-chained functions into a section and separate multiple sections with commas. Every section ends in a render function. Filters intersect; rank, page, name, and render modifiers use the last call of their kind. No whitespace is allowed outside quoted strings. Quote multi-word names, dates, durations, and topic paths.\n\n")
+	b.WriteString("## Grammar\n\n```text\n")
+	for _, line := range model.grammar {
+		b.WriteString(line + "\n")
+	}
+	b.WriteString("```\n\n## Vocabulary\n\n| Category | Syntax | Meaning |\n| --- | --- | --- |\n")
+	for _, section := range model.sections {
+		if len(section.items) == 0 {
+			continue
+		}
+		for _, item := range section.items {
+			fmt.Fprintf(&b, "| %s | `%s` | %s |\n", escapeTable(section.title), escapeTable(item.syntax), escapeTable(item.description))
 		}
-		fmt.Fprintf(&b, "    %s\n", description)
 	}
-
+	b.WriteString("\n## Example layout specifications\n\n```text\n")
+	for _, example := range model.examples {
+		b.WriteString(example + "\n")
+	}
+	b.WriteString("```\n")
 	return b.String()
 }
 
-// MissingReferenceNames returns live vocabulary names that lack descriptive
-// metadata. Tests use it to keep the reference explanatory as well as
-// mechanically complete.
+func escapeTable(value string) string {
+	return strings.ReplaceAll(value, "|", `\|`)
+}
+
+// MissingReferenceNames reports live names without descriptive metadata.
 func MissingReferenceNames(v Vocabulary) []string {
 	var missing []string
 	for _, name := range v.Functions {
diff --git a/internal/viewlayout/reference_test.go b/internal/viewlayout/reference_test.go
index 09db85c5..5d9d99f2 100644
--- a/internal/viewlayout/reference_test.go
+++ b/internal/viewlayout/reference_test.go
@@ -5,33 +5,85 @@ import (
 	"testing"
 )
 
-func TestReferenceBodyIsHostNeutral(t *testing.T) {
+func TestReferenceWrapsBodyWithCLIFraming(t *testing.T) {
+	reference := Reference(Vocabulary{})
+	for _, want := range []string{"Usage: sdd view", "Grammar:", "Examples:", "sdd view --layout='top(20)'"} {
+		if !strings.Contains(reference, want) {
+			t.Errorf("Reference output missing %q", want)
+		}
+	}
+}
+
+func TestReferenceRetainsTerminalShape(t *testing.T) {
 	vocabulary := Vocabulary{
-		Functions:  []string{"active", "as-list"},
-		Renders:    []string{"as-list"},
-		Algorithms: []string{"heat"},
-		Decays:     []string{"exp-14d"},
-		Macros:     []string{"top"},
+		Functions: []string{"active", "indexed", "as-list"}, Renders: []string{"as-list"},
+		Algorithms: []string{"heat"}, Decays: []string{"exp-14d"}, Macros: []string{"top"},
 	}
+	reference := Reference(vocabulary)
+	for _, want := range []string{"Usage: sdd view --layout=<spec>", "layout  := section", "Implemented pipeline vocabulary:", "active", "indexed", "top(N) — active entries ranked by heat", "Examples:"} {
+		if !strings.Contains(reference, want) {
+			t.Errorf("Reference output missing %q", want)
+		}
+	}
+	for _, example := range ExampleSpecs() {
+		want := "  sdd view --layout='" + example + "'"
+		if !strings.Contains(reference, want) {
+			t.Errorf("Reference output missing terminal example %q", want)
+		}
+	}
+}
 
-	body := ReferenceBody(vocabulary)
-	for _, want := range []string{"Grammar:", "active", "as-list", "heat", "exp-14d", "top(N)"} {
-		if !strings.Contains(body, want) {
-			t.Errorf("ReferenceBody output missing %q", want)
+func TestMarkdownUsesNativeStructureAndSharedExamples(t *testing.T) {
+	vocabulary := Vocabulary{
+		Functions: []string{"active", "indexed", "as-list"}, Renders: []string{"as-list"},
+		Algorithms: []string{"heat"}, Decays: []string{"exp-14d"}, Macros: []string{"top"},
+	}
+	markdown := Markdown(vocabulary)
+	for _, want := range []string{"# How to compose graph views", "## Grammar", "```text", "## Vocabulary", "| Category | Syntax | Meaning |", "| Filters | `indexed` |", "## Example layout specifications", "active:indexed:as-list"} {
+		if !strings.Contains(markdown, want) {
+			t.Errorf("Markdown output missing %q", want)
+		}
+	}
+	for _, unwanted := range []string{"sdd view", "--layout", "MCP", "debugging"} {
+		if strings.Contains(markdown, unwanted) {
+			t.Errorf("Markdown output contains host-specific framing %q", unwanted)
+		}
+	}
+	if strings.Contains(markdown, "<br>") {
+		t.Fatal("Markdown vocabulary uses HTML line-break packing")
+	}
+	wantRows := 2
+	for _, section := range buildReference(vocabulary).sections {
+		wantRows += len(section.items)
+	}
+	gotRows := 0
+	for _, line := range strings.Split(markdown, "\n") {
+		if strings.HasPrefix(line, "|") {
+			gotRows++
 		}
 	}
-	for _, unwanted := range []string{"Usage:", "Examples:", "sdd view"} {
-		if strings.Contains(body, unwanted) {
-			t.Errorf("ReferenceBody output contains host-specific framing %q", unwanted)
+	if gotRows != wantRows {
+		t.Fatalf("Markdown table rows = %d, want %d", gotRows, wantRows)
+	}
+	terminal := Reference(vocabulary)
+	for _, example := range ExampleSpecs() {
+		if !strings.Contains(markdown, example) || !strings.Contains(terminal, example) {
+			t.Errorf("shared example %q is missing from a renderer", example)
 		}
 	}
 }
 
-func TestReferenceWrapsBodyWithCLIFraming(t *testing.T) {
-	reference := Reference(Vocabulary{})
-	for _, want := range []string{"Usage: sdd view", "Grammar:", "Examples:", "sdd view --layout='top(20)'"} {
-		if !strings.Contains(reference, want) {
-			t.Errorf("Reference output missing %q", want)
+func TestMarkdownCoversEveryLiveVocabularyItem(t *testing.T) {
+	vocabulary := Vocabulary{
+		Functions: []string{"source", "active", "indexed", "as-list"}, Renders: []string{"as-list"},
+		Algorithms: []string{"heat"}, Decays: []string{"none"}, Macros: []string{"top"},
+	}
+	markdown := Markdown(vocabulary)
+	for _, section := range buildReference(vocabulary).sections {
+		for _, item := range section.items {
+			if !strings.Contains(markdown, "`"+escapeTable(item.syntax)+"`") {
+				t.Errorf("Markdown output missing live syntax %q", item.syntax)
+			}
 		}
 	}
 }
diff --git a/mcpapp/server_test.go b/mcpapp/server_test.go
index 0122f629..5be13892 100644
--- a/mcpapp/server_test.go
+++ b/mcpapp/server_test.go
@@ -600,6 +600,41 @@ func TestOrientationListsMoveParamSignatures(t *testing.T) {
 	}
 }
 
+func TestOpeningServeIncludesDerivedFactIndex(t *testing.T) {
+	env := newTestServer(t, nil, "", "")
+	serve := openSession(t, connect(t, env.srv))
+	const pointer = "- `20260717-110000-s-prc-vwg` — How to compose graph views (view tool): layout grammar, filters, ranking, quoting, and examples"
+	if !strings.Contains(serve.Instructions, pointer) {
+		t.Fatalf("opening serve missing fact pointer %q:\n%s", pointer, serve.Instructions)
+	}
+}
+
+func TestOpeningServeOmitsEmptyDerivedFactIndex(t *testing.T) {
+	graphDir := writeFixtureGraph(t)
+	path := filepath.Join(graphDir, "2026/07/17-110000-s-prc-vwg.md")
+	if err := os.MkdirAll(filepath.Dir(path), 0755); err != nil {
+		t.Fatal(err)
+	}
+	const override = `---
+type: signal
+layer: process
+kind: fact
+topics: [cli/view]
+summary: Project override deliberately leaves this fact out of session discovery.
+---
+
+Project-local reference override.
+`
+	if err := os.WriteFile(path, []byte(override), 0644); err != nil {
+		t.Fatal(err)
+	}
+	env := newTestServer(t, nil, graphDir, "")
+	serve := openSession(t, connect(t, env.srv))
+	if strings.Contains(serve.Instructions, "Reference facts available") {
+		t.Fatalf("opening serve rendered an empty fact-index block:\n%s", serve.Instructions)
+	}
+}
+
 // TestCaptureProcedureLoop drives the full capture spine over MCP: batch
 // report, playback chooser with served-instruction memory, staged
 // attachment materialized by the write gate, summary verification, and the