peaks-cli 1.0.28 → 1.1.0

package/dist/src/cli/commands/core-artifact-commands.js

@@ -227,11 +227,11 @@ export function registerCoreAndArtifactCommands(program, io) {
     const memory = program.command('memory').description('Manage project-local Peaks memory');
     addJsonOption(memory
         .command('extract')
-        .description('Extract stable project memory from skill artifacts into project .claude/memory')
+        .description('Extract stable project memory from skill artifacts into project .peaks/memory')
         .requiredOption('--project <path>', 'target project root')
         .requiredOption('--artifact <path...>', 'skill artifact paths inside the project')
         .option('--dry-run', 'preview writes without changing files', true)
-        .option('--apply', 'write extracted memories into project .claude/memory')).action((options) => {
+        .option('--apply', 'write extracted memories into project .peaks/memory')).action((options) => {
         try {
             const result = executeProjectMemoryExtract({ projectRoot: options.project, artifactPaths: options.artifact, apply: options.apply === true });
             printResult(io, ok('memory.extract', summarizeProjectMemoryExtractResult(result)), options.json);
@@ -243,11 +243,11 @@ export function registerCoreAndArtifactCommands(program, io) {
     });
     addJsonOption(memory
         .command('sync')
-        .description('Back up project .claude/memory into the artifact workspace')
+        .description('Back up project .peaks/memory into the artifact workspace')
         .requiredOption('--project <path>', 'target project root')
         .requiredOption('--workspace <path>', 'artifact workspace path')
         .option('--dry-run', 'preview copies without changing files', true)
-        .option('--apply', 'copy project .claude/memory into artifact workspace backup')).action((options) => {
+        .option('--apply', 'copy project .peaks/memory into artifact workspace backup')).action((options) => {
         try {
             const result = executeProjectMemoryBackup({ projectRoot: options.project, artifactWorkspacePath: options.workspace, apply: options.apply === true });
             printResult(io, ok('memory.sync', summarizeProjectMemoryBackupResult(result)), options.json);

package/dist/src/cli/commands/project-commands.js

@@ -1,15 +1,8 @@
 import { loadProjectDashboard } from '../../services/dashboard/project-dashboard-service.js';
-import { generateProjectContext, loadOntology, readProjectContext, upsertDecision, upsertModule } from '../../services/memory/project-context-service.js';
+import { generateProjectContext, readProjectContext } from '../../services/memory/project-context-service.js';
+import { readProjectMemories } from '../../services/memory/project-memory-service.js';
 import { fail, ok } from '../../shared/result.js';
 import { addJsonOption, getErrorMessage, printResult } from '../cli-helpers.js';
-function defined(obj) {
-    const result = {};
-    for (const [k, v] of Object.entries(obj)) {
-        if (v !== undefined)
-            result[k] = v;
-    }
-    return result;
-}
 export function registerProjectCommands(program, io) {
     const project = program.command('project').description('Aggregate Peaks state for a target project (read-only)');
     addJsonOption(project
@@ -75,104 +68,33 @@ export function registerProjectCommands(program, io) {
             process.exitCode = 1;
         }
     });
-    // --- Ontology commands (structured project memory for LLM consumption) ---
-    const ontology = project.command('ontology').description('Query structured project memory (modules, decisions, conventions)');
-    addJsonOption(ontology
-        .command('show')
-        .description('Read the full ontology JSON for LLM consumption')
-        .requiredOption('--project <path>', 'target project root')).action((options) => {
-        try {
-            const onto = loadOntology(options.project);
-            if (onto === null) {
-                // Auto-generate if missing
-                const result = generateProjectContext(options.project);
-                printResult(io, ok('project.ontology', result.ontology), options.json);
-                return;
-            }
-            printResult(io, ok('project.ontology', onto), options.json);
-        }
-        catch (error) {
-            printResult(io, fail('project.ontology', 'ONTOLOGY_FAILED', getErrorMessage(error), { projectRoot: options.project }, ['Check the project path']), options.json);
-            process.exitCode = 1;
-        }
-    });
-    addJsonOption(ontology
-        .command('module')
-        .description('Record or query a project module')
-        .requiredOption('--project <path>', 'target project root')
-        .option('--id <id>', 'module id (kebab-case)')
-        .option('--path <path>', 'file path for the module')
-        .option('--risk <level>', 'risk level: low, medium, high')
-        .option('--summary <text>', 'brief module description')
-        .option('--session <id>', 'session id')
-        .option('--put', 'write/update the module entry')).action((options) => {
-        try {
-            if (options.put) {
-                if (!options.id || !options.path || !options.session) {
-                    printResult(io, fail('project.ontology.module', 'MISSING_FIELDS', '--id, --path, --session required with --put', {}, ['Provide all required fields']), options.json);
-                    process.exitCode = 1;
-                    return;
-                }
-                const risk = (options.risk === 'low' || options.risk === 'medium' || options.risk === 'high') ? options.risk : undefined;
-                const result = upsertModule(options.project, defined({
-                    id: options.id,
-                    path: options.path,
-                    session: options.session,
-                    risk,
-                    summary: options.summary
-                }));
-                printResult(io, ok('project.ontology.module', { modules: result.modules }), options.json);
-                return;
-            }
-            const onto = loadOntology(options.project) ?? generateProjectContext(options.project).ontology;
-            if (options.id) {
-                const mod = onto.modules.find((m) => m.id === options.id);
-                printResult(io, ok('project.ontology.module', mod ?? { notFound: true, id: options.id }), options.json);
-                return;
-            }
-            printResult(io, ok('project.ontology.module', { modules: onto.modules }), options.json);
-        }
-        catch (error) {
-            printResult(io, fail('project.ontology.module', 'ONTOLOGY_MODULE_FAILED', getErrorMessage(error), {}, []), options.json);
-            process.exitCode = 1;
-        }
-    });
-    addJsonOption(ontology
-        .command('decision')
-        .description('Record or query architectural decisions')
+    // --- Structured project memory (durable, LLM-authored, stored under .peaks/memory) ---
+    addJsonOption(project
+        .command('memories')
+        .description('Read durable project memories (decisions, conventions, modules, rules) from .peaks/memory for LLM consumption')
         .requiredOption('--project <path>', 'target project root')
-        .option('--id <id>', 'decision id')
-        .option('--what <text>', 'what was decided')
-        .option('--why <text>', 'rationale behind the decision')
-        .option('--scope <modules>', 'comma-separated module ids')
-        .option('--session <id>', 'session id')
-        .option('--date <date>', 'decision date')
-        .option('--put', 'write/update the decision')).action((options) => {
+        .option('--kind <kind>', 'filter by kind: project, rule, decision, reference, feedback, convention, module')).action((options) => {
         try {
-            if (options.put) {
-                if (!options.id || !options.what || !options.session || !options.date) {
-                    printResult(io, fail('project.ontology.decision', 'MISSING_FIELDS', '--id, --what, --session, --date required with --put', {}, []), options.json);
-                    process.exitCode = 1;
-                    return;
-                }
-                const result = upsertDecision(options.project, defined({
-                    id: options.id, what: options.what, why: options.why,
-                    scope: options.scope ? options.scope.split(',').map((s) => s.trim()).filter(Boolean) : [],
-                    session: options.session, date: options.date
-                }));
-                printResult(io, ok('project.ontology.decision', { decisions: result.decisions }), options.json);
+            const result = readProjectMemories(options.project);
+            if (options.kind) {
+                const memories = result.memories.filter((memory) => memory.kind === options.kind);
+                printResult(io, ok('project.memories', {
+                    memoryDir: result.memoryDir,
+                    kind: options.kind,
+                    total: memories.length,
+                    memories
+                }), options.json);
                 return;
             }
-            const onto = loadOntology(options.project) ?? generateProjectContext(options.project).ontology;
-            if (options.id) {
-                const dec = onto.decisions.find((d) => d.id === options.id);
-                printResult(io, ok('project.ontology.decision', dec ?? { notFound: true, id: options.id }), options.json);
-                return;
-            }
-            printResult(io, ok('project.ontology.decision', { decisions: onto.decisions }), options.json);
+            printResult(io, ok('project.memories', {
+                memoryDir: result.memoryDir,
+                total: result.total,
+                byKind: result.byKind,
+                memories: result.memories
+            }), options.json);
         }
         catch (error) {
-            printResult(io, fail('project.ontology.decision', 'ONTOLOGY_DECISION_FAILED', getErrorMessage(error), {}, []), options.json);
+            printResult(io, fail('project.memories', 'PROJECT_MEMORIES_FAILED', getErrorMessage(error), { projectRoot: options.project }, ['Check the project path and .peaks/memory directory']), options.json);
             process.exitCode = 1;
         }
     });

package/dist/src/services/memory/project-context-service.d.ts

@@ -2,48 +2,10 @@ export type ProjectContextSection = {
     heading: string;
     body: string;
 };
-export type Module = {
-    id: string;
-    path: string;
-    risk?: 'low' | 'medium' | 'high';
-    sessions: string[];
-    summary?: string;
-};
-export type Decision = {
-    id: string;
-    what: string;
-    why?: string;
-    scope: string[];
-    session: string;
-    date: string;
-};
-export type Convention = {
-    id: string;
-    rule: string;
-    category: 'code-style' | 'architecture' | 'naming' | 'tooling' | 'other';
-    source: string;
-    date: string;
-};
-export type Ontology = {
-    version: 1;
-    updated: string;
-    project: string;
-    modules: Module[];
-    decisions: Decision[];
-    conventions: Convention[];
-};
-export declare function loadOntology(projectRoot: string): Ontology | null;
-export declare function saveOntology(projectRoot: string, onto: Ontology): void;
-export declare function upsertModule(projectRoot: string, mod: Omit<Module, 'sessions'> & {
-    session: string;
-}): Ontology;
-export declare function upsertDecision(projectRoot: string, dec: Decision): Ontology;
-export declare function upsertConvention(projectRoot: string, conv: Convention): Ontology;
 export declare function generateProjectContext(projectRoot: string): {
     path: string;
     content: string;
     sessionCount: number;
-    ontology: Ontology;
 };
 export declare function readProjectContext(projectRoot: string): string | null;
 export declare function getProjectContextPath(projectRoot: string): string;

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

@@ -1,8 +1,7 @@
 import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from 'node:fs';
-import { join, relative } from 'node:path';
+import { join } from 'node:path';
 import { listSessionMetas } from '../session/session-manager.js';
 const PROJECT_CONTEXT_FILE = '.peaks/PROJECT.md';
-const ONTOLOGY_FILE = '.peaks/ontology.json';
 const CONTEXT_HEADER = `# Peaks Project Context
 
 > Auto-generated project memory. Peaks reads this at the start of each session to understand
@@ -46,26 +45,6 @@ function listMdFiles(dir, maxDepth = 3) {
     }
     return results;
 }
-function extractArtifactSummary(filePath, sessionRoot) {
-    try {
-        const content = readFileSync(filePath, 'utf8');
-        const lines = content.split(/\r?\n/);
-        const firstHeading = lines.find((l) => /^#\s/.test(l))?.replace(/^#\s+/, '').trim();
-        const stateLine = lines.find((l) => /^\-\s*state:\s*/.test(l))?.trim();
-        const relPath = relative(sessionRoot, filePath).split(/[\\/]/).join('/');
-        const parts = [];
-        if (firstHeading)
-            parts.push(firstHeading);
-        if (stateLine)
-            parts.push(stateLine.replace(/^-\s*state:\s*/, ''));
-        if (parts.length === 0)
-            return `- \`${relPath}\``;
-        return `- \`${relPath}\` — ${parts.join(' | ')}`;
-    }
-    catch {
-        return null;
-    }
-}
 function extractOneLineSummary(sessionRoot) {
     const artifacts = listMdFiles(sessionRoot, 4);
     for (const artifact of artifacts.slice(0, 5)) {
@@ -88,27 +67,6 @@ function extractOneLineSummary(sessionRoot) {
     }
     return null;
 }
-function renderSessionBlock(meta, projectRoot) {
-    const title = meta.title ?? 'Untitled';
-    const date = meta.createdAt ? meta.createdAt.slice(0, 10) : '?';
-    const skill = meta.skill ?? '-';
-    const mode = meta.mode ?? '-';
-    let block = `### ${date} — ${title}\n`;
-    block += `- ${skill} (${mode})`;
-    const sessionRoot = join(projectRoot, '.peaks', meta.sessionId);
-    const summary = extractOneLineSummary(sessionRoot);
-    if (summary) {
-        block += ` — ${summary.slice(0, 120)}`;
-    }
-    block += '\n';
-    // Key artifact paths only
-    const artifacts = listMdFiles(sessionRoot, 3);
-    if (artifacts.length > 0) {
-        const paths = artifacts.slice(0, 8).map((f) => relative(sessionRoot, f).split(/[\\/]/).join('/'));
-        block += `  ${paths.join('  ')}\n`;
-    }
-    return block;
-}
 function buildSessionHistory(projectRoot) {
     const metas = listSessionMetas(projectRoot);
     if (metas.length === 0) {
@@ -139,263 +97,6 @@ function buildSessionHistory(projectRoot) {
     body += `\n${MANAGED_BLOCK_END}`;
     return body;
 }
-// --- Ontology engine ---
-function emptyOntology(projectName) {
-    return {
-        version: 1,
-        updated: new Date().toISOString(),
-        project: projectName,
-        modules: [],
-        decisions: [],
-        conventions: []
-    };
-}
-function ontoPath(projectRoot) {
-    return join(projectRoot, ONTOLOGY_FILE);
-}
-export function loadOntology(projectRoot) {
-    const path = ontoPath(projectRoot);
-    if (!existsSync(path))
-        return null;
-    try {
-        const raw = JSON.parse(readFileSync(path, 'utf8'));
-        if (raw?.version === 1 && Array.isArray(raw.modules)) {
-            return raw;
-        }
-        return null;
-    }
-    catch {
-        return null;
-    }
-}
-function slugify(text) {
-    return text.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '') || 'unknown';
-}
-function scanModulesFromArtifacts(sessionRoot, sessionId) {
-    const artifacts = listMdFiles(sessionRoot, 4);
-    const modules = [];
-    const seen = new Set();
-    for (const artifact of artifacts.slice(0, 10)) {
-        try {
-            const content = readFileSync(artifact, 'utf8');
-            // Extract file paths — non-capturing groups for extensions
-            const patterns = [
-                /\b(src\/[^\s)`\]}"]+\.(?:tsx?|jsx?|css|less|scss|vue|svelte))\b/g,
-                /\b(packages\/[^\s)`\]}"]+\.(?:tsx?|jsx?))\b/g
-            ];
-            for (const pattern of patterns) {
-                let m;
-                while ((m = pattern.exec(content)) !== null) {
-                    const filePath = m[1] ?? '';
-                    if (!filePath || filePath.length > 120 || filePath.length < 5)
-                        continue;
-                    const id = slugify(filePath.replace(/\.[^.]+$/, '').replace(/[\/\\]/g, '-'));
-                    if (seen.has(id))
-                        continue;
-                    seen.add(id);
-                    modules.push({ id, path: filePath });
-                    if (modules.length >= 30)
-                        break;
-                }
-                if (modules.length >= 30)
-                    break;
-            }
-        }
-        catch {
-            // skip unreadable
-        }
-    }
-    return modules;
-}
-function scanDecisionsFromArtifacts(sessionRoot, session) {
-    const artifacts = listMdFiles(sessionRoot, 4);
-    const decisions = [];
-    const date = session.createdAt ? session.createdAt.slice(0, 10) : new Date().toISOString().slice(0, 10);
-    for (const artifact of artifacts.slice(0, 10)) {
-        try {
-            const content = readFileSync(artifact, 'utf8');
-            // Look for decision markers: "- Decision: ..." or "Decision: ..." or "ADR: ..."
-            const decRegex = /^[\s-]*(?:decision|adr|决定|决策)\s*:\s*(.+?)$/gim;
-            let m;
-            while ((m = decRegex.exec(content)) !== null) {
-                const what = (m[1] ?? '').trim().slice(0, 200);
-                if (what.length < 5)
-                    continue;
-                const id = slugify(what.slice(0, 40));
-                // Collect scope from surrounding context (modules mentioned within 3 lines before/after)
-                const scope = [];
-                const lineIdx = content.slice(0, m.index).split('\n').length;
-                const lines = content.split('\n');
-                for (let i = Math.max(0, lineIdx - 3); i < Math.min(lines.length, lineIdx + 3); i++) {
-                    const line = lines[i] ?? '';
-                    const pathMatch = /src\/[^\s)`\]}"]+\.(tsx?|jsx?)/.exec(line);
-                    if (pathMatch?.[0])
-                        scope.push(pathMatch[0]);
-                }
-                decisions.push({ id, what, scope: [...new Set(scope)].slice(0, 5), session: session.sessionId, date });
-                if (decisions.length >= 10)
-                    break;
-            }
-        }
-        catch {
-            // skip unreadable
-        }
-    }
-    return decisions;
-}
-function scanConventionsFromArtifacts(sessionRoot, session) {
-    const artifacts = listMdFiles(sessionRoot, 4);
-    const conventions = [];
-    const date = session.createdAt ? session.createdAt.slice(0, 10) : new Date().toISOString().slice(0, 10);
-    for (const artifact of artifacts.slice(0, 10)) {
-        try {
-            const content = readFileSync(artifact, 'utf8');
-            const convRegex = /^[\s-]*(?:convention|约定|规范)\s*:\s*(.+?)$/gim;
-            let m;
-            while ((m = convRegex.exec(content)) !== null) {
-                const rule = (m[1] ?? '').trim().slice(0, 200);
-                if (rule.length < 5)
-                    continue;
-                const id = slugify(rule.slice(0, 40));
-                // Infer category from keywords
-                let category = 'other';
-                if (/class|function|interface|type|hook|component/i.test(rule))
-                    category = 'code-style';
-                else if (/service|layer|package|module|shared|extract/i.test(rule))
-                    category = 'architecture';
-                else if (/naming|命名|文件名|prefix|suffix/i.test(rule))
-                    category = 'naming';
-                else if (/tooling|lint|format|build|test/i.test(rule))
-                    category = 'tooling';
-                conventions.push({ id, rule, category, source: session.sessionId, date });
-                if (conventions.length >= 10)
-                    break;
-            }
-        }
-        catch {
-            // skip unreadable
-        }
-    }
-    return conventions;
-}
-function buildOntology(projectRoot) {
-    const name = projectName(projectRoot);
-    const existing = loadOntology(projectRoot);
-    const onto = existing ?? emptyOntology(name);
-    onto.updated = new Date().toISOString();
-    onto.project = name;
-    const metas = listSessionMetas(projectRoot);
-    const knownSessions = new Set(metas.map((m) => m.sessionId));
-    // Prune: remove modules/decisions/conventions from sessions that no longer exist
-    onto.modules = onto.modules.filter((m) => m.sessions.some((s) => knownSessions.has(s)));
-    onto.decisions = onto.decisions.filter((d) => knownSessions.has(d.session));
-    onto.conventions = onto.conventions.filter((c) => knownSessions.has(c.source));
-    // Merge: scan each session for new modules and decisions
-    const moduleMap = new Map();
-    for (const m of onto.modules)
-        moduleMap.set(m.id, m);
-    const decisionMap = new Map();
-    for (const d of onto.decisions)
-        decisionMap.set(d.id, d);
-    for (const meta of metas) {
-        const sessionRoot = join(projectRoot, '.peaks', meta.sessionId);
-        // Modules
-        const foundModules = scanModulesFromArtifacts(sessionRoot, meta.sessionId);
-        for (const fm of foundModules) {
-            if (moduleMap.has(fm.id)) {
-                const existing = moduleMap.get(fm.id);
-                if (!existing.sessions.includes(meta.sessionId)) {
-                    existing.sessions.push(meta.sessionId);
-                }
-            }
-            else {
-                moduleMap.set(fm.id, {
-                    id: fm.id,
-                    path: fm.path,
-                    sessions: [meta.sessionId]
-                });
-            }
-        }
-        // Decisions
-        const foundDecisions = scanDecisionsFromArtifacts(sessionRoot, meta);
-        for (const fd of foundDecisions) {
-            if (!decisionMap.has(fd.id)) {
-                decisionMap.set(fd.id, fd);
-            }
-        }
-        // Conventions
-        const foundConventions = scanConventionsFromArtifacts(sessionRoot, meta);
-        const convMap = new Map();
-        for (const c of onto.conventions)
-            convMap.set(c.id, c);
-        for (const fc of foundConventions) {
-            if (!convMap.has(fc.id)) {
-                convMap.set(fc.id, fc);
-            }
-        }
-        onto.conventions = [...convMap.values()].sort((a, b) => a.date.localeCompare(b.date));
-    }
-    // Dedup: remove shorter paths that are substring-matches of longer paths
-    const modules = [...moduleMap.values()];
-    const deduped = modules.filter((m) => {
-        return !modules.some((other) => other !== m && other.path.length > m.path.length && other.path.endsWith(m.path));
-    });
-    onto.modules = deduped.sort((a, b) => b.sessions.length - a.sessions.length);
-    onto.decisions = [...decisionMap.values()].sort((a, b) => b.date.localeCompare(a.date));
-    return onto;
-}
-export function saveOntology(projectRoot, onto) {
-    const peaksDir = join(projectRoot, '.peaks');
-    if (!existsSync(peaksDir))
-        mkdirSync(peaksDir, { recursive: true });
-    writeFileSync(ontoPath(projectRoot), JSON.stringify(onto, null, 2), 'utf8');
-}
-// Mutations for skills to call when they discover new facts
-export function upsertModule(projectRoot, mod) {
-    const onto = buildOntology(projectRoot);
-    const existing = onto.modules.find((m) => m.id === mod.id);
-    if (existing) {
-        if (!existing.sessions.includes(mod.session))
-            existing.sessions.push(mod.session);
-        if (mod.risk)
-            existing.risk = mod.risk;
-        if (mod.summary)
-            existing.summary = mod.summary;
-    }
-    else {
-        onto.modules.push({ ...mod, sessions: [mod.session] });
-    }
-    onto.updated = new Date().toISOString();
-    saveOntology(projectRoot, onto);
-    return onto;
-}
-export function upsertDecision(projectRoot, dec) {
-    const onto = buildOntology(projectRoot);
-    const idx = onto.decisions.findIndex((d) => d.id === dec.id);
-    if (idx >= 0) {
-        onto.decisions[idx] = dec;
-    }
-    else {
-        onto.decisions.push(dec);
-    }
-    onto.updated = new Date().toISOString();
-    saveOntology(projectRoot, onto);
-    return onto;
-}
-export function upsertConvention(projectRoot, conv) {
-    const onto = buildOntology(projectRoot);
-    const idx = onto.conventions.findIndex((c) => c.id === conv.id);
-    if (idx >= 0) {
-        onto.conventions[idx] = conv;
-    }
-    else {
-        onto.conventions.push(conv);
-    }
-    onto.updated = new Date().toISOString();
-    saveOntology(projectRoot, onto);
-    return onto;
-}
-// --- Context generator (unified: PROJECT.md + ontology.json) ---
 export function generateProjectContext(projectRoot) {
     const peaksDir = join(projectRoot, '.peaks');
     if (!existsSync(peaksDir)) {
@@ -428,10 +129,7 @@ export function generateProjectContext(projectRoot) {
         content = header + '\n' + sessionHistory + '\n';
     }
     writeFileSync(contextPath, content, 'utf8');
-    // Build and save ontology alongside PROJECT.md
-    const ontology = buildOntology(projectRoot);
-    saveOntology(projectRoot, ontology);
-    return { path: contextPath, content, sessionCount: listSessionMetas(projectRoot).length, ontology };
+    return { path: contextPath, content, sessionCount: listSessionMetas(projectRoot).length };
 }
 export function readProjectContext(projectRoot) {
     const contextPath = join(projectRoot, PROJECT_CONTEXT_FILE);

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

@@ -1,4 +1,4 @@
-export type ProjectMemoryKind = 'project' | 'rule' | 'decision' | 'reference' | 'feedback';
+export type ProjectMemoryKind = 'project' | 'rule' | 'decision' | 'reference' | 'feedback' | 'convention' | 'module';
 export type ExtractedProjectMemory = {
     title: string;
     kind: ProjectMemoryKind;
@@ -59,6 +59,21 @@ export type ProjectMemoryBackupPlan = {
 export type ProjectMemoryBackupResult = ProjectMemoryBackupPlan & {
     copiedFiles: string[];
 };
+export type StoredProjectMemory = {
+    name: string;
+    title: string;
+    kind: ProjectMemoryKind;
+    sourceArtifact: string | null;
+    body: string;
+    filePath: string;
+};
+export type ProjectMemoryReadResult = {
+    projectRoot: string;
+    memoryDir: string;
+    total: number;
+    byKind: Record<ProjectMemoryKind, StoredProjectMemory[]>;
+    memories: StoredProjectMemory[];
+};
 type ExtractPlanOptions = {
     projectRoot: string;
     artifactPaths: string[];
@@ -76,4 +91,5 @@ export declare function createProjectMemoryBackupPlan(options: BackupPlanOptions
 export declare function executeProjectMemoryBackup(options: BackupPlanOptions): ProjectMemoryBackupResult;
 export declare function summarizeProjectMemoryExtractResult(result: ProjectMemoryExtractResult): ProjectMemoryExtractSummary;
 export declare function summarizeProjectMemoryBackupResult(result: ProjectMemoryBackupResult): ProjectMemoryBackupSummary;
+export declare function readProjectMemories(projectRoot: string): ProjectMemoryReadResult;
 export {};

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

@@ -4,7 +4,7 @@ import { isInsidePath, isWindowsAbsolutePath, normalizePath, resolveInputPath, s
 import { containsSensitiveConfigValue, isSensitiveConfigPath } from '../config/config-service.js';
 const START_MARKER = '<!-- peaks-memory:start -->';
 const END_MARKER = '<!-- peaks-memory:end -->';
-const VALID_MEMORY_KINDS = new Set(['project', 'rule', 'decision', 'reference', 'feedback']);
+const VALID_MEMORY_KINDS = new Set(['project', 'rule', 'decision', 'reference', 'feedback', 'convention', 'module']);
 function normalizeRoot(path) {
     return resolveInputPath(path);
 }
@@ -42,11 +42,11 @@ function assertInsideProject(path, projectRoot) {
 function assertSafeProjectMemoryDir(projectRoot) {
     const resolvedRoot = normalizeRoot(projectRoot);
     const realRoot = normalizeRealRoot(projectRoot);
-    const claudeDir = join(resolvedRoot, '.claude');
-    if (existsSync(claudeDir) && lstatSync(claudeDir).isSymbolicLink()) {
+    const peaksDir = join(resolvedRoot, '.peaks');
+    if (existsSync(peaksDir) && lstatSync(peaksDir).isSymbolicLink()) {
         throw new Error('Project memory directory must stay inside the project root');
     }
-    const memoryDir = join(claudeDir, 'memory');
+    const memoryDir = join(peaksDir, 'memory');
     if (existsSync(memoryDir)) {
         if (lstatSync(memoryDir).isSymbolicLink()) {
             throw new Error('Project memory directory must stay inside the project root');
@@ -136,6 +136,41 @@ function renderMemoryFile(memory) {
         ''
     ].join('\n');
 }
+function parseStoredMemoryFile(content, filePath) {
+    const normalized = content.replace(/\r\n/g, '\n');
+    if (!normalized.startsWith('---\n'))
+        return null;
+    const endIndex = normalized.indexOf('\n---\n', 4);
+    if (endIndex < 0)
+        return null;
+    const frontmatter = normalized.slice(4, endIndex);
+    const body = normalized.slice(endIndex + '\n---\n'.length).trim();
+    let name;
+    let description;
+    let kind;
+    let sourceArtifact;
+    for (const rawLine of frontmatter.split('\n')) {
+        const line = rawLine.trim();
+        if (line.startsWith('name:'))
+            name = line.slice('name:'.length).trim();
+        else if (line.startsWith('description:'))
+            description = line.slice('description:'.length).trim();
+        else if (line.startsWith('type:'))
+            kind = line.slice('type:'.length).trim();
+        else if (line.startsWith('sourceArtifact:'))
+            sourceArtifact = line.slice('sourceArtifact:'.length).trim();
+    }
+    if (!name || !kind || !VALID_MEMORY_KINDS.has(kind) || body.length === 0)
+        return null;
+    return {
+        name,
+        title: description ?? name,
+        kind: kind,
+        sourceArtifact: sourceArtifact && sourceArtifact !== 'undefined' ? sourceArtifact : null,
+        body,
+        filePath
+    };
+}
 function summarizeExtractResult(result) {
     return {
         apply: result.apply,
@@ -304,3 +339,36 @@ export function summarizeProjectMemoryExtractResult(result) {
 export function summarizeProjectMemoryBackupResult(result) {
     return summarizeBackupResult(result);
 }
+function emptyByKind() {
+    return {
+        project: [],
+        rule: [],
+        decision: [],
+        reference: [],
+        feedback: [],
+        convention: [],
+        module: []
+    };
+}
+export function readProjectMemories(projectRoot) {
+    const normalizedRoot = normalizeRoot(projectRoot);
+    const memoryDir = assertSafeProjectMemoryDir(normalizedRoot);
+    const memories = [];
+    for (const filePath of listMarkdownFiles(memoryDir)) {
+        const parsed = parseStoredMemoryFile(readFileSync(filePath, 'utf8'), filePath);
+        if (parsed)
+            memories.push(parsed);
+    }
+    memories.sort((left, right) => left.name.localeCompare(right.name));
+    const byKind = emptyByKind();
+    for (const memory of memories) {
+        byKind[memory.kind].push(memory);
+    }
+    return {
+        projectRoot: normalizedRoot,
+        memoryDir,
+        total: memories.length,
+        byKind,
+        memories
+    };
+}

package/dist/src/shared/version.d.ts

@@ -1 +1 @@
-export declare const CLI_VERSION = "1.0.28";
+export declare const CLI_VERSION = "1.1.0";

package/dist/src/shared/version.js

@@ -1 +1 @@
-export const CLI_VERSION = "1.0.28";
+export const CLI_VERSION = "1.1.0";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "peaks-cli",
-  "version": "1.0.28",
+  "version": "1.1.0",
   "description": "Peaks CLI and short skill family for Claude Code automation.",
   "author": "SquabbyZ",
   "license": "MIT",

package/skills/peaks-prd/SKILL.md

@@ -14,13 +14,13 @@ Before any analysis or tool call, immediately run:
 ```bash
 peaks skill presence:set peaks-prd --project <repo> --mode <mode> --gate startup
 ```
-Read persistent project memory via CLI (structured ontology for LLM):
+Read persistent project memory via CLI (durable, LLM-authored memories):
 
 ```bash
-peaks project ontology show --project <repo> --json
+peaks project memories --project <repo> --json
 ```
 
-This returns `.peaks/ontology.json` — structured modules, decisions, and conventions from past sessions. (`.peaks/PROJECT.md` is a human-readable timeline only.)
+This returns durable memories from `.peaks/memory` — decisions, conventions, modules, and rules captured in past sessions. Filter with `--kind <decision|convention|module|rule|reference|project>`. (`.peaks/PROJECT.md` is a human-readable session timeline only.)
 Then display: `Peaks-Cli Skill: peaks-prd | Peaks-Cli Gate: startup | Next: <one short action>`. Update with `peaks skill presence:set peaks-prd --project <repo> --mode <mode> --gate <gate>` when gates change. When the role's work ends, run `peaks skill presence:clear --project <repo>`.
 
 ## Responsibilities

package/skills/peaks-qa/SKILL.md

@@ -14,13 +14,13 @@ Before any analysis or tool call, immediately run:
 ```bash
 peaks skill presence:set peaks-qa --project <repo> --mode <mode> --gate startup
 ```
-Read persistent project memory via CLI (structured ontology for LLM):
+Read persistent project memory via CLI (durable, LLM-authored memories):
 
 ```bash
-peaks project ontology show --project <repo> --json
+peaks project memories --project <repo> --json
 ```
 
-This returns `.peaks/ontology.json` — structured modules, decisions, and conventions from past sessions. (`.peaks/PROJECT.md` is a human-readable timeline only.)
+This returns durable memories from `.peaks/memory` — decisions, conventions, modules, and rules captured in past sessions. Filter with `--kind <decision|convention|module|rule|reference|project>`. (`.peaks/PROJECT.md` is a human-readable session timeline only.)
 Then display: `Peaks-Cli Skill: peaks-qa | Peaks-Cli Gate: startup | Next: <one short action>`. Update with `peaks skill presence:set peaks-qa --project <repo> --mode <mode> --gate <gate>` when gates change. When the role's work ends, run `peaks skill presence:clear --project <repo>`.
 
 ## Responsibilities

package/skills/peaks-rd/SKILL.md

@@ -14,13 +14,13 @@ Before any analysis or tool call, immediately run:
 ```bash
 peaks skill presence:set peaks-rd --project <repo> --mode <mode> --gate startup
 ```
-Read persistent project memory via CLI (structured ontology for LLM):
+Read persistent project memory via CLI (durable, LLM-authored memories):
 
 ```bash
-peaks project ontology show --project <repo> --json
+peaks project memories --project <repo> --json
 ```
 
-This returns `.peaks/ontology.json` — structured modules, decisions, and conventions from past sessions. (`.peaks/PROJECT.md` is a human-readable timeline only.)
+This returns durable memories from `.peaks/memory` — decisions, conventions, modules, and rules captured in past sessions. Filter with `--kind <decision|convention|module|rule|reference|project>`. (`.peaks/PROJECT.md` is a human-readable session timeline only.)
 Then display: `Peaks-Cli Skill: peaks-rd | Peaks-Cli Gate: startup | Next: <one short action>`. Update with `peaks skill presence:set peaks-rd --project <repo> --mode <mode> --gate <gate>` when gates change. When the role's work ends, run `peaks skill presence:clear --project <repo>`.
 
 ## Responsibilities

package/skills/peaks-sc/SKILL.md

@@ -14,13 +14,13 @@ Before any analysis or tool call, immediately run:
 ```bash
 peaks skill presence:set peaks-sc --project <repo> --mode <mode> --gate startup
 ```
-Read persistent project memory via CLI (structured ontology for LLM):
+Read persistent project memory via CLI (durable, LLM-authored memories):
 
 ```bash
-peaks project ontology show --project <repo> --json
+peaks project memories --project <repo> --json
 ```
 
-This returns `.peaks/ontology.json` — structured modules, decisions, and conventions from past sessions. (`.peaks/PROJECT.md` is a human-readable timeline only.)
+This returns durable memories from `.peaks/memory` — decisions, conventions, modules, and rules captured in past sessions. Filter with `--kind <decision|convention|module|rule|reference|project>`. (`.peaks/PROJECT.md` is a human-readable session timeline only.)
 Then display: `Peaks-Cli Skill: peaks-sc | Peaks-Cli Gate: startup | Next: <one short action>`. Update with `peaks skill presence:set peaks-sc --project <repo> --mode <mode> --gate <gate>` when gates change. When the role's work ends, run `peaks skill presence:clear --project <repo>`.
 
 ## Responsibilities
@@ -56,7 +56,7 @@ Use gstack as a concrete source-control and release workflow reference for the `
 
 ## Project memory backup
 
-Project `.claude/memory` is the primary source for durable project memory. At approved checkpoints, use `peaks memory sync --project <path> --workspace <artifact-workspace> --apply` to back up the full project memory directory into the artifact repository workspace; do not treat the artifact backup as a second writable memory source.
+Project `.peaks/memory` is the primary source for durable project memory. At approved checkpoints, use `peaks memory sync --project <path> --workspace <artifact-workspace> --apply` to back up the full project memory directory into the artifact repository workspace; do not treat the artifact backup as a second writable memory source.
 
 ## Commit boundary derivation
 

package/skills/peaks-solo/SKILL.md

@@ -78,22 +78,23 @@ Then display the compact status header: `Peaks-Cli Skill: peaks-solo | Peaks-Cli
 
 Update with `peaks skill presence:set peaks-solo --project <repo> --mode <mode> --gate <gate>` when gates change. The presence file persists across the full workflow lifecycle — do NOT clear it at workflow end.
 
-### Peaks-Cli Step 2.3: Load project memory (structured ontology for LLM)
+### Peaks-Cli Step 2.3: Load project memory (durable, LLM-authored memories)
 
-Before planning any work, read the project's persistent memory — structured data that survives across sessions:
+Before planning any work, read the project's persistent memory — durable memories that survive across sessions:
 
 ```bash
-peaks project ontology show --project <repo> --json
+peaks project memories --project <repo> --json
 ```
 
-This returns `.peaks/ontology.json` containing:
-- **modules** — code areas touched, with risk levels and which sessions modified them
-- **decisions** — architectural choices, why they were made, what modules they affect
-- **conventions** — discovered project patterns (code style, naming, tooling)
+This returns durable memories from `.peaks/memory`, grouped by kind:
+- **module** — code areas touched, with risk and rationale captured by past sessions
+- **decision** — architectural choices, why they were made, what they affect
+- **convention** — discovered project patterns (code style, naming, tooling)
+- **rule** / **reference** / **project** — standing constraints, external pointers, and project context
 
-Use this to understand what exists, what was decided, and what to avoid re-litigating. The ontology is auto-updated on `peaks skill presence:clear`.
+Filter with `--kind <decision|convention|module|rule|reference|project>` when you only need one slice. Use this to understand what exists, what was decided, and what to avoid re-litigating. Memories are LLM-authored at approved checkpoints via `peaks memory extract`.
 
-`.peaks/PROJECT.md` is a human-readable timeline only — do NOT use it for LLM context.
+`.peaks/PROJECT.md` is a human-readable session timeline only — do NOT use it for LLM context.
 
 ### Peaks-Cli Step 2.5: Set session title
 

package/skills/peaks-txt/SKILL.md

@@ -14,13 +14,13 @@ Before any analysis or tool call, immediately run:
 ```bash
 peaks skill presence:set peaks-txt --project <repo> --mode <mode> --gate startup
 ```
-Read persistent project memory via CLI (structured ontology for LLM):
+Read persistent project memory via CLI (durable, LLM-authored memories):
 
 ```bash
-peaks project ontology show --project <repo> --json
+peaks project memories --project <repo> --json
 ```
 
-This returns `.peaks/ontology.json` — structured modules, decisions, and conventions from past sessions. (`.peaks/PROJECT.md` is a human-readable timeline only.)
+This returns durable memories from `.peaks/memory` — decisions, conventions, modules, and rules captured in past sessions. Filter with `--kind <decision|convention|module|rule|reference|project>`. (`.peaks/PROJECT.md` is a human-readable session timeline only.)
 Then display: `Peaks-Cli Skill: peaks-txt | Peaks-Cli Gate: startup | Next: <one short action>`. Update with `peaks skill presence:set peaks-txt --project <repo> --mode <mode> --gate <gate>` when gates change. When the role's work ends, run `peaks skill presence:clear --project <repo>`.
 
 ## Responsibilities
@@ -96,7 +96,7 @@ Each entry should include:
 - why it exists;
 - affected skills;
 - how future PRD/RD/UI/QA/SC/Solo workflows should apply it;
-- whether it is stable enough for `.claude/memory` extraction.
+- whether it is stable enough for `.peaks/memory` extraction.
 
 ## Project memory guidance
 
@@ -111,7 +111,7 @@ Stable memory body.
 <!-- peaks-memory:end -->
 ```
 
-The primary write target is the target project's `.claude/memory`. Use `peaks memory extract --project <path> --artifact <artifact> --apply` only after the user or active profile allows durable project memory writes.
+The primary write target is the target project's `.peaks/memory`. Use `peaks memory extract --project <path> --artifact <artifact> --apply` only after the user or active profile allows durable project memory writes.
 
 ## Matt Pocock skills integration
 

package/skills/peaks-ui/SKILL.md

@@ -14,13 +14,13 @@ Before any analysis or tool call, immediately run:
 ```bash
 peaks skill presence:set peaks-ui --project <repo> --mode <mode> --gate startup
 ```
-Read persistent project memory via CLI (structured ontology for LLM):
+Read persistent project memory via CLI (durable, LLM-authored memories):
 
 ```bash
-peaks project ontology show --project <repo> --json
+peaks project memories --project <repo> --json
 ```
 
-This returns `.peaks/ontology.json` — structured modules, decisions, and conventions from past sessions. (`.peaks/PROJECT.md` is a human-readable timeline only.)
+This returns durable memories from `.peaks/memory` — decisions, conventions, modules, and rules captured in past sessions. Filter with `--kind <decision|convention|module|rule|reference|project>`. (`.peaks/PROJECT.md` is a human-readable session timeline only.)
 Then display: `Peaks-Cli Skill: peaks-ui | Peaks-Cli Gate: startup | Next: <one short action>`. Update with `peaks skill presence:set peaks-ui --project <repo> --mode <mode> --gate <gate>` when gates change. When the role's work ends, run `peaks skill presence:clear --project <repo>`.
 
 ## Responsibilities