@phuetz/code-buddy 1.1.0 → 1.2.0

package/dist/memory/memory-candidate-queue.js

@@ -0,0 +1,261 @@
+/**
+ * Review-gated long-term memory candidates.
+ *
+ * Declarative memories are more dangerous than procedural lessons because they
+ * are injected into future prompts as "facts". The safe loop is therefore:
+ * infer -> enqueue with evidence -> human accepts/rejects -> write bounded
+ * persistent memory. Proposing a candidate never mutates CODEBUDDY_MEMORY.md.
+ */
+import fs from 'fs';
+import path from 'path';
+import { scanForSecrets, redactSecrets } from '../fleet/privacy-lint.js';
+import { logger } from '../utils/logger.js';
+import { getMemoryManager, } from './persistent-memory.js';
+export const MEMORY_CANDIDATE_SCHEMA_VERSION = 1;
+const VALID_CATEGORIES = [
+    'project',
+    'preferences',
+    'decisions',
+    'patterns',
+    'context',
+    'custom',
+];
+const registry = new Map();
+export function getMemoryCandidateQueue(workDir = process.cwd()) {
+    const key = path.resolve(workDir);
+    if (!registry.has(key)) {
+        registry.set(key, new MemoryCandidateQueue(key));
+        if (registry.size > 20) {
+            const firstKey = registry.keys().next().value;
+            if (firstKey)
+                registry.delete(firstKey);
+        }
+    }
+    return registry.get(key);
+}
+export function resetMemoryCandidateQueues() {
+    registry.clear();
+}
+export class MemoryCandidateQueue {
+    workDir;
+    memoryManager;
+    filePath;
+    candidates = [];
+    loaded = false;
+    constructor(workDir = process.cwd(), memoryManager) {
+        this.workDir = workDir;
+        this.memoryManager = memoryManager;
+        this.filePath = path.join(workDir, '.codebuddy', 'memory-candidates.json');
+    }
+    propose(input) {
+        this.load();
+        const key = normalizeText(input.key);
+        const value = normalizeText(input.value);
+        const scope = normalizeScope(input.scope);
+        const category = normalizeCategory(input.category);
+        if (!key)
+            throw new Error('Memory candidate key is required.');
+        if (!value)
+            throw new Error('Memory candidate value is required.');
+        const citations = sanitizeCitations(input.citations);
+        const lintTarget = [
+            key,
+            value,
+            input.rationale ?? '',
+            ...citations.map((citation) => citation.snippet),
+        ].join('\n');
+        const lint = scanForSecrets(lintTarget);
+        if (lint.hasSecrets) {
+            throw new Error(`Memory candidate rejected before queueing: sensitive material detected (${lint.matches.map((m) => m.kind).join(', ')}).`);
+        }
+        const existing = this.candidates.find((candidate) => candidate.status === 'pending' &&
+            candidate.scope === scope &&
+            candidate.key.trim().toLowerCase() === key.toLowerCase() &&
+            candidate.value.trim().toLowerCase() === value.toLowerCase());
+        if (existing) {
+            return { candidate: existing, deduped: true };
+        }
+        const candidate = {
+            id: `mc-${Date.now().toString(36)}${Math.random().toString(36).slice(2, 5)}`,
+            key,
+            value,
+            scope,
+            category,
+            status: 'pending',
+            createdAt: Date.now(),
+            source: input.source ?? 'self_observed',
+            ...(typeof input.confidence === 'number' ? { confidence: clampConfidence(input.confidence) } : {}),
+            ...(input.rationale?.trim() ? { rationale: input.rationale.trim() } : {}),
+            ...(citations.length > 0 ? { citations } : {}),
+        };
+        this.candidates.push(candidate);
+        this.save();
+        return { candidate, deduped: false };
+    }
+    list(status) {
+        this.load();
+        const items = status ? this.candidates.filter((candidate) => candidate.status === status) : this.candidates;
+        return [...items].sort((a, b) => b.createdAt - a.createdAt);
+    }
+    get(id) {
+        this.load();
+        return this.candidates.find((candidate) => candidate.id === id) ?? null;
+    }
+    async accept(id, input) {
+        this.load();
+        const reviewedBy = input.reviewedBy?.trim();
+        if (!reviewedBy) {
+            throw new Error('Human approval (reviewedBy) is required before a memory candidate can be written.');
+        }
+        const candidate = this.candidates.find((item) => item.id === id);
+        if (!candidate)
+            throw new Error(`Memory candidate not found: ${id}`);
+        if (candidate.status !== 'pending') {
+            throw new Error(`Memory candidate ${id} is already ${candidate.status}; only pending candidates can be accepted.`);
+        }
+        const key = input.key !== undefined ? normalizeText(input.key) : candidate.key;
+        const value = input.value !== undefined ? normalizeText(input.value) : candidate.value;
+        const scope = input.scope ? normalizeScope(input.scope) : candidate.scope;
+        const category = input.category ? normalizeCategory(input.category) : candidate.category;
+        if (!key)
+            throw new Error('Accepted memory key cannot be empty.');
+        if (!value)
+            throw new Error('Accepted memory value cannot be empty.');
+        const manager = this.memoryManager ?? getMemoryManager();
+        await manager.initialize();
+        const write = await manager.remember(key, value, {
+            scope,
+            category,
+            tags: ['memory-candidate', candidate.id],
+        });
+        candidate.key = key;
+        candidate.value = value;
+        candidate.scope = scope;
+        candidate.category = category;
+        candidate.status = 'accepted';
+        candidate.reviewedAt = Date.now();
+        candidate.reviewedBy = reviewedBy;
+        candidate.write = { status: write.status, usage: write.usage };
+        if (input.reviewNote?.trim()) {
+            candidate.reviewNote = input.reviewNote.trim();
+        }
+        this.save();
+        return { candidate, write };
+    }
+    reject(id, input = {}) {
+        this.load();
+        const candidate = this.candidates.find((item) => item.id === id);
+        if (!candidate)
+            throw new Error(`Memory candidate not found: ${id}`);
+        if (candidate.status === 'accepted') {
+            throw new Error(`Memory candidate ${id} was already accepted and cannot be rejected.`);
+        }
+        candidate.status = 'rejected';
+        candidate.reviewedAt = Date.now();
+        if (input.reviewedBy?.trim()) {
+            candidate.reviewedBy = input.reviewedBy.trim();
+        }
+        if (input.reason?.trim()) {
+            candidate.reviewNote = input.reason.trim();
+        }
+        this.save();
+        return candidate;
+    }
+    getStats() {
+        this.load();
+        const byStatus = {
+            pending: 0,
+            accepted: 0,
+            rejected: 0,
+        };
+        for (const candidate of this.candidates) {
+            byStatus[candidate.status] += 1;
+        }
+        return { total: this.candidates.length, byStatus };
+    }
+    load() {
+        if (this.loaded)
+            return;
+        this.loaded = true;
+        try {
+            if (!fs.existsSync(this.filePath))
+                return;
+            const parsed = JSON.parse(fs.readFileSync(this.filePath, 'utf-8'));
+            if (Array.isArray(parsed.candidates)) {
+                this.candidates = parsed.candidates.filter(isValidCandidate);
+            }
+        }
+        catch (err) {
+            logger.warn('[memory-candidates] failed to load queue', {
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }
+    }
+    save() {
+        try {
+            fs.mkdirSync(path.dirname(this.filePath), { recursive: true });
+            const file = {
+                schemaVersion: MEMORY_CANDIDATE_SCHEMA_VERSION,
+                candidates: this.candidates,
+            };
+            fs.writeFileSync(this.filePath, JSON.stringify(file, null, 2), 'utf-8');
+        }
+        catch (err) {
+            logger.warn('[memory-candidates] failed to save queue', {
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }
+    }
+}
+function normalizeText(value) {
+    return (value ?? '').replace(/\s+/g, ' ').trim();
+}
+function normalizeScope(scope) {
+    return scope === 'user' ? 'user' : 'project';
+}
+function normalizeCategory(category) {
+    const normalized = category ?? 'context';
+    if (!VALID_CATEGORIES.includes(normalized)) {
+        throw new Error(`Memory category must be one of: ${VALID_CATEGORIES.join(', ')}`);
+    }
+    return normalized;
+}
+function clampConfidence(value) {
+    if (!Number.isFinite(value))
+        return 0;
+    return Math.max(0, Math.min(1, value));
+}
+function sanitizeCitations(citations) {
+    if (!Array.isArray(citations))
+        return [];
+    return citations
+        .map((citation) => {
+        const snippet = redactSecrets(normalizeText(citation.snippet)).slice(0, 280);
+        if (!snippet)
+            return null;
+        return {
+            ...(citation.sessionId ? { sessionId: citation.sessionId } : {}),
+            ...(typeof citation.messageId === 'number' ? { messageId: citation.messageId } : {}),
+            ...(typeof citation.messageIndex === 'number' ? { messageIndex: citation.messageIndex } : {}),
+            ...(citation.role ? { role: citation.role } : {}),
+            snippet,
+        };
+    })
+        .filter((citation) => citation !== null)
+        .slice(0, 3);
+}
+function isValidCandidate(value) {
+    if (!value || typeof value !== 'object')
+        return false;
+    const candidate = value;
+    return (typeof candidate.id === 'string' &&
+        typeof candidate.key === 'string' &&
+        typeof candidate.value === 'string' &&
+        (candidate.scope === 'project' || candidate.scope === 'user') &&
+        typeof candidate.category === 'string' &&
+        VALID_CATEGORIES.includes(candidate.category) &&
+        (candidate.status === 'pending' || candidate.status === 'accepted' || candidate.status === 'rejected') &&
+        typeof candidate.createdAt === 'number' &&
+        typeof candidate.source === 'string');
+}
+//# sourceMappingURL=memory-candidate-queue.js.map

package/dist/memory/persistent-memory.d.ts

@@ -15,6 +15,32 @@ export interface MemoryConfig {
     autoCapture: boolean;
     maxMemories: number;
     relevanceThreshold: number;
+    enforceCharLimits: boolean;
+    projectCharLimit: number;
+    userCharLimit: number;
+    securityScan: boolean;
+    rejectExactDuplicates: boolean;
+}
+export type MemoryScope = "project" | "user";
+export interface MemoryUsage {
+    scope: MemoryScope;
+    used: number;
+    limit: number;
+    percent: number;
+}
+export type MemoryWriteStatus = 'stored' | 'updated' | 'duplicate' | 'replaced' | 'missing';
+export interface MemoryWriteResult {
+    status: MemoryWriteStatus;
+    key: string;
+    scope: MemoryScope;
+    category?: MemoryCategory;
+    usage: MemoryUsage;
+    message: string;
+}
+export declare class MemoryWriteRejectedError extends Error {
+    readonly code: 'memory_limit_exceeded' | 'memory_security_rejected';
+    readonly usage?: MemoryUsage | undefined;
+    constructor(message: string, code: 'memory_limit_exceeded' | 'memory_security_rejected', usage?: MemoryUsage | undefined);
 }
 /**
  * Persistent Memory Manager - Inspired by Claude's CLAUDE.md memory system
@@ -50,10 +76,25 @@ export declare class PersistentMemoryManager extends EventEmitter {
      * Remember something (store in memory)
      */
     remember(key: string, value: string, options?: {
-        scope?: "project" | "user";
+        scope?: MemoryScope;
         category?: MemoryCategory;
         tags?: string[];
-    }): Promise<void>;
+    }): Promise<MemoryWriteResult>;
+    replace(key: string, value: string, options?: {
+        scope?: MemoryScope;
+        category?: MemoryCategory;
+        tags?: string[];
+    }): Promise<MemoryWriteResult>;
+    private setMemoryDirect;
+    private assertMemoryWriteSafe;
+    private assertScopeWithinLimit;
+    private getMemoryLimit;
+    private renderScopeEntries;
+    getMemoryUsage(scope: MemoryScope): MemoryUsage;
+    getMemoryUsages(): {
+        project: MemoryUsage;
+        user: MemoryUsage;
+    };
     /**
      * Recall something from memory
      */
@@ -82,6 +123,8 @@ export declare class PersistentMemoryManager extends EventEmitter {
      * Get context string for system prompt
      */
     getContextForPrompt(): string;
+    getHermesSnapshotForPrompt(): string;
+    private renderHermesMemorySection;
     /**
      * Auto-capture important information from conversation
      */

package/dist/memory/persistent-memory.js

@@ -33,7 +33,39 @@ const DEFAULT_CONFIG = {
     autoCapture: true,
     maxMemories: 100,
     relevanceThreshold: 0.5,
+    enforceCharLimits: process.env.CODEBUDDY_MEMORY_ENFORCE_LIMITS !== 'false',
+    projectCharLimit: parsePositiveInt(process.env.CODEBUDDY_MEMORY_PROJECT_CHAR_LIMIT, 2200),
+    userCharLimit: parsePositiveInt(process.env.CODEBUDDY_MEMORY_USER_CHAR_LIMIT, 1375),
+    securityScan: process.env.CODEBUDDY_MEMORY_SECURITY_SCAN !== 'false',
+    rejectExactDuplicates: process.env.CODEBUDDY_MEMORY_REJECT_DUPLICATES !== 'false',
 };
+export class MemoryWriteRejectedError extends Error {
+    code;
+    usage;
+    constructor(message, code, usage) {
+        super(message);
+        this.code = code;
+        this.usage = usage;
+        this.name = 'MemoryWriteRejectedError';
+    }
+}
+function parsePositiveInt(value, fallback) {
+    if (!value)
+        return fallback;
+    const parsed = Number.parseInt(value, 10);
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+}
+function cloneMemoryMap(memories) {
+    return new Map(Array.from(memories.entries()).map(([key, memory]) => [
+        key,
+        {
+            ...memory,
+            createdAt: new Date(memory.createdAt),
+            updatedAt: new Date(memory.updatedAt),
+            tags: memory.tags ? [...memory.tags] : undefined,
+        },
+    ]));
+}
 const MEMORY_TEMPLATE = `# Code Buddy Memory
 
 This file stores persistent memory for the Code Buddy agent.
@@ -147,6 +179,7 @@ export class PersistentMemoryManager extends EventEmitter {
             "User Preferences": "preferences",
             "Decisions": "decisions",
             "Patterns": "patterns",
+            "Context": "context",
             "Custom": "custom",
         };
         let currentCategory = "custom";
@@ -212,13 +245,29 @@ export class PersistentMemoryManager extends EventEmitter {
     async remember(key, value, options = {}) {
         const { scope = "project", category = "context", tags } = options;
         const memories = scope === "project" ? this.projectMemories : this.userMemories;
+        const normalizedKey = key.trim();
+        const normalizedValue = value.trim();
+        this.assertMemoryWriteSafe(normalizedKey, normalizedValue);
+        const existing = memories.get(normalizedKey);
+        if (this.config.rejectExactDuplicates && existing?.value === normalizedValue) {
+            return {
+                status: 'duplicate',
+                key: normalizedKey,
+                scope,
+                category: existing.category,
+                usage: this.getMemoryUsage(scope),
+                message: `No duplicate added for "${normalizedKey}".`,
+            };
+        }
+        const previousMemories = cloneMemoryMap(memories);
+        const status = existing ? 'updated' : 'stored';
         try {
             const { FactsMemoryService } = await import('./facts-memory.js');
             const service = new FactsMemoryService();
             if (await service.isAvailable()) {
                 const newFact = {
                     category: mapMemoryCategoryToFactCategory(category),
-                    text: `${key}: ${value}`,
+                    text: `${normalizedKey}: ${normalizedValue}`,
                     source: tags?.join(', ') || 'manual',
                     updatedAt: new Date()
                 };
@@ -252,35 +301,166 @@ export class PersistentMemoryManager extends EventEmitter {
             }
             else {
                 // Fallback to default direct write
-                const existing = memories.get(key);
-                const memory = {
-                    key,
-                    value,
-                    category,
-                    createdAt: existing?.createdAt || new Date(),
-                    updatedAt: new Date(),
-                    accessCount: existing?.accessCount || 0,
-                    tags,
-                };
-                memories.set(key, memory);
+                this.setMemoryDirect(memories, normalizedKey, normalizedValue, category, tags);
             }
         }
         catch (err) {
-            logger.warn(`[FactsMemory] Failed to reconcile remember, falling back to default behavior: ${err.message}`);
-            const existing = memories.get(key);
-            const memory = {
-                key,
-                value,
+            const message = err instanceof Error ? err.message : String(err);
+            logger.warn(`[FactsMemory] Failed to reconcile remember, falling back to default behavior: ${message}`);
+            memories.clear();
+            for (const [memoryKey, memory] of previousMemories) {
+                memories.set(memoryKey, memory);
+            }
+            this.setMemoryDirect(memories, normalizedKey, normalizedValue, category, tags);
+        }
+        try {
+            this.assertScopeWithinLimit(scope);
+        }
+        catch (err) {
+            memories.clear();
+            for (const [memoryKey, memory] of previousMemories) {
+                memories.set(memoryKey, memory);
+            }
+            throw err;
+        }
+        await this.saveMemories(scope);
+        this.emit("memory:remembered", { key: normalizedKey, scope, category });
+        return {
+            status,
+            key: normalizedKey,
+            scope,
+            category,
+            usage: this.getMemoryUsage(scope),
+            message: status === 'updated'
+                ? `Updated "${normalizedKey}" in ${scope} memory.`
+                : `Stored "${normalizedKey}" in ${scope} memory.`,
+        };
+    }
+    async replace(key, value, options = {}) {
+        const { scope = 'project', category, tags } = options;
+        const memories = scope === 'project' ? this.projectMemories : this.userMemories;
+        const normalizedKey = key.trim();
+        const normalizedValue = value.trim();
+        const existing = memories.get(normalizedKey);
+        if (!existing) {
+            return {
+                status: 'missing',
+                key: normalizedKey,
+                scope,
                 category,
-                createdAt: existing?.createdAt || new Date(),
-                updatedAt: new Date(),
-                accessCount: existing?.accessCount || 0,
-                tags,
+                usage: this.getMemoryUsage(scope),
+                message: `No memory found for key "${normalizedKey}" in ${scope} scope.`,
             };
-            memories.set(key, memory);
+        }
+        this.assertMemoryWriteSafe(normalizedKey, normalizedValue);
+        const previousMemories = cloneMemoryMap(memories);
+        memories.set(normalizedKey, {
+            ...existing,
+            value: normalizedValue,
+            category: category ?? existing.category,
+            updatedAt: new Date(),
+            tags: tags ?? existing.tags,
+        });
+        try {
+            this.assertScopeWithinLimit(scope);
+        }
+        catch (err) {
+            memories.clear();
+            for (const [memoryKey, memory] of previousMemories) {
+                memories.set(memoryKey, memory);
+            }
+            throw err;
         }
         await this.saveMemories(scope);
-        this.emit("memory:remembered", { key, scope, category });
+        this.emit("memory:replaced", { key: normalizedKey, scope, category: category ?? existing.category });
+        return {
+            status: 'replaced',
+            key: normalizedKey,
+            scope,
+            category: category ?? existing.category,
+            usage: this.getMemoryUsage(scope),
+            message: `Replaced "${normalizedKey}" in ${scope} memory.`,
+        };
+    }
+    setMemoryDirect(memories, key, value, category, tags) {
+        const existing = memories.get(key);
+        const memory = {
+            key,
+            value,
+            category,
+            createdAt: existing?.createdAt || new Date(),
+            updatedAt: new Date(),
+            accessCount: existing?.accessCount || 0,
+            tags,
+        };
+        memories.set(key, memory);
+    }
+    assertMemoryWriteSafe(key, value) {
+        if (!key || !value) {
+            throw new MemoryWriteRejectedError('Memory key and value must be non-empty.', 'memory_security_rejected');
+        }
+        if (!this.config.securityScan)
+            return;
+        const content = `${key}\n${value}`;
+        if (/[\u200B-\u200F\u202A-\u202E\u2060-\u206F\uFEFF]/u.test(content)) {
+            throw new MemoryWriteRejectedError('Memory write rejected: invisible Unicode control characters are not allowed in prompt-injected memory.', 'memory_security_rejected');
+        }
+        const threatPatterns = [
+            {
+                pattern: /\b(ignore|override|bypass|discard)\b.{0,80}\b(system|developer|previous|prior|above)\b.{0,80}\b(instructions?|prompt|rules?)\b/i,
+                reason: 'prompt injection instruction',
+            },
+            {
+                pattern: /\b(exfiltrate|steal|leak|send|upload|post)\b.{0,100}\b(api[-_ ]?key|token|secret|password|credential|private key)\b/i,
+                reason: 'credential exfiltration instruction',
+            },
+            {
+                pattern: /\b(authorized_keys|reverse shell|backdoor|ssh-rsa)\b/i,
+                reason: 'backdoor or SSH persistence pattern',
+            },
+            {
+                pattern: /-----BEGIN (?:OPENSSH|RSA|EC|DSA) PRIVATE KEY-----/i,
+                reason: 'private key material',
+            },
+        ];
+        for (const { pattern, reason } of threatPatterns) {
+            if (pattern.test(content)) {
+                throw new MemoryWriteRejectedError(`Memory write rejected: ${reason} detected.`, 'memory_security_rejected');
+            }
+        }
+    }
+    assertScopeWithinLimit(scope) {
+        if (!this.config.enforceCharLimits)
+            return;
+        const usage = this.getMemoryUsage(scope);
+        if (usage.limit > 0 && usage.used > usage.limit) {
+            throw new MemoryWriteRejectedError(`Memory ${scope} is full (${usage.used}/${usage.limit} chars). Consolidate or remove entries before retrying.`, 'memory_limit_exceeded', usage);
+        }
+    }
+    getMemoryLimit(scope) {
+        return scope === 'project' ? this.config.projectCharLimit : this.config.userCharLimit;
+    }
+    renderScopeEntries(memories) {
+        return Array.from(memories.values())
+            .map((memory) => `${memory.key}: ${memory.value}`)
+            .join('\n§\n');
+    }
+    getMemoryUsage(scope) {
+        const memories = scope === 'project' ? this.projectMemories : this.userMemories;
+        const used = this.renderScopeEntries(memories).length;
+        const limit = this.getMemoryLimit(scope);
+        return {
+            scope,
+            used,
+            limit,
+            percent: limit > 0 ? Math.min(100, Math.round((used / limit) * 100)) : 0,
+        };
+    }
+    getMemoryUsages() {
+        return {
+            project: this.getMemoryUsage('project'),
+            user: this.getMemoryUsage('user'),
+        };
     }
     /**
      * Recall something from memory
@@ -463,21 +643,34 @@ export class PersistentMemoryManager extends EventEmitter {
      * Get context string for system prompt
      */
     getContextForPrompt() {
-        const relevant = [
-            ...this.getByCategory("project", "project"),
-            ...this.getByCategory("preferences", "user"),
-            ...this.getByCategory("decisions"),
-            ...this.getByCategory("patterns"),
-        ].slice(0, 20);
-        if (relevant.length === 0) {
+        const snapshot = this.getHermesSnapshotForPrompt();
+        if (!snapshot)
             return "";
+        return `--- PERSISTENT MEMORY ---\n${snapshot}\n--- END MEMORY ---\n`;
+    }
+    getHermesSnapshotForPrompt() {
+        const sections = [];
+        const projectEntries = this.renderScopeEntries(this.projectMemories);
+        const userEntries = this.renderScopeEntries(this.userMemories);
+        if (projectEntries) {
+            const usage = this.getMemoryUsage('project');
+            sections.push(this.renderHermesMemorySection('MEMORY (project notes)', usage, projectEntries));
         }
-        let context = "\n--- PERSISTENT MEMORY ---\n";
-        for (const memory of relevant) {
-            context += `• ${memory.key}: ${memory.value}\n`;
+        if (userEntries) {
+            const usage = this.getMemoryUsage('user');
+            sections.push(this.renderHermesMemorySection('USER (profile and preferences)', usage, userEntries));
         }
-        context += "--- END MEMORY ---\n";
-        return context;
+        return sections.join('\n\n');
+    }
+    renderHermesMemorySection(title, usage, entries) {
+        const width = 46;
+        const bar = '═'.repeat(width);
+        return [
+            bar,
+            `${title} [${usage.percent}% - ${usage.used}/${usage.limit} chars]`,
+            bar,
+            entries,
+        ].join('\n');
     }
     /**
      * Auto-capture important information from conversation
@@ -527,7 +720,8 @@ export class PersistentMemoryManager extends EventEmitter {
             await this.saveMemories("project");
         }
         catch (err) {
-            logger.warn(`[FactsMemory] Failed to autoCapture facts, falling back to pattern matching: ${err.message}`);
+            const message = err instanceof Error ? err.message : String(err);
+            logger.warn(`[FactsMemory] Failed to autoCapture facts, falling back to pattern matching: ${message}`);
             // Fallback: Detect project context
             const projectPatterns = [
                 /this (?:is|project) (?:a|an) ([^.]+)/i,
@@ -605,8 +799,10 @@ export class PersistentMemoryManager extends EventEmitter {
      */
     formatMemories(scope) {
         let output = `\n🧠 Persistent Memory\n${"═".repeat(50)}\n\n`;
-        const formatScope = (name, memories) => {
+        const formatScope = (name, memories, memoryScope) => {
+            const usage = this.getMemoryUsage(memoryScope);
             output += `📁 ${name}\n`;
+            output += `   Capacity: ${usage.used}/${usage.limit} chars (${usage.percent}%)\n`;
             if (memories.size === 0) {
                 output += `   (empty)\n`;
             }
@@ -619,13 +815,13 @@ export class PersistentMemoryManager extends EventEmitter {
             output += `\n`;
         };
         if (!scope || scope === "project") {
-            formatScope("Project Memory", this.projectMemories);
+            formatScope("Project Memory", this.projectMemories, 'project');
         }
         if (!scope || scope === "user") {
-            formatScope("User Memory", this.userMemories);
+            formatScope("User Memory", this.userMemories, 'user');
         }
         output += `${"═".repeat(50)}\n`;
-        output += `💡 Commands: /remember <key> <value>, /recall <key>, /forget <key>\n`;
+        output += `💡 Commands: /remember <key> <value>, /memory replace <key> <value>, /recall <key>, /forget <key>\n`;
         return output;
     }
     getStats() {

package/dist/ml/bayesian-qualifier.d.ts

@@ -56,7 +56,7 @@ export declare class BayesianQualifier {
     /**
      * Load the qualifier state from a JSON string
      */
-    loadState(stateJson: string): void;
+    loadState(stateJson: string): boolean;
     private rbfKernel;
     /**
      * Solve L * x = b for lower triangular matrix L