@phuetz/code-buddy 2.0.0 → 2.1.0

package/dist/mcp/import-normalize.d.ts

@@ -0,0 +1,12 @@
+import type { MCPServerConfig } from './types.js';
+export type MCPImportSource = 'hermes' | 'openclaw';
+export interface MCPImportResult {
+    servers: MCPServerConfig[];
+    warnings: string[];
+    rejected: string[];
+}
+/** Supported subset: exact names and star globs. Unsupported exclusions must never broaden exposure. */
+export declare function validateMCPToolFilter(filter: MCPServerConfig['toolFilter']): void;
+export declare function mcpToolAllowed(name: string, filter: MCPServerConfig['toolFilter']): boolean;
+/** Pure import: never resolve env, connect, run commands or transfer credentials. */
+export declare function normalizeMCPImports(input: unknown, source: MCPImportSource): MCPImportResult;

package/dist/mcp/import-normalize.js

@@ -0,0 +1,114 @@
+import { SECRET_PATTERNS } from '../security/secret-patterns.js';
+const record = (value) => !!value && typeof value === 'object' && !Array.isArray(value);
+const sensitiveKey = /KEY|TOKEN|SECRET|PASSWORD|AUTHORIZATION|COOKIE/i;
+const reference = /^\$\{[A-Za-z_][A-Za-z0-9_]*\}$/;
+const hasSecret = (value) => SECRET_PATTERNS.some(p => new RegExp(p.pattern.source, p.pattern.flags.replace('g', '')).test(value));
+/** Supported subset: exact names and star globs. Unsupported exclusions must never broaden exposure. */
+export function validateMCPToolFilter(filter) {
+    if (!filter)
+        return;
+    for (const patterns of [filter.include, filter.exclude]) {
+        if (patterns !== undefined && (!Array.isArray(patterns) || patterns.some(p => typeof p !== 'string' || !/^[A-Za-z0-9_.:*-]+$/.test(p)))) {
+            throw new Error('Unsupported MCP tool filter; only names and * are supported');
+        }
+    }
+}
+export function mcpToolAllowed(name, filter) {
+    validateMCPToolFilter(filter);
+    const matches = (pattern) => new RegExp(`^${pattern.split('*').map(p => p.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')).join('.*')}$`).test(name);
+    return (!filter?.include || filter.include.some(matches)) && !filter?.exclude?.some(matches);
+}
+/** Pure import: never resolve env, connect, run commands or transfer credentials. */
+export function normalizeMCPImports(input, source) {
+    const result = { servers: [], warnings: [], rejected: [] };
+    if (!record(input)) {
+        result.rejected.push('MCP server map must be an object');
+        return result;
+    }
+    for (const [name, raw] of Object.entries(input)) {
+        if (!/^[A-Za-z0-9][A-Za-z0-9_.-]{0,95}$/.test(name) || !record(raw)) {
+            result.rejected.push('Invalid MCP server entry');
+            continue;
+        }
+        const warn = (message) => result.warnings.push(`${name}: ${message}`);
+        try {
+            const clean = (key, value) => {
+                if (typeof value !== 'string')
+                    throw new Error('Expected string configuration value');
+                if (reference.test(value) || /^Bearer \$\{[A-Za-z_][A-Za-z0-9_]*\}$/i.test(value))
+                    return value;
+                if (sensitiveKey.test(key) || /^(?:--)?[^=]*(?:token|secret|password|authorization|api[_-]?key)[^=]*=/i.test(value) || hasSecret(value)) {
+                    const envName = `MCP_IMPORT_${name}_${key}`.replace(/[^A-Za-z0-9_]/g, '_').toUpperCase();
+                    warn(`secret not copied; configure environment ${envName}`);
+                    return '${' + envName + '}';
+                }
+                return value;
+            };
+            const map = (key) => {
+                if (raw[key] === undefined)
+                    return undefined;
+                if (!record(raw[key]))
+                    throw new Error(`Invalid ${key}`);
+                return Object.fromEntries(Object.entries(raw[key]).map(([k, v]) => [k, clean(`${key}_${k}`, v)]));
+            };
+            const type = raw.transport ?? raw.type;
+            let transport;
+            if (type === 'stdio' || (type === undefined && typeof raw.command === 'string')) {
+                if (typeof raw.command !== 'string' || !raw.command.trim())
+                    throw new Error('stdio requires command');
+                if (raw.args !== undefined && (!Array.isArray(raw.args) || raw.args.some(a => typeof a !== 'string')))
+                    throw new Error('Invalid args');
+                const args = (raw.args ?? []);
+                transport = { type: 'stdio', inheritEnv: false, command: clean('command', raw.command), args: args.map((v, i) => clean(sensitiveKey.test(args[i - 1] ?? '') ? `arg_secret_${i}` : `arg_${i}`, v)), env: map('env') };
+                if (raw.cwd !== undefined)
+                    transport.cwd = clean('cwd', raw.cwd);
+            }
+            else {
+                const mapped = type === undefined ? (source === 'hermes' ? 'streamable_http' : 'sse')
+                    : type === 'http' || type === 'streamable-http' || type === 'streamable_http' ? 'streamable_http'
+                        : type === 'sse' || type === 'sse_sdk' ? 'sse' : undefined;
+                if (!mapped)
+                    throw new Error('Unsupported transport');
+                if (typeof raw.url !== 'string')
+                    throw new Error('Remote transport requires URL');
+                if (!reference.test(raw.url)) {
+                    const url = new URL(raw.url);
+                    if (!['http:', 'https:'].includes(url.protocol) || url.username || url.password || url.hash || url.search)
+                        throw new Error('Remote URL must not contain credentials, query or fragment; use environment reference');
+                }
+                transport = { type: mapped, url: raw.url, headers: map('headers') };
+                if (type === undefined && source === 'hermes')
+                    warn('streamable HTTP selected; implicit SSE fallback is not imported');
+            }
+            const server = { name, transport, enabled: raw.enabled !== false };
+            const filter = raw.toolFilter ?? raw.tool_filter ?? raw.tools;
+            if (filter !== undefined) {
+                if (!record(filter))
+                    throw new Error('Invalid tool filter');
+                const allowedKeys = filter === raw.tools ? ['include', 'exclude', 'resources', 'prompts'] : ['include', 'exclude'];
+                if (Object.keys(filter).some(key => !allowedKeys.includes(key)))
+                    throw new Error('Unsupported tool filter fields');
+                if (filter.resources !== undefined || filter.prompts !== undefined)
+                    warn('resource/prompt utilities are not imported; Buddy imports native tools only');
+                if (filter.include !== undefined || filter.exclude !== undefined) {
+                    server.toolFilter = { ...(filter.include !== undefined ? { include: typeof filter.include === 'string' ? [filter.include] : filter.include } : {}),
+                        ...(filter.exclude !== undefined ? { exclude: typeof filter.exclude === 'string' ? [filter.exclude] : filter.exclude } : {}) };
+                    validateMCPToolFilter(server.toolFilter);
+                    // OpenClaw treats an empty include as unrestricted, unlike Hermes.
+                    if (source === 'openclaw' && server.toolFilter.include?.length === 0)
+                        delete server.toolFilter.include;
+                }
+            }
+            if (raw.auth !== undefined || raw.oauth !== undefined) {
+                server.enabled = false;
+                warn('authentication settings not imported; server disabled until operator configures authentication in Buddy');
+            }
+            result.servers.push(server);
+        }
+        catch {
+            result.rejected.push(`${name}: unsupported or unsafe configuration; no values copied`);
+        }
+    }
+    return result;
+}
+//# sourceMappingURL=import-normalize.js.map

package/dist/mcp/transports.d.ts

@@ -1,9 +1,12 @@
 import { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
 import { EventEmitter } from "events";
-export type TransportType = 'stdio' | 'http' | 'sse' | 'streamable_http';
+export type TransportType = 'stdio' | 'http' | 'sse' | 'sse_sdk' | 'legacy_rpc' | 'streamable_http';
 export interface TransportConfig {
     type: TransportType;
     command?: string;
+    cwd?: string;
+    /** Imported stdio servers receive SDK baseline env plus explicit declarations only. */
+    inheritEnv?: boolean;
     args?: string[];
     env?: Record<string, string>;
     url?: string;
@@ -31,9 +34,9 @@ export declare class HttpTransport extends EventEmitter implements MCPTransport
     disconnect(): Promise<void>;
     getType(): TransportType;
 }
-export declare class SSETransport extends EventEmitter implements MCPTransport {
+export declare class SSETransport implements MCPTransport {
     private config;
-    private connected;
+    private transport?;
     constructor(config: TransportConfig);
     connect(): Promise<Transport>;
     disconnect(): Promise<void>;
@@ -41,10 +44,12 @@ export declare class SSETransport extends EventEmitter implements MCPTransport {
 }
 export declare class StreamableHttpTransport extends EventEmitter implements MCPTransport {
     private config;
-    private connected;
+    private transport?;
     constructor(config: TransportConfig);
     connect(): Promise<Transport>;
     disconnect(): Promise<void>;
     getType(): TransportType;
 }
-export declare function createTransport(config: TransportConfig): MCPTransport;
+/** Resolve references only at connection time; missing credentials fail closed. */
+export declare function resolveMCPTransport(config: TransportConfig): TransportConfig;
+export declare function createTransport(input: TransportConfig): MCPTransport;

package/dist/mcp/transports.js

@@ -1,4 +1,6 @@
-import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { SSEClientTransport as SDKSSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { StdioClientTransport, getDefaultEnvironment } from "@modelcontextprotocol/sdk/client/stdio.js";
 import { EventEmitter } from "events";
 import axios from "axios";
 import { logger } from '../utils/logger.js';
@@ -14,7 +16,7 @@ export class StdioTransport {
     async connect() {
         // Create transport with environment variables to suppress verbose output
         const env = {
-            ...process.env,
+            ...(this.config.inheritEnv === false ? getDefaultEnvironment() : process.env),
             ...this.config.env,
             // Try to suppress verbose output from mcp-remote
             MCP_REMOTE_QUIET: '1',
@@ -25,6 +27,7 @@ export class StdioTransport {
         const transportConfig = {
             command: this.config.command,
             args: this.config.args || [],
+            cwd: this.config.cwd,
             env,
             // The SDK default is stderr:'inherit', which lets a noisy MCP server
             // (startup banners, progress logs) write raw bytes into the CLI's own
@@ -69,6 +72,7 @@ export class HttpTransport extends EventEmitter {
     async connect() {
         this.client = axios.create({
             baseURL: this.config.url,
+            maxRedirects: 0,
             headers: {
                 'Content-Type': 'application/json',
                 ...this.config.headers
@@ -93,35 +97,28 @@ export class HttpTransport extends EventEmitter {
         return 'http';
     }
 }
-export class SSETransport extends EventEmitter {
+export class SSETransport {
     config;
-    connected = false;
+    transport;
     constructor(config) {
-        super();
         this.config = config;
-        if (!config.url) {
-            throw new Error('URL is required for SSE MCP transport. Specify the server URL in your MCP configuration.');
-        }
+        if (!config.url)
+            throw new Error('URL is required for SSE MCP transport');
     }
     async connect() {
-        return new Promise((resolve, reject) => {
-            try {
-                // For Node.js environment, we'll use a simple HTTP-based approach
-                // In a real implementation, you'd use a proper SSE library like 'eventsource'
-                this.connected = true;
-                resolve(new SSEClientTransport(this.config.url));
-            }
-            catch (error) {
-                reject(error);
-            }
+        this.transport = new SDKSSEClientTransport(new URL(this.config.url), {
+            requestInit: { headers: this.config.headers, redirect: 'error' },
+            eventSourceInit: { fetch: (url, init) => {
+                    const headers = new Headers(init?.headers);
+                    for (const [key, value] of Object.entries(this.config.headers ?? {}))
+                        headers.set(key, value);
+                    return fetch(url, { ...init, headers, redirect: 'error' });
+                } },
         });
+        return this.transport;
     }
-    async disconnect() {
-        this.connected = false;
-    }
-    getType() {
-        return 'sse';
-    }
+    async disconnect() { await this.transport?.close(); this.transport = undefined; }
+    getType() { return 'sse'; }
 }
 // Custom HTTP Transport implementation
 class HttpClientTransport extends EventEmitter {
@@ -156,105 +153,70 @@ class HttpClientTransport extends EventEmitter {
         }
     }
 }
-// Custom SSE Transport implementation
-class SSEClientTransport extends EventEmitter {
-    url;
-    onclose;
-    onerror;
-    onmessage;
-    sessionId;
-    constructor(url) {
-        super();
-        this.url = url;
-    }
-    async start() {
-        // SSE transport is event-driven, so we're always "started"
-    }
-    async close() {
-        // Nothing to close for basic SSE transport
-    }
-    async send(message, _options) {
-        // For bidirectional communication over SSE, we typically use HTTP POST
-        // for sending messages and SSE for receiving
-        try {
-            const response = await axios.post(this.url.replace('/sse', '/rpc'), message, {
-                headers: { 'Content-Type': 'application/json' }
-            });
-            if (this.onmessage && response.data) {
-                this.onmessage(response.data);
-            }
-        }
-        catch (error) {
-            const err = new Error(`SSE transport error: ${error}`);
-            if (this.onerror) {
-                this.onerror(err);
-            }
-            throw err;
-        }
-    }
-}
 export class StreamableHttpTransport extends EventEmitter {
     config;
-    connected = false;
+    transport;
     constructor(config) {
         super();
         this.config = config;
-        if (!config.url) {
+        if (!config.url)
             throw new Error('URL is required for streamable_http transport');
-        }
     }
     async connect() {
-        return new Promise((resolve, reject) => {
-            try {
-                this.connected = true;
-                resolve(new StreamableHttpClientTransport(this.config.url, this.config.headers));
-            }
-            catch (error) {
-                reject(error);
-            }
+        const url = new URL(this.config.url);
+        if (!['http:', 'https:'].includes(url.protocol)) {
+            throw new Error('Streamable HTTP MCP requires an HTTP(S) URL');
+        }
+        this.transport = new StreamableHTTPClientTransport(url, {
+            requestInit: { headers: this.config.headers, redirect: 'error' },
         });
+        return this.transport;
     }
     async disconnect() {
-        this.connected = false;
+        const transport = this.transport;
+        this.transport = undefined;
+        await transport?.close();
     }
     getType() {
         return 'streamable_http';
     }
 }
-// Custom Streamable HTTP Transport implementation for GitHub Copilot MCP
-class StreamableHttpClientTransport extends EventEmitter {
-    url;
-    headers;
-    onclose;
-    onerror;
-    onmessage;
-    sessionId;
-    constructor(url, headers) {
-        super();
-        this.url = url;
-        this.headers = headers;
-    }
-    async start() {
-        // Streamable HTTP transport is connection-less, so we're always "started"
-    }
-    async close() {
-        // Nothing to close for streamable HTTP transport
-    }
-    async send(_message, _options) {
-        logger.warn('StreamableHttpTransport: SSE endpoints require persistent connections, not suitable for MCP request-response pattern');
-        logger.debug('StreamableHttpTransport: Message that would be sent', { message: _message });
-        // For now, throw an error to indicate the transport type is not compatible
-        // with the MCP protocol's request-response pattern
-        throw new Error('StreamableHttpTransport: SSE endpoints are not compatible with MCP request-response pattern. GitHub Copilot MCP may require a different integration approach.');
+/** Resolve references only at connection time; missing credentials fail closed. */
+export function resolveMCPTransport(config) {
+    const resolve = (value) => value.replace(/\$\{([A-Za-z_][A-Za-z0-9_]*)\}/g, (_match, key) => {
+        const result = process.env[key];
+        if (!result)
+            throw new Error(`Missing MCP environment reference: ${key}`);
+        return result;
+    });
+    const map = (values) => values && Object.fromEntries(Object.entries(values).map(([k, v]) => [k, resolve(v)]));
+    const resolved = { ...config, command: config.command && resolve(config.command), cwd: config.cwd && resolve(config.cwd),
+        args: config.args?.map(resolve), env: map(config.env), headers: map(config.headers), url: config.url && resolve(config.url) };
+    if (resolved.url) {
+        let url;
+        try {
+            url = new URL(resolved.url);
+        }
+        catch {
+            throw new Error('Invalid MCP endpoint configuration');
+        }
+        if (!['http:', 'https:'].includes(url.protocol) || url.username || url.password || url.search || url.hash)
+            throw new Error('MCP requires HTTP(S) without embedded credentials, query or fragment');
     }
+    return resolved;
 }
-export function createTransport(config) {
+export function createTransport(input) {
+    const config = resolveMCPTransport(input);
     switch (config.type) {
         case 'stdio':
             return new StdioTransport(config);
         case 'http':
+            logger.warn('MCP http /rpc transport is deprecated; use legacy_rpc explicitly or streamable_http for MCP HTTP');
+            return new HttpTransport(config);
+        case 'legacy_rpc':
             return new HttpTransport(config);
         case 'sse':
+        case 'sse_sdk':
             return new SSETransport(config);
         case 'streamable_http':
             return new StreamableHttpTransport(config);

package/dist/mcp/types.d.ts

@@ -15,6 +15,11 @@ export interface MCPServerConfig {
     maxRetries?: number;
     /** Optional: Enable/disable this server (default: true) */
     enabled?: boolean;
+    /** Exact names and star globs; exclusions win. Empty include denies every tool. */
+    toolFilter?: {
+        include?: string[];
+        exclude?: string[];
+    };
 }
 export type ServerStatus = 'connecting' | 'connected' | 'disconnected' | 'error';
 export interface MCPTool {

package/dist/media/comfyui-recipe-contract.d.ts

@@ -473,12 +473,6 @@ export declare const comfyUIRecipeSchema: z.ZodObject<{
         name?: string | undefined;
         url?: string | undefined;
     };
-    schemaVersion: 1;
-    fallback: {
-        id: string;
-        reason?: string | undefined;
-        version?: string | undefined;
-    }[];
     resources: {
         tier: "high" | "low" | "balanced" | "extreme";
         maxConcurrency: number;
@@ -486,6 +480,12 @@ export declare const comfyUIRecipeSchema: z.ZodObject<{
         minRamMiB: number;
         estimatedSeconds?: number | undefined;
     };
+    schemaVersion: 1;
+    fallback: {
+        id: string;
+        reason?: string | undefined;
+        version?: string | undefined;
+    }[];
     bindings: {
         prompt: {
             input: string;
@@ -573,7 +573,6 @@ export declare const comfyUIRecipeSchema: z.ZodObject<{
         name?: string | undefined;
         url?: string | undefined;
     };
-    schemaVersion: 1;
     resources: {
         tier: "high" | "low" | "balanced" | "extreme";
         minVramMiB: number;
@@ -581,6 +580,7 @@ export declare const comfyUIRecipeSchema: z.ZodObject<{
         maxConcurrency?: number | undefined;
         estimatedSeconds?: number | undefined;
     };
+    schemaVersion: 1;
     bindings: {
         prompt: {
             input: string;

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

@@ -63,8 +63,18 @@ export declare const ReconciliationActionSchema: z.ZodObject<{
     } | undefined;
 }>;
 export type ReconciliationAction = z.infer<typeof ReconciliationActionSchema>;
+/** Keep concurrent command sessions on their own provider, including an explicit offline scope. */
+export declare function withFactsMemorySessionClient<T>(client: CodeBuddyClient | null, action: () => T): T;
+/**
+ * Async generators execute on next/return/throw, not when they are created.
+ * Scope every resumption so model/tool/cleanup work belongs to this agent,
+ * while consumers outside a yielded event keep their own async context.
+ */
+export declare function bindFactsMemorySession<T>(client: CodeBuddyClient, iterator: AsyncGenerator<T, void, unknown>): AsyncGenerator<T, void, unknown>;
+export declare function setFactsMemorySessionClient(client: CodeBuddyClient | null): void;
 export declare class FactsMemoryService {
-    private client;
+    private readonly explicitClient;
+    private fallbackClient;
     constructor(client?: CodeBuddyClient);
     isAvailable(): Promise<boolean>;
     private getClient;

package/dist/memory/facts-memory.js

@@ -1,3 +1,4 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
 import { z } from 'zod';
 import { logger } from '../utils/logger.js';
 import { CodeBuddyClient } from '../codebuddy/client.js';
@@ -30,20 +31,58 @@ export const ReconciliationActionSchema = z.object({
     targetIndex: z.number().optional(),
     fact: FactSchema.optional()
 });
+/**
+ * Client of the live session (the provider and endpoint the user actually
+ * started with). Without it, reconciliation fell back to environment
+ * auto-detection and could send project memories to a different, cloud
+ * provider than the local session (e.g. xAI because GROK_API_KEY was set while
+ * the CLI ran on --base-url http://127.0.0.1:11434/v1).
+ */
+let sessionClient = null;
+const sessionScope = new AsyncLocalStorage();
+/** Keep concurrent command sessions on their own provider, including an explicit offline scope. */
+export function withFactsMemorySessionClient(client, action) {
+    return sessionScope.run({ client }, action);
+}
+/**
+ * Async generators execute on next/return/throw, not when they are created.
+ * Scope every resumption so model/tool/cleanup work belongs to this agent,
+ * while consumers outside a yielded event keep their own async context.
+ */
+export function bindFactsMemorySession(client, iterator) {
+    return {
+        next(...args) { return withFactsMemorySessionClient(client, () => iterator.next(...args)); },
+        return(value) { return withFactsMemorySessionClient(client, () => iterator.return(value)); },
+        throw(error) { return withFactsMemorySessionClient(client, () => iterator.throw(error)); },
+        [Symbol.asyncIterator]() { return this; },
+        async [Symbol.asyncDispose]() {
+            await withFactsMemorySessionClient(client, () => iterator.return());
+        },
+    };
+}
+export function setFactsMemorySessionClient(client) {
+    sessionClient = client;
+}
 export class FactsMemoryService {
-    client = null;
+    explicitClient;
+    fallbackClient = null;
     constructor(client) {
-        if (client) {
-            this.client = client;
-        }
+        this.explicitClient = client ?? null;
     }
     async isAvailable() {
         const client = await this.getClient();
         return client !== null;
     }
     async getClient() {
-        if (this.client)
-            return this.client;
+        if (this.explicitClient)
+            return this.explicitClient;
+        const scoped = sessionScope.getStore();
+        if (scoped)
+            return scoped.client;
+        if (sessionClient)
+            return sessionClient;
+        if (this.fallbackClient)
+            return this.fallbackClient;
         // Skip auto-detecting client in unit tests to prevent timeouts/real API calls
         if (process.env.NODE_ENV === 'test' || process.env.VITEST) {
             return null;
@@ -53,8 +92,8 @@ export class FactsMemoryService {
             logger.warn('[FactsMemory] No LLM provider configuration found.');
             return null;
         }
-        this.client = new CodeBuddyClient(detected.apiKey, detected.defaultModel, detected.baseURL);
-        return this.client;
+        this.fallbackClient = new CodeBuddyClient(detected.apiKey, detected.defaultModel, detected.baseURL);
+        return this.fallbackClient;
     }
     /**
      * Extract atom facts from a conversation or context block.

package/dist/memory/memory-candidate-queue.d.ts

@@ -72,7 +72,7 @@ export interface MemoryCandidateStats {
     total: number;
     byStatus: Record<MemoryCandidateStatus, number>;
 }
-export declare function getMemoryCandidateQueue(workDir?: string): MemoryCandidateQueue;
+export declare function getMemoryCandidateQueue(workDir?: string, botId?: string): MemoryCandidateQueue;
 export declare function resetMemoryCandidateQueues(): void;
 export declare class MemoryCandidateQueue {
     private workDir;
@@ -80,7 +80,7 @@ export declare class MemoryCandidateQueue {
     private filePath;
     private candidates;
     private loaded;
-    constructor(workDir?: string, memoryManager?: PersistentMemoryManager | undefined);
+    constructor(workDir?: string, memoryManager?: PersistentMemoryManager | undefined, botId?: string);
     propose(input: ProposeMemoryCandidateInput): ProposeMemoryCandidateResult;
     list(status?: MemoryCandidateStatus): MemoryCandidate[];
     get(id: string): MemoryCandidate | null;

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

@@ -22,10 +22,10 @@ const VALID_CATEGORIES = [
     'custom',
 ];
 const registry = new Map();
-export function getMemoryCandidateQueue(workDir = process.cwd()) {
-    const key = path.resolve(workDir);
+export function getMemoryCandidateQueue(workDir = process.cwd(), botId) {
+    const key = JSON.stringify([path.resolve(workDir), botId ?? '']);
     if (!registry.has(key)) {
-        registry.set(key, new MemoryCandidateQueue(key));
+        registry.set(key, new MemoryCandidateQueue(path.resolve(workDir), botId ? getMemoryManager(undefined, botId, workDir) : undefined, botId));
         if (registry.size > 20) {
             const firstKey = registry.keys().next().value;
             if (firstKey)
@@ -43,10 +43,10 @@ export class MemoryCandidateQueue {
     filePath;
     candidates = [];
     loaded = false;
-    constructor(workDir = process.cwd(), memoryManager) {
+    constructor(workDir = process.cwd(), memoryManager, botId) {
         this.workDir = workDir;
         this.memoryManager = memoryManager;
-        this.filePath = path.join(workDir, '.codebuddy', 'memory-candidates.json');
+        this.filePath = path.join(workDir, '.codebuddy', botId ? `memory-candidates-${encodeURIComponent(botId)}.json` : 'memory-candidates.json');
     }
     propose(input) {
         this.load();
@@ -122,7 +122,7 @@ export class MemoryCandidateQueue {
             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();
+        const manager = this.memoryManager ?? getMemoryManager(undefined, undefined, this.workDir);
         await manager.initialize();
         const write = await manager.remember(key, value, {
             scope,

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

@@ -53,6 +53,15 @@ export interface MemoryWriteResult {
     category?: MemoryCategory;
     usage: MemoryUsage;
     message: string;
+    /**
+     * Outcome of the optional LLM fact reconciliation, separate from the primary
+     * write: `failed` means the memory was still written directly and existing
+     * memories were restored unchanged.
+     */
+    reconciliation?: {
+        status: 'applied' | 'skipped' | 'failed';
+        reason?: string;
+    };
 }
 export declare class MemoryWriteRejectedError extends Error {
     readonly code: 'memory_limit_exceeded' | 'memory_security_rejected';
@@ -164,6 +173,8 @@ export declare class PersistentMemoryManager extends EventEmitter {
      * poking the private maps. Does NOT reinforce (unlike getRelevantMemories).
      */
     listMemories(scope: MemoryScope): Memory[];
+    /** Guard the result, including model renames/omissions, rather than trusting DELETE alone. */
+    private guardReconciliation;
     /**
      * Ebbinghaus forgetting pass (recoverable): memories whose retention decayed
      * below the threshold are appended to a sibling `*.archive.md`, then removed.
@@ -250,12 +261,6 @@ export declare class PersistentMemoryManager extends EventEmitter {
     };
     private assertScopeReadable;
 }
-/**
- * Get the memory manager. With no `botId`, returns the global singleton (default
- * — CLI / desktop / server behavior unchanged). With a `botId` (multi-bot
- * channels), returns a per-bot instance whose memory files live under
- * `~/.codebuddy/bots/<botId>/`, so bots never share each other's `remember` facts.
- */
-export declare function getMemoryManager(config?: Partial<MemoryConfig>, botId?: string): PersistentMemoryManager;
+export declare function getMemoryManager(config?: Partial<MemoryConfig>, botId?: string, cwd?: string): PersistentMemoryManager;
 export declare function resetMemoryManagerForTests(): void;
-export declare function initializeMemory(config?: Partial<MemoryConfig>): Promise<PersistentMemoryManager>;
+export declare function initializeMemory(config?: Partial<MemoryConfig>, cwd?: string): Promise<PersistentMemoryManager>;