hafez 1.1.0 → 1.3.0

package/dist/knowledge-index.js

@@ -1,10 +1,10 @@
 // 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 { readFileSync, writeFileSync, existsSync, statSync, mkdirSync } from 'fs';
 import { join, basename } from 'path';
-import { parseFilePath } from './vault.js';
-import { deriveSummary } from './sections.js';
+import { parseFilePath, scanVaultDir, kindDir } from './vault.js';
+import { deriveSummary } from './document.js';
 import { ENTITY_STATUSES } from './contracts.js';
 function truncate(s) {
     return s.length > 100 ? s.slice(0, 97) + '...' : s;
@@ -19,9 +19,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 });
@@ -55,8 +57,8 @@ 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');
+    const entitiesDir = join(vaultPath, kindDir('entity'));
+    const knowledgeDir = join(vaultPath, kindDir('knowledge'));
     const hasEntities = existsSync(entitiesDir);
     const hasKnowledge = existsSync(knowledgeDir);
     if (!hasEntities && !hasKnowledge)

package/dist/merge.js

@@ -1,6 +1,7 @@
 // src/merge.ts
 import { parseContent, serializeFile } from './vault.js';
-import { parseSessionLogHeading } from './parser.js';
+import { parseSessionLogHeading, splitStructural } 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
@@ -51,41 +52,28 @@ function unionArrays(a, b) {
     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 };
-}
+// --- Body merge ---
 function mergeBody(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 = splitStructural(remoteBody);
+    const local = 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) {
@@ -106,7 +94,7 @@ function mergeBody(remoteBody, localBody, localWins) {
     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);
+    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

package/dist/query.d.ts

@@ -9,7 +9,7 @@ export declare function queryChildren(index: HafezIndex, parentSlug: string): {
     total: number;
 };
 export declare function queryRelatedTo(index: HafezIndex, slug: string, relation?: string): {
-    items: (QueryResult | KnowledgeQueryResult)[];
+    items: UnifiedResult[];
     total: number;
 };
 export declare function queryKnowledge(index: HafezIndex, opts?: KnowledgeQueryOpts): {

package/dist/query.js

@@ -89,7 +89,9 @@ export function queryRelatedTo(index, slug, relation) {
     index.syncIfStale();
     const { items, total } = index.queryItems({ relatedTo: slug, relation });
     return {
-        items: items.map(i => i.kind === 'entity' ? toQueryResult(i.slug, i) : toKnowledgeResult(i.slug, i)),
+        items: items.map(i => i.kind === 'entity'
+            ? { ...toQueryResult(i.slug, i), kind: 'entity' }
+            : { ...toKnowledgeResult(i.slug, i), kind: 'knowledge' }),
         total,
     };
 }

package/dist/types.d.ts

@@ -61,7 +61,30 @@ export interface KnowledgeFrontmatter {
     status?: 'active' | 'done';
     'last-touched'?: string;
 }
+export interface SessionFrontmatter {
+    name: string;
+    created: string;
+    'session-date'?: string;
+    related?: string[];
+}
+/** What parseFilePath returns: the kind comes from Layout (the file's
+ * directory), so consumers switch on `kind` instead of sniffing keys. */
+export type ParsedVaultFile = {
+    kind: 'entity';
+    frontmatter: EntityFrontmatter;
+    body: string;
+} | {
+    kind: 'knowledge';
+    frontmatter: KnowledgeFrontmatter;
+    body: string;
+} | {
+    kind: 'session';
+    frontmatter: SessionFrontmatter;
+    body: string;
+};
 export interface ParsedFile<T = EntityFrontmatter | KnowledgeFrontmatter> {
+    /** Populated by read(): which side of the vault the slug resolved to. */
+    kind?: 'entity' | 'knowledge';
     frontmatter: T;
     body: string;
 }
@@ -112,6 +135,7 @@ export interface CreateEntityFields {
     tags?: string[];
     brief?: string;
     add_action?: string;
+    add_actions?: string[];
 }
 export interface CreateKnowledgeFields {
     subtype?: KnowledgeSubtype;
@@ -259,6 +283,18 @@ export type BatchOperation = {
     slug: string;
     target: 'entity' | 'project' | 'knowledge';
 };
+export interface BatchOpValidation {
+    index: number;
+    op: string;
+    slug: string;
+    created?: boolean;
+    errors: string[];
+    warning?: string;
+}
+export interface BatchValidationReport {
+    valid: boolean;
+    operations: BatchOpValidation[];
+}
 export type HafezErrorCode = 'NOT_FOUND' | 'SLUG_EXISTS' | 'VALIDATION_FAILED' | 'GIT_PUSH_FAILED' | 'GIT_COMMIT_FAILED' | 'VAULT_LOCKED';
 export declare class HafezError extends Error {
     code: HafezErrorCode;
@@ -268,10 +304,34 @@ export declare class HafezError extends Error {
 export interface GitConfig {
     push?: boolean;
 }
+/**
+ * The persistence seam (see CONTEXT.md: Journal) — everything core needs
+ * from the history layer behind vault mutations. Git satisfies it in
+ * production (src/git.ts); tests may inject an in-memory adapter.
+ */
+export interface Journal {
+    /** Persist one logical change: stage written+deleted paths (vault-relative)
+     * and commit under message. Must clean up its own partial state (e.g.
+     * staged files) before rethrowing on a commit-stage failure; a push-stage
+     * failure surfaces as GIT_PUSH_FAILED with the commit kept. */
+    commit(written: string[], deleted: string[], message: string): Promise<void>;
+    /** Bidirectional sync with the remote, if any. */
+    sync(): Promise<{
+        pulled: boolean;
+        pushed: boolean;
+        remote: boolean;
+    }>;
+    /** History-derived changelog for entities/ and knowledge/ since a date. */
+    changelog(since: string): Promise<ChangelogEntry[]>;
+    /** Newest history timestamp per vault file (modified = any change, added = creation). */
+    fileTimes(mode: 'modified' | 'added'): Promise<Map<string, string>>;
+}
 export interface HafezConfig {
     vaultPath: string;
     readOnly?: boolean;
     git?: GitConfig;
+    /** Override the persistence layer. Defaults to the git adapter. */
+    persistence?: Journal;
     onWrite?: (slug: string, operation: string) => void;
 }
 export interface Hafez {
@@ -294,6 +354,7 @@ export interface Hafez {
     unlink(slug: string, target: string, relation: LinkRelation): Promise<void>;
     promote(slug: string, target: 'entity' | 'project' | 'knowledge'): Promise<string>;
     batch(operations: BatchOperation[]): Promise<BatchResult[]>;
+    validateBatch(operations: BatchOperation[]): Promise<BatchValidationReport>;
     sync(): Promise<{
         pulled: boolean;
         pushed: boolean;
@@ -304,7 +365,7 @@ export interface Hafez {
         total: number;
     }>;
     related_to(slug: string, relation?: string): Promise<{
-        items: (QueryResult | KnowledgeQueryResult)[];
+        items: UnifiedResult[];
         total: number;
     }>;
     query_knowledge(opts?: KnowledgeQueryOpts): Promise<{

package/dist/vault.d.ts

@@ -1,10 +1,38 @@
+import type { ParsedVaultFile } from './types.js';
 export declare function slugify(name: string): string;
-export declare function resolveFilePath(vaultPath: string, slug: string, kind: 'entity' | 'knowledge'): string;
-export declare function slugExists(vaultPath: string, slug: string): boolean;
-export declare function parseFilePath(path: string): {
-    frontmatter: Record<string, any>;
-    body: string;
-};
+export type VaultKind = 'entity' | 'knowledge' | 'session';
+/** Kinds that live in the SQLite read index (sessions are files-and-git only). */
+export declare const INDEXED_KINDS: ReadonlyArray<'entity' | 'knowledge'>;
+/** Vault directory for a kind, relative to the vault root. */
+export declare function kindDir(kind: VaultKind): string;
+/** A vault content file: anything a sync/merge must treat semantically. */
+export declare const VAULT_FILE_RE: RegExp;
+/** True for vault-relative paths whose kind lives in the read index. */
+export declare function isIndexedRelPath(relPath: string): boolean;
+/** History pathspecs covering the indexed dirs (changelog, file times). */
+export declare const INDEXED_DIR_PATHSPECS: ReadonlyArray<string>;
+/** Classify a vault-relative path into an indexed kind + slug; null outside
+ * the indexed dirs (sessions, non-vault files). Nested paths keep their
+ * historical shape: entities/archive/x-log.md → entity 'archive/x-log'. */
+export declare function classifyIndexedRelPath(relPath: string): {
+    kind: 'entity' | 'knowledge';
+    slug: string;
+} | null;
+/** All .md files directly in dir — non-recursive (archive/ subdirs are
+ * invisible by construction) and dotfile-free: dotfile slugs are rejected by
+ * resolveFilePath, so listing them would surface files no operation can reach. */
+export declare function scanVaultDir(dirPath: string): string[];
+/** Where an entity's overflow session-log entries are archived. */
+export declare function archiveLogPath(vaultPath: string, slug: string): string;
+export declare function resolveFilePath(vaultPath: string, slug: string, kind: VaultKind): string;
+export declare function kindFromPath(filePath: string): 'entity' | 'knowledge';
+/** Full-kind path classification (kindFromPath only distinguishes the
+ * indexed kinds — sessions default to knowledge there for compatibility).
+ * Session files live directly in sessions/, so only the immediate parent
+ * counts — matching anywhere in the path misclassifies every file of a
+ * vault that happens to live under a directory named "sessions". */
+export declare function vaultKindFromPath(filePath: string): VaultKind;
+export declare function parseFilePath(path: string): ParsedVaultFile;
 export declare function parseContent(content: string): {
     frontmatter: Record<string, any>;
     body: string;

package/dist/vault.js

@@ -1,7 +1,7 @@
 // src/vault.ts
 import matter from 'gray-matter';
 import yaml from 'js-yaml';
-import { readFileSync, existsSync } from 'fs';
+import { readFileSync, readdirSync } from 'fs';
 import { join } from 'path';
 import { HafezError } from './types.js';
 // Prevent gray-matter from auto-coercing YAML date strings into JS Date objects
@@ -16,6 +16,48 @@ export function slugify(name) {
         .replace(/^-|-$/g, '')
         .replace(/-{2,}/g, '-');
 }
+const KIND_DIRS = { entity: 'entities', knowledge: 'knowledge', session: 'sessions' };
+/** Kinds that live in the SQLite read index (sessions are files-and-git only). */
+export const INDEXED_KINDS = ['entity', 'knowledge'];
+/** Vault directory for a kind, relative to the vault root. */
+export function kindDir(kind) {
+    return KIND_DIRS[kind];
+}
+/** A vault content file: anything a sync/merge must treat semantically. */
+export const VAULT_FILE_RE = new RegExp(`^(?:${Object.values(KIND_DIRS).join('|')})/.+\\.md$`);
+/** True for vault-relative paths whose kind lives in the read index. */
+export function isIndexedRelPath(relPath) {
+    return INDEXED_KINDS.some(k => relPath.startsWith(`${KIND_DIRS[k]}/`));
+}
+/** History pathspecs covering the indexed dirs (changelog, file times). */
+export const INDEXED_DIR_PATHSPECS = INDEXED_KINDS.map(k => `${KIND_DIRS[k]}/`);
+/** Classify a vault-relative path into an indexed kind + slug; null outside
+ * the indexed dirs (sessions, non-vault files). Nested paths keep their
+ * historical shape: entities/archive/x-log.md → entity 'archive/x-log'. */
+export function classifyIndexedRelPath(relPath) {
+    for (const kind of INDEXED_KINDS) {
+        const prefix = `${KIND_DIRS[kind]}/`;
+        if (relPath.startsWith(prefix)) {
+            return { kind, slug: relPath.replace(prefix, '').replace('.md', '') };
+        }
+    }
+    return null;
+}
+/** All .md files directly in dir — non-recursive (archive/ subdirs are
+ * invisible by construction) and dotfile-free: dotfile slugs are rejected by
+ * resolveFilePath, so listing them would surface files no operation can reach. */
+export function scanVaultDir(dirPath) {
+    try {
+        return readdirSync(dirPath).filter(f => f.endsWith('.md') && !f.startsWith('.')).map(f => join(dirPath, f));
+    }
+    catch {
+        return [];
+    }
+}
+/** Where an entity's overflow session-log entries are archived. */
+export function archiveLogPath(vaultPath, slug) {
+    return join(vaultPath, KIND_DIRS.entity, 'archive', `${slug}-log.md`);
+}
 // Slugs are path components: anything with separators (or a leading dot, or a
 // Windows drive colon) could escape the vault — "../../outside/secret" reads,
 // writes, and deletes files anywhere on disk. Block only those; spaces and
@@ -25,12 +67,14 @@ export function resolveFilePath(vaultPath, slug, kind) {
     if (!slug || slug.startsWith('.') || /[/\\:\0]/.test(slug)) {
         throw new HafezError('VALIDATION_FAILED', `Invalid slug: '${slug}'`);
     }
-    const dir = kind === 'entity' ? 'entities' : 'knowledge';
-    return join(vaultPath, dir, `${slug}.md`);
+    return join(vaultPath, KIND_DIRS[kind], `${slug}.md`);
 }
-export function slugExists(vaultPath, slug) {
-    return existsSync(resolveFilePath(vaultPath, slug, 'entity'))
-        || existsSync(resolveFilePath(vaultPath, slug, 'knowledge'));
+// Separator-agnostic: OS paths use '/' or '\' depending on platform, and a
+// POSIX-only check silently classifies every entity as knowledge on Windows
+// (all updates then fail on kind rules). Exported pure so win32 paths are
+// unit-testable from any platform.
+export function kindFromPath(filePath) {
+    return /[/\\]entities[/\\]/.test(filePath) ? 'entity' : 'knowledge';
 }
 // Fields that must always be arrays when present (may be scalar in hand-edited YAML)
 const ARRAY_FIELDS = ['related', 'tags', 'domain'];
@@ -42,10 +86,30 @@ function normalizeFrontmatter(fm) {
     }
     return fm;
 }
+/** Full-kind path classification (kindFromPath only distinguishes the
+ * indexed kinds — sessions default to knowledge there for compatibility).
+ * Session files live directly in sessions/, so only the immediate parent
+ * counts — matching anywhere in the path misclassifies every file of a
+ * vault that happens to live under a directory named "sessions". */
+export function vaultKindFromPath(filePath) {
+    if (new RegExp(`[/\\\\]${KIND_DIRS.session}[/\\\\][^/\\\\]+$`).test(filePath))
+        return 'session';
+    return kindFromPath(filePath);
+}
 export function parseFilePath(path) {
     const content = readFileSync(path, 'utf-8');
     const { data, content: body } = matter(content, MATTER_OPTIONS);
-    return { frontmatter: normalizeFrontmatter(data), body: body.trim() };
+    const fm = normalizeFrontmatter(data);
+    const trimmed = body.trim();
+    const kind = vaultKindFromPath(path);
+    // Types over classes (C7): the frontmatter is normalized once here and
+    // asserted to the kind's shape — validation of required fields stays with
+    // schema.ts and the index builder, which tolerate malformed files.
+    if (kind === 'entity')
+        return { kind, frontmatter: fm, body: trimmed };
+    if (kind === 'session')
+        return { kind, frontmatter: fm, body: trimmed };
+    return { kind: 'knowledge', frontmatter: fm, body: trimmed };
 }
 export function parseContent(content) {
     const { data, content: body } = matter(content, MATTER_OPTIONS);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hafez",
-  "version": "1.1.0",
+  "version": "1.3.0",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -17,7 +17,7 @@
     "LICENSE"
   ],
   "scripts": {
-    "build": "rm -rf dist && tsc",
+    "build": "rm -rf dist && tsc && chmod +x dist/cli.js",
     "install:local": "chmod +x \"$(pwd)/dist/cli.js\" && mkdir -p ~/.local/bin && ln -sf \"$(pwd)/dist/cli.js\" ~/.local/bin/hafez && rm -f ~/.claude/skills/hafez/SKILL.md && mkdir -p ~/.claude/skills/hafez && cp \"$(pwd)/skill/SKILL.md\" ~/.claude/skills/hafez/SKILL.md",
     "pretest": "npm run build",
     "test": "vitest run",
@@ -34,15 +34,15 @@
   },
   "devDependencies": {
     "@types/better-sqlite3": "^7.6.13",
-    "@types/proper-lockfile": "^4.1.4",
     "@types/js-yaml": "^4.0.9",
     "@types/node": "^25.4.0",
+    "@types/proper-lockfile": "^4.1.4",
     "tsx": "^4.21.0",
     "typescript": "^5.9.3",
     "vitest": "^4.0.18"
   },
   "license": "MIT",
-  "description": "Agent-native personal knowledge vault: markdown + YAML frontmatter, SQLite FTS5 search, git-backed",
+  "description": "A knowledge and project vault shared between you and your agents — plain markdown + git, schema-enforced writes, FTS5 search, operated by agents through a CLI",
   "keywords": [
     "knowledge-base",
     "knowledge-vault",

package/skill/SKILL.md

@@ -41,7 +41,7 @@ Quick reference for common operations:
 | Add evidence to knowledge | `hafez update <slug> --add-evidence "text"` |
 | Add source to knowledge | `hafez update <slug> --add-source "url"` |
 | Export OKF bundle | `hafez export --okf [--out <dir>]` (re-export overwrites, never deletes) |
-| Digest session → batch | `echo '{...}' \| hafez digest \| hafez batch` |
+| Digest session → batch | `echo '{...}' \| hafez digest \| hafez batch` (no pipes? `--file` on both) |
 
 Note: `--insight` is an alias for `--synthesis`.
 
@@ -143,6 +143,10 @@ echo '[
 
 Batch output includes created slugs: `Batch complete: 3 operations (created: new-thing, insight)`
 
+On shells that can't pipe stdin to native executables (Windows PowerShell 5.1), write the payload to a file and use `hafez batch --file payload.json` — same JSON, same behavior. (`cmd /c "hafez batch < payload.json"` also works.)
+
+**Slug contract.** Slugs derive deterministically from names: lowercase, non-alphanumeric runs become single `-` (`"Auth Refactor!"` → `auth-refactor`). Batch executes sequentially, so later ops can reference the slugs of earlier creates in the same payload — create-then-link works in one batch. Collisions hard-error, so a wrong prediction can't touch the wrong document; `hafez batch --dry-run` reports the derived slug for every create op if you want to verify first.
+
 For a single operation, individual commands are fine — they auto-sync.
 
 ## Session End — Digest
@@ -163,6 +167,8 @@ echo '{
 }' | hafez digest | hafez batch
 ```
 
+On shells that can't pipe (PowerShell 5.1), use files instead — digest stays inspectable in the middle: `hafez digest --file summary.json > ops.json`, then `hafez batch --file ops.json`.
+
 Digest adds a session log entry to each touched entity and creates a session note linking them all. Authoritative field docs: `hafez schema digest`.
 
 Digest itself is pure — it only prints batch JSON; `hafez batch` is what writes. If you are unsure the slugs exist, run `hafez digest` alone first: unknown slugs warn on stderr (they are omitted from the output). Fix `entities_touched`, regenerate, and pipe to batch **once** — re-running the full pipe after a successful batch creates a duplicate session note.

package/dist/parser.d.ts

@@ -1,18 +0,0 @@
-import type { SessionLogEntry, SessionLogType } from './types.js';
-export declare function parseSessionLogHeading(line: string): {
-    date: string;
-    agent: string;
-    type: SessionLogType;
-} | null;
-export declare function formatSessionLogEntry(entry: SessionLogEntry): string;
-export declare function countSessionLogEntries(body: string): number;
-export declare function parseSessionLog(body: string): Array<{
-    date: string;
-    agent: string;
-    type: SessionLogType;
-    summary: string;
-}>;
-export declare function extractOldestSessionLogEntry(body: string): {
-    entry: string;
-    remaining: string;
-} | null;

package/dist/parser.js

@@ -1,68 +0,0 @@
-import { findNextStructuralHeading } from './sections.js';
-const HEADING_RE = /^### (\d{4}-\d{2}-\d{2}) (?:—|--) (.+?)(?:\s+\[(\w+)\])?$/;
-export function parseSessionLogHeading(line) {
-    const match = line.match(HEADING_RE);
-    if (!match)
-        return null;
-    return {
-        date: match[1],
-        agent: match[2],
-        type: match[3] || 'progress'
-    };
-}
-export function formatSessionLogEntry(entry) {
-    const today = new Date().toISOString().slice(0, 10);
-    const lines = [`### ${today} — ${entry.agent} [${entry.type}]`, `Summary: ${entry.summary}`];
-    if (entry.body)
-        lines.push(entry.body);
-    return lines.join('\n');
-}
-export function countSessionLogEntries(body) {
-    return (body.match(/^### \d{4}-\d{2}-\d{2} (?:—|--)/gm) || []).length;
-}
-export function parseSessionLog(body) {
-    // Inline section extraction to avoid circular import with sections.ts
-    const idx = body.indexOf('## Session Log');
-    if (idx === -1)
-        return [];
-    const afterPos = idx + '## Session Log'.length;
-    // Find end: next structural ## heading or end of string
-    const nextH = findNextStructuralHeading(body, afterPos);
-    const sectionContent = nextH !== -1 ? body.slice(afterPos, nextH) : body.slice(afterPos);
-    const entries = [];
-    const lines = sectionContent.split('\n');
-    let current = null;
-    let summaryLine = null;
-    for (const line of lines) {
-        const heading = parseSessionLogHeading(line);
-        if (heading) {
-            if (current && summaryLine) {
-                entries.push({ ...current, summary: summaryLine });
-            }
-            current = heading;
-            summaryLine = null;
-        }
-        else if (current && !summaryLine && line.startsWith('Summary: ')) {
-            summaryLine = line.slice('Summary: '.length);
-        }
-    }
-    if (current && summaryLine) {
-        entries.push({ ...current, summary: summaryLine });
-    }
-    return entries;
-}
-export function extractOldestSessionLogEntry(body) {
-    const sectionStart = body.indexOf('## Session Log');
-    if (sectionStart === -1)
-        return null;
-    const afterHeader = body.slice(sectionStart + '## Session Log'.length);
-    const entryStarts = [...afterHeader.matchAll(/^### \d{4}-\d{2}-\d{2} (?:—|--)/gm)];
-    if (entryStarts.length < 2)
-        return null;
-    // Entries are newest-first in the file, so the oldest is the last match
-    const lastIdx = entryStarts.length - 1;
-    const oldestStart = entryStarts[lastIdx].index;
-    const entry = afterHeader.slice(oldestStart).trim();
-    const remaining = body.slice(0, sectionStart + '## Session Log'.length) + afterHeader.slice(0, oldestStart);
-    return { entry, remaining };
-}

package/dist/sections.d.ts

@@ -1,54 +0,0 @@
-/**
- * Known structural section headings in Hafez entities and knowledge notes.
- * Derived from contracts.ts (defaultSections + optionalSections) plus
- * auto-generated sections not tracked in contracts (Related, Summary).
- * Only these are treated as section boundaries. Any other `## ` heading
- * inside section content (e.g. in a brief or session log) is preserved as-is.
- */
-export declare const STRUCTURAL_SECTIONS: Set<string>;
-/**
- * Find the next structural `## Heading` boundary after a given position.
- * Skips `## ` headings that are not known structural sections (content headings).
- * Returns the index of the `\n` before the `## `, or -1 if no structural heading found.
- */
-export declare function findNextStructuralHeading(body: string, from: number): number;
-/**
- * Find a ## Heading section and its content.
- * Returns { start, end, content } or null if not found.
- * Matches heading exactly (e.g. "## Brief" won't match "## Briefing").
- * Only treats known structural headings as section boundaries -- content
- * inside a section may contain arbitrary `## ` headings without corruption.
- */
-export declare function findSection(body: string, heading: string): {
-    start: number;
-    end: number;
-    content: string;
-} | null;
-export declare function getBrief(body: string): string | null;
-export declare function setBrief(body: string, content: string): string;
-export declare function removeBrief(body: string): string;
-export declare function getNextActions(body: string): string[];
-export declare function addNextAction(body: string, action: string): string;
-export declare function completeNextAction(body: string, query: string): {
-    matched: string;
-    body: string;
-};
-export declare function removeNextAction(body: string, query: string): {
-    matched: string;
-    body: string;
-};
-export declare function clearNextActions(body: string): string;
-export declare function firstNonEmptyLine(s: string | null | undefined): string;
-/**
- * One-line summary for a doc: frontmatter description first, then the first
- * non-empty line of the kind's primary section (entity: Brief; knowledge:
- * Synthesis, falling back to Goal for plans; session: Summary).
- * Shared by the vault index and the OKF export so the two surfaces agree.
- */
-export declare function deriveSummary(kind: 'entity' | 'knowledge' | 'session', fm: Record<string, any>, body: string): string;
-/** Matches [[slug]] or [[slug|display text]], capturing slug in group 1. Non-global — wrap with `new RegExp(WIKI_LINK_RE.source, 'g')` for iteration. */
-export declare const WIKI_LINK_RE: RegExp;
-export declare function syncRelatedSection(body: string, frontmatter: {
-    parent?: string;
-    related?: string[];
-}): string;