hafez 1.2.0 → 1.4.0

package/dist/knowledge-index.d.ts

@@ -1,3 +1,25 @@
+/** One indexed document, as the SQLite index can hand it over. index.md needs
+ * nothing the index does not already hold, so a regeneration reads rows
+ * instead of re-reading and re-parsing every file in the vault. Declared here
+ * (not in db.ts) to keep the module edge pointing one way: db.ts already
+ * imports from this file. */
+export interface VaultIndexRow {
+    slug: string;
+    kind: 'entity' | 'knowledge';
+    name: string;
+    type: string | null;
+    status: string | null;
+    confidence: string | null;
+    description: string | null;
+    domain: string[];
+    body: string;
+}
 /** Ensure every generated local-only artifact is covered by .git/info/exclude. */
 export declare function ensureLocalExclude(vaultPath: string): void;
-export declare function generateVaultIndex(vaultPath: string): void;
+/** Regenerate the vault-root index.md.
+ *
+ * `rows` is the SQLite index's view of the vault — every mutation refreshes
+ * those rows anyway, so passing them avoids a second full-vault read for the
+ * same content. Omitting them (standalone/one-off use) falls back to reading
+ * the files directly. */
+export declare function generateVaultIndex(vaultPath: string, rows?: VaultIndexRow[]): void;

package/dist/knowledge-index.js

@@ -1,11 +1,29 @@
 // src/knowledge-index.ts
 // Generates the vault-root index.md covering entities (grouped by status) and
 // knowledge (grouped by domain) — local-only, auto-regenerated on every entity/knowledge write.
-import { readdirSync, readFileSync, writeFileSync, existsSync, statSync, mkdirSync } from 'fs';
-import { join, basename } from 'path';
-import { parseFilePath } from './vault.js';
-import { deriveSummary } from './sections.js';
+import { readFileSync, writeFileSync, existsSync, statSync, mkdirSync } from 'fs';
+import { join, basename, resolve } from 'path';
+import { parseFilePath, scanVaultDir, kindDir } from './vault.js';
+import { deriveSummary } from './document.js';
 import { ENTITY_STATUSES } from './contracts.js';
+/** Index rows in the shape the renderer below expects — the same
+ * {slug, fm, body} triple scanParsed produces from disk. */
+function fromRows(rows, kind) {
+    return rows
+        .filter(r => r.kind === kind)
+        .map(r => ({
+        slug: r.slug,
+        body: r.body,
+        fm: {
+            name: r.name,
+            type: r.type ?? undefined,
+            status: r.status ?? undefined,
+            confidence: r.confidence ?? undefined,
+            description: r.description ?? undefined,
+            domain: r.domain,
+        },
+    }));
+}
 function truncate(s) {
     return s.length > 100 ? s.slice(0, 97) + '...' : s;
 }
@@ -19,9 +37,11 @@ function formatEntry(item) {
 /** Parse every .md directly in dir (non-recursive — auto-excludes archive/), skipping malformed files. */
 function scanParsed(dir) {
     const docs = [];
-    for (const file of readdirSync(dir).filter(f => f.endsWith('.md'))) {
+    for (const file of scanVaultDir(dir)) {
         try {
-            const { frontmatter: fm, body } = parseFilePath(join(dir, file));
+            const parsed = parseFilePath(file);
+            const fm = parsed.frontmatter;
+            const body = parsed.body;
             if (!fm.name)
                 continue;
             docs.push({ slug: basename(file, '.md'), fm, body });
@@ -36,11 +56,42 @@ function scanParsed(dir) {
  * show up in the user's `git status`, but forcing a tracked .gitignore entry
  * would dirty their vault — so they go into .git/info/exclude instead. */
 const LOCAL_EXCLUDES = ['/index.md', '/.hafez.db', '/.hafez.db-shm', '/.hafez.db-wal'];
+/** Locate the git directory that owns `info/exclude` for this vault.
+ * `.git` is a directory in a normal clone, but a *gitfile* (`gitdir: <path>`)
+ * in a linked worktree or submodule — treating that file as "not a repo" is
+ * what let index.md and .hafez.db pollute `git status` there. Git reads
+ * `info/exclude` from the COMMON dir, so for a linked worktree the pointed-at
+ * per-worktree dir is one more hop from the answer: its `commondir` file names
+ * the shared dir (writing the exclude in the per-worktree dir has no effect).
+ * Returns null when the vault is not a git repo at all. */
+function resolveExcludeGitDir(vaultPath) {
+    const dotGit = join(vaultPath, '.git');
+    if (!existsSync(dotGit))
+        return null;
+    const stat = statSync(dotGit);
+    if (stat.isDirectory())
+        return dotGit;
+    if (!stat.isFile())
+        return null;
+    const pointer = /^gitdir:\s*(.+)$/m.exec(readFileSync(dotGit, 'utf-8'));
+    if (!pointer)
+        return null;
+    const gitDir = resolve(vaultPath, pointer[1].trim());
+    if (!existsSync(gitDir))
+        return null;
+    const commonDirFile = join(gitDir, 'commondir');
+    if (existsSync(commonDirFile)) {
+        const commonDir = resolve(gitDir, readFileSync(commonDirFile, 'utf-8').trim());
+        if (existsSync(commonDir))
+            return commonDir;
+    }
+    return gitDir;
+}
 /** Ensure every generated local-only artifact is covered by .git/info/exclude. */
 export function ensureLocalExclude(vaultPath) {
     try {
-        const gitDir = join(vaultPath, '.git');
-        if (!existsSync(gitDir) || !statSync(gitDir).isDirectory())
+        const gitDir = resolveExcludeGitDir(vaultPath);
+        if (!gitDir)
             return;
         const excludePath = join(gitDir, 'info', 'exclude');
         const existing = existsSync(excludePath) ? readFileSync(excludePath, 'utf-8') : '';
@@ -54,17 +105,24 @@ export function ensureLocalExclude(vaultPath) {
     }
     catch { /* best effort — never fail a vault write over ignore hygiene */ }
 }
-export function generateVaultIndex(vaultPath) {
-    const entitiesDir = join(vaultPath, 'entities');
-    const knowledgeDir = join(vaultPath, 'knowledge');
+/** Regenerate the vault-root index.md.
+ *
+ * `rows` is the SQLite index's view of the vault — every mutation refreshes
+ * those rows anyway, so passing them avoids a second full-vault read for the
+ * same content. Omitting them (standalone/one-off use) falls back to reading
+ * the files directly. */
+export function generateVaultIndex(vaultPath, rows) {
+    const entitiesDir = join(vaultPath, kindDir('entity'));
+    const knowledgeDir = join(vaultPath, kindDir('knowledge'));
     const hasEntities = existsSync(entitiesDir);
     const hasKnowledge = existsSync(knowledgeDir);
     if (!hasEntities && !hasKnowledge)
         return;
+    const docsFor = (kind, dir) => rows ? fromRows(rows, kind) : scanParsed(dir);
     const lines = ['# Vault Index', '', '> Auto-generated by hafez. Do not edit manually.', ''];
     if (hasEntities) {
         const byStatus = new Map();
-        for (const { slug, fm, body } of scanParsed(entitiesDir)) {
+        for (const { slug, fm, body } of docsFor('entity', entitiesDir)) {
             const status = fm.status ?? 'active';
             const list = byStatus.get(status) ?? [];
             list.push({ slug, name: fm.name, summary: truncate(deriveSummary('entity', fm, body)), suffix: fm.type ?? 'entity' });
@@ -90,7 +148,7 @@ export function generateVaultIndex(vaultPath) {
     }
     if (hasKnowledge) {
         const entries = [];
-        for (const { slug, fm, body } of scanParsed(knowledgeDir)) {
+        for (const { slug, fm, body } of docsFor('knowledge', knowledgeDir)) {
             entries.push({
                 slug,
                 name: fm.name,

package/dist/merge.d.ts

@@ -1 +1 @@
-export declare function mergeVaultContent(remote: string, local: string): string;
+export declare function mergeVaultContent(remote: string, local: string, kind: 'entity' | 'knowledge' | 'session'): string;

package/dist/merge.js

@@ -1,13 +1,13 @@
 // src/merge.ts
-import { parseContent, serializeFile } from './vault.js';
-import { parseSessionLogHeading } from './parser.js';
+import { parseContent, serializeFile, ARRAY_FIELDS } from './vault.js';
+import { parseSessionLogHeading, splitLogEntries, documentFor } from './document.js';
+import { APPEND_ONLY_SECTIONS } from './contracts.js';
 // Fields that are ISO date strings — latest date wins
 const DATE_FIELDS = ['last-touched', 'last-reinforced', 'created'];
 // Fields that are numeric counters — max wins
 const COUNT_FIELDS = ['reinforcement-count', 'staleness-days'];
-// Fields that are always arrays — union with dedup
-const ARRAY_FIELDS_UNCAPPED = ['tags', 'domain', 'related'];
-export function mergeVaultContent(remote, local) {
+// Array fields (vault.ARRAY_FIELDS — the same set parsing coerces) union with dedup
+export function mergeVaultContent(remote, local, kind) {
     const r = parseContent(remote);
     const l = parseContent(local);
     // Scalar policy: the side with the newer last-touched wins; local on tie.
@@ -15,7 +15,18 @@ export function mergeVaultContent(remote, local) {
     // array/date/count frontmatter fields are always unioned regardless.
     const localWins = String(l.frontmatter?.['last-touched'] ?? '') >= String(r.frontmatter?.['last-touched'] ?? '');
     const fm = mergeFrontmatter(r.frontmatter, l.frontmatter, localWins);
-    const body = mergeBody(r.body, l.body, localWins);
+    // The Document binds by kind — the same binding every write path uses (see
+    // DocContext), so a section this merge preserves stays structural for the
+    // next update too. The two sides come from divergent histories whose type
+    // may differ (a promote race leaves one side 'capture' and the other
+    // 'project'); the kind-level set keeps every same-kind section structural,
+    // while cross-KIND headings (a session-only ## Decisions quoted in an
+    // entity Brief) are not boundaries. Known residual: a same-kind heading
+    // quoted at line start in one side's section splits at that false boundary
+    // and can survive the merge as its own section — the fix is fence/quote
+    // awareness in Document's splitter, not a narrower binding here.
+    const doc = documentFor({ kind });
+    const body = mergeBody(doc, r.body, l.body, localWins);
     return serializeFile(fm, body);
 }
 function mergeFrontmatter(remote, local, localWins) {
@@ -38,7 +49,7 @@ function mergeFrontmatter(remote, local, localWins) {
             merged[key] = r;
     }
     // Array fields: union
-    for (const key of ARRAY_FIELDS_UNCAPPED) {
+    for (const key of ARRAY_FIELDS) {
         merged[key] = unionArrays(remote[key], local[key]);
         if (merged[key].length === 0)
             delete merged[key];
@@ -46,46 +57,34 @@ function mergeFrontmatter(remote, local, localWins) {
     return merged;
 }
 function unionArrays(a, b) {
-    // Local (b) items first so they survive cap truncation
+    // Local (b) items first: nothing is truncated, but the local side's order is
+    // the one the user last saw, so it stays the order they get back.
     const arrA = Array.isArray(a) ? a : a ? [a] : [];
     const arrB = Array.isArray(b) ? b : b ? [b] : [];
     return [...new Set([...arrB, ...arrA])];
 }
-function splitSections(body) {
-    const parts = body.split(/\n(?=## )/g);
-    const sections = [];
-    let preamble = '';
-    for (const part of parts) {
-        if (part.startsWith('## ')) {
-            const nlIdx = part.indexOf('\n');
-            const heading = nlIdx === -1 ? part : part.slice(0, nlIdx);
-            const content = nlIdx === -1 ? '' : part.slice(nlIdx + 1);
-            sections.push({ heading: heading.trim(), content: content.trim() });
-        }
-        else {
-            preamble = part.trim();
-        }
-    }
-    return { preamble, sections };
-}
-function mergeBody(remoteBody, localBody, localWins) {
+// --- Body merge ---
+function mergeBody(doc, remoteBody, localBody, localWins) {
     if (remoteBody === localBody)
         return localBody;
-    const remote = splitSections(remoteBody);
-    const local = splitSections(localBody);
+    // Structural split (see document.ts): sections are atomic — a user ##
+    // heading inside a Brief or a session-log entry body stays with its
+    // section instead of being split out and merged under its own policy.
+    const remote = doc.splitStructural(remoteBody);
+    const local = doc.splitStructural(localBody);
     // Build merged sections starting from local (local section order is canonical)
     const localHeadings = new Set(local.sections.map(s => s.heading));
     const mergedSections = [];
     for (const ls of local.sections) {
         const rs = remote.sections.find(s => s.heading === ls.heading);
-        if (ls.heading === '## Session Log' && rs) {
+        if (ls.heading === 'Session Log' && rs) {
             mergedSections.push({ heading: ls.heading, content: mergeSessionLogs(rs.content, ls.content) });
         }
-        else if (ls.heading === '## Next Actions' && rs) {
+        else if (ls.heading === 'Next Actions' && rs) {
             mergedSections.push({ heading: ls.heading, content: mergeNextActions(rs.content, ls.content) });
         }
-        else if ((ls.heading === '## Evidence' || ls.heading === '## Sources') && rs) {
-            // Append-only sections: union lines from both sides, dedup identical
+        else if (APPEND_ONLY_SECTIONS.has(ls.heading) && rs) {
+            // Append-only sections (contracts.ts): union lines from both sides, dedup identical
             mergedSections.push({ heading: ls.heading, content: mergeAppendOnlyLines(rs.content, ls.content) });
         }
         else if (rs && !localWins) {
@@ -102,11 +101,17 @@ function mergeBody(remoteBody, localBody, localWins) {
             mergedSections.push(rs);
         }
     }
-    // Reassemble
-    const preamble = localWins
-        ? (local.preamble || remote.preamble)
-        : (remote.preamble || local.preamble);
-    const parts = [preamble, ...mergedSections.map(s => `${s.heading}\n\n${s.content}`)].filter(Boolean);
+    // Reassemble. A preamble that is itself a session-log entry stream is
+    // append-only content living outside any heading — the archive-log files
+    // under entities/archive/ are exactly this shape. Merging those by the
+    // scalar wins policy drops one machine's archived entries wholesale, so
+    // union them by the same entry policy the Session Log section uses.
+    const preamble = isLogEntryStream(remote.preamble) && isLogEntryStream(local.preamble)
+        ? mergeSessionLogs(remote.preamble, local.preamble)
+        : localWins
+            ? (local.preamble || remote.preamble)
+            : (remote.preamble || local.preamble);
+    const parts = [preamble, ...mergedSections.map(s => `## ${s.heading}\n\n${s.content}`)].filter(Boolean);
     return parts.join('\n\n');
 }
 /** Union merge for append-only free-text sections: local lines first, then
@@ -123,6 +128,12 @@ function mergeAppendOnlyLines(remoteContent, localContent) {
         return localContent;
     return [...localLines, ...remoteOnly].join('\n');
 }
+/** True when a block is nothing but session-log entries — it starts with an
+ *  entry heading, so splitLogEntries drops no leading prose. */
+function isLogEntryStream(text) {
+    const first = text.trim().split('\n')[0];
+    return first !== '' && parseSessionLogHeading(first) !== null;
+}
 function mergeSessionLogs(remoteContent, localContent) {
     const remoteEntries = parseLogEntries(remoteContent);
     const localEntries = parseLogEntries(localContent);
@@ -140,64 +151,73 @@ function mergeSessionLogs(remoteContent, localContent) {
     return merged.map(e => e.raw).join('\n\n');
 }
 function parseLogEntries(content) {
-    const entries = [];
-    const blocks = content.split(/\n(?=### \d{4}-\d{2}-\d{2})/);
-    for (const block of blocks) {
-        const trimmed = block.trim();
-        if (!trimmed)
-            continue;
-        const firstLine = trimmed.split('\n')[0];
-        const parsed = parseSessionLogHeading(firstLine);
-        if (parsed) {
-            entries.push({
-                key: `${parsed.date}|${parsed.agent}|${parsed.type}`,
-                date: parsed.date,
-                raw: trimmed,
-            });
-        }
-    }
-    return entries;
+    // Document owns entry block splitting; the identity key and dedup/sort
+    // policy stay here — merge semantics, not document structure.
+    //
+    // Identity is the entry's whole content. Date+agent+type is not an identity:
+    // two machines each running a digest on the same day produce two entries with
+    // the same heading and different bodies, and keying on the heading collapses
+    // them to one — the other machine's session history is gone. Entries the two
+    // sides share came from the same commit, so they are byte-identical and still
+    // dedup.
+    return splitLogEntries(content).map(raw => {
+        const parsed = parseSessionLogHeading(raw.split('\n')[0]);
+        return { key: raw, date: parsed.date, raw };
+    });
 }
 function mergeNextActions(remoteContent, localContent) {
-    const remoteItems = parseActionItems(remoteContent);
-    const localItems = parseActionItems(localContent);
-    // Build merged set: start with local items
-    const seen = new Set();
-    const merged = [];
-    // Add all local items
-    for (const item of localItems) {
-        seen.add(item.text);
-        merged.push(item);
-    }
-    // Add remote items not in local
-    for (const item of remoteItems) {
-        if (!seen.has(item.text)) {
-            seen.add(item.text);
-            merged.push(item);
-        }
-        else {
-            // If remote has it checked but local has it unchecked, upgrade to checked
-            const existing = merged.find(m => m.text === item.text);
-            if (existing && item.checked && !existing.checked) {
-                existing.checked = true;
-            }
+    const remote = parseActionItems(remoteContent);
+    const local = parseActionItems(localContent);
+    // Start with local items; index by action text for the remote pass
+    const merged = local.items.map(i => ({ ...i, notes: [...i.notes] }));
+    const byText = new Map(merged.map(i => [i.text, i]));
+    for (const item of remote.items) {
+        const existing = byText.get(item.text);
+        if (!existing) {
+            merged.push({ ...item, notes: [...item.notes] });
+            byText.set(item.text, merged[merged.length - 1]);
+            continue;
         }
+        // Checked on either side means done
+        if (item.checked)
+            existing.checked = true;
+        // Union the item's own notes/sub-bullets — they are authored content, not
+        // re-derivable from the checkbox line
+        existing.notes.push(...unionLines(item.notes, existing.notes));
     }
-    return merged.map(i => `- [${i.checked ? 'x' : ' '}] ${i.text}`).join('\n');
+    const lines = [...local.preamble, ...unionLines(remote.preamble, local.preamble)];
+    for (const item of merged) {
+        lines.push(`- [${item.checked ? 'x' : ' '}] ${item.text}`);
+        lines.push(...item.notes);
+    }
+    return lines.join('\n').replace(/\n+$/, '');
+}
+/** Lines of `from` not already present in `into` (blank lines only from `into`). */
+function unionLines(from, into) {
+    const seen = new Set(into.map(l => l.trim()).filter(Boolean));
+    return from.filter(l => l.trim() && !seen.has(l.trim()));
 }
+/**
+ * Split a Next Actions section into its leading non-item lines and its items,
+ * each item carrying the lines that follow it (indented sub-bullets, notes)
+ * until the next checkbox. Non-checkbox lines are authored content — parsing
+ * checkbox lines alone and re-rendering from them deletes everything else.
+ * `- [X]` is the same as `- [x]`: a completed action, not an unknown line.
+ */
 function parseActionItems(content) {
+    const preamble = [];
     const items = [];
     for (const line of content.split('\n')) {
-        const unchecked = line.match(/^- \[ \] (.+)$/);
-        if (unchecked) {
-            items.push({ checked: false, text: unchecked[1] });
-            continue;
+        const match = line.match(/^- \[([ xX])\] (.+)$/);
+        if (match) {
+            items.push({ checked: match[1].toLowerCase() === 'x', text: match[2], notes: [] });
         }
-        const checked = line.match(/^- \[x\] (.+)$/);
-        if (checked) {
-            items.push({ checked: true, text: checked[1] });
-            continue;
+        else if (items.length === 0) {
+            preamble.push(line);
+        }
+        else {
+            items[items.length - 1].notes.push(line);
         }
     }
-    return items;
+    return { preamble, items };
 }

package/dist/schema.js

@@ -1,5 +1,5 @@
 // src/schema.ts
-import { ENTITY_TYPES, ENTITY_STATUSES, CONFIDENCE_LEVELS, SESSION_LOG_TYPES, VALID_SUBTYPES, } from './contracts.js';
+import { ENTITY_TYPES, ENTITY_STATUSES, CONFIDENCE_LEVELS, SESSION_LOG_TYPES, VALID_SUBTYPES, PLAN_STATUSES, } from './contracts.js';
 export function validateEntityFrontmatter(fm) {
     const errors = [];
     if (!fm.name || typeof fm.name !== 'string')
@@ -35,9 +35,9 @@ export function validateKnowledgeSubtype(fm) {
     if (fm.subtype && !VALID_SUBTYPES.includes(fm.subtype)) {
         errors.push(`invalid subtype: ${fm.subtype} (expected: ${VALID_SUBTYPES.join(', ')})`);
     }
-    // Plan-specific: status must be active or done
-    if (fm.subtype === 'plan' && fm.status && !['active', 'done'].includes(fm.status)) {
-        errors.push(`invalid plan status: ${fm.status} (expected: active, done)`);
+    // Plan-specific: status must be one of the plan lifecycle statuses
+    if (fm.subtype === 'plan' && fm.status && !PLAN_STATUSES.includes(fm.status)) {
+        errors.push(`invalid plan status: ${fm.status} (expected: ${PLAN_STATUSES.join(', ')})`);
     }
     return errors;
 }

package/dist/templates.d.ts

@@ -6,3 +6,9 @@ export declare function bodyTemplate(type: EntityType, fields?: {
 export declare function knowledgeBodyTemplate(subtype?: KnowledgeSubtype, fields?: {
     synthesis?: string;
 }): string;
+/** Session bodies. Sessions have no TypeContract, but their headings are
+ * structural for Document splitting — so the list lives in contracts with
+ * every other section set, and this renders it. */
+export declare function sessionBodyTemplate(fields?: {
+    synthesis?: string;
+}): string;

package/dist/templates.js

@@ -1,39 +1,39 @@
-import { SUBTYPE_SECTIONS } from './contracts.js';
-const ITEM_TEMPLATES = {
-    capture: ['## Notes'],
-    entity: ['## Context', '## Session Log'],
-    project: ['## Purpose', '## Goals', '## Session Log'],
-};
-export function bodyTemplate(type, fields) {
-    const sections = ITEM_TEMPLATES[type];
-    if (!sections)
-        throw new Error(`Unknown item type: ${type}`);
+import { SUBTYPE_SECTIONS, DEFAULT_KNOWLEDGE_SUBTYPE, SESSION_SECTIONS, ENTITY_TYPES, getContract } from './contracts.js';
+/** Render a body from a section list, injecting each field's text under the
+ * section that field writes into (contracts.CREATE_FIELD_SECTIONS names the
+ * pairs; a field whose section this template lacks is rejected upstream by
+ * `unreachableFields`, so an unplaced value never reaches here). */
+function render(sections, content) {
     const lines = [];
     for (const section of sections) {
-        lines.push(section);
-        if (section === '## Purpose' && fields?.purpose) {
-            lines.push('', fields.purpose);
-        }
-        if (section === '## Notes' && fields?.notes) {
-            lines.push('', fields.notes);
-        }
+        lines.push(`## ${section}`);
+        const text = content[section];
+        if (text)
+            lines.push('', text);
         lines.push('');
     }
     return lines.join('\n');
 }
+export function bodyTemplate(type, fields) {
+    // The template IS the contract's default sections — the Document module
+    // derives its structural set from the same place, so the two can't drift.
+    if (!ENTITY_TYPES.includes(type))
+        throw new Error(`Unknown item type: ${type}`);
+    return render(getContract(type).defaultSections, { Purpose: fields?.purpose, Notes: fields?.notes });
+}
 export function knowledgeBodyTemplate(subtype, fields) {
     if (subtype === 'session') {
         throw new Error("subtype 'session' is no longer supported for knowledge notes. " +
             "Use batch kind: 'session' instead. See knowledge-v2 migration.");
     }
-    const sections = SUBTYPE_SECTIONS[subtype ?? 'insight'];
-    const lines = [];
-    for (const section of sections) {
-        lines.push(`## ${section}`);
-        if ((section === 'Synthesis' || section === 'Summary') && fields?.synthesis) {
-            lines.push('', fields.synthesis);
-        }
-        lines.push('');
-    }
-    return lines.join('\n');
+    // 'Summary' was a second injection target here until sessions stopped being
+    // a knowledge subtype; no SUBTYPE_SECTIONS entry has carried it since — the
+    // session body is its own template below.
+    return render(SUBTYPE_SECTIONS[subtype ?? DEFAULT_KNOWLEDGE_SUBTYPE], { Synthesis: fields?.synthesis });
+}
+/** Session bodies. Sessions have no TypeContract, but their headings are
+ * structural for Document splitting — so the list lives in contracts with
+ * every other section set, and this renders it. */
+export function sessionBodyTemplate(fields) {
+    return render([...SESSION_SECTIONS], { Summary: fields?.synthesis });
 }