peaks-loop 4.0.34 → 4.0.35

package/dist/services/memory/project-memory-service/index/ranking.d.ts

@@ -1,6 +1,14 @@
 import type { MemoryIndex } from '../types.js';
 export declare function readMemoryFileMtime(filePath: string): string;
 export declare function readStoredMemoryNames(memoryDir: string): Set<string>;
-export declare function generateMemoryIndexFile(projectRoot: string, memoryDir: string, indexPath: string): void;
+/**
+ * Build the hot/warm index object from the current `.peaks/memory/` contents
+ * without touching disk. Pure read + in-memory assembly; `generateMemoryIndexFile`
+ * serializes the result. Exposed so `peaks memory reindex` can reuse the exact
+ * same entry construction for its counts + `MEMORY.md` regeneration instead of
+ * duplicating it.
+ */
+export declare function buildMemoryIndex(projectRoot: string): MemoryIndex;
+export declare function generateMemoryIndexFile(projectRoot: string, memoryDir: string, indexPath: string, prebuilt?: MemoryIndex): void;
 export declare function readExistingIndex(indexPath: string): MemoryIndex | null;
 export declare function readMemoryIndex(projectRoot: string): MemoryIndex | null;

package/dist/services/memory/project-memory-service/index/ranking.js

@@ -4,9 +4,9 @@
 // The memory index is the always-available summary of every memory in
 // `.peaks/memory/`. This module owns its write path:
 //
-//   - `HOT_KINDS` — the kinds whose full body is kept in the index
-//     (`feedback`, `decision`, `rule`, `convention`, `module`, `lesson`).
-//     Anything not in `HOT_KINDS` lands in `warm` with the same shape.
+//   - `HOT_KINDS` — the kinds whose full body is kept in the index,
+//     derived from `MEMORY_KIND_TIER` in `../types.ts`. Anything not in
+//     `HOT_KINDS` lands in `warm` with the same shape.
 //   - `readMemoryFileMtime` / `readStoredMemoryNames` — small stat /
 //     filename helpers used by the index generator and by the slug-
 //     collision idempotency check.
@@ -22,12 +22,13 @@
 // ---------------------------------------------------------------------------
 import { closeSync, constants, existsSync, openSync, readFileSync, statSync, writeFileSync } from 'node:fs';
 import { basename, join } from 'node:path';
+import { HOT_MEMORY_KINDS, MEMORY_KIND_TIER, PROJECT_MEMORY_KINDS } from '../types.js';
 import { parseStoredMemoryFile } from '../parsers/frontmatter.js';
 import { summarizeMemoryBody } from '../parsers/markdown-pure.js';
 import { assertSafeProjectMemoryDir, normalizeRoot } from '../store/paths.js';
 import { ensureMemoryBootstrap, listMarkdownFiles, readProjectMemories } from './search.js';
-// Hot kinds: full body kept in index for always-available context
-const HOT_KINDS = new Set(['feedback', 'decision', 'rule', 'convention', 'module', 'lesson']);
+// Hot kinds: full body kept in index for always-available context.
+const HOT_KINDS = new Set(HOT_MEMORY_KINDS);
 export function readMemoryFileMtime(filePath) {
     try {
         return statSync(filePath).mtime.toISOString().slice(0, 10);
@@ -60,14 +61,22 @@ export function readStoredMemoryNames(memoryDir) {
     }
     return names;
 }
-export function generateMemoryIndexFile(projectRoot, memoryDir, indexPath) {
+/**
+ * Build the hot/warm index object from the current `.peaks/memory/` contents
+ * without touching disk. Pure read + in-memory assembly; `generateMemoryIndexFile`
+ * serializes the result. Exposed so `peaks memory reindex` can reuse the exact
+ * same entry construction for its counts + `MEMORY.md` regeneration instead of
+ * duplicating it.
+ */
+export function buildMemoryIndex(projectRoot) {
     const memories = readProjectMemories(projectRoot);
-    const hot = {
-        feedback: [], decision: [], rule: [], convention: [], module: [], lesson: []
-    };
-    const warm = {
-        project: [], reference: []
-    };
+    // Full-shape hot/warm buckets, derived from the canonical tier map so a
+    // newly accepted kind cannot be silently absent from the index.
+    const hot = {};
+    const warm = {};
+    for (const kind of PROJECT_MEMORY_KINDS) {
+        (MEMORY_KIND_TIER[kind] === 'hot' ? hot : warm)[kind] = [];
+    }
     for (const memory of memories.memories) {
         const entry = {
             name: memory.name,
@@ -89,12 +98,15 @@ export function generateMemoryIndexFile(projectRoot, memoryDir, indexPath) {
         if (arr)
             arr.sort((a, b) => a.name.localeCompare(b.name));
     }
-    const index = {
+    return {
         version: 1,
         updatedAt: new Date().toISOString(),
         hot: hot,
         warm: warm
     };
+}
+export function generateMemoryIndexFile(projectRoot, memoryDir, indexPath, prebuilt) {
+    const index = prebuilt ?? buildMemoryIndex(projectRoot);
     const fd = openSync(indexPath, constants.O_WRONLY | constants.O_CREAT | constants.O_TRUNC, 0o644);
     try {
         writeFileSync(fd, JSON.stringify(index, null, 2), 'utf8');

package/dist/services/memory/project-memory-service/index/reindex.d.ts

@@ -0,0 +1,75 @@
+import type { MemoryIndex, ProjectMemoryKind } from '../types.js';
+/** Marker line that owns `MEMORY.md`. Anything above it is machine output. */
+export declare const MEMORY_MD_BANNER = "<!-- generated by `peaks memory reindex` \u2014 do not edit -->";
+/** `MEMORY.md` is the generated index itself — never a memory source. */
+export declare const MEMORY_MD_FILENAME = "MEMORY.md";
+/**
+ * Deterministic section order for the generated `MEMORY.md`: hot kinds
+ * first (mirrors `HOT_KINDS` in `ranking.ts`), warm kinds last. Derived
+ * from the insertion order of `MEMORY_KIND_TIER` so the vocabulary has
+ * exactly one definition.
+ */
+export declare const KIND_ORDER: readonly ProjectMemoryKind[];
+export interface ReindexUnclassified {
+    name: string;
+    filePath: string;
+    /** The first raw type/kind value found in the frontmatter (null when absent). */
+    rawKind: string | null;
+    reason: string;
+}
+export interface ReindexOrphanEntry {
+    name: string;
+    kind: string;
+    /** The `sourcePath` recorded in the previous index that no longer exists on disk. */
+    sourcePath: string;
+}
+/**
+ * Two or more different files resolve to the same memory name (after the
+ * `name:` → `title:` → filename-stem fallback chain). Reported, never
+ * resolved by overwriting: both files keep their own index entry, and the
+ * collision is surfaced so a human/LLM can rename one of them.
+ */
+export interface ReindexNameConflict {
+    name: string;
+    /** Every file that resolves to this name, sorted. Always length >= 2. */
+    filePaths: string[];
+}
+export interface MemoryReindexReport {
+    apply: boolean;
+    projectRoot: string;
+    memoryDir: string;
+    indexPath: string;
+    memoryMdPath: string;
+    /** Markdown files scanned (excludes the generated `MEMORY.md`). */
+    scannedFiles: number;
+    /** Files represented in the rebuilt index. */
+    indexed: number;
+    indexedByKind: Record<string, number>;
+    /** Files on disk with no resolvable kind — reported, never invented. */
+    unclassified: ReindexUnclassified[];
+    /** Distinct files that resolve to the same index name — reported, never overwritten. */
+    nameConflicts: ReindexNameConflict[];
+    /** Previous index entries whose `sourcePath` no longer exists (error-class drift). */
+    orphanIndex: ReindexOrphanEntry[];
+    /** Files on disk that the rebuilt index does not contain (warn-class drift). */
+    orphanDisk: string[];
+    memoryMd: {
+        path: string;
+        regenerated: boolean;
+    };
+    writtenFiles: string[];
+}
+export interface MemoryReindexOptions {
+    projectRoot: string;
+    apply?: boolean;
+}
+/**
+ * Render the human/LLM-facing `MEMORY.md` from a built index. Deterministic:
+ * kinds in `KIND_ORDER`, entries sorted by name, no timestamps.
+ */
+export declare function renderMemoryMarkdown(index: MemoryIndex, memoryDir: string): string;
+/**
+ * Rebuild `.peaks/memory/index.json` from disk and (on `--apply`) regenerate
+ * `MEMORY.md`. Always returns the drift report, even on a dry run.
+ */
+export declare function executeMemoryReindex(options: MemoryReindexOptions): MemoryReindexReport;

package/dist/services/memory/project-memory-service/index/reindex.js

@@ -0,0 +1,207 @@
+// ---------------------------------------------------------------------------
+// `peaks memory reindex` — full rebuild of `.peaks/memory/index.json` from
+// the markdown files on disk, plus regeneration of the human/LLM-facing
+// `MEMORY.md` index and a drift report.
+//
+// Why this exists (slice 2026-09-09-memory-system-overhaul, B):
+//   - `peaks memory extract` only ever wrote memories FROM artifacts; it
+//     never re-scanned files already on disk, and there was no rebuild
+//     command. 78 top-level files were absent from index.json.
+//   - The index's `kind` came only from the nested `metadata.type` field;
+//     files using a top-level `kind:` were silently dropped.
+//   - `index.json` (machine) and `MEMORY.md` (human/LLM) were two
+//     unsynchronised indexes with nothing keeping them in sync.
+//
+// Contract:
+//   - read-only on the memory markdown files (never rewrites a memory body)
+//   - deterministic ordering: kinds in `KIND_ORDER`, entries by name
+//   - nothing is silently dropped: every file that could not be classified
+//     is reported with its path + raw value
+//   - `MEMORY.md` is regenerated with a "do not edit" banner (the previous
+//     hand-maintained index had drifted to 116 lines against 231 index
+//     entries; a derived view is the only way to keep them in sync)
+// ---------------------------------------------------------------------------
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { basename, join, relative } from 'node:path';
+import { MEMORY_KIND_TIER } from '../types.js';
+import { parseMemoryFrontmatter, parseStoredMemoryFile } from '../parsers/frontmatter.js';
+import { assertSafeProjectMemoryDir, normalizeRoot } from '../store/paths.js';
+import { buildMemoryIndex, generateMemoryIndexFile, readExistingIndex } from './ranking.js';
+import { listMarkdownFiles, readProjectMemories } from './search.js';
+/** Marker line that owns `MEMORY.md`. Anything above it is machine output. */
+export const MEMORY_MD_BANNER = '<!-- generated by `peaks memory reindex` — do not edit -->';
+/** `MEMORY.md` is the generated index itself — never a memory source. */
+export const MEMORY_MD_FILENAME = 'MEMORY.md';
+/**
+ * Deterministic section order for the generated `MEMORY.md`: hot kinds
+ * first (mirrors `HOT_KINDS` in `ranking.ts`), warm kinds last. Derived
+ * from the insertion order of `MEMORY_KIND_TIER` so the vocabulary has
+ * exactly one definition.
+ */
+export const KIND_ORDER = Object.keys(MEMORY_KIND_TIER);
+function emptyKindCounts() {
+    const counts = {};
+    for (const kind of KIND_ORDER)
+        counts[kind] = 0;
+    return counts;
+}
+function readPreviousIndexEntries(indexPath) {
+    // `readExistingIndex` is fail-soft (null on missing / unparsable / wrong
+    // version), which is exactly what a drift report wants: a corrupt index
+    // simply yields no orphan-index findings instead of throwing.
+    const previous = readExistingIndex(indexPath);
+    if (previous === null)
+        return [];
+    return [
+        ...Object.values(previous.hot ?? {}).flat(),
+        ...Object.values(previous.warm ?? {}).flat(),
+        ...(previous.cold ?? [])
+    ];
+}
+function collectUnclassified(diskFiles) {
+    const unclassified = [];
+    for (const filePath of diskFiles) {
+        let parsed;
+        try {
+            parsed = parseMemoryFrontmatter(readFileSync(filePath, 'utf8'));
+        }
+        catch {
+            // Unreadable file: still report it rather than dropping it silently.
+            unclassified.push({ name: basename(filePath, '.md'), filePath, rawKind: null, reason: 'file could not be read' });
+            continue;
+        }
+        if (parsed.kind.kind !== null)
+            continue;
+        const rawKind = parsed.kind.rawKind;
+        unclassified.push({
+            name: parsed.name ?? basename(filePath, '.md'),
+            filePath,
+            rawKind,
+            reason: rawKind === null
+                ? 'no metadata.type / kind / type field in frontmatter'
+                : `unrecognized kind value: ${rawKind}`
+        });
+    }
+    return unclassified.sort((left, right) => left.filePath.localeCompare(right.filePath));
+}
+/**
+ * Detect files that resolve to the same memory name. Only files the read
+ * path actually indexes participate (a file rejected for a missing kind is
+ * not an index entry and cannot collide with one).
+ *
+ * Deterministic: names sorted, each `filePaths` sorted. Never resolves the
+ * collision itself — the caller reports it; both files keep their entries.
+ */
+function collectNameConflicts(diskFiles) {
+    const byName = new Map();
+    for (const filePath of diskFiles) {
+        let parsed;
+        try {
+            parsed = parseStoredMemoryFile(readFileSync(filePath, 'utf8'), filePath);
+        }
+        catch {
+            continue; // unreadable files are reported by collectUnclassified
+        }
+        if (parsed === null)
+            continue;
+        const bucket = byName.get(parsed.name);
+        if (bucket === undefined)
+            byName.set(parsed.name, [filePath]);
+        else if (!bucket.includes(filePath))
+            bucket.push(filePath);
+    }
+    return [...byName.entries()]
+        .filter(([, filePaths]) => filePaths.length > 1)
+        .map(([name, filePaths]) => ({ name, filePaths: [...filePaths].sort((left, right) => left.localeCompare(right)) }))
+        .sort((left, right) => left.name.localeCompare(right.name));
+}
+/**
+ * Render the human/LLM-facing `MEMORY.md` from a built index. Deterministic:
+ * kinds in `KIND_ORDER`, entries sorted by name, no timestamps.
+ */
+export function renderMemoryMarkdown(index, memoryDir) {
+    const lines = [
+        MEMORY_MD_BANNER,
+        '',
+        '# Peaks Memory Index',
+        '',
+        '> Auto-generated by `peaks memory reindex`. Do not edit by hand — the next',
+        '> reindex overwrites this file. Source of truth: `.peaks/memory/*.md`',
+        '> (bodies) and `.peaks/memory/index.json` (machine index).',
+        ''
+    ];
+    for (const kind of KIND_ORDER) {
+        const entries = [...(index.hot[kind] ?? []), ...(index.warm[kind] ?? [])]
+            .sort((left, right) => left.name.localeCompare(right.name));
+        if (entries.length === 0)
+            continue;
+        lines.push(`## ${kind} (${entries.length})`, '');
+        for (const entry of entries) {
+            const link = relative(memoryDir, entry.sourcePath).replaceAll('\\', '/');
+            lines.push(`- [${entry.name}](${link}) — ${entry.description}`);
+        }
+        lines.push('');
+    }
+    return lines.join('\n').replace(/\n+$/, '\n');
+}
+/**
+ * Rebuild `.peaks/memory/index.json` from disk and (on `--apply`) regenerate
+ * `MEMORY.md`. Always returns the drift report, even on a dry run.
+ */
+export function executeMemoryReindex(options) {
+    const projectRoot = normalizeRoot(options.projectRoot);
+    const apply = options.apply ?? false;
+    const memoryDir = assertSafeProjectMemoryDir(projectRoot);
+    const indexPath = join(memoryDir, 'index.json');
+    const memoryMdPath = join(memoryDir, MEMORY_MD_FILENAME);
+    const diskFiles = listMarkdownFiles(memoryDir).filter((filePath) => basename(filePath) !== MEMORY_MD_FILENAME);
+    const orphanIndex = readPreviousIndexEntries(indexPath)
+        .filter((entry) => typeof entry.sourcePath !== 'string' || entry.sourcePath.length === 0 || !existsSync(entry.sourcePath))
+        .map((entry) => ({ name: entry.name, kind: entry.kind, sourcePath: entry.sourcePath }))
+        .sort((left, right) => left.name.localeCompare(right.name));
+    const unclassified = collectUnclassified(diskFiles);
+    const nameConflicts = collectNameConflicts(diskFiles);
+    // Build once; reuse for the write, the counts, and MEMORY.md so all three
+    // views are guaranteed identical.
+    const index = buildMemoryIndex(projectRoot);
+    const writtenFiles = [];
+    if (apply) {
+        generateMemoryIndexFile(projectRoot, memoryDir, indexPath, index);
+        writtenFiles.push(indexPath);
+    }
+    // Authoritative post-rebuild view: read the memories back through the same
+    // read path every consumer uses, so `orphanDisk` is measured against the
+    // real index rather than against this module's own scan.
+    const memories = readProjectMemories(projectRoot);
+    const indexedFilePaths = new Set(memories.memories.map((memory) => memory.filePath));
+    const orphanDisk = diskFiles.filter((filePath) => !indexedFilePaths.has(filePath));
+    const indexedByKind = emptyKindCounts();
+    for (const memory of memories.memories) {
+        indexedByKind[memory.kind] = (indexedByKind[memory.kind] ?? 0) + 1;
+    }
+    let memoryMdRegenerated = false;
+    if (apply) {
+        const markdown = renderMemoryMarkdown(index, memoryDir);
+        // Plain write (not O_EXCL): MEMORY.md is a derived view and is expected
+        // to be overwritten on every reindex.
+        writeFileSync(memoryMdPath, markdown, 'utf8');
+        writtenFiles.push(memoryMdPath);
+        memoryMdRegenerated = true;
+    }
+    return {
+        apply,
+        projectRoot,
+        memoryDir,
+        indexPath,
+        memoryMdPath,
+        scannedFiles: diskFiles.length,
+        indexed: memories.memories.length,
+        indexedByKind,
+        unclassified,
+        nameConflicts,
+        orphanIndex,
+        orphanDisk,
+        memoryMd: { path: memoryMdPath, regenerated: memoryMdRegenerated },
+        writtenFiles
+    };
+}

package/dist/services/memory/project-memory-service/index/search.js

@@ -21,6 +21,7 @@
 // ---------------------------------------------------------------------------
 import { existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from 'node:fs';
 import { basename, join } from 'node:path';
+import { MEMORY_KIND_TIER, PROJECT_MEMORY_KINDS } from '../types.js';
 import { parseStoredMemoryFile } from '../parsers/frontmatter.js';
 import { assertSafeProjectMemoryDir, normalizeRoot } from '../store/paths.js';
 export function listMarkdownFiles(dirPath, options = {}) {
@@ -52,38 +53,27 @@ export function listMarkdownFiles(dirPath, options = {}) {
     return files.sort((left, right) => left.localeCompare(right));
 }
 export function emptyByKind() {
-    return {
-        project: [],
-        rule: [],
-        decision: [],
-        reference: [],
-        feedback: [],
-        convention: [],
-        module: [],
-        lesson: []
-    };
+    const byKind = {};
+    for (const kind of PROJECT_MEMORY_KINDS)
+        byKind[kind] = [];
+    return byKind;
 }
 export function emptyIndex() {
     // Cast through unknown: we *intend* the two halves to together cover the
     // union `ProjectMemoryKind`, but TS does not know that. The `MemoryIndex`
     // type's `hot` / `warm` fields together cover the union; we split the
-    // construction so the JSON output mirrors the hot/warm layout the reader
-    // expects.
+    // construction from the canonical tier map so the JSON output mirrors the
+    // hot/warm layout the reader expects.
+    const hot = {};
+    const warm = {};
+    for (const kind of PROJECT_MEMORY_KINDS) {
+        (MEMORY_KIND_TIER[kind] === 'hot' ? hot : warm)[kind] = [];
+    }
     return {
         version: 1,
         updatedAt: new Date().toISOString(),
-        hot: {
-            feedback: [],
-            decision: [],
-            rule: [],
-            convention: [],
-            module: [],
-            lesson: []
-        },
-        warm: {
-            project: [],
-            reference: []
-        }
+        hot: hot,
+        warm: warm
     };
 }
 export function renderEmptyIndex() {

package/dist/services/memory/project-memory-service/index.d.ts

@@ -1,9 +1,13 @@
-export type { BackupPlanOptions, ExtractedProjectMemory, ExtractPlanOptions, ExtractSessionMemoriesOptions, ExtractSessionMemoriesResult, MemoryIndex, MemoryIndexEntry, ProjectMemoryBackupPlan, ProjectMemoryBackupResult, ProjectMemoryBackupSummary, ProjectMemoryCopy, ProjectMemoryExtractPlan, ProjectMemoryExtractResult, ProjectMemoryExtractSummary, ProjectMemoryKind, ProjectMemoryReadResult, ProjectMemoryShowResult, ProjectMemoryWrite, StoredProjectMemory } from './types.js';
+export type { BackupPlanOptions, ExtractedProjectMemory, MemoryKindTier, ExtractPlanOptions, ExtractSessionMemoriesOptions, ExtractSessionMemoriesResult, MemoryIndex, MemoryIndexEntry, ProjectMemoryBackupPlan, ProjectMemoryBackupResult, ProjectMemoryBackupSummary, ProjectMemoryCopy, ProjectMemoryExtractPlan, ProjectMemoryExtractResult, ProjectMemoryExtractSummary, ProjectMemoryKind, ProjectMemoryReadResult, ProjectMemoryShowResult, ProjectMemoryWrite, StoredProjectMemory } from './types.js';
 export { VALID_PROJECT_MEMORY_KINDS } from './parsers/frontmatter.js';
+export { HOT_MEMORY_KINDS, MEMORY_KIND_TIER, PROJECT_MEMORY_KINDS, WARM_MEMORY_KINDS } from './types.js';
 export { summarizeBackupResult, summarizeExtractResult, summarizeMemoryBody, extractStableProjectMemories, END_MARKER, START_MARKER } from './parsers/markdown-pure.js';
-export { parseBlock, parseStoredMemoryFile, renderMemoryFile, slugify } from './parsers/frontmatter.js';
+export { parseBlock, parseMemoryFrontmatter, parseStoredMemoryFile, renderMemoryFile, resolveMemoryKind, resolveMemoryName, slugify } from './parsers/frontmatter.js';
+export type { MemoryKindResolution, MemoryKindSource, MemoryNameResolution, MemoryNameSource, ParsedMemoryFrontmatter } from './parsers/frontmatter.js';
 export { assertInsideProject, assertSafeProjectMemoryDir, assertSafeSessionDir, normalizeRealRoot, normalizeRoot, realPathOrThrow, resolveProjectPath, safeRealpath } from './store/paths.js';
 export { assertSafeMemory, assertSafeMemoryFileContent, hasSensitiveMemoryContent, writeNewFile } from './store/atomic-write.js';
 export { ensureMemoryBootstrap, emptyByKind, emptyIndex, listMarkdownFiles, readProjectMemories, readProjectMemoryBody } from './index/search.js';
-export { generateMemoryIndexFile, readExistingIndex, readMemoryFileMtime, readMemoryIndex, readStoredMemoryNames } from './index/ranking.js';
+export { buildMemoryIndex, generateMemoryIndexFile, readExistingIndex, readMemoryFileMtime, readMemoryIndex, readStoredMemoryNames } from './index/ranking.js';
+export { executeMemoryReindex, renderMemoryMarkdown, KIND_ORDER, MEMORY_MD_BANNER, MEMORY_MD_FILENAME } from './index/reindex.js';
+export type { MemoryReindexOptions, MemoryReindexReport, ReindexNameConflict, ReindexOrphanEntry, ReindexUnclassified } from './index/reindex.js';
 export { createProjectMemoryBackupPlan, createProjectMemoryExtractPlan, executeProjectMemoryBackup, executeProjectMemoryExtract, extractSessionMemories, summarizeProjectMemoryBackupResult, summarizeProjectMemoryExtractResult } from './index/kind-dispatch.js';

package/dist/services/memory/project-memory-service/index.js

@@ -11,14 +11,18 @@
 // `./types.ts` and are re-exported here.
 // ---------------------------------------------------------------------------
 export { VALID_PROJECT_MEMORY_KINDS } from './parsers/frontmatter.js';
+// Canonical kind vocabulary + hot/warm tier map (slice E)
+export { HOT_MEMORY_KINDS, MEMORY_KIND_TIER, PROJECT_MEMORY_KINDS, WARM_MEMORY_KINDS } from './types.js';
 // Pure markdown helpers
 export { summarizeBackupResult, summarizeExtractResult, summarizeMemoryBody, extractStableProjectMemories, END_MARKER, START_MARKER } from './parsers/markdown-pure.js';
 // Frontmatter parser + renderer
-export { parseBlock, parseStoredMemoryFile, renderMemoryFile, slugify } from './parsers/frontmatter.js';
+export { parseBlock, parseMemoryFrontmatter, parseStoredMemoryFile, renderMemoryFile, resolveMemoryKind, resolveMemoryName, slugify } from './parsers/frontmatter.js';
 // Store: path safety + sensitive content
 export { assertInsideProject, assertSafeProjectMemoryDir, assertSafeSessionDir, normalizeRealRoot, normalizeRoot, realPathOrThrow, resolveProjectPath, safeRealpath } from './store/paths.js';
 export { assertSafeMemory, assertSafeMemoryFileContent, hasSensitiveMemoryContent, writeNewFile } from './store/atomic-write.js';
 // Index: search / ranking / dispatch
 export { ensureMemoryBootstrap, emptyByKind, emptyIndex, listMarkdownFiles, readProjectMemories, readProjectMemoryBody } from './index/search.js';
-export { generateMemoryIndexFile, readExistingIndex, readMemoryFileMtime, readMemoryIndex, readStoredMemoryNames } from './index/ranking.js';
+export { buildMemoryIndex, generateMemoryIndexFile, readExistingIndex, readMemoryFileMtime, readMemoryIndex, readStoredMemoryNames } from './index/ranking.js';
+// Full index rebuild + drift report (`peaks memory reindex`)
+export { executeMemoryReindex, renderMemoryMarkdown, KIND_ORDER, MEMORY_MD_BANNER, MEMORY_MD_FILENAME } from './index/reindex.js';
 export { createProjectMemoryBackupPlan, createProjectMemoryExtractPlan, executeProjectMemoryBackup, executeProjectMemoryExtract, extractSessionMemories, summarizeProjectMemoryBackupResult, summarizeProjectMemoryExtractResult } from './index/kind-dispatch.js';

package/dist/services/memory/project-memory-service/parsers/frontmatter.d.ts

@@ -1,9 +1,81 @@
 import type { ExtractedProjectMemory, ProjectMemoryKind, StoredProjectMemory } from '../types.js';
-export declare const VALID_MEMORY_KINDS: Set<ProjectMemoryKind>;
-/** Exported for guard tests + tooling that needs to enumerate the valid
- *  set without duplicating the literal. Single source of truth. */
+/** Accepted-kind set, derived from the canonical `PROJECT_MEMORY_KINDS`
+ *  tuple so the parser cannot drift from the union type / tier map. */
+export declare const VALID_MEMORY_KINDS: ReadonlySet<ProjectMemoryKind>;
+/** Exported for guard tests + tooling that needs to enumerate the accepted
+ *  set (CLI help text, `--kind` validation) without duplicating the literal. */
 export declare const VALID_PROJECT_MEMORY_KINDS: readonly ProjectMemoryKind[];
 export declare function slugify(title: string): string;
 export declare function parseBlock(block: string, sourceArtifact: string): ExtractedProjectMemory | null;
 export declare function renderMemoryFile(memory: ExtractedProjectMemory): string;
+/**
+ * Where a stored memory file's `kind` came from. `'none'` means the file
+ * has no resolvable kind (no `metadata.type`, no `kind:`, no `type:`, or
+ * the value present is not one of the accepted kinds in
+ * `PROJECT_MEMORY_KINDS`).
+ */
+export type MemoryKindSource = 'metadata.type' | 'kind' | 'type' | 'none';
+export interface MemoryKindResolution {
+    kind: ProjectMemoryKind | null;
+    source: MemoryKindSource;
+    /** The first raw value found in the frontmatter, even when it is not a valid kind. */
+    rawKind: string | null;
+}
+export interface ParsedMemoryFrontmatter {
+    hasFrontmatter: boolean;
+    name?: string;
+    /** Top-level `title:` frontmatter value. Never the nested `metadata.title`
+     *  (that is a different semantic); used only as a name fallback on the
+     *  read path — see `resolveMemoryName`. */
+    title?: string;
+    description?: string;
+    sourceArtifact?: string;
+    kind: MemoryKindResolution;
+    /** Raw frontmatter block text (without the `---` fences); '' when absent. */
+    frontmatter: string;
+    body: string;
+}
+/**
+ * Resolve the peaks memory kind from a stored memory file's frontmatter.
+ *
+ * Resolution order (first *valid* kind wins):
+ *   1. nested `metadata.type`   — the canonical peaks contract
+ *   2. top-level `kind:`        — the legacy alias (was silently dropped before)
+ *   3. top-level `type:`        — tolerated by the pre-existing trim-based reader
+ *   4. `none`                   — reported as unclassified; never invented
+ *
+ * Slice 2026-09-09-memory-system-overhaul (B): before this helper, files
+ * using a top-level `kind:` were silently dropped by the reader (defect
+ * #2). Falling through to `kind:` / `type:` is a strict superset of the
+ * old behaviour — no previously-indexed file changes kind.
+ */
+export declare function resolveMemoryKind(content: string): MemoryKindResolution;
+/**
+ * Single parse surface for stored memory frontmatter. Both
+ * `parseStoredMemoryFile` (read path) and the reindex / ingest / doctor
+ * classifiers consume this so there is exactly one kind-resolution rule
+ * in the codebase.
+ */
+export declare function parseMemoryFrontmatter(content: string): ParsedMemoryFrontmatter;
+/** Which frontmatter field (or the filename) supplied a memory's name. */
+export type MemoryNameSource = 'name' | 'title' | 'stem' | 'none';
+export interface MemoryNameResolution {
+    /** The resolved name, or null when every fallback was empty. */
+    name: string | null;
+    source: MemoryNameSource;
+}
+/**
+ * Deterministic name fallback chain for the read path:
+ *
+ *   1. `name:`            — the canonical field written by `renderMemoryFile`
+ *   2. `title:`           — hand-written / legacy files (the 5 on-disk files
+ *                           this slice fixes carried only `title:` + `kind:`)
+ *   3. filename stem      — last resort, so a well-formed memory with a valid
+ *                           kind is never dropped just for missing a name
+ *
+ * Empty values are skipped rather than accepted: a `name:` of `''` still
+ * falls through, and a file whose stem is also empty resolves to null so the
+ * caller's validation is preserved (never invents a name).
+ */
+export declare function resolveMemoryName(parsed: ParsedMemoryFrontmatter, filePath: string): MemoryNameResolution;
 export declare function parseStoredMemoryFile(content: string, filePath: string): StoredProjectMemory | null;