peaks-loop 4.0.54 → 4.1.1

package/dist/services/memory/llm-reranker.js

@@ -48,68 +48,11 @@
  *   - No integration with `memory-search-service.ts` (Z-A is a spike;
  *     the wiring into `peaks memory search` is Z-B).
  */
-// Approximate 1 token = 4 bytes for English text. Standard rough
-// approximation used across the pipeline (AC-ZA-5 benchmark).
-const BYTES_PER_TOKEN = 4;
-// Hard caps so a pathological query / 60-candidate list cannot blow
-// up the LLM prompt. These are conservative defaults; Z-B may tune.
-const DEFAULT_TOP_N = 10;
-const DEFAULT_TOP_K = 5;
-const MAX_CANDIDATES = 30;
-const MAX_DESCRIPTION_CHARS = 240;
-const DEFAULT_CHAT_TIMEOUT_MS = 5_000;
-/**
- * Estimate token count for a string. `1 token ≈ 4 bytes` for English
- * text (standard rough approximation).
- */
-export function estimateTokens(text) {
-    return Math.ceil(Buffer.byteLength(text, 'utf8') / BYTES_PER_TOKEN);
-}
-/**
- * Truncate a string to a maximum character count, appending an
- * ellipsis marker when truncated. Used to keep the rerank prompt
- * bounded when a candidate's description is unusually long.
- */
-function truncateForPrompt(text, maxChars) {
-    if (text.length <= maxChars)
-        return text;
-    return `${text.slice(0, Math.max(0, maxChars - 1))}…`;
-}
-/**
- * Build the rerank prompt. Pure function — no IO, no side effects.
- * Trivially testable.
- *
- * Format (locked for Z-A; Z-B may tune):
- *
- *   Query: "<query>"
- *
- *   Rank the following <N> candidate memories by relevance to the
- *   query. Return a JSON array of the candidate indices in
- *   descending relevance. Return only the JSON — no prose, no
- *   markdown.
- *
- *   Candidates:
- *   [0] name-a — description-a…
- *   [1] name-b — description-b…
- *   ...
- *
- * The LLM is expected to return e.g. `[3, 0, 4, 1, 2]`. The
- * output is parsed by `parseRerankResponse`.
- */
-export function renderRerankPrompt(query, candidates) {
-    const blocks = candidates.map((c, i) => {
-        const desc = truncateForPrompt(c.description, MAX_DESCRIPTION_CHARS);
-        return `[${i}] ${c.name} — ${desc}`;
-    });
-    return [
-        `Query: "${query}"`,
-        '',
-        `Rank the following ${candidates.length} candidate memories by relevance to the query. Return a JSON array of the candidate indices in descending relevance. Return only the JSON — no prose, no markdown.`,
-        '',
-        'Candidates:',
-        ...blocks,
-    ].join('\n');
-}
+import { applyRerankOrder, DEFAULT_CHAT_TIMEOUT_MS, DEFAULT_TOP_K, DEFAULT_TOP_N, estimateTokens, MAX_CANDIDATES, renderRerankPrompt } from './llm-reranker-core.js';
+// The pure core (constants, public option/result types, synchronous helpers)
+// now lives in `llm-reranker-core.ts`. Re-export it from this module path so
+// every existing importer of `llm-reranker.js` keeps resolving the same names.
+export { applyRerankOrder, estimateTokens, renderRerankPrompt } from './llm-reranker-core.js';
 /**
  * Parse the LLM's raw text response into an ordered list of
  * candidate indices. Tolerates:
@@ -142,7 +85,8 @@ export function parseRerankResponse(raw) {
     try {
         parsed = JSON.parse(candidate);
     }
-    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;
     }
     if (!Array.isArray(parsed))
@@ -156,39 +100,6 @@ export function parseRerankResponse(raw) {
     }
     return indices;
 }
-/**
- * Apply a parsed index ordering to a candidate list. Indices that
- * are out-of-range or duplicated are skipped (defensive). If the
- * ordering covers fewer candidates than `topK`, the remaining
- * slots are filled from the original fuzzy order.
- */
-export function applyRerankOrder(candidates, order, topK) {
-    const result = [];
-    const seen = new Set();
-    for (const idx of order) {
-        if (idx >= candidates.length)
-            continue;
-        if (seen.has(idx))
-            continue;
-        seen.add(idx);
-        const item = candidates[idx];
-        if (item === undefined)
-            continue;
-        result.push(item);
-        if (result.length >= topK)
-            return result;
-    }
-    for (let i = 0; i < candidates.length && result.length < topK; i += 1) {
-        if (seen.has(i))
-            continue;
-        const item = candidates[i];
-        if (item === undefined)
-            continue;
-        seen.add(i);
-        result.push(item);
-    }
-    return result;
-}
 /**
  * The no-op chat function. Used when no real chat injection is
  * available — the rerank layer fails-open and the caller gets
@@ -213,7 +124,7 @@ export async function rerank(query, candidates, options = {}) {
             topK: [],
             tokens: { promptTokens: 0, responseTokens: 0, total: 0 },
             degradation: 'noop-empty-input',
-            warning: null,
+            warning: null
         };
     }
     // Edge case 2: input fits within topK already. Rerank would be
@@ -223,7 +134,7 @@ export async function rerank(query, candidates, options = {}) {
             topK: candidates.slice(0, topK),
             tokens: { promptTokens: 0, responseTokens: 0, total: 0 },
             degradation: 'noop-empty-input',
-            warning: null,
+            warning: null
         };
     }
     // Slice to topN (fuzzy already returns in score-descending order).
@@ -236,7 +147,7 @@ export async function rerank(query, candidates, options = {}) {
             topK: truncated.slice(0, topK),
             tokens: { promptTokens, responseTokens: 0, total: promptTokens },
             degradation: 'skipped-no-chat-fn',
-            warning: 'No chat function provided; returning original fuzzy order.',
+            warning: 'No chat function provided; returning original fuzzy order.'
         };
     }
     // Chat call with timeout (AbortController-based).
@@ -256,7 +167,7 @@ export async function rerank(query, candidates, options = {}) {
             degradation: isTimeout ? 'timeout-fallback' : 'chat-failed-fallback',
             warning: isTimeout
                 ? `Chat timeout after ${chatTimeoutMs}ms; returning original fuzzy order.`
-                : `Chat failed: ${message}; returning original fuzzy order.`,
+                : `Chat failed: ${message}; returning original fuzzy order.`
         };
     }
     clearTimeout(timeoutHandle);
@@ -268,7 +179,7 @@ export async function rerank(query, candidates, options = {}) {
             topK: truncated.slice(0, topK),
             tokens: { promptTokens, responseTokens, total: promptTokens + responseTokens },
             degradation: 'parse-failed-fallback',
-            warning: 'LLM response was not a valid JSON index array; returning original fuzzy order.',
+            warning: 'LLM response was not a valid JSON index array; returning original fuzzy order.'
         };
     }
     // Apply the order and return.
@@ -277,6 +188,6 @@ export async function rerank(query, candidates, options = {}) {
         topK: topKResult,
         tokens: { promptTokens, responseTokens, total: promptTokens + responseTokens },
         degradation: 'reranked',
-        warning: null,
+        warning: null
     };
 }

package/dist/services/memory/memory-ingest-service.d.ts

@@ -1,4 +1,5 @@
 import type { ProjectMemoryKind } from './project-memory-service/types.js';
+export { defaultIdeMemoryDir, encodeIdeProjectDir, renderNormalizedMemory } from './memory-ingest-support.js';
 export interface MemoryIngestOptions {
     projectRoot: string;
     /** Override the IDE-side source dir (defaults to `~/.claude/projects/<encoded>/memory`). */
@@ -50,28 +51,6 @@ export interface MemoryIngestReport {
     writtenFiles: string[];
     warnings: string[];
 }
-/**
- * Claude Code encodes a project cwd into its `~/.claude/projects/<name>/`
- * directory by replacing every non-alphanumeric character with `-`
- * (`D:\peaks-loop` → `D--peaks-loop`). Separator-agnostic, so the same
- * encoding holds for POSIX paths.
- */
-export declare function encodeIdeProjectDir(projectRoot: string): string;
-/** Default IDE-side memory dir for a project: `~/.claude/projects/<encoded>/memory`. */
-export declare function defaultIdeMemoryDir(projectRoot: string, homeDir?: string): string;
-/**
- * Rewrite a source file's frontmatter to the peaks contract: `name` pinned to
- * the destination filename stem, and `metadata.type` set to the resolved
- * kind. Non-contract keys (e.g. `originSessionId`, `modified`, `node_type`)
- * are preserved verbatim so provenance survives the import; `type` / `kind`
- * are consumed by the normalization and not duplicated.
- */
-export declare function renderNormalizedMemory(input: {
-    stem: string;
-    kind: ProjectMemoryKind;
-    frontmatter: string;
-    body: string;
-}): string;
 /**
  * Import IDE-side memories into `.peaks/memory/`. Always returns the full
  * envelope; `apply` only controls whether files are actually written.

package/dist/services/memory/memory-ingest-service.js

@@ -25,86 +25,20 @@
 // no type is invented silently.
 // ---------------------------------------------------------------------------
 import { existsSync, mkdirSync, readFileSync } from 'node:fs';
-import { homedir } from 'node:os';
 import { basename, join } from 'node:path';
 import { isInsidePath, resolveInputPath, stablePath, stableRealPath } from '../../shared/path-utils.js';
 import { parseMemoryFrontmatter } from './project-memory-service/parsers/frontmatter.js';
-import { summarizeMemoryBody } from './project-memory-service/parsers/markdown-pure.js';
 import { assertSafeProjectMemoryDir, normalizeRoot } from './project-memory-service/store/paths.js';
 import { assertSafeMemoryFileContent, writeNewFile } from './project-memory-service/store/atomic-write.js';
 import { listMarkdownFiles } from './project-memory-service/index/search.js';
+import { defaultIdeMemoryDir, renderNormalizedMemory } from './memory-ingest-support.js';
+// The IDE-source-dir encoding and the frontmatter-normalisation helpers live
+// in `./memory-ingest-support.ts`. Re-exported here so `memory-commands.ts`
+// and the ingest test keep resolving them from `memory-ingest-service.js`
+// unchanged.
+export { defaultIdeMemoryDir, encodeIdeProjectDir, renderNormalizedMemory } from './memory-ingest-support.js';
 /** `MEMORY.md` is the IDE's own generated index, not a memory source. */
 const IDE_INDEX_FILENAME = 'MEMORY.md';
-const RESERVED_TOP_LEVEL_KEYS = new Set(['name', 'description', 'metadata', 'type', 'kind']);
-const RESERVED_METADATA_KEYS = new Set(['type', 'kind', 'description']);
-/**
- * Claude Code encodes a project cwd into its `~/.claude/projects/<name>/`
- * directory by replacing every non-alphanumeric character with `-`
- * (`D:\peaks-loop` → `D--peaks-loop`). Separator-agnostic, so the same
- * encoding holds for POSIX paths.
- */
-export function encodeIdeProjectDir(projectRoot) {
-    return projectRoot.replace(/[^A-Za-z0-9]/g, '-');
-}
-/** Default IDE-side memory dir for a project: `~/.claude/projects/<encoded>/memory`. */
-export function defaultIdeMemoryDir(projectRoot, homeDir) {
-    return join(homeDir ?? homedir(), '.claude', 'projects', encodeIdeProjectDir(projectRoot), 'memory');
-}
-function parseFrontmatterDoc(frontmatter) {
-    const top = [];
-    const metadata = [];
-    let inMetadata = false;
-    for (const rawLine of frontmatter.split('\n')) {
-        if (rawLine.trim() === '')
-            continue;
-        const indented = /^\s/.test(rawLine);
-        const line = rawLine.trim();
-        const separator = line.indexOf(':');
-        if (separator < 0)
-            continue;
-        const key = line.slice(0, separator).trim();
-        const value = line.slice(separator + 1).trim();
-        if (indented) {
-            if (inMetadata)
-                metadata.push([key, value]);
-            continue;
-        }
-        inMetadata = key === 'metadata';
-        if (!inMetadata)
-            top.push([key, value]);
-    }
-    return { top, metadata };
-}
-/**
- * Rewrite a source file's frontmatter to the peaks contract: `name` pinned to
- * the destination filename stem, and `metadata.type` set to the resolved
- * kind. Non-contract keys (e.g. `originSessionId`, `modified`, `node_type`)
- * are preserved verbatim so provenance survives the import; `type` / `kind`
- * are consumed by the normalization and not duplicated.
- */
-export function renderNormalizedMemory(input) {
-    const doc = parseFrontmatterDoc(input.frontmatter);
-    const topMap = new Map(doc.top);
-    const metaMap = new Map(doc.metadata);
-    const description = topMap.get('description')
-        ?? metaMap.get('description')
-        ?? summarizeMemoryBody(input.body);
-    const lines = ['---', `name: ${input.stem}`, `description: ${description}`];
-    for (const [key, value] of doc.top) {
-        if (RESERVED_TOP_LEVEL_KEYS.has(key))
-            continue;
-        lines.push(`${key}: ${value}`);
-    }
-    lines.push('metadata:');
-    lines.push(`  type: ${input.kind}`);
-    for (const [key, value] of doc.metadata) {
-        if (RESERVED_METADATA_KEYS.has(key))
-            continue;
-        lines.push(`  ${key}: ${value}`);
-    }
-    lines.push('---', '', input.body, '');
-    return lines.join('\n');
-}
 function emptyReport(overrides) {
     return {
         apply: false,
@@ -177,7 +111,12 @@ export function executeMemoryIngest(options) {
             });
             continue;
         }
-        const normalized = renderNormalizedMemory({ stem, kind, frontmatter: parsed.frontmatter, body: parsed.body });
+        const normalized = renderNormalizedMemory({
+            stem,
+            kind,
+            frontmatter: parsed.frontmatter,
+            body: parsed.body
+        });
         // Never import secrets into the peaks store. Fail-soft: report, skip.
         try {
             assertSafeMemoryFileContent(normalized);
@@ -194,14 +133,24 @@ export function executeMemoryIngest(options) {
                 existing = readFileSync(targetPath, 'utf8');
             }
             catch {
-                report.conflicts.push({ name: stem, sourcePath, targetPath, reason: 'destination exists but could not be read' });
+                report.conflicts.push({
+                    name: stem,
+                    sourcePath,
+                    targetPath,
+                    reason: 'destination exists but could not be read'
+                });
                 continue;
             }
             if (existing === normalized) {
                 report.skippedIdentical.push({ name: stem, sourcePath, targetPath });
             }
             else {
-                report.conflicts.push({ name: stem, sourcePath, targetPath, reason: 'destination exists with different content; both copies left untouched' });
+                report.conflicts.push({
+                    name: stem,
+                    sourcePath,
+                    targetPath,
+                    reason: 'destination exists with different content; both copies left untouched'
+                });
             }
             continue;
         }
@@ -214,7 +163,11 @@ export function executeMemoryIngest(options) {
         // ~/.claude/**" structural rather than a convention.
         const stableTargetPath = stablePath(resolveInputPath(targetPath));
         if (stableMemoryDir === null || !isInsidePath(stableTargetPath, stableMemoryDir)) {
-            report.refused.push({ name: stem, sourcePath, reason: 'refused: target path escapes the project memory directory' });
+            report.refused.push({
+                name: stem,
+                sourcePath,
+                reason: 'refused: target path escapes the project memory directory'
+            });
             continue;
         }
         writeNewFile(targetPath, normalized);

package/dist/services/memory/memory-ingest-support.d.ts

@@ -0,0 +1,23 @@
+import type { ProjectMemoryKind } from './project-memory-service/types.js';
+/**
+ * Claude Code encodes a project cwd into its `~/.claude/projects/<name>/`
+ * directory by replacing every non-alphanumeric character with `-`
+ * (`D:\peaks-loop` → `D--peaks-loop`). Separator-agnostic, so the same
+ * encoding holds for POSIX paths.
+ */
+export declare function encodeIdeProjectDir(projectRoot: string): string;
+/** Default IDE-side memory dir for a project: `~/.claude/projects/<encoded>/memory`. */
+export declare function defaultIdeMemoryDir(projectRoot: string, homeDir?: string): string;
+/**
+ * Rewrite a source file's frontmatter to the peaks contract: `name` pinned to
+ * the destination filename stem, and `metadata.type` set to the resolved
+ * kind. Non-contract keys (e.g. `originSessionId`, `modified`, `node_type`)
+ * are preserved verbatim so provenance survives the import; `type` / `kind`
+ * are consumed by the normalization and not duplicated.
+ */
+export declare function renderNormalizedMemory(input: {
+    stem: string;
+    kind: ProjectMemoryKind;
+    frontmatter: string;
+    body: string;
+}): string;

package/dist/services/memory/memory-ingest-support.js

@@ -0,0 +1,81 @@
+// ---------------------------------------------------------------------------
+// `peaks memory ingest` — support surface.
+//
+// Split out of `./memory-ingest-service.ts` by the `b1-filesplit-campaign`
+// (wave 3, leaf `b1w3-c-memory`): the IDE-side source-dir encoding and the
+// frontmatter-normalisation helpers. `./memory-ingest-service.ts` imports
+// `defaultIdeMemoryDir` / `renderNormalizedMemory` for its orchestrator and
+// re-exports the three public helpers, so `memory-commands.ts` and the ingest
+// test keep importing them from `memory-ingest-service.js` unchanged.
+// ---------------------------------------------------------------------------
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { summarizeMemoryBody } from './project-memory-service/parsers/markdown-pure.js';
+const RESERVED_TOP_LEVEL_KEYS = new Set(['name', 'description', 'metadata', 'type', 'kind']);
+const RESERVED_METADATA_KEYS = new Set(['type', 'kind', 'description']);
+/**
+ * Claude Code encodes a project cwd into its `~/.claude/projects/<name>/`
+ * directory by replacing every non-alphanumeric character with `-`
+ * (`D:\peaks-loop` → `D--peaks-loop`). Separator-agnostic, so the same
+ * encoding holds for POSIX paths.
+ */
+export function encodeIdeProjectDir(projectRoot) {
+    return projectRoot.replace(/[^A-Za-z0-9]/g, '-');
+}
+/** Default IDE-side memory dir for a project: `~/.claude/projects/<encoded>/memory`. */
+export function defaultIdeMemoryDir(projectRoot, homeDir) {
+    return join(homeDir ?? homedir(), '.claude', 'projects', encodeIdeProjectDir(projectRoot), 'memory');
+}
+function parseFrontmatterDoc(frontmatter) {
+    const top = [];
+    const metadata = [];
+    let inMetadata = false;
+    for (const rawLine of frontmatter.split('\n')) {
+        if (rawLine.trim() === '')
+            continue;
+        const indented = /^\s/.test(rawLine);
+        const line = rawLine.trim();
+        const separator = line.indexOf(':');
+        if (separator < 0)
+            continue;
+        const key = line.slice(0, separator).trim();
+        const value = line.slice(separator + 1).trim();
+        if (indented) {
+            if (inMetadata)
+                metadata.push([key, value]);
+            continue;
+        }
+        inMetadata = key === 'metadata';
+        if (!inMetadata)
+            top.push([key, value]);
+    }
+    return { top, metadata };
+}
+/**
+ * Rewrite a source file's frontmatter to the peaks contract: `name` pinned to
+ * the destination filename stem, and `metadata.type` set to the resolved
+ * kind. Non-contract keys (e.g. `originSessionId`, `modified`, `node_type`)
+ * are preserved verbatim so provenance survives the import; `type` / `kind`
+ * are consumed by the normalization and not duplicated.
+ */
+export function renderNormalizedMemory(input) {
+    const doc = parseFrontmatterDoc(input.frontmatter);
+    const topMap = new Map(doc.top);
+    const metaMap = new Map(doc.metadata);
+    const description = topMap.get('description') ?? metaMap.get('description') ?? summarizeMemoryBody(input.body);
+    const lines = ['---', `name: ${input.stem}`, `description: ${description}`];
+    for (const [key, value] of doc.top) {
+        if (RESERVED_TOP_LEVEL_KEYS.has(key))
+            continue;
+        lines.push(`${key}: ${value}`);
+    }
+    lines.push('metadata:');
+    lines.push(`  type: ${input.kind}`);
+    for (const [key, value] of doc.metadata) {
+        if (RESERVED_METADATA_KEYS.has(key))
+            continue;
+        lines.push(`  ${key}: ${value}`);
+    }
+    lines.push('---', '', input.body, '');
+    return lines.join('\n');
+}

package/dist/services/memory/memory-rotate-service.js

@@ -51,7 +51,11 @@ export const MEMORY_ROTATION_ARCHIVED_DIRNAME = 'archived';
 /** Default reference-grep roots, relative to the project root. */
 export const MEMORY_ROTATION_REFERENCE_ROOTS = ['src', 'skills'];
 /** Tier A — operational contracts. Never selected for rotation. */
-const TIER_A_KINDS = new Set(['rule', 'convention', 'project-rule']);
+const TIER_A_KINDS = new Set([
+    'rule',
+    'convention',
+    'project-rule'
+]);
 /** Tier B — descriptive governance. Never selected for rotation. */
 const TIER_B_KINDS = new Set([
     'decision',
@@ -65,10 +69,26 @@ const TIER_B_KINDS = new Set([
 const EXPLICIT_TIERS = new Set(['A', 'B', 'C', 'D']);
 /** Files we are willing to read during the reference grep. */
 const REFERENCE_SCAN_EXTENSIONS = new Set([
-    '.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs', '.md', '.json', '.yaml', '.yml', '.txt'
+    '.ts',
+    '.tsx',
+    '.js',
+    '.jsx',
+    '.mjs',
+    '.cjs',
+    '.md',
+    '.json',
+    '.yaml',
+    '.yml',
+    '.txt'
 ]);
 const REFERENCE_SCAN_SKIP_DIRS = new Set([
-    'node_modules', '.git', 'dist', 'build', 'coverage', '.next', '.turbo'
+    'node_modules',
+    '.git',
+    'dist',
+    'build',
+    'coverage',
+    '.next',
+    '.turbo'
 ]);
 /** Bound the reference grep so a pathological tree cannot hang the command. */
 const REFERENCE_SCAN_MAX_FILES = 20_000;
@@ -213,8 +233,8 @@ export function executeMemoryRotate(options) {
     const memoryDir = assertSafeProjectMemoryDir(projectRoot);
     const archivedDir = join(memoryDir, MEMORY_ROTATION_ARCHIVED_DIRNAME);
     const now = options.now ?? new Date();
-    const referenceRoots = options.referenceRoots
-        ?? MEMORY_ROTATION_REFERENCE_ROOTS.map((root) => join(projectRoot, root));
+    const referenceRoots = options.referenceRoots ??
+        MEMORY_ROTATION_REFERENCE_ROOTS.map((root) => join(projectRoot, root));
     const report = {
         apply,
         projectRoot,
@@ -270,7 +290,12 @@ export function executeMemoryRotate(options) {
         // (the interesting case); unpinned A/B files are simply not candidates.
         if (tier === 'A' || tier === 'B') {
             if (pinned) {
-                report.excluded.push({ name: parsed.name ?? stem, filePath, tier, reason: 'pinned in MEMORY.md index' });
+                report.excluded.push({
+                    name: parsed.name ?? stem,
+                    filePath,
+                    tier,
+                    reason: 'pinned in MEMORY.md index'
+                });
             }
             continue;
         }
@@ -295,12 +320,20 @@ export function executeMemoryRotate(options) {
             continue; // within the retention window — not a candidate yet
         }
         if (pinned) {
-            report.excluded.push({ name: parsed.name ?? stem, filePath, tier, reason: 'pinned in MEMORY.md index' });
+            report.excluded.push({
+                name: parsed.name ?? stem,
+                filePath,
+                tier,
+                reason: 'pinned in MEMORY.md index'
+            });
             continue;
         }
         const hits = findReferenceHits(stem, referenceRoots);
         if (hits.length > 0) {
-            const preview = hits.slice(0, 2).map((hit) => relative(projectRoot, hit).replaceAll('\\', '/')).join(', ');
+            const preview = hits
+                .slice(0, 2)
+                .map((hit) => relative(projectRoot, hit).replaceAll('\\', '/'))
+                .join(', ');
             report.excluded.push({
                 name: parsed.name ?? stem,
                 filePath,

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

@@ -36,13 +36,13 @@ export function loadMemoryIndex(projectRoot) {
     const index = parsed;
     const hot = index.hot ?? {};
     const flatFromHot = Object.values(hot).flat();
-    const flatFromCold = (index.cold ?? []);
+    const flatFromCold = index.cold ?? [];
     const entries = [...flatFromHot, ...flatFromCold];
     return {
         indexPath,
         version: index.version ?? 1,
         updatedAt: index.updatedAt ?? '',
-        entries,
+        entries
     };
 }
 /**
@@ -65,7 +65,11 @@ export function searchMemory(input) {
     }
     // Per spec: searchable text is name + " " + description.
     // The keyFn is invoked once per item per call.
-    const matches = fuzzyMatchWithKey(input.query, candidates, { keyFn: (e) => `${e.name} ${e.description}`, limit, caseSensitive: false });
+    const matches = fuzzyMatchWithKey(input.query, candidates, {
+        keyFn: (e) => `${e.name} ${e.description}`,
+        limit,
+        caseSensitive: false
+    });
     return matches.map((m) => {
         const entry = m.item;
         return {
@@ -74,7 +78,7 @@ export function searchMemory(input) {
             description: entry.description,
             sourcePath: entry.sourcePath,
             score: m.score,
-            positions: m.positions,
+            positions: m.positions
         };
     });
 }

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

@@ -1,5 +1,7 @@
 import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
+import { z } from 'zod';
+import { parseJson } from '../../shared/json-parse.js';
 import { listSessionMetas } from '../session/session-manager.js';
 import { getSessionDir } from '../session/getSessionDir.js';
 import { bootstrapProjectScan } from '../prd/project-scan-bootstrap-service.js';
@@ -11,15 +13,29 @@ const CONTEXT_HEADER = `# Peaks Project Context
 > Last updated: `;
 const MANAGED_BLOCK_START = '<!-- peaks-managed:session-history-start -->';
 const MANAGED_BLOCK_END = '<!-- peaks-managed:session-history-end -->';
+/**
+ * The one field `projectName` reads out of a `package.json` on disk.
+ *
+ * `looseObject` on purpose: a package.json carries far more than this reader
+ * consumes, and validation is not licence to reject the rest of the file.
+ * `name` is optional, which is a measured fact — a package.json with no `name`
+ * is exactly what the folder-name fallback in `projectName` exists for.
+ */
+const packageNameFileSchema = z.looseObject({ name: z.string().optional() });
 function projectName(projectRoot) {
     const pkgPath = join(projectRoot, 'package.json');
     if (!existsSync(pkgPath))
         return projectRoot.split(/[\\/]/).pop() ?? 'unknown';
     try {
-        const pkg = JSON.parse(readFileSync(pkgPath, 'utf8'));
+        // Only `name` is consumed. Naming it here is what stops the read from
+        // being an `any` read: the folder name fallback below is reached for a
+        // package.json that is malformed OR has no `name`, which is already the
+        // behaviour this `try`/`catch` pair encodes.
+        const pkg = parseJson(readFileSync(pkgPath, 'utf8'), packageNameFileSchema);
         return pkg.name ?? projectRoot.split(/[\\/]/).pop() ?? 'unknown';
     }
-    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 projectRoot.split(/[\\/]/).pop() ?? 'unknown';
     }
 }
@@ -56,14 +72,18 @@ function extractOneLineSummary(sessionRoot) {
             const lines = content.split(/\r?\n/);
             for (const line of lines) {
                 const trimmed = line.trim();
-                if (!trimmed || trimmed.startsWith('#') || trimmed.startsWith('-') || trimmed.startsWith('`'))
+                if (!trimmed ||
+                    trimmed.startsWith('#') ||
+                    trimmed.startsWith('-') ||
+                    trimmed.startsWith('`'))
                     continue;
                 if (trimmed.length > 10 && trimmed.length < 200)
                     return trimmed;
                 break;
             }
         }
-        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)
             // skip unreadable
         }
     }
@@ -152,7 +172,8 @@ export function readProjectContext(projectRoot) {
     try {
         return readFileSync(contextPath, 'utf8');
     }
-    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;
     }
 }

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

@@ -1,8 +1,3 @@
-import type { BackupPlanOptions, ExtractPlanOptions, ExtractSessionMemoriesOptions, ExtractSessionMemoriesResult, 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;
+import type { ExtractSessionMemoriesOptions, ExtractSessionMemoriesResult } from '../types.js';
+export { createProjectMemoryBackupPlan, createProjectMemoryExtractPlan, executeProjectMemoryBackup, executeProjectMemoryExtract, summarizeProjectMemoryBackupResult, summarizeProjectMemoryExtractResult } from './project-memory-plan-exec.js';
 export declare function extractSessionMemories(options: ExtractSessionMemoriesOptions): ExtractSessionMemoriesResult;