feat(import): index quadlet unit files and jinja templates (A9 revision)

Phase 47 (owner permission 2026-08-27, TODO.md L10–11, roadmap R1): the
full Podman quadlet family (.container, .network, .volume, .image,
.pod, .kube, .swap, .os, .endpoint) and .j2 Jinja templates join the
allowed + default A9 import formats, chunked as plain text (owner
decision — no TOML/Jinja-aware splitter). No env configuration needed:
a default import now indexes them.

- app/config.py: _ALLOWED_IMPORT_EXTENSIONS + the default
  import_extensions CSV gain the ten names (the original seven first);
  the never-widen BOR_IMPORT_EXTENSIONS validator is untouched and
  still rejects truly unknown extensions.
- app/rag/chunker.py: ten _FORMAT_CHUNKERS entries -> chunk_text
  (HARD_MAX_CHARS 1200 honored, unknown-suffix fallback unchanged);
  docstring/comments cite the A9 revision 2026-08-27.
- tests/fixtures/docs/homelab/: quadlet/compose.container (realistic
  quadlet TOML, >1500 chars, [Unit]/[Service]/[Container] sections,
  RESE-QUADLET-SENTINEL-77aa), quadlet/lan.network,
  quadlet/cache.volume, templates/deploy.j2 (for/set/if Jinja
  constructs + RESE-JINJA-SENTINEL-33dd). Every suite that seeds the
  fixture tree updates its 9 -> 13 document-count constants.
- tests/unit/test_config.py: allowed set carries all seventeen formats,
  default CSV + dotted import_extension_set include the ten, the
  validator accepts the new names and still rejects unknowns.
- tests/unit/test_chunker.py: dispatch parity with chunk_text for every
  new suffix (parametrized), the .container fixture chunks >=2 under
  the cap with the sentinel surviving, the .j2 fixture keeps {{ }}
  verbatim, the unknown-suffix fallback is unchanged.
- tests/unit/test_importer.py: a default-extensions walk over a temp
  tree indexes exactly the ten new files (unknown/hidden/excluded
  filtered), the original seven still walk, stem-title fallback holds.
- tests/integration/test_import_quadlet_jinja.py (new): import_sources
  over a temp tree with .container/.volume/.j2 -> documents + chunks
  rows with stem titles; delta re-import updates only the changed .j2
  doc; prune drops the deleted .volume doc with cascade.
- tests/e2e/test_quadlet_jinja_import.py (new, story suite, mock-only,
  isolation): GET /api/docs (admin session) lists the four new-format
  docs with non-zero chunk counts and stem titles; the Sources table
  renders a row + .doc-link per file; the phase-26 modal shows the
  .container TOML ([Container] section + sentinel) with stem title and
  the container format badge; a RESE-JINJA-SENTINEL-33dd question
  FTS-matches the .j2 chunk -> honest-positive (A8: LOW requires zero
  FTS hits) — the bubble is not .is-deflected and a source chip names
  templates/deploy.j2.
- README.md + .env.example: the extended default format set (A9
  revised 2026-08-27, plain-text chunking, narrow-only rule intact).
- .agent/PLAN.md: the A9 revision (owner-locked R1) — A9 row status,
  the revision note under the anchors table, and the §5 chunking-policy
  + §11 workflow lines. The only PLAN edit this phase.

Gates: uv run pytest 795 passed; app/ coverage TOTAL 99% (>90%);
ruff check + pyright clean; story E2E 4/4 in isolation (DB up);
regression E2E suites test_import_documents (3) / test_sync_button
(3) / test_git_sources_admin (6) green in isolation.

Also records the 47_quadlet_jinja_import task-file moves (01–03)
todo/ -> complete/.

tests/unit/test_chunker.py

@@ -7,6 +7,7 @@ unchanged); the per-format tests cover the phase-09 dispatcher
 from __future__ import annotations
 
 from itertools import pairwise
+from pathlib import Path
 
 import pytest
 
@@ -361,6 +362,63 @@ def test_txt_long_doc_packs_with_overlap() -> None:
     assert all(f"para {i}" in "\n".join(chunks) for i in range(6))
 
 
+# ---------------------------------------------------------------------------
+# quadlet family + j2 (A9 revised 2026-08-27) — plain-text dispatch
+# ---------------------------------------------------------------------------
+
+#: The ten suffixes added 2026-08-27 (owner decision R1): the full Podman
+#: quadlet family + Jinja templates, all chunked as plain text.
+NEW_FORMAT_SUFFIXES = [
+    ".container", ".network", ".volume", ".image", ".pod",
+    ".kube", ".swap", ".os", ".endpoint", ".j2",
+]
+
+REPO_ROOT = Path(__file__).resolve().parents[2]
+FIXTURE_DOCS = REPO_ROOT / "tests" / "fixtures" / "docs" / "homelab"
+
+
+@pytest.mark.parametrize("suffix", NEW_FORMAT_SUFFIXES)
+def test_dispatch_new_suffixes_match_plain_text(suffix: str) -> None:
+    """Every new suffix dispatches to plain-text paragraph packing — the
+    chunks are identical to a direct ``chunk_text`` call."""
+    content = "[Unit]\nDescription=one\n\n[Service]\nRestart=always\n\n[Container]\nImage=busybox\n"
+    name = suffix.lstrip(".")
+    assert chunk_document(content, f"x/{name}{suffix}") == chunk_text(content)
+
+
+def test_container_fixture_chunks_past_single_paragraph_pack() -> None:
+    """The realistic quadlet TOML fixture (≥1 500 chars) splits into ≥2
+    chunks, every chunk stays under the hard cap, and the sentinel token
+    survives the split."""
+    rel = "quadlet/compose.container"
+    content = (FIXTURE_DOCS / rel).read_text(encoding="utf-8")
+    assert len(content) >= 1500  # the fixture must exercise sub-splitting
+    chunks = chunk_document(content, rel)
+    assert len(chunks) >= 2
+    assert all(len(c) <= HARD_MAX_CHARS for c in chunks)
+    assert any("RESE-QUADLET-SENTINEL-77aa" in c for c in chunks)
+    joined = "\n".join(chunks)
+    assert "[Container]" in joined and "Restart=always" in joined
+
+
+def test_j2_fixture_chunks_braces_as_plain_text() -> None:
+    """Jinja braces are just text — no special handling; the ``{{ … }}``
+    line and the ``{% set %}`` sentinel appear verbatim in the chunks."""
+    rel = "templates/deploy.j2"
+    content = (FIXTURE_DOCS / rel).read_text(encoding="utf-8")
+    chunks = chunk_document(content, rel)
+    assert chunks
+    assert all(len(c) <= HARD_MAX_CHARS for c in chunks)
+    joined = "\n".join(chunks)
+    assert "RESE-JINJA-SENTINEL-33dd" in joined
+    assert any("[{{ svc.name }}]" in c for c in chunks)
+
+
+def test_dispatch_still_falls_back_for_unknown_suffix() -> None:
+    content = "alpha\n\nbeta\n"
+    assert chunk_document(content, "x/notes.whatever") == chunk_text(content)
+
+
 # ---------------------------------------------------------------------------
 # Hard cap across every format (aipi ~1024-token request cap)
 # ---------------------------------------------------------------------------
@@ -374,6 +432,8 @@ def test_txt_long_doc_packs_with_overlap() -> None:
         ('{"blob": "' + "z" * 5000 + '"}', "big.json"),
         ("def f():\n" + "    x = 1\n" * 1000, "big.py"),
         ("line of text\n\n" * 800, "big.txt"),
+        ("[Unit]\n" + "key=" + "v" * 5000 + "\n", "big.container"),  # phase 47
+        ("{% for x in y %}" + "{{ x }} " * 400 + "{% endfor %}", "big.j2"),  # phase 47
     ],
 )
 def test_hard_cap_holds_for_every_format(content: str, path: str) -> None:

tests/unit/test_config.py

@@ -8,7 +8,7 @@ import pytest
 from pydantic import ValidationError
 from pydantic_settings import SettingsError
 
-from app.config import Settings
+from app.config import _ALLOWED_IMPORT_EXTENSIONS, Settings  # pyright: ignore[reportPrivateUsage]
 
 
 def _settings(**kwargs: Any) -> Settings:
@@ -42,12 +42,46 @@ def test_defaults_match_locked_decisions(monkeypatch: pytest.MonkeyPatch) -> Non
     # Phase 17: the model's thinking streams by default (kill-switch off).
     assert s.stream_thinking is True
     assert len(s.suggestions) >= 3
-    # A9 (revised): the import scope covers the seven A9 formats.
+    # A9 (revised 2026-08-27): the import scope covers all seventeen
+    # A9 formats (original seven + quadlet family + jinja).
     assert s.import_extension_set == {
-        ".md", ".markdown", ".txt", ".yaml", ".yml", ".json", ".py"
+        ".md", ".markdown", ".txt", ".yaml", ".yml", ".json", ".py",
+        ".container", ".network", ".volume", ".image", ".pod",
+        ".kube", ".swap", ".os", ".endpoint", ".j2",
     }
 
 
+NEW_A9_FORMATS = (
+    "container", "network", "volume", "image", "pod",
+    "kube", "swap", "os", "endpoint", "j2",
+)
+
+
+def test_allowed_import_extensions_contains_all_seventeen_formats() -> None:
+    """The validator's base set is the full A9 set: the original seven
+    plus the ten added 2026-08-27 (quadlet family + ``j2``). The
+    never-widen contract bounds :py:data:`import_extensions` against
+    exactly this set."""
+    assert {
+        "md", "markdown", "txt", "yaml", "yml", "json", "py",
+        *NEW_A9_FORMATS,
+    } == _ALLOWED_IMPORT_EXTENSIONS
+
+
+def test_default_import_extensions_include_the_ten_new_formats() -> None:
+    """A9 revised 2026-08-27 (owner permission): the quadlet family +
+    ``j2`` are imported by default — no env configuration needed — with
+    the original seven first (order is cosmetic, the set is what
+    matters)."""
+    s = _settings()
+    for ext in NEW_A9_FORMATS:
+        assert ext in s.import_extensions
+    assert s.import_extension_set == (
+        {".md", ".markdown", ".txt", ".yaml", ".yml", ".json", ".py"}
+        | {f".{ext}" for ext in NEW_A9_FORMATS}
+    )
+
+
 def test_env_override(monkeypatch) -> None:
     monkeypatch.setenv("BOR_RELEVANCE_THRESHOLD", "0.42")
     monkeypatch.setenv("BOR_LLM_CHAT_MODEL", "juggernaut")
@@ -131,6 +165,23 @@ def test_import_extensions_rejects_empty(monkeypatch) -> None:
         _settings()
 
 
+def test_import_extensions_validator_accepts_new_a9_formats(monkeypatch) -> None:
+    """A9 revised 2026-08-27: the new names are first-class — the
+    never-widen contract now holds against the widened base set, so a
+    narrowing CSV with quadlet/jinja names is accepted."""
+    monkeypatch.setenv("BOR_IMPORT_EXTENSIONS", "md,container,j2")
+    s = _settings()
+    assert s.import_extension_set == {".md", ".container", ".j2"}
+
+
+def test_import_extensions_validator_still_rejects_unknown(monkeypatch) -> None:
+    """Truly unknown extensions still fail loudly at startup (the
+    validator is intact — only the allowed base set widened)."""
+    monkeypatch.setenv("BOR_IMPORT_EXTENSIONS", "md,xyz")
+    with pytest.raises(ValidationError, match="xyz"):
+        _settings()
+
+
 def test_git_sources_default_empty_and_sources_dir_default() -> None:
     """Phase 28: no git sources by default (backwards-compatible with the
     ``--source`` / ``DEFAULT_SOURCES`` fallback); the clone location stays

tests/unit/test_importer.py

@@ -18,6 +18,7 @@ from pathlib import Path
 import pytest
 from sqlalchemy import func, select
 
+from app.config import Settings
 from app.models import Chunk, Document
 from app.rag.importer import (
     EXCLUDED_DIRS,
@@ -29,8 +30,9 @@ from app.rag.importer import (
 from app.rag.llm import EmbeddingError
 from tests.fakes import FakeEmbedder
 
-#: A9 default extension set as dotted suffixes (what the importer passes to
-#: the walker when no override is configured).
+#: The original seven A9 formats as dotted suffixes (pre-phase-47 default
+#: set). The phase-47 walk test uses the live config default
+#: (``Settings().import_extension_set`` — now seventeen formats).
 DEFAULT_EXTS = frozenset({".md", ".markdown", ".txt", ".yaml", ".yml", ".json", ".py"})
 
 
@@ -121,6 +123,70 @@ def test_iter_importable_files_missing_dir_yields_nothing(tmp_path: Path) -> Non
     assert iter_importable_files(tmp_path / "definitely-missing", DEFAULT_EXTS) == []
 
 
+def test_iter_importable_files_walker_picks_up_new_formats_by_default(
+    tmp_path: Path,
+) -> None:
+    """Phase 47 (A9 revised 2026-08-27): the ten new formats — the full
+    quadlet family + j2 — walk under the *default* extension set (no env
+    configuration needed), the original seven still walk (regression), and
+    unknown/hidden-dir/excluded-dir filtering is unchanged for them."""
+    root = tmp_path / "quadproj"
+    (root / ".esphome").mkdir(parents=True)
+    (root / "node_modules").mkdir()
+    files = {
+        # the ten new formats (A9 revised 2026-08-27):
+        "web.container": "# RESE-QUADLET-SENTINEL-77aa\n[Container]\nImage=alpine\n",
+        "lan.network": "[Network]\nDriver=bridge\n",
+        "cache.volume": "[Volume]\nDriver=local\n",
+        "alpine.image": "[Image]\nImages=alpine\n",
+        "app.pod": "[Pod]\nPodName=app\n",
+        "k3s.kube": "apiVersion: v1\nkind: Pod\n",
+        "zram.swap": "[Swap]\nFile=/swapfile\n",
+        "fedora.os": "[OS]\nImage=fedora\n",
+        "edge.endpoint": "[Endpoint]\nPort=8080\n",
+        "deploy.j2": "{% for s in services %}\n[{{ s }}]\n{% endfor %}\n",
+        # the original seven — regression:
+        "note.md": "# n\n",
+        "note.markdown": "# m\n",
+        "note.txt": "t\n",
+        "cfg.yaml": "a: b\n",
+        "cfg.yml": "a: b\n",
+        "data.json": "{}\n",
+        "agent.py": "x = 1\n",
+        # must be skipped — filtering is unchanged for the new formats too:
+        "mystery.xyz": "unknown extension",
+        ".esphome/x.container": "hidden dir (new-format file)",
+        "node_modules/y.container": "excluded dir (new-format file)",
+    }
+    for rel, text in files.items():
+        (root / rel).write_text(text)
+    # The live config default (Settings with no env override) — no
+    # BOR_IMPORT_EXTENSIONS needed for the new formats to walk.
+    exts = Settings(_env_file=None).import_extension_set  # pyright: ignore[reportCallIssue]
+    found = {p.relative_to(root).as_posix() for p in iter_importable_files(root, exts)}
+    assert found == {
+        # all ten new formats:
+        "web.container",
+        "lan.network",
+        "cache.volume",
+        "alpine.image",
+        "app.pod",
+        "k3s.kube",
+        "zram.swap",
+        "fedora.os",
+        "edge.endpoint",
+        "deploy.j2",
+        # …and the original seven:
+        "note.md",
+        "note.markdown",
+        "note.txt",
+        "cfg.yaml",
+        "cfg.yml",
+        "data.json",
+        "agent.py",
+    }
+
+
 def test_iter_importable_files_respects_custom_extension_filter(tmp_path: Path) -> None:
     """A narrower filter (e.g. md only) excludes the other A9 formats."""
     root = tmp_path / "filtered"
@@ -358,6 +424,64 @@ def test_multi_format_import_counts_per_format_and_titles_stem(db, tmp_path: Pat
         _cleanup_source(db, root.name)
 
 
+def test_quadlet_and_j2_files_get_stem_titles_and_per_format_counts(
+    db, tmp_path: Path
+) -> None:
+    """Phase 47: the ten new formats import like any other A9 format — the
+    per-format counts land in the summary, every file yields content
+    chunks, and a leading ``#`` line (a TOML comment in quadlet files, not
+    a heading) never becomes the title: the file stem wins."""
+    root = tmp_path / "quadsrc"
+    (root / "quadlet").mkdir(parents=True)
+    (root / "tpl").mkdir(parents=True)
+    (root / "quadlet" / "web.container").write_text(
+        "# RESE-QUADLET-SENTINEL-77aa\n\n[Container]\nImage=alpine\n"
+    )
+    (root / "quadlet" / "lan.network").write_text("# net\n[Network]\nDriver=bridge\n")
+    (root / "quadlet" / "cache.volume").write_text("[Volume]\nDriver=local\n")
+    (root / "quadlet" / "alpine.image").write_text("[Image]\nImages=alpine\n")
+    (root / "quadlet" / "app.pod").write_text("[Pod]\nPodName=app\n")
+    (root / "quadlet" / "k3s.kube").write_text("apiVersion: v1\nkind: Pod\n")
+    (root / "quadlet" / "zram.swap").write_text("[Swap]\nFile=/swapfile\n")
+    (root / "quadlet" / "fedora.os").write_text("[OS]\nImage=fedora\n")
+    (root / "quadlet" / "edge.endpoint").write_text("[Endpoint]\nPort=8080\n")
+    (root / "tpl" / "deploy.j2").write_text(
+        "{% for s in services %}\n[{{ s }}]\nport = {{ s.port }}\n{% endfor %}\n"
+    )
+    llm = FakeEmbedder()
+    try:
+        summary = asyncio.run(import_sources([root], llm, session=db))
+        assert summary.files == 10 and summary.added == 10
+        assert summary.formats == {
+            "container": 1, "network": 1, "volume": 1, "image": 1, "pod": 1,
+            "kube": 1, "swap": 1, "os": 1, "endpoint": 1, "j2": 1,
+        }
+        docs = {
+            d.path: d
+            for d in db.scalars(select(Document).where(Document.source == root.name)).all()
+        }
+        titles = {p: d.title for p, d in docs.items()}
+        assert titles == {
+            # the ``#`` line is a comment in these formats — stem titles:
+            "quadlet/web.container": "web",
+            "quadlet/lan.network": "lan",
+            "quadlet/cache.volume": "cache",
+            "quadlet/alpine.image": "alpine",
+            "quadlet/app.pod": "app",
+            "quadlet/k3s.kube": "k3s",
+            "quadlet/zram.swap": "zram",
+            "quadlet/fedora.os": "fedora",
+            "quadlet/edge.endpoint": "edge",
+            "tpl/deploy.j2": "deploy",
+        }
+        for doc in docs.values():
+            content = [c for c in doc.chunks if not c.is_summary]
+            assert content  # every new-format file yields content chunks
+            assert all(c.embedding is not None and len(c.embedding) == 768 for c in content)
+    finally:
+        _cleanup_source(db, root.name)
+
+
 # ---------- phase 30: lite-model summaries for non-markdown files ----------