From 304bb2eb4016d02da1c5a56aa2526735e15fb02a Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Fri, 16 Oct 2026 04:52:54 +0000
Subject: [PATCH 1/3] CLAUDE.md is a view: rendered from
 record/views.d/CLAUDE.md.j2

The hand-written map moves into the template verbatim, so the rendered
file matches today's CLAUDE.md byte for byte apart from the generated
stamp and one new section: the principles in force, from
docs("DP", in_force=true), so the bootloader cannot name a retired
principle or miss a new one.

The regenerated CLAUDE.md is not committed here; the generate job on main
writes it, as for every view (CONTRIBUTING).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Dex8HCzKcCoo8P71LRqAve
---
 luria.yaml                           |  6 +++
 record/changelog.d/claude-md-view.md |  7 ++++
 record/views.d/CLAUDE.md.j2          | 62 ++++++++++++++++++++++++++++
 tests/test_bootloader_view.py        | 38 +++++++++++++++++
 4 files changed, 113 insertions(+)
 create mode 100644 record/changelog.d/claude-md-view.md
 create mode 100644 record/views.d/CLAUDE.md.j2
 create mode 100644 tests/test_bootloader_view.py

diff --git a/luria.yaml b/luria.yaml
index 5b415105..ffd2ef5a 100644
--- a/luria.yaml
+++ b/luria.yaml
@@ -165,6 +165,12 @@ schemes:
         many: true
         required: false
     influence: influenced_by
+# Files rendered from a template over the record (ADR-130). The
+# bootloader keeps its prose in the template and derives what would drift.
+views:
+  bootloader:
+    template: record/views.d/CLAUDE.md.j2
+    output: CLAUDE.md
 remotes:
   SG:
     name: strata-g
diff --git a/record/changelog.d/claude-md-view.md b/record/changelog.d/claude-md-view.md
new file mode 100644
index 00000000..8d09176b
--- /dev/null
+++ b/record/changelog.d/claude-md-view.md
@@ -0,0 +1,7 @@
+### Documentation
+
+- This repository's `CLAUDE.md` is now a view ([ADR-130](record/decisions.d/ADR-130.md)), rendered by
+  `luria index` from `record/views.d/CLAUDE.md.j2`. The hand-written map
+  stays prose in the template. A new "Principles in force" section lists
+  the active design principles, derived from the record. Edit the
+  template, never `CLAUDE.md`.
diff --git a/record/views.d/CLAUDE.md.j2 b/record/views.d/CLAUDE.md.j2
new file mode 100644
index 00000000..a9606c76
--- /dev/null
+++ b/record/views.d/CLAUDE.md.j2
@@ -0,0 +1,62 @@
+# CLAUDE.md
+
+Luria is a CLI that keeps a project's memory — and this repository is its
+own first user: the record here is scaffolded, generated, and linted by
+the code in `luria/`. This file is a map, not a manual; when it disagrees
+with `luria --help` or the docs, it is this file that is wrong.
+
+Orient first:
+
+- **Run `luria --help`** — the live command surface; every command takes
+  `--help`.
+- [Project memory](docs/project-memory.md) — the model: sources vs. generated views,
+  schemes, journals, fragments, remotes, and how references are checked.
+- [The record](docs/record.md) — this project's own configuration,
+  generated: what kinds of entry exist and what to type to file one.
+- [Decisions](docs/decisions/README.md) and
+  [design principles](docs/design-principles.md) — why things are the way
+  they are. Check here before re-deriving or re-litigating a choice.
+- [Comment directives](docs/directives.md) — how to acknowledge a lint
+  finding deliberately instead of working around it.
+
+## Working agreements
+
+- **Work goes to a branch and a pull request, never straight to `main`.**
+  The record is the deliverable; it needs a chance to be read before it
+  becomes what the project believes.
+- **File the record entry in the same contribution as the work**
+  (`luria new`): a changelog fragment for the change, a devlog entry for
+  anything the next person would otherwise rediscover, a decision document
+  when a real alternative was rejected. Filed with context loaded it costs
+  a paragraph; re-derived cold it costs a session.
+- **Never edit a generated file.** Anything stamped `GENERATED` — the
+  decision index, tag pages, `docs/design-principles.md`, journal books,
+  reports, `docs/record.md`, `docs/configuration.md`, the README badge
+  region — is rebuilt by `luria index`. Edit the sources, rerun it.
+- **Never hand-write a link target for a code.** Write the bare code and
+  run `luria link --fix`; record prose renders into views in other
+  directories, so only the fixer knows the frame a target must resolve
+  from. Codes in backticks are mentions, not citations, and are left
+  alone.
+- **A guard that keeps catching you is a bug report about the workflow.**
+  One catch is the net working; the same catch twice means the hazard is
+  upstream, and the fix is to remove what generates the mistake, not to
+  keep thanking the net.
+
+## Developing the package
+
+`python -m pytest tests -q` plus `luria lint` is what CI runs. A new check
+joins the lint only if the violation is always wrong and mechanically
+fixable; anything needing judgement is a report with an acknowledgement
+directive. Fire any new guard once on a real case before trusting it, and
+say so in the devlog.
+
+## Principles in force
+
+The standing values decisions cite by number, derived from the record so
+this list cannot name a retired one or miss a new one. The argument behind
+each is in the [design principles](docs/design-principles.md).
+
+{% for p in docs("DP", in_force=true) %}
+- {{ p.code }}: {{ p.title }}
+{% endfor %}
diff --git a/tests/test_bootloader_view.py b/tests/test_bootloader_view.py
new file mode 100644
index 00000000..244fa3c5
--- /dev/null
+++ b/tests/test_bootloader_view.py
@@ -0,0 +1,38 @@
+# tests/test_bootloader_view.py
+"""This repository's own `CLAUDE.md` is a view (ADR-130): the hand-written
+map stays prose in its template, and the principles it lists are derived,
+so the bootloader cannot name a principle that was retired or miss one
+that was adopted.
+"""
+
+from __future__ import annotations
+
+from luria import adr_index, config, views
+
+
+def bootloader():
+    return config.current().views["bootloader"]
+
+
+def test_claude_md_is_rendered_from_a_template():
+    view = bootloader()
+    root = config.current().root
+    assert view.output == root / "CLAUDE.md"
+    assert view.template == root / "record/views.d/CLAUDE.md.j2"
+
+
+def test_it_lists_exactly_the_principles_in_force():
+    text = views.render(bootloader())
+    section = text.split("## Principles in force", 1)[1]
+    for scheme in [config.current().schemes["DP"]]:
+        for doc in adr_index.load_scheme(scheme):
+            listed = f"[{doc.code}]" in section
+            assert listed == (doc.status_value == scheme.active), doc.code
+
+
+def test_it_keeps_the_hand_written_map():
+    text = views.render(bootloader())
+    assert "This file is a map, not a manual" in text
+    assert "## Working agreements" in text
+    assert text.startswith("<!-- GENERATED by `luria index` from "
+                           "record/views.d/CLAUDE.md.j2")

From 26cee97690d53a06eb1384e3bddbfad600939031 Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Fri, 16 Oct 2026 04:58:50 +0000
Subject: [PATCH 2/3] Derive the list of generated files: Config.generated(),
 one list

Config.generated() names everything luria index writes, each target a
label plus a file or a directory of generated pages. is_generated asks
those targets instead of its own chain of special cases, so the fixer,
the reference report and a template read one list (DP-004). Behaviour is
unchanged; a property test holds that every file the index renders is
covered, per record under its own config.

Templates get generated(), and CLAUDE.md's "never edit a generated
file" bullet now prints it instead of a hand-kept list (DP-003).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Dex8HCzKcCoo8P71LRqAve
---
 luria/config.py                         | 119 +++++++++++++-----------
 luria/views.py                          |  17 +++-
 record/changelog.d/generated-targets.md |  13 +++
 record/devlog.d/2026/10/16/045651.md    |  19 ++++
 record/views.d/CLAUDE.md.j2             |  11 ++-
 tests/test_generated_targets.py         |  63 +++++++++++++
 6 files changed, 181 insertions(+), 61 deletions(-)
 create mode 100644 record/changelog.d/generated-targets.md
 create mode 100644 record/devlog.d/2026/10/16/045651.md
 create mode 100644 tests/test_generated_targets.py

diff --git a/luria/config.py b/luria/config.py
index 11910d54..13a12db9 100644
--- a/luria/config.py
+++ b/luria/config.py
@@ -1998,6 +1998,24 @@ class View:
     pin: bool = False
 
 
+@dataclass(frozen=True)
+class Generated:
+    """One thing `luria index` writes, named for a reader (DP-004).
+
+    `files` are generated outright, and so is every page directly inside
+    one of `dirs`. `shown` is the path a reader is pointed at: a view's
+    directory, not each of its pages. `Config.generated` lists them, and
+    `Config.is_generated` asks them, so the generator's own answer and the
+    list a bootloader prints are one list."""
+    label: str
+    shown: Path
+    files: tuple[Path, ...] = ()
+    dirs: tuple[Path, ...] = ()
+
+    def covers(self, path: Path) -> bool:
+        return path in self.files or path.parent in self.dirs
+
+
 def _views(raw: dict, root: Path) -> dict[str, View]:
     """Every declared view. Both paths are required: a view without a
     template renders nothing, and a view without an output renders it
@@ -2390,64 +2408,53 @@ def remotes_lock(self) -> Path:
         and a private remote can only be read from a local clone anyway."""
         return self.root / "remotes.lock.json"
 
+    def generated(self) -> list[Generated]:
+        """Everything `luria index` writes, in the order a reader meets it.
+
+        Each target carries the reason it is generated where the reason is
+        not just "a view": the status reports *list* retired and dangling
+        codes, so scanning them would report the report (#35); the
+        configuration reference and the record description are made of
+        example codes; a chain page shows a line *including* its retired
+        steps; and a view's codes were put there by its template. An index
+        scheme's view directory is not a target as a whole: in the
+        collocated layout it holds the sources, so its index page and the
+        directory of each grouped field's pages are (ADR-098)."""
+        out: list[Generated] = []
+        for s in self.schemes.values():
+            name = s.title or s.prefix
+            if s.render == "index":
+                out.append(Generated(
+                    f"the {name} index and its per-value pages",
+                    s.view, files=(s.index_path,),
+                    dirs=tuple(s.vocab_dir(f) for f in s.grouped_fields)))
+            elif s.output:
+                out.append(Generated(f"the {name} document", s.output,
+                                     files=(s.output,)))
+        for j in self.journals.values():
+            out.append(Generated(f"the {j.title} books", j.output,
+                                 dirs=(j.output,)))
+        for c in self.chains.values():
+            out.append(Generated(f"the {c.title} chain page", c.output,
+                                 files=(c.output,)))
+        for v in self.views.values():
+            out.append(Generated(f"the `{v.name}` view", v.output,
+                                 files=(v.output,)))
+        out.append(Generated("the status reports", self.reports,
+                             dirs=(self.reports,)))
+        out.append(Generated("the record description", self.record_doc,
+                             files=(self.record_doc,)))
+        out.append(Generated("the configuration reference", self.config_doc,
+                             files=(self.config_doc,)))
+        return out
+
     def is_generated(self, path: Path) -> bool:
         """A view the generator owns. Rewriting one is pointless — the next
-        build undoes it — so the reference fixer skips them.
-
-        The status reports count too (#35): they *list* retired and dangling
-        codes, so scanning them would report the report — every flagged code
-        would gain a citation site inside the page that flags it, and the
-        view could never converge."""
-        if path.parent == self.reports:
-            return True
-        # The configuration reference (`luria index` renders it from this
-        # module's own dataclasses). Generated for the usual reason — a
-        # hand-written copy of a schema drifts — and flagged here for a second
-        # one: the page is *made* of example codes, and `doc_refs.doc_files`
-        # filters on this method, so the bare-reference lint and the fixer
-        # both leave it alone.
-        if path == self.config_doc:
-            return True
-        # The record description, generated from this config for the same two
-        # reasons: a hand-written "how our record works" drifts, and the page
-        # is made of example codes.
-        if path == self.record_doc:
-            return True
-        # A chain page (#171). Generated for the usual reason, and excluded
-        # here for a sharper one: its whole job is to show a line *including*
-        # its retired steps, so scanning it would report every superseded
-        # document in every chain as an unacknowledged citation — at a site
-        # the reader must not edit, in a file the next build overwrites.
-        if any(path == c.output for c in self.chains.values()):
-            return True
-        # A view's output (ADR-130), for the chain page's reason: a
-        # code in it was put there by a template, so a finding sited in the
-        # output names a line nobody can annotate. What a view reads is
-        # checked at the template line instead (`view_reads`).
-        if any(path == v.output for v in self.views.values()):
-            return True
-        for s in self.schemes.values():
-            # The index, and a page per value of every field it groups by —
-            # the axis's among them, on the same template and in the same
-            # kind of directory (ADR-098).
-            #
-            # The non-axis half of this was missing for as long as
-            # vocabularies existed, and invisible until a *retired* document
-            # became a vocabulary member: the reference report scans what
-            # this method does not exclude, so it found a citation of a
-            # superseded document inside a page nobody can annotate — an
-            # `inactive-ok:` written there is erased by the next build.
-            # Worse, the page is written in the same pass that renders the
-            # report, so the report saw the *previous* run's copy and
-            # `luria index` stopped converging.
-            if s.render == "index" and (
-                    path == s.index_path
-                    or any(path.parent == s.vocab_dir(f)
-                           for f in s.grouped_fields)):
-                return True
-            if s.output == path:
-                return True
-        return any(path.parent == j.output for j in self.journals.values())
+        build undoes it — so the reference fixer skips them, and the
+        reference report does not scan them: a finding sited in a page the
+        next build overwrites names a line nobody can annotate. What counts
+        is `generated()`, the one list of what the generator writes."""
+        return any(t.covers(path) for t in self.generated())
 
     def is_template(self, path: Path) -> bool:
         """A scheme's `_template.md` — a form, not a document.
diff --git a/luria/views.py b/luria/views.py
index 0b0cb332..7ad58b81 100644
--- a/luria/views.py
+++ b/luria/views.py
@@ -77,6 +77,14 @@ class SchemeInfo:
     output: str
 
 
+@dataclass(frozen=True)
+class GeneratedInfo:
+    """One thing `luria index` writes, as a template names it: a label and
+    a root-relative path (`Config.generated`)."""
+    label: str
+    path: str
+
+
 @dataclass(frozen=True)
 class JournalInfo:
     """The same for a journal: where entries are filed, where books land."""
@@ -216,6 +224,12 @@ def schemes(self) -> list[SchemeInfo]:
                            self.cfg.rel(s.output) if s.output else "")
                 for s in self.cfg.schemes.values()]
 
+    def generated(self) -> list[GeneratedInfo]:
+        """Everything `luria index` writes, from the generator's own list,
+        so a page telling people what not to edit cannot drift from it."""
+        return [GeneratedInfo(t.label, self.cfg.rel(t.shown))
+                for t in self.cfg.generated()]
+
     def journals(self) -> list[JournalInfo]:
         return [JournalInfo(j.name, str(j.title or ""),
                             str(j.blurb or "").strip(), self.cfg.rel(j.dir),
@@ -307,7 +321,8 @@ def render(view) -> str:
     env.globals.update(doc=record.doc, docs=record.docs,
                        vocabulary=record.vocabulary, schemes=record.schemes,
                        match=record.match,
-                       journals=record.journals)
+                       journals=record.journals,
+                       generated=record.generated)
     try:
         text = env.get_template(_name(view)).render()
     except (jinja2.TemplateError, _Refused, TypeError, ValueError,
diff --git a/record/changelog.d/generated-targets.md b/record/changelog.d/generated-targets.md
new file mode 100644
index 00000000..d37c06cb
--- /dev/null
+++ b/record/changelog.d/generated-targets.md
@@ -0,0 +1,13 @@
+### Added
+
+- `generated()` in a view template: everything `luria index` writes, each
+  with a label and a root-relative path. This repository's `CLAUDE.md`
+  uses it, so its "never edit a generated file" list is derived.
+
+### Changed
+
+- `Config.is_generated` is now one question asked of
+  `Config.generated()`, the list of what the generator writes, so what
+  the fixer and the reference report skip is the same list a template
+  prints ([DP-004](record/principles.d/DP-004.md)). Behaviour is unchanged. A test holds that every file
+  `luria index` renders is covered by some target.
diff --git a/record/devlog.d/2026/10/16/045651.md b/record/devlog.d/2026/10/16/045651.md
new file mode 100644
index 00000000..1f02c092
--- /dev/null
+++ b/record/devlog.d/2026/10/16/045651.md
@@ -0,0 +1,19 @@
+---
+title: 'One list of what luria generates'
+created: '2026-10-16T04:56:51'
+tags: []
+---
+
+`CLAUDE.md` named the generated files by hand, in a bullet saying never to
+edit them. The generator already knew the list, but only as a chain of
+special cases in `Config.is_generated`. `Config.generated()` now names each
+target with a label: one file, or a directory whose pages are all
+generated. `is_generated` asks those targets, and a template prints them,
+so the check and the bootloader read one list ([DP-004](../../record/principles.d/DP-004.md)).
+
+Trap for the guard: `adr_index.outputs()` includes nested records' views
+([ADR-078](../../record/decisions.d/ADR-078.md)), rendered under each record's own config. The parent's targets
+never covered them, before this change or after it. A property test that
+iterates the parent's outputs therefore reports 133 "uncovered" example
+pages. The test asks each record about its own outputs, under its own
+config.
diff --git a/record/views.d/CLAUDE.md.j2 b/record/views.d/CLAUDE.md.j2
index a9606c76..4e137d74 100644
--- a/record/views.d/CLAUDE.md.j2
+++ b/record/views.d/CLAUDE.md.j2
@@ -29,10 +29,13 @@ Orient first:
   anything the next person would otherwise rediscover, a decision document
   when a real alternative was rejected. Filed with context loaded it costs
   a paragraph; re-derived cold it costs a session.
-- **Never edit a generated file.** Anything stamped `GENERATED` — the
-  decision index, tag pages, `docs/design-principles.md`, journal books,
-  reports, `docs/record.md`, `docs/configuration.md`, the README badge
-  region — is rebuilt by `luria index`. Edit the sources, rerun it.
+- **Never edit a generated file.** Anything stamped `GENERATED` is rebuilt
+  by `luria index`; edit the sources and rerun it. The README's generated
+  regions are rebuilt too, and so is everything below, which is the
+  generator's own list:
+{% for g in generated() %}
+  - {{ g.label }}: `{{ g.path }}`
+{% endfor %}
 - **Never hand-write a link target for a code.** Write the bare code and
   run `luria link --fix`; record prose renders into views in other
   directories, so only the fixer knows the frame a target must resolve
diff --git a/tests/test_generated_targets.py b/tests/test_generated_targets.py
new file mode 100644
index 00000000..33f0ec9c
--- /dev/null
+++ b/tests/test_generated_targets.py
@@ -0,0 +1,63 @@
+# tests/test_generated_targets.py
+"""What luria generates, named once (DP-004): `Config.generated()` lists the
+targets with a reader's label, `is_generated` asks it, and a template can
+print it, so a bootloader's "never edit these" cannot drift from what the
+generator actually writes (DP-003).
+"""
+
+from __future__ import annotations
+
+from luria import adr_index, config, views
+
+
+def covered(cfg, path) -> bool:
+    return any(t.covers(path) for t in cfg.generated())
+
+
+def test_every_file_the_index_writes_is_a_named_target():
+    # The property, not the list (DP-003): whatever `luria index` renders,
+    # some target names it. A nested record's views are its own config's to
+    # name (ADR-078), so each record is asked under its own.
+    from luria.config import rooted
+    cfg = config.current()
+    missing = [cfg.rel(p) for p in adr_index.outputs(nested=False)
+               if not covered(cfg, p)]
+    for record in cfg.nested_records():
+        with rooted(record):
+            inner = config.current()
+            missing += [inner.rel(p) for p in adr_index.outputs(nested=False)
+                        if not covered(inner, p)]
+    assert missing == []
+
+
+def test_every_file_the_index_writes_in_a_fixture_is_named(project):
+    cfg = config.current()
+    missing = [cfg.rel(p) for p in adr_index.outputs() if not covered(cfg, p)]
+    assert missing == []
+
+
+def test_is_generated_is_the_targets_question():
+    cfg = config.current()
+    for path in adr_index.outputs(nested=False):
+        assert cfg.is_generated(path) == covered(cfg, path)
+    source = cfg.root / "record/decisions.d/ADR-001.md"
+    assert not cfg.is_generated(source) and not covered(cfg, source)
+
+
+def test_each_target_has_a_label_and_a_path():
+    cfg = config.current()
+    found = {cfg.rel(t.shown): t.label for t in cfg.generated()}
+    assert "docs/decisions" in found
+    assert "docs/design-principles.md" in found
+    assert "docs/reports" in found
+    assert "docs/record.md" in found
+    assert all(found.values())
+
+
+def test_a_template_can_list_them():
+    cfg = config.current()
+    view = cfg.views["bootloader"]
+    text = views.render(view)
+    assert "`docs/design-principles.md`" in text
+    assert "`docs/record.md`" in text
+    assert "`CLAUDE.md`" in text      # the bootloader names itself

From b325618d47cad7118a64e6f3eaf81df7415f9c7d Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Fri, 16 Oct 2026 05:12:48 +0000
Subject: [PATCH 3/3] Move the generated-file loops into the CLAUDE.md template

Review: the labels and loops are presentation and belong in the template.
Config.generated() is gone and is_generated is back to what main has.
Templates instead get what the loops need: each scheme's render kind,
chains(), views(), and paths() for the reports, record description and
configuration reference.

The template is now a second derivation of what luria index writes, so
the test guards the property: every file the index renders falls under a
path the rendered bootloader names. Fired once by deleting the journals
loop; it failed naming docs/devlog/2026-10.md.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Dex8HCzKcCoo8P71LRqAve
---
 luria/config.py                         | 119 +++++++++++-------------
 luria/views.py                          |  49 +++++++---
 record/changelog.d/generated-targets.md |  18 ++--
 record/devlog.d/2026/10/16/045651.md    |  31 +++---
 record/views.d/CLAUDE.md.j2             |  21 ++++-
 tests/test_generated_targets.py         |  76 ++++++---------
 6 files changed, 164 insertions(+), 150 deletions(-)

diff --git a/luria/config.py b/luria/config.py
index 13a12db9..11910d54 100644
--- a/luria/config.py
+++ b/luria/config.py
@@ -1998,24 +1998,6 @@ class View:
     pin: bool = False
 
 
-@dataclass(frozen=True)
-class Generated:
-    """One thing `luria index` writes, named for a reader (DP-004).
-
-    `files` are generated outright, and so is every page directly inside
-    one of `dirs`. `shown` is the path a reader is pointed at: a view's
-    directory, not each of its pages. `Config.generated` lists them, and
-    `Config.is_generated` asks them, so the generator's own answer and the
-    list a bootloader prints are one list."""
-    label: str
-    shown: Path
-    files: tuple[Path, ...] = ()
-    dirs: tuple[Path, ...] = ()
-
-    def covers(self, path: Path) -> bool:
-        return path in self.files or path.parent in self.dirs
-
-
 def _views(raw: dict, root: Path) -> dict[str, View]:
     """Every declared view. Both paths are required: a view without a
     template renders nothing, and a view without an output renders it
@@ -2408,53 +2390,64 @@ def remotes_lock(self) -> Path:
         and a private remote can only be read from a local clone anyway."""
         return self.root / "remotes.lock.json"
 
-    def generated(self) -> list[Generated]:
-        """Everything `luria index` writes, in the order a reader meets it.
-
-        Each target carries the reason it is generated where the reason is
-        not just "a view": the status reports *list* retired and dangling
-        codes, so scanning them would report the report (#35); the
-        configuration reference and the record description are made of
-        example codes; a chain page shows a line *including* its retired
-        steps; and a view's codes were put there by its template. An index
-        scheme's view directory is not a target as a whole: in the
-        collocated layout it holds the sources, so its index page and the
-        directory of each grouped field's pages are (ADR-098)."""
-        out: list[Generated] = []
-        for s in self.schemes.values():
-            name = s.title or s.prefix
-            if s.render == "index":
-                out.append(Generated(
-                    f"the {name} index and its per-value pages",
-                    s.view, files=(s.index_path,),
-                    dirs=tuple(s.vocab_dir(f) for f in s.grouped_fields)))
-            elif s.output:
-                out.append(Generated(f"the {name} document", s.output,
-                                     files=(s.output,)))
-        for j in self.journals.values():
-            out.append(Generated(f"the {j.title} books", j.output,
-                                 dirs=(j.output,)))
-        for c in self.chains.values():
-            out.append(Generated(f"the {c.title} chain page", c.output,
-                                 files=(c.output,)))
-        for v in self.views.values():
-            out.append(Generated(f"the `{v.name}` view", v.output,
-                                 files=(v.output,)))
-        out.append(Generated("the status reports", self.reports,
-                             dirs=(self.reports,)))
-        out.append(Generated("the record description", self.record_doc,
-                             files=(self.record_doc,)))
-        out.append(Generated("the configuration reference", self.config_doc,
-                             files=(self.config_doc,)))
-        return out
-
     def is_generated(self, path: Path) -> bool:
         """A view the generator owns. Rewriting one is pointless — the next
-        build undoes it — so the reference fixer skips them, and the
-        reference report does not scan them: a finding sited in a page the
-        next build overwrites names a line nobody can annotate. What counts
-        is `generated()`, the one list of what the generator writes."""
-        return any(t.covers(path) for t in self.generated())
+        build undoes it — so the reference fixer skips them.
+
+        The status reports count too (#35): they *list* retired and dangling
+        codes, so scanning them would report the report — every flagged code
+        would gain a citation site inside the page that flags it, and the
+        view could never converge."""
+        if path.parent == self.reports:
+            return True
+        # The configuration reference (`luria index` renders it from this
+        # module's own dataclasses). Generated for the usual reason — a
+        # hand-written copy of a schema drifts — and flagged here for a second
+        # one: the page is *made* of example codes, and `doc_refs.doc_files`
+        # filters on this method, so the bare-reference lint and the fixer
+        # both leave it alone.
+        if path == self.config_doc:
+            return True
+        # The record description, generated from this config for the same two
+        # reasons: a hand-written "how our record works" drifts, and the page
+        # is made of example codes.
+        if path == self.record_doc:
+            return True
+        # A chain page (#171). Generated for the usual reason, and excluded
+        # here for a sharper one: its whole job is to show a line *including*
+        # its retired steps, so scanning it would report every superseded
+        # document in every chain as an unacknowledged citation — at a site
+        # the reader must not edit, in a file the next build overwrites.
+        if any(path == c.output for c in self.chains.values()):
+            return True
+        # A view's output (ADR-130), for the chain page's reason: a
+        # code in it was put there by a template, so a finding sited in the
+        # output names a line nobody can annotate. What a view reads is
+        # checked at the template line instead (`view_reads`).
+        if any(path == v.output for v in self.views.values()):
+            return True
+        for s in self.schemes.values():
+            # The index, and a page per value of every field it groups by —
+            # the axis's among them, on the same template and in the same
+            # kind of directory (ADR-098).
+            #
+            # The non-axis half of this was missing for as long as
+            # vocabularies existed, and invisible until a *retired* document
+            # became a vocabulary member: the reference report scans what
+            # this method does not exclude, so it found a citation of a
+            # superseded document inside a page nobody can annotate — an
+            # `inactive-ok:` written there is erased by the next build.
+            # Worse, the page is written in the same pass that renders the
+            # report, so the report saw the *previous* run's copy and
+            # `luria index` stopped converging.
+            if s.render == "index" and (
+                    path == s.index_path
+                    or any(path.parent == s.vocab_dir(f)
+                           for f in s.grouped_fields)):
+                return True
+            if s.output == path:
+                return True
+        return any(path.parent == j.output for j in self.journals.values())
 
     def is_template(self, path: Path) -> bool:
         """A scheme's `_template.md` — a form, not a document.
diff --git a/luria/views.py b/luria/views.py
index 7ad58b81..9ac00571 100644
--- a/luria/views.py
+++ b/luria/views.py
@@ -75,14 +75,28 @@ class SchemeInfo:
     blurb: str
     dir: str
     output: str
+    # "index" (a table and per-value pages under `output`) or "document"
+    # (the bodies assembled into the one page `output`).
+    render: str = "index"
 
 
 @dataclass(frozen=True)
-class GeneratedInfo:
-    """One thing `luria index` writes, as a template names it: a label and
-    a root-relative path (`Config.generated`)."""
-    label: str
-    path: str
+class OutputInfo:
+    """A chain or a view, as a template names it: its name, its title where
+    it has one, and the page it renders into, relative to the project root."""
+    name: str
+    title: str
+    output: str
+
+
+@dataclass(frozen=True)
+class PathsInfo:
+    """The pages and directories luria renders at fixed, configured places,
+    relative to the project root."""
+    docs: str
+    reports: str
+    record: str             # the record description
+    configuration: str      # the configuration reference
 
 
 @dataclass(frozen=True)
@@ -221,14 +235,23 @@ def vocabulary(self, name: str) -> list[Term]:
     def schemes(self) -> list[SchemeInfo]:
         return [SchemeInfo(s.prefix, str(s.title or ""),
                            str(s.blurb or "").strip(), self.cfg.rel(s.dir),
-                           self.cfg.rel(s.output) if s.output else "")
+                           self.cfg.rel(s.output) if s.output else "",
+                           s.render)
                 for s in self.cfg.schemes.values()]
 
-    def generated(self) -> list[GeneratedInfo]:
-        """Everything `luria index` writes, from the generator's own list,
-        so a page telling people what not to edit cannot drift from it."""
-        return [GeneratedInfo(t.label, self.cfg.rel(t.shown))
-                for t in self.cfg.generated()]
+    def chains(self) -> list[OutputInfo]:
+        return [OutputInfo(c.name, c.title, self.cfg.rel(c.output))
+                for c in self.cfg.chains.values()]
+
+    def views(self) -> list[OutputInfo]:
+        return [OutputInfo(v.name, v.name, self.cfg.rel(v.output))
+                for v in self.cfg.views.values()]
+
+    def paths(self) -> PathsInfo:
+        return PathsInfo(self.cfg.rel(self.cfg.docs),
+                         self.cfg.rel(self.cfg.reports),
+                         self.cfg.rel(self.cfg.record_doc),
+                         self.cfg.rel(self.cfg.config_doc))
 
     def journals(self) -> list[JournalInfo]:
         return [JournalInfo(j.name, str(j.title or ""),
@@ -321,8 +344,8 @@ def render(view) -> str:
     env.globals.update(doc=record.doc, docs=record.docs,
                        vocabulary=record.vocabulary, schemes=record.schemes,
                        match=record.match,
-                       journals=record.journals,
-                       generated=record.generated)
+                       journals=record.journals, chains=record.chains,
+                       views=record.views, paths=record.paths)
     try:
         text = env.get_template(_name(view)).render()
     except (jinja2.TemplateError, _Refused, TypeError, ValueError,
diff --git a/record/changelog.d/generated-targets.md b/record/changelog.d/generated-targets.md
index d37c06cb..e9038c41 100644
--- a/record/changelog.d/generated-targets.md
+++ b/record/changelog.d/generated-targets.md
@@ -1,13 +1,9 @@
 ### Added
 
-- `generated()` in a view template: everything `luria index` writes, each
-  with a label and a root-relative path. This repository's `CLAUDE.md`
-  uses it, so its "never edit a generated file" list is derived.
-
-### Changed
-
-- `Config.is_generated` is now one question asked of
-  `Config.generated()`, the list of what the generator writes, so what
-  the fixer and the reference report skip is the same list a template
-  prints ([DP-004](record/principles.d/DP-004.md)). Behaviour is unchanged. A test holds that every file
-  `luria index` renders is covered by some target.
+- More of the configuration reaches a view template: each scheme's
+  `render` kind on `schemes()`, `chains()` and `views()` with their
+  outputs, and `paths()` for the status reports, the record description
+  and the configuration reference. This repository's `CLAUDE.md` uses
+  them to derive its "never edit a generated file" list in the template.
+  A test holds that every file `luria index` writes falls under a path
+  the bootloader names.
diff --git a/record/devlog.d/2026/10/16/045651.md b/record/devlog.d/2026/10/16/045651.md
index 1f02c092..88903d1c 100644
--- a/record/devlog.d/2026/10/16/045651.md
+++ b/record/devlog.d/2026/10/16/045651.md
@@ -1,19 +1,26 @@
 ---
-title: 'One list of what luria generates'
+title: 'CLAUDE.md derives its list of generated files'
 created: '2026-10-16T04:56:51'
 tags: []
 ---
 
 `CLAUDE.md` named the generated files by hand, in a bullet saying never to
-edit them. The generator already knew the list, but only as a chain of
-special cases in `Config.is_generated`. `Config.generated()` now names each
-target with a label: one file, or a directory whose pages are all
-generated. `is_generated` asks those targets, and a template prints them,
-so the check and the bootloader read one list ([DP-004](../../record/principles.d/DP-004.md)).
+edit them. The list is now derived in its template, from loops over
+`schemes()`, `journals()`, `chains()` and `views()`, plus `paths()` for
+the pages luria renders at fixed places. A first version put the list in
+`Config.generated()` and had `is_generated` ask it, so the check and the
+page would share one list. It was dropped in review: the labels and the
+loops are presentation and belong in the template, and `is_generated` was
+right as it stood.
 
-Trap for the guard: `adr_index.outputs()` includes nested records' views
-([ADR-078](../../record/decisions.d/ADR-078.md)), rendered under each record's own config. The parent's targets
-never covered them, before this change or after it. A property test that
-iterates the parent's outputs therefore reports 133 "uncovered" example
-pages. The test asks each record about its own outputs, under its own
-config.
+The cost is a second derivation of "what luria writes", in the template,
+so the guard is a property and not a list ([DP-003](../../record/principles.d/DP-003.md)). Every file
+`luria index` renders for this record has to fall under a path the
+rendered bootloader names. I fired it once ([DP-006](../../record/principles.d/DP-006.md)): with the journals
+loop deleted from the template, it failed and named
+`docs/devlog/2026-10.md`. A new kind of generated output fails it until
+the template learns to say it.
+
+Trap: `adr_index.outputs()` includes nested records' views ([ADR-078](../../record/decisions.d/ADR-078.md)),
+which this record's bootloader does not name. The test asks
+`outputs(nested=False)`.
diff --git a/record/views.d/CLAUDE.md.j2 b/record/views.d/CLAUDE.md.j2
index 4e137d74..c9786607 100644
--- a/record/views.d/CLAUDE.md.j2
+++ b/record/views.d/CLAUDE.md.j2
@@ -31,11 +31,24 @@ Orient first:
   a paragraph; re-derived cold it costs a session.
 - **Never edit a generated file.** Anything stamped `GENERATED` is rebuilt
   by `luria index`; edit the sources and rerun it. The README's generated
-  regions are rebuilt too, and so is everything below, which is the
-  generator's own list:
-{% for g in generated() %}
-  - {{ g.label }}: `{{ g.path }}`
+  regions are rebuilt too, and so is everything below, derived from this
+  record's configuration:
+{% for s in schemes() if s.output %}
+  - the {{ s.title or s.prefix }} {{ "index and its per-value pages" if s.render == "index" else "document" }}: `{{ s.output }}`
 {% endfor %}
+{% for j in journals() %}
+  - the {{ j.title }} books: `{{ j.output }}`
+{% endfor %}
+{% for c in chains() %}
+  - the {{ c.title }} chain page: `{{ c.output }}`
+{% endfor %}
+{% for v in views() %}
+  - the `{{ v.name }}` view: `{{ v.output }}`
+{% endfor %}
+{% set p = paths() %}
+  - the status reports: `{{ p.reports }}`
+  - the record description: `{{ p.record }}`
+  - the configuration reference: `{{ p.configuration }}`
 - **Never hand-write a link target for a code.** Write the bare code and
   run `luria link --fix`; record prose renders into views in other
   directories, so only the fixer knows the frame a target must resolve
diff --git a/tests/test_generated_targets.py b/tests/test_generated_targets.py
index 33f0ec9c..ccba4e0d 100644
--- a/tests/test_generated_targets.py
+++ b/tests/test_generated_targets.py
@@ -1,63 +1,45 @@
 # tests/test_generated_targets.py
-"""What luria generates, named once (DP-004): `Config.generated()` lists the
-targets with a reader's label, `is_generated` asks it, and a template can
-print it, so a bootloader's "never edit these" cannot drift from what the
-generator actually writes (DP-003).
+"""`CLAUDE.md`'s "never edit a generated file" list is derived in its
+template (ADR-130), from what the record's config says it renders. The
+template is then a second derivation of what `luria index` writes, beside
+the generator itself, so this guards the property and not the list (DP-003):
+every file the index writes lies at or under a path the bootloader names.
 """
 
 from __future__ import annotations
 
-from luria import adr_index, config, views
-
+import re
 
-def covered(cfg, path) -> bool:
-    return any(t.covers(path) for t in cfg.generated())
+from luria import adr_index, config, views
 
 
-def test_every_file_the_index_writes_is_a_named_target():
-    # The property, not the list (DP-003): whatever `luria index` renders,
-    # some target names it. A nested record's views are its own config's to
-    # name (ADR-078), so each record is asked under its own.
-    from luria.config import rooted
-    cfg = config.current()
-    missing = [cfg.rel(p) for p in adr_index.outputs(nested=False)
-               if not covered(cfg, p)]
-    for record in cfg.nested_records():
-        with rooted(record):
-            inner = config.current()
-            missing += [inner.rel(p) for p in adr_index.outputs(nested=False)
-                        if not covered(inner, p)]
-    assert missing == []
+def named_paths() -> list[str]:
+    text = views.render(config.current().views["bootloader"])
+    section = text.split("**Never edit a generated file.**", 1)[1]
+    section = section.split("\n- **", 1)[0]
+    return re.findall(r"^  - .*: `([^`]+)`$", section, re.MULTILINE)
 
 
-def test_every_file_the_index_writes_in_a_fixture_is_named(project):
+def test_the_bootloader_names_every_file_the_index_writes():
     cfg = config.current()
-    missing = [cfg.rel(p) for p in adr_index.outputs() if not covered(cfg, p)]
+    named = [cfg.root / p for p in named_paths()]
+    missing = [cfg.rel(out) for out in adr_index.outputs(nested=False)
+               if not any(out == n or n in out.parents for n in named)]
     assert missing == []
 
 
-def test_is_generated_is_the_targets_question():
-    cfg = config.current()
-    for path in adr_index.outputs(nested=False):
-        assert cfg.is_generated(path) == covered(cfg, path)
-    source = cfg.root / "record/decisions.d/ADR-001.md"
-    assert not cfg.is_generated(source) and not covered(cfg, source)
-
+def test_it_names_each_kind_of_view():
+    named = named_paths()
+    for path in ("docs/decisions", "docs/design-principles.md",
+                 "docs/devlog", "CLAUDE.md", "docs/reports",
+                 "docs/record.md", "docs/configuration.md"):
+        assert path in named
 
-def test_each_target_has_a_label_and_a_path():
-    cfg = config.current()
-    found = {cfg.rel(t.shown): t.label for t in cfg.generated()}
-    assert "docs/decisions" in found
-    assert "docs/design-principles.md" in found
-    assert "docs/reports" in found
-    assert "docs/record.md" in found
-    assert all(found.values())
 
-
-def test_a_template_can_list_them():
-    cfg = config.current()
-    view = cfg.views["bootloader"]
-    text = views.render(view)
-    assert "`docs/design-principles.md`" in text
-    assert "`docs/record.md`" in text
-    assert "`CLAUDE.md`" in text      # the bootloader names itself
+def test_paths_and_scheme_render_kinds_reach_a_template():
+    view = config.current().views["bootloader"]
+    record = views._Record(view.output)
+    kinds = {s.prefix: s.render for s in record.schemes()}
+    assert kinds == {"ADR": "index", "DP": "document"}
+    assert record.paths().record == "docs/record.md"
+    assert [v.output for v in record.views()] == ["CLAUDE.md"]