peaks-loop 4.0.54 → 4.1.0

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

@@ -23,144 +23,20 @@
 //     runs (even if every write was skipped) so the index is always
 //     rebuilt against the current directory.
 // ---------------------------------------------------------------------------
-import { copyFileSync, mkdirSync, readFileSync } from 'node:fs';
-import { dirname, join, relative } from 'node:path';
+import { mkdirSync, readFileSync } from 'node:fs';
+import { join, relative } from 'node:path';
 import { isInsidePath, resolveInputPath, stablePath, stableRealPath } from '../../../../shared/path-utils.js';
 import { renderMemoryFile, slugify } from '../parsers/frontmatter.js';
-import { extractStableProjectMemoriesWithDiagnostics, summarizeBackupResult, summarizeExtractResult } from '../parsers/markdown-pure.js';
-import { assertInsideProject, assertSafeProjectMemoryDir, assertSafeSessionDir, normalizeRoot, realPathOrThrow } from '../store/paths.js';
-import { assertSafeMemoryFileContent, writeNewFile } from '../store/atomic-write.js';
+import { extractStableProjectMemoriesWithDiagnostics } from '../parsers/markdown-pure.js';
+import { assertSafeProjectMemoryDir, assertSafeSessionDir, normalizeRoot } from '../store/paths.js';
+import { writeNewFile } from '../store/atomic-write.js';
 import { generateMemoryIndexFile, readStoredMemoryNames } from './ranking.js';
 import { listMarkdownFiles } from './search.js';
-export function createProjectMemoryExtractPlan(options) {
-    const projectRoot = normalizeRoot(options.projectRoot);
-    const primaryMemoryDir = assertSafeProjectMemoryDir(projectRoot);
-    const extractedMemories = [];
-    const droppedBlocks = [];
-    for (const artifactPath of options.artifactPaths) {
-        const safeArtifactPath = assertInsideProject(artifactPath, projectRoot);
-        const relativeArtifactPath = relative(projectRoot, safeArtifactPath).replaceAll('\\', '/');
-        const extracted = extractStableProjectMemoriesWithDiagnostics(readFileSync(safeArtifactPath, 'utf8'), relativeArtifactPath);
-        // Push order + the sort below are the pre-existing ordering contract:
-        // artifacts in argument order, memories sorted by slug.
-        extractedMemories.push(...extracted.memories);
-        droppedBlocks.push(...extracted.dropped);
-    }
-    extractedMemories.sort((left, right) => slugify(left.title).localeCompare(slugify(right.title)));
-    const slugCounts = new Map();
-    for (const memory of extractedMemories) {
-        const slug = slugify(memory.title);
-        slugCounts.set(slug, (slugCounts.get(slug) ?? 0) + 1);
-    }
-    const duplicateTitles = [...slugCounts.entries()].filter(([, count]) => count > 1).map(([slug]) => slug);
-    if (duplicateTitles.length > 0) {
-        throw new Error(`Duplicate memory titles are not allowed: ${duplicateTitles.join(', ')}`);
-    }
-    const plannedWrites = extractedMemories.map((memory) => ({
-        memory,
-        filePath: join(primaryMemoryDir, `${slugify(memory.title)}.md`),
-        content: renderMemoryFile(memory)
-    }));
-    return {
-        apply: options.apply ?? false,
-        projectRoot,
-        primaryMemoryDir,
-        backupPolicy: 'project-memory-primary-artifact-backup',
-        extractedMemories,
-        plannedWrites,
-        droppedBlocks
-    };
-}
-export function executeProjectMemoryExtract(options) {
-    const plan = createProjectMemoryExtractPlan(options);
-    const writtenFiles = [];
-    if (plan.apply) {
-        mkdirSync(plan.primaryMemoryDir, { recursive: true });
-        const safeMemoryDir = assertSafeProjectMemoryDir(plan.projectRoot);
-        // Idempotency: skip writes for memories whose slug already lives in
-        // .peaks/memory/. Re-running `peaks memory extract --apply` on the
-        // same handoff is a normal peaks-code / peaks-txt retry pattern (the
-        // skill prompt may invoke extract more than once when a handoff is
-        // edited and re-extracted). Without this, writeNewFile's O_EXCL
-        // throws EEXIST and aborts the whole batch. Symmetric with
-        // extractSessionMemories (line ~614) which does the same skip.
-        const existingNames = readStoredMemoryNames(plan.primaryMemoryDir);
-        for (const write of plan.plannedWrites) {
-            const slug = slugify(write.memory.title);
-            if (existingNames.has(slug))
-                continue;
-            const targetPath = resolveInputPath(write.filePath);
-            const stableTargetPath = stablePath(targetPath);
-            if (!isInsidePath(stableTargetPath, stableRealPath(safeMemoryDir))) {
-                throw new Error('Project memory write target must stay inside the project memory directory');
-            }
-            writeNewFile(targetPath, write.content);
-            writtenFiles.push(targetPath);
-        }
-        // After writing any markdown, regenerate the index so downstream
-        // readers (peaks project memory-index, peaks-txt re-runs, the next
-        // session's presence-set bootstrap) see the new memory. Without
-        // this, `peaks memory extract --apply` would leave the index stale
-        // and `readMemoryIndex` would either return the empty bootstrap or
-        // — pre-bootstrap-fix — return null. Symmetric with
-        // extractSessionMemories, which already regenerates the index on
-        // apply (see line ~626). We regen whenever --apply is set, even
-        // if every write was skipped by idempotency, so the index is
-        // always rebuilt against the current .peaks/memory/ directory.
-        const indexPath = join(plan.primaryMemoryDir, 'index.json');
-        generateMemoryIndexFile(plan.projectRoot, plan.primaryMemoryDir, indexPath);
-    }
-    return { ...plan, writtenFiles };
-}
-export function createProjectMemoryBackupPlan(options) {
-    const projectRoot = normalizeRoot(options.projectRoot);
-    const artifactWorkspacePath = normalizeRoot(options.artifactWorkspacePath);
-    if (isInsidePath(artifactWorkspacePath, projectRoot)) {
-        throw new Error('Artifact workspace must be outside the project root');
-    }
-    const primaryMemoryDir = assertSafeProjectMemoryDir(projectRoot);
-    const backupMemoryDir = join(artifactWorkspacePath, '.peaks', 'memory-backups', 'project-memory-primary');
-    const plannedCopies = listMarkdownFiles(primaryMemoryDir).map((sourcePath) => {
-        assertSafeMemoryFileContent(readFileSync(sourcePath, 'utf8'));
-        const relativeMemoryPath = relative(primaryMemoryDir, sourcePath);
-        return {
-            sourcePath,
-            targetPath: join(backupMemoryDir, relativeMemoryPath)
-        };
-    });
-    return {
-        apply: options.apply ?? false,
-        projectRoot,
-        artifactWorkspacePath,
-        primaryMemoryDir,
-        backupMemoryDir,
-        plannedCopies
-    };
-}
-export function executeProjectMemoryBackup(options) {
-    const plan = createProjectMemoryBackupPlan(options);
-    const copiedFiles = [];
-    if (plan.apply) {
-        const safeMemoryDir = assertSafeProjectMemoryDir(plan.projectRoot);
-        mkdirSync(plan.backupMemoryDir, { recursive: true });
-        for (const copy of plan.plannedCopies) {
-            const sourcePath = realPathOrThrow(copy.sourcePath, 'Project memory source must stay inside the project memory directory', 'Project memory source does not exist');
-            if (!isInsidePath(sourcePath, stableRealPath(safeMemoryDir))) {
-                throw new Error('Project memory source must stay inside the project memory directory');
-            }
-            mkdirSync(dirname(copy.targetPath), { recursive: true });
-            copyFileSync(sourcePath, copy.targetPath);
-            copiedFiles.push(copy.targetPath);
-        }
-    }
-    return { ...plan, copiedFiles };
-}
-export function summarizeProjectMemoryExtractResult(result) {
-    return summarizeExtractResult(result);
-}
-export function summarizeProjectMemoryBackupResult(result) {
-    return summarizeBackupResult(result);
-}
+// The `peaks memory extract` / `backup` plan-execute-summarize surface now
+// lives in `./project-memory-plan-exec.ts`. Re-exported here so the `index.ts`
+// barrel and `memory-path-missing-vs-escape.test.ts` keep resolving it from
+// `./index/kind-dispatch.js` unchanged.
+export { createProjectMemoryBackupPlan, createProjectMemoryExtractPlan, executeProjectMemoryBackup, executeProjectMemoryExtract, summarizeProjectMemoryBackupResult, summarizeProjectMemoryExtractResult } from './project-memory-plan-exec.js';
 export function extractSessionMemories(options) {
     const projectRoot = normalizeRoot(options.projectRoot);
     const apply = options.apply ?? false;
@@ -223,7 +99,10 @@ export function extractSessionMemories(options) {
             // string arithmetic on two already-validated absolute path strings and
             // does not throw for them, so hoisting it cannot turn a path-join problem
             // into a fatal error that the old swallow would have absorbed.
-            scanFailures.push({ file: relativePath, detail: error instanceof Error ? error.message : String(error) });
+            scanFailures.push({
+                file: relativePath,
+                detail: error instanceof Error ? error.message : String(error)
+            });
         }
     }
     if (allExtracted.length === 0) {
@@ -246,7 +125,9 @@ export function extractSessionMemories(options) {
         const slug = slugify(memory.title);
         slugCounts.set(slug, (slugCounts.get(slug) ?? 0) + 1);
     }
-    const duplicateTitles = [...slugCounts.entries()].filter(([, count]) => count > 1).map(([slug]) => slug);
+    const duplicateTitles = [...slugCounts.entries()]
+        .filter(([, count]) => count > 1)
+        .map(([slug]) => slug);
     if (duplicateTitles.length > 0) {
         throw new Error(`Duplicate memory titles are not allowed: ${duplicateTitles.join(', ')}`);
     }

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

@@ -0,0 +1,7 @@
+import type { BackupPlanOptions, ExtractPlanOptions, ProjectMemoryBackupPlan, ProjectMemoryBackupResult, ProjectMemoryBackupSummary, ProjectMemoryExtractPlan, ProjectMemoryExtractResult, ProjectMemoryExtractSummary } from '../types.js';
+export declare function createProjectMemoryExtractPlan(options: ExtractPlanOptions): ProjectMemoryExtractPlan;
+export declare function executeProjectMemoryExtract(options: ExtractPlanOptions): ProjectMemoryExtractResult;
+export declare function createProjectMemoryBackupPlan(options: BackupPlanOptions): ProjectMemoryBackupPlan;
+export declare function executeProjectMemoryBackup(options: BackupPlanOptions): ProjectMemoryBackupResult;
+export declare function summarizeProjectMemoryExtractResult(result: ProjectMemoryExtractResult): ProjectMemoryExtractSummary;
+export declare function summarizeProjectMemoryBackupResult(result: ProjectMemoryBackupResult): ProjectMemoryBackupSummary;

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

@@ -0,0 +1,150 @@
+// ---------------------------------------------------------------------------
+// Project-memory create-plan / execute / summarize orchestrators.
+//
+// Split out of `./kind-dispatch.ts` by the `b1-filesplit-campaign` (wave 3,
+// leaf `b1w3-c-memory`): the four `peaks memory extract` / `backup` entry
+// points and their two projectors. `./kind-dispatch.ts` re-exports them so
+// the `index.ts` barrel and `memory-path-missing-vs-escape.test.ts` keep
+// resolving them from `./index/kind-dispatch.js` unchanged. The session-dir
+// extractor (`extractSessionMemories`) stays in `kind-dispatch.ts`.
+// ---------------------------------------------------------------------------
+import { copyFileSync, mkdirSync, readFileSync } from 'node:fs';
+import { dirname, join, relative } from 'node:path';
+import { isInsidePath, resolveInputPath, stablePath, stableRealPath } from '../../../../shared/path-utils.js';
+import { renderMemoryFile, slugify } from '../parsers/frontmatter.js';
+import { extractStableProjectMemoriesWithDiagnostics, summarizeBackupResult, summarizeExtractResult } from '../parsers/markdown-pure.js';
+import { assertInsideProject, assertSafeProjectMemoryDir, normalizeRoot, realPathOrThrow } from '../store/paths.js';
+import { assertSafeMemoryFileContent, writeNewFile } from '../store/atomic-write.js';
+import { generateMemoryIndexFile, readStoredMemoryNames } from './ranking.js';
+import { listMarkdownFiles } from './search.js';
+export function createProjectMemoryExtractPlan(options) {
+    const projectRoot = normalizeRoot(options.projectRoot);
+    const primaryMemoryDir = assertSafeProjectMemoryDir(projectRoot);
+    const extractedMemories = [];
+    const droppedBlocks = [];
+    for (const artifactPath of options.artifactPaths) {
+        const safeArtifactPath = assertInsideProject(artifactPath, projectRoot);
+        const relativeArtifactPath = relative(projectRoot, safeArtifactPath).replaceAll('\\', '/');
+        const extracted = extractStableProjectMemoriesWithDiagnostics(readFileSync(safeArtifactPath, 'utf8'), relativeArtifactPath);
+        // Push order + the sort below are the pre-existing ordering contract:
+        // artifacts in argument order, memories sorted by slug.
+        extractedMemories.push(...extracted.memories);
+        droppedBlocks.push(...extracted.dropped);
+    }
+    extractedMemories.sort((left, right) => slugify(left.title).localeCompare(slugify(right.title)));
+    const slugCounts = new Map();
+    for (const memory of extractedMemories) {
+        const slug = slugify(memory.title);
+        slugCounts.set(slug, (slugCounts.get(slug) ?? 0) + 1);
+    }
+    const duplicateTitles = [...slugCounts.entries()]
+        .filter(([, count]) => count > 1)
+        .map(([slug]) => slug);
+    if (duplicateTitles.length > 0) {
+        throw new Error(`Duplicate memory titles are not allowed: ${duplicateTitles.join(', ')}`);
+    }
+    const plannedWrites = extractedMemories.map((memory) => ({
+        memory,
+        filePath: join(primaryMemoryDir, `${slugify(memory.title)}.md`),
+        content: renderMemoryFile(memory)
+    }));
+    return {
+        apply: options.apply ?? false,
+        projectRoot,
+        primaryMemoryDir,
+        backupPolicy: 'project-memory-primary-artifact-backup',
+        extractedMemories,
+        plannedWrites,
+        droppedBlocks
+    };
+}
+export function executeProjectMemoryExtract(options) {
+    const plan = createProjectMemoryExtractPlan(options);
+    const writtenFiles = [];
+    if (plan.apply) {
+        mkdirSync(plan.primaryMemoryDir, { recursive: true });
+        const safeMemoryDir = assertSafeProjectMemoryDir(plan.projectRoot);
+        // Idempotency: skip writes for memories whose slug already lives in
+        // .peaks/memory/. Re-running `peaks memory extract --apply` on the
+        // same handoff is a normal peaks-code / peaks-txt retry pattern (the
+        // skill prompt may invoke extract more than once when a handoff is
+        // edited and re-extracted). Without this, writeNewFile's O_EXCL
+        // throws EEXIST and aborts the whole batch. Symmetric with
+        // extractSessionMemories (line ~614) which does the same skip.
+        const existingNames = readStoredMemoryNames(plan.primaryMemoryDir);
+        for (const write of plan.plannedWrites) {
+            const slug = slugify(write.memory.title);
+            if (existingNames.has(slug))
+                continue;
+            const targetPath = resolveInputPath(write.filePath);
+            const stableTargetPath = stablePath(targetPath);
+            if (!isInsidePath(stableTargetPath, stableRealPath(safeMemoryDir))) {
+                throw new Error('Project memory write target must stay inside the project memory directory');
+            }
+            writeNewFile(targetPath, write.content);
+            writtenFiles.push(targetPath);
+        }
+        // After writing any markdown, regenerate the index so downstream
+        // readers (peaks project memory-index, peaks-txt re-runs, the next
+        // session's presence-set bootstrap) see the new memory. Without
+        // this, `peaks memory extract --apply` would leave the index stale
+        // and `readMemoryIndex` would either return the empty bootstrap or
+        // — pre-bootstrap-fix — return null. Symmetric with
+        // extractSessionMemories, which already regenerates the index on
+        // apply (see line ~626). We regen whenever --apply is set, even
+        // if every write was skipped by idempotency, so the index is
+        // always rebuilt against the current .peaks/memory/ directory.
+        const indexPath = join(plan.primaryMemoryDir, 'index.json');
+        generateMemoryIndexFile(plan.projectRoot, plan.primaryMemoryDir, indexPath);
+    }
+    return { ...plan, writtenFiles };
+}
+export function createProjectMemoryBackupPlan(options) {
+    const projectRoot = normalizeRoot(options.projectRoot);
+    const artifactWorkspacePath = normalizeRoot(options.artifactWorkspacePath);
+    if (isInsidePath(artifactWorkspacePath, projectRoot)) {
+        throw new Error('Artifact workspace must be outside the project root');
+    }
+    const primaryMemoryDir = assertSafeProjectMemoryDir(projectRoot);
+    const backupMemoryDir = join(artifactWorkspacePath, '.peaks', 'memory-backups', 'project-memory-primary');
+    const plannedCopies = listMarkdownFiles(primaryMemoryDir).map((sourcePath) => {
+        assertSafeMemoryFileContent(readFileSync(sourcePath, 'utf8'));
+        const relativeMemoryPath = relative(primaryMemoryDir, sourcePath);
+        return {
+            sourcePath,
+            targetPath: join(backupMemoryDir, relativeMemoryPath)
+        };
+    });
+    return {
+        apply: options.apply ?? false,
+        projectRoot,
+        artifactWorkspacePath,
+        primaryMemoryDir,
+        backupMemoryDir,
+        plannedCopies
+    };
+}
+export function executeProjectMemoryBackup(options) {
+    const plan = createProjectMemoryBackupPlan(options);
+    const copiedFiles = [];
+    if (plan.apply) {
+        const safeMemoryDir = assertSafeProjectMemoryDir(plan.projectRoot);
+        mkdirSync(plan.backupMemoryDir, { recursive: true });
+        for (const copy of plan.plannedCopies) {
+            const sourcePath = realPathOrThrow(copy.sourcePath, 'Project memory source must stay inside the project memory directory', 'Project memory source does not exist');
+            if (!isInsidePath(sourcePath, stableRealPath(safeMemoryDir))) {
+                throw new Error('Project memory source must stay inside the project memory directory');
+            }
+            mkdirSync(dirname(copy.targetPath), { recursive: true });
+            copyFileSync(sourcePath, copy.targetPath);
+            copiedFiles.push(copy.targetPath);
+        }
+    }
+    return { ...plan, copiedFiles };
+}
+export function summarizeProjectMemoryExtractResult(result) {
+    return summarizeExtractResult(result);
+}
+export function summarizeProjectMemoryBackupResult(result) {
+    return summarizeBackupResult(result);
+}

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

@@ -55,7 +55,8 @@ export function readStoredMemoryNames(memoryDir) {
             if (parsed)
                 names.add(parsed.name);
         }
-        catch { // TODO(g2): legacy silent catch — grace: 1 minor release (v2.14.0)
+        catch {
+            // TODO(g2): legacy silent catch — grace: 1 minor release (v2.14.0)
             // ignore unreadable files
         }
     }
@@ -125,7 +126,8 @@ export function readExistingIndex(indexPath) {
             return parsed;
         return null;
     }
-    catch { // TODO(g2): legacy silent catch — grace: 1 minor release (v2.14.0)
+    catch {
+        // TODO(g2): legacy silent catch — grace: 1 minor release (v2.14.0)
         return null;
     }
 }
@@ -175,7 +177,8 @@ export function readMemoryIndex(projectRoot) {
         try {
             generateMemoryIndexFile(normalizedRoot, memoryDir, indexPath);
         }
-        catch { // TODO(g2): legacy silent catch — grace: 1 minor release (v2.14.0)
+        catch {
+            // TODO(g2): legacy silent catch — grace: 1 minor release (v2.14.0)
             // fall through to read existing
         }
     }

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

@@ -67,7 +67,12 @@ function collectUnclassified(diskFiles) {
         }
         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' });
+            unclassified.push({
+                name: basename(filePath, '.md'),
+                filePath,
+                rawKind: null,
+                reason: 'file could not be read'
+            });
             continue;
         }
         if (parsed.kind.kind !== null)
@@ -112,7 +117,10 @@ function collectNameConflicts(diskFiles) {
     }
     return [...byName.entries()]
         .filter(([, filePaths]) => filePaths.length > 1)
-        .map(([name, filePaths]) => ({ name, filePaths: [...filePaths].sort((left, right) => left.localeCompare(right)) }))
+        .map(([name, filePaths]) => ({
+        name,
+        filePaths: [...filePaths].sort((left, right) => left.localeCompare(right))
+    }))
         .sort((left, right) => left.name.localeCompare(right.name));
 }
 /**
@@ -131,8 +139,7 @@ export function renderMemoryMarkdown(index, memoryDir) {
         ''
     ];
     for (const kind of KIND_ORDER) {
-        const entries = [...(index.hot[kind] ?? []), ...(index.warm[kind] ?? [])]
-            .sort((left, right) => left.name.localeCompare(right.name));
+        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})`, '');
@@ -156,7 +163,9 @@ export function executeMemoryReindex(options) {
     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))
+        .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);

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

@@ -0,0 +1,31 @@
+/**
+ * Canonical memory-kind vocabulary — the single source of truth.
+ *
+ * The union type, the accepted-kind set in the frontmatter parser, the
+ * hot/warm tier map below, `KIND_ORDER` in the reindex view, and the CLI
+ * `--kind` help text all derive from this tuple. Adding a kind here is the
+ * only edit required; TypeScript then forces `MEMORY_KIND_TIER` to cover it.
+ *
+ * Slice 2026-09-10-memory-vocab-and-rotate (E): the original 8 kinds are
+ * unchanged. The 13 appended kinds were observed on disk with real values
+ * that the index schema rejected (`peaks memory reindex` reported them as
+ * `unrecognized kind value`). Accepting them moves those files into the
+ * index; files with no kind field at all stay reported as unclassified.
+ */
+export declare const PROJECT_MEMORY_KINDS: readonly ["project", "rule", "decision", "reference", "feedback", "convention", "module", "lesson", "bug", "investigation", "technical-pattern", "project-rule", "design", "handoff", "session-handoff", "project-todo", "publish-closure", "project-closure", "slice-closure", "slice-pilot-findings", "sediment"];
+export type ProjectMemoryKind = (typeof PROJECT_MEMORY_KINDS)[number];
+/** Hot kinds keep their body in the always-available index; warm kinds are
+ *  indexed with the same entry shape but read on demand. */
+export type MemoryKindTier = 'hot' | 'warm';
+/**
+ * Hot/warm tier per kind. Insertion order IS the deterministic section order
+ * used by the generated `MEMORY.md` (`KIND_ORDER` in `index/reindex.ts`),
+ * so this object's key order is load-bearing — append new kinds at the end
+ * of their tier block rather than reshuffling existing entries.
+ *
+ * The `Record<ProjectMemoryKind, MemoryKindTier>` annotation makes a missing
+ * tier a compile error whenever `PROJECT_MEMORY_KINDS` grows.
+ */
+export declare const MEMORY_KIND_TIER: Record<ProjectMemoryKind, MemoryKindTier>;
+export declare const HOT_MEMORY_KINDS: readonly ProjectMemoryKind[];
+export declare const WARM_MEMORY_KINDS: readonly ProjectMemoryKind[];

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

@@ -0,0 +1,87 @@
+// ---------------------------------------------------------------------------
+// Canonical memory-kind vocabulary + hot/warm tier map.
+//
+// Extracted from `types.ts` by the `b1-filesplit-campaign` (wave 3, leaf
+// `b1w3-c-memory`). This module has no imports — the tuple, the derived
+// union type, the tier map and the two tier-filtered arrays reference only
+// each other — so it is the leaf of the dependency graph. `types.ts`
+// re-exports every name below so downstream callers (the `index.ts` barrel,
+// the frontmatter parser, memory-rotate / memory-ingest) keep importing
+// them from `./types.js` unchanged.
+// ---------------------------------------------------------------------------
+/**
+ * Canonical memory-kind vocabulary — the single source of truth.
+ *
+ * The union type, the accepted-kind set in the frontmatter parser, the
+ * hot/warm tier map below, `KIND_ORDER` in the reindex view, and the CLI
+ * `--kind` help text all derive from this tuple. Adding a kind here is the
+ * only edit required; TypeScript then forces `MEMORY_KIND_TIER` to cover it.
+ *
+ * Slice 2026-09-10-memory-vocab-and-rotate (E): the original 8 kinds are
+ * unchanged. The 13 appended kinds were observed on disk with real values
+ * that the index schema rejected (`peaks memory reindex` reported them as
+ * `unrecognized kind value`). Accepting them moves those files into the
+ * index; files with no kind field at all stay reported as unclassified.
+ */
+export const PROJECT_MEMORY_KINDS = [
+    // Original 8 (pre-2026-09-10).
+    'project',
+    'rule',
+    'decision',
+    'reference',
+    'feedback',
+    'convention',
+    'module',
+    'lesson',
+    // Slice E expansion — observed on-disk values, hot tier.
+    'bug',
+    'investigation',
+    'technical-pattern',
+    'project-rule',
+    // Slice E expansion — observed on-disk values, warm tier.
+    'design',
+    'handoff',
+    'session-handoff',
+    'project-todo',
+    'publish-closure',
+    'project-closure',
+    'slice-closure',
+    'slice-pilot-findings',
+    'sediment'
+];
+/**
+ * Hot/warm tier per kind. Insertion order IS the deterministic section order
+ * used by the generated `MEMORY.md` (`KIND_ORDER` in `index/reindex.ts`),
+ * so this object's key order is load-bearing — append new kinds at the end
+ * of their tier block rather than reshuffling existing entries.
+ *
+ * The `Record<ProjectMemoryKind, MemoryKindTier>` annotation makes a missing
+ * tier a compile error whenever `PROJECT_MEMORY_KINDS` grows.
+ */
+export const MEMORY_KIND_TIER = {
+    // hot — full body kept in the index
+    feedback: 'hot',
+    decision: 'hot',
+    rule: 'hot',
+    convention: 'hot',
+    module: 'hot',
+    lesson: 'hot',
+    bug: 'hot',
+    investigation: 'hot',
+    'technical-pattern': 'hot',
+    'project-rule': 'hot',
+    // warm — same entry shape, read on demand
+    project: 'warm',
+    reference: 'warm',
+    design: 'warm',
+    handoff: 'warm',
+    'session-handoff': 'warm',
+    'project-todo': 'warm',
+    'publish-closure': 'warm',
+    'project-closure': 'warm',
+    'slice-closure': 'warm',
+    'slice-pilot-findings': 'warm',
+    sediment: 'warm'
+};
+export const HOT_MEMORY_KINDS = PROJECT_MEMORY_KINDS.filter((kind) => MEMORY_KIND_TIER[kind] === 'hot');
+export const WARM_MEMORY_KINDS = PROJECT_MEMORY_KINDS.filter((kind) => MEMORY_KIND_TIER[kind] === 'warm');

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

@@ -0,0 +1,24 @@
+import { type ExtractedProjectMemory, type MemoryBlockParse, type ProjectMemoryKind } from '../types.js';
+/** 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;
+/**
+ * Single implementation of the extract-path block parse. Returns a
+ * discriminated result so the caller can say WHY a found block was rejected.
+ *
+ * The precondition order mirrors the original combined `if` exactly
+ * (separator → title → kind present → kind valid → body non-empty), so the
+ * accepted set is bit-for-bit what it always was; only the explanation is new.
+ */
+export declare function parseBlockResult(block: string, sourceArtifact: string): MemoryBlockParse;
+/**
+ * `null`-on-failure projection of `parseBlockResult`. Kept because callers
+ * (and the parser's own contract) consume a plain nullable value; both views
+ * come from the one implementation above, so they cannot diverge.
+ */
+export declare function parseBlock(block: string, sourceArtifact: string): ExtractedProjectMemory | null;
+export declare function renderMemoryFile(memory: ExtractedProjectMemory): string;

package/dist/services/memory/project-memory-service/parsers/frontmatter-parse.js

@@ -0,0 +1,104 @@
+// ---------------------------------------------------------------------------
+// Frontmatter extract-path surface for project memory files.
+//
+// Split out of `./frontmatter.ts` by the `b1-filesplit-campaign` (wave 3,
+// leaf `b1w3-c-memory`): the accepted-kind allow-list, the `slugify` helper,
+// and the extract-path block parser / renderer. `./frontmatter.ts` re-exports
+// every name here so the `index.ts` barrel, `markdown-pure.ts` and the CLI
+// keep importing them from `./parsers/frontmatter.js` unchanged.
+// ---------------------------------------------------------------------------
+import { PROJECT_MEMORY_KINDS } from '../types.js';
+/** Accepted-kind set, derived from the canonical `PROJECT_MEMORY_KINDS`
+ *  tuple so the parser cannot drift from the union type / tier map. */
+export const VALID_MEMORY_KINDS = new Set(PROJECT_MEMORY_KINDS);
+/** Exported for guard tests + tooling that needs to enumerate the accepted
+ *  set (CLI help text, `--kind` validation) without duplicating the literal. */
+export const VALID_PROJECT_MEMORY_KINDS = PROJECT_MEMORY_KINDS;
+export function slugify(title) {
+    const slug = title
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '');
+    return slug.length > 0 ? slug : 'project-memory';
+}
+/**
+ * Single implementation of the extract-path block parse. Returns a
+ * discriminated result so the caller can say WHY a found block was rejected.
+ *
+ * The precondition order mirrors the original combined `if` exactly
+ * (separator → title → kind present → kind valid → body non-empty), so the
+ * accepted set is bit-for-bit what it always was; only the explanation is new.
+ */
+export function parseBlockResult(block, sourceArtifact) {
+    const normalizedBlock = block.replace(/\r\n/g, '\n');
+    const separatorIndex = normalizedBlock.indexOf('\n---\n');
+    if (separatorIndex < 0) {
+        return {
+            ok: false,
+            reason: 'missing-separator',
+            detail: "block header is not followed by a '---' separator line"
+        };
+    }
+    const header = normalizedBlock.slice(0, separatorIndex).trim();
+    const body = normalizedBlock.slice(separatorIndex + '\n---\n'.length).trim();
+    const fields = new Map();
+    for (const line of header.split('\n')) {
+        const [key, ...valueParts] = line.split(':');
+        const normalizedKey = key?.trim();
+        const value = valueParts.join(':').trim();
+        if (normalizedKey && value) {
+            fields.set(normalizedKey, value);
+        }
+    }
+    const title = fields.get('title')?.trim();
+    const kind = fields.get('kind')?.trim();
+    if (!title) {
+        return {
+            ok: false,
+            reason: 'missing-title',
+            detail: "block header has no non-empty 'title:' field"
+        };
+    }
+    if (!kind) {
+        return {
+            ok: false,
+            reason: 'missing-kind',
+            detail: "block header has no non-empty 'kind:' field"
+        };
+    }
+    if (!VALID_MEMORY_KINDS.has(kind)) {
+        return {
+            ok: false,
+            reason: 'unknown-kind',
+            detail: `block declares kind '${kind}', which is not an accepted memory kind`
+        };
+    }
+    if (body.length === 0) {
+        return { ok: false, reason: 'empty-body', detail: 'block body is empty' };
+    }
+    return { ok: true, memory: { title, kind, body, sourceArtifact } };
+}
+/**
+ * `null`-on-failure projection of `parseBlockResult`. Kept because callers
+ * (and the parser's own contract) consume a plain nullable value; both views
+ * come from the one implementation above, so they cannot diverge.
+ */
+export function parseBlock(block, sourceArtifact) {
+    const parsed = parseBlockResult(block, sourceArtifact);
+    return parsed.ok ? parsed.memory : null;
+}
+export function renderMemoryFile(memory) {
+    const name = slugify(memory.title);
+    return [
+        '---',
+        `name: ${name}`,
+        `description: ${memory.title}`,
+        'metadata:',
+        `  type: ${memory.kind}`,
+        `  sourceArtifact: ${memory.sourceArtifact}`,
+        '---',
+        '',
+        memory.body,
+        ''
+    ].join('\n');
+}