@vectorize-io/hindsight-openclaw 0.4.8 → 0.4.10

package/dist/client.d.ts

@@ -1,4 +1,27 @@
 import type { RetainRequest, RetainResponse, RecallRequest, RecallResponse } from './types.js';
+/**
+ * Escape a string for use as a single-quoted shell argument.
+ *
+ * In POSIX shells, single-quoted strings treat ALL characters literally
+ * except for the single quote itself. To include a literal single quote,
+ * we use the pattern: end quote + escaped quote + start quote = '\''
+ *
+ * Example: "It's $100" becomes 'It'\''s $100'
+ * Shell interprets: 'It' + \' + 's $100' = It's $100
+ *
+ * This handles ALL shell-special characters including:
+ * - $ (variable expansion)
+ * - ` (command substitution)
+ * - ! (history expansion)
+ * - ? * [ ] (glob patterns)
+ * - ( ) { } (subshell/brace expansion)
+ * - < > | & ; (redirection/control)
+ * - \ " # ~ newlines
+ *
+ * @param arg - The string to escape
+ * @returns The escaped string (without surrounding quotes - caller adds those)
+ */
+export declare function escapeShellArg(arg: string): string;
 export declare class HindsightClient {
     private bankId;
     private llmProvider;

package/dist/client.js

@@ -1,6 +1,34 @@
 import { exec } from 'child_process';
 import { promisify } from 'util';
 const execAsync = promisify(exec);
+/**
+ * Escape a string for use as a single-quoted shell argument.
+ *
+ * In POSIX shells, single-quoted strings treat ALL characters literally
+ * except for the single quote itself. To include a literal single quote,
+ * we use the pattern: end quote + escaped quote + start quote = '\''
+ *
+ * Example: "It's $100" becomes 'It'\''s $100'
+ * Shell interprets: 'It' + \' + 's $100' = It's $100
+ *
+ * This handles ALL shell-special characters including:
+ * - $ (variable expansion)
+ * - ` (command substitution)
+ * - ! (history expansion)
+ * - ? * [ ] (glob patterns)
+ * - ( ) { } (subshell/brace expansion)
+ * - < > | & ; (redirection/control)
+ * - \ " # ~ newlines
+ *
+ * @param arg - The string to escape
+ * @returns The escaped string (without surrounding quotes - caller adds those)
+ */
+export function escapeShellArg(arg) {
+    // Replace single quotes with the escape sequence: '\''
+    // This ends the current single-quoted string, adds an escaped literal quote,
+    // and starts a new single-quoted string.
+    return arg.replace(/'/g, "'\\''");
+}
 export class HindsightClient {
     bankId = 'default'; // Always use default bank
     llmProvider;
@@ -36,7 +64,7 @@ export class HindsightClient {
         if (!mission || mission.trim().length === 0) {
             return;
         }
-        const escapedMission = mission.replace(/'/g, "'\\''"); // Escape single quotes
+        const escapedMission = escapeShellArg(mission);
         const embedCmd = this.getEmbedCommandPrefix();
         const cmd = `${embedCmd} --profile openclaw bank mission ${this.bankId} '${escapedMission}'`;
         try {
@@ -49,8 +77,8 @@ export class HindsightClient {
         }
     }
     async retain(request) {
-        const content = request.content.replace(/'/g, "'\\''"); // Escape single quotes
-        const docId = request.document_id || 'conversation';
+        const content = escapeShellArg(request.content);
+        const docId = escapeShellArg(request.document_id || 'conversation');
         const embedCmd = this.getEmbedCommandPrefix();
         const cmd = `${embedCmd} --profile openclaw memory retain ${this.bankId} '${content}' --doc-id '${docId}' --async`;
         try {
@@ -68,7 +96,7 @@ export class HindsightClient {
         }
     }
     async recall(request) {
-        const query = request.query.replace(/'/g, "'\\''"); // Escape single quotes
+        const query = escapeShellArg(request.query);
         const maxTokens = request.max_tokens || 1024;
         const embedCmd = this.getEmbedCommandPrefix();
         const cmd = `${embedCmd} --profile openclaw memory recall ${this.bankId} '${query}' --output json --max-tokens ${maxTokens}`;

package/dist/index.js

@@ -7,6 +7,11 @@ let embedManager = null;
 let client = null;
 let initPromise = null;
 let isInitialized = false;
+let usingExternalApi = false; // Track if using external API (skip daemon management)
+// Store the current plugin config for bank ID derivation
+let currentPluginConfig = null;
+// Track which banks have had their mission set (to avoid re-setting on every request)
+const banksWithMissionSet = new Set();
 // Global access for hooks (Moltbot loads hooks separately)
 if (typeof global !== 'undefined') {
     global.__hindsightClient = {
@@ -17,13 +22,59 @@ if (typeof global !== 'undefined') {
             if (initPromise)
                 await initPromise;
         },
+        /**
+         * Get a client configured for a specific agent context.
+         * Derives the bank ID from the context for per-channel isolation.
+         * Also ensures the bank mission is set on first use.
+         */
+        getClientForContext: async (ctx) => {
+            if (!client)
+                return null;
+            const config = currentPluginConfig || {};
+            const bankId = deriveBankId(ctx, config);
+            client.setBankId(bankId);
+            // Set bank mission on first use of this bank (if configured)
+            if (config.bankMission && config.dynamicBankId && !banksWithMissionSet.has(bankId)) {
+                try {
+                    await client.setBankMission(config.bankMission);
+                    banksWithMissionSet.add(bankId);
+                    console.log(`[Hindsight] Set mission for new bank: ${bankId}`);
+                }
+                catch (error) {
+                    // Log but don't fail - bank mission is not critical
+                    console.warn(`[Hindsight] Could not set bank mission for ${bankId}: ${error}`);
+                }
+            }
+            return client;
+        },
+        getPluginConfig: () => currentPluginConfig,
     };
 }
 // Get directory of current module
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
-// Default bank name
-const BANK_NAME = 'openclaw';
+// Default bank name (fallback when channel context not available)
+const DEFAULT_BANK_NAME = 'openclaw';
+/**
+ * Derive a bank ID from the agent context.
+ * Creates channel-specific banks: {messageProvider}-{channelId}
+ * Falls back to default bank when context is unavailable.
+ */
+function deriveBankId(ctx, pluginConfig) {
+    // If dynamic bank ID is disabled, use static bank
+    if (pluginConfig.dynamicBankId === false) {
+        return pluginConfig.bankIdPrefix
+            ? `${pluginConfig.bankIdPrefix}-${DEFAULT_BANK_NAME}`
+            : DEFAULT_BANK_NAME;
+    }
+    const channelType = ctx?.messageProvider || 'unknown';
+    const channelId = ctx?.channelId || 'default';
+    // Build bank ID: {prefix?}-{channelType}-{channelId}
+    const baseBankId = `${channelType}-${channelId}`;
+    return pluginConfig.bankIdPrefix
+        ? `${pluginConfig.bankIdPrefix}-${baseBankId}`
+        : baseBankId;
+}
 // Provider detection from standard env vars
 const PROVIDER_DETECTION = [
     { name: 'openai', keyEnv: 'OPENAI_API_KEY', defaultModel: 'gpt-4o-mini' },
@@ -121,6 +172,33 @@ function detectLLMConfig(pluginConfig) {
         `  export HINDSIGHT_API_LLM_BASE_URL=https://openrouter.ai/api/v1  # Optional\n\n` +
         `Tip: Use a cheap/fast model for memory extraction (e.g., gpt-4o-mini, claude-3-5-haiku, or free models on OpenRouter)`);
 }
+/**
+ * Detect external Hindsight API configuration.
+ * Priority: env vars > plugin config
+ */
+function detectExternalApi(pluginConfig) {
+    const apiUrl = process.env.HINDSIGHT_EMBED_API_URL || pluginConfig?.hindsightApiUrl || null;
+    const apiToken = process.env.HINDSIGHT_EMBED_API_TOKEN || pluginConfig?.hindsightApiToken || null;
+    return { apiUrl, apiToken };
+}
+/**
+ * Health check for external Hindsight API.
+ */
+async function checkExternalApiHealth(apiUrl) {
+    const healthUrl = `${apiUrl.replace(/\/$/, '')}/health`;
+    console.log(`[Hindsight] Checking external API health at ${healthUrl}...`);
+    try {
+        const response = await fetch(healthUrl, { signal: AbortSignal.timeout(10000) });
+        if (!response.ok) {
+            throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+        }
+        const data = await response.json();
+        console.log(`[Hindsight] External API health: ${JSON.stringify(data)}`);
+    }
+    catch (error) {
+        throw new Error(`Cannot connect to external Hindsight API at ${apiUrl}: ${error}`);
+    }
+}
 function getPluginConfig(api) {
     const config = api.config.plugins?.entries?.['hindsight-openclaw']?.config || {};
     const defaultMission = 'You are an AI assistant helping users across multiple communication channels (Telegram, Slack, Discord, etc.). Remember user preferences, instructions, and important context from conversations to provide personalized assistance.';
@@ -133,6 +211,12 @@ function getPluginConfig(api) {
         llmProvider: config.llmProvider,
         llmModel: config.llmModel,
         llmApiKeyEnv: config.llmApiKeyEnv,
+        hindsightApiUrl: config.hindsightApiUrl,
+        hindsightApiToken: config.hindsightApiToken,
+        apiPort: config.apiPort || 9077,
+        // Dynamic bank ID options (default: enabled)
+        dynamicBankId: config.dynamicBankId !== false,
+        bankIdPrefix: config.bankIdPrefix,
     };
 }
 export default function (api) {
@@ -141,6 +225,8 @@ export default function (api) {
         // Get plugin config first (needed for LLM detection)
         console.log('[Hindsight] Getting plugin config...');
         const pluginConfig = getPluginConfig(api);
+        // Store config globally for bank ID derivation in hooks
+        currentPluginConfig = pluginConfig;
         // Detect LLM configuration (env vars > plugin config > auto-detect)
         console.log('[Hindsight] Detecting LLM config...');
         const llmConfig = detectLLMConfig(pluginConfig);
@@ -155,33 +241,80 @@ export default function (api) {
         if (pluginConfig.bankMission) {
             console.log(`[Hindsight] Custom bank mission configured: "${pluginConfig.bankMission.substring(0, 50)}..."`);
         }
-        console.log(`[Hindsight] Daemon idle timeout: ${pluginConfig.daemonIdleTimeout}s (0 = never timeout)`);
+        // Log dynamic bank ID mode
+        if (pluginConfig.dynamicBankId) {
+            const prefixInfo = pluginConfig.bankIdPrefix ? ` (prefix: ${pluginConfig.bankIdPrefix})` : '';
+            console.log(`[Hindsight] ✓ Dynamic bank IDs enabled${prefixInfo} - each channel gets isolated memory`);
+        }
+        else {
+            console.log(`[Hindsight] Dynamic bank IDs disabled - using static bank: ${DEFAULT_BANK_NAME}`);
+        }
+        // Detect external API mode
+        const externalApi = detectExternalApi(pluginConfig);
         // Get API port from config (default: 9077)
         const apiPort = pluginConfig.apiPort || 9077;
-        console.log(`[Hindsight] API Port: ${apiPort}`);
+        if (externalApi.apiUrl) {
+            // External API mode - skip local daemon
+            usingExternalApi = true;
+            console.log(`[Hindsight] ✓ Using external API: ${externalApi.apiUrl}`);
+            // Set env vars so CLI commands (uvx hindsight-embed) use external API
+            process.env.HINDSIGHT_EMBED_API_URL = externalApi.apiUrl;
+            if (externalApi.apiToken) {
+                process.env.HINDSIGHT_EMBED_API_TOKEN = externalApi.apiToken;
+                console.log('[Hindsight] API token configured');
+            }
+        }
+        else {
+            console.log(`[Hindsight] Daemon idle timeout: ${pluginConfig.daemonIdleTimeout}s (0 = never timeout)`);
+            console.log(`[Hindsight] API Port: ${apiPort}`);
+        }
         // Initialize in background (non-blocking)
         console.log('[Hindsight] Starting initialization in background...');
         initPromise = (async () => {
             try {
-                // Initialize embed manager
-                console.log('[Hindsight] Creating HindsightEmbedManager...');
-                embedManager = new HindsightEmbedManager(apiPort, llmConfig.provider, llmConfig.apiKey, llmConfig.model, llmConfig.baseUrl, pluginConfig.daemonIdleTimeout, pluginConfig.embedVersion, pluginConfig.embedPackagePath);
-                // Start the embedded server
-                console.log('[Hindsight] Starting embedded server...');
-                await embedManager.start();
-                // Initialize client
-                console.log('[Hindsight] Creating HindsightClient...');
-                client = new HindsightClient(llmConfig.provider, llmConfig.apiKey, llmConfig.model, pluginConfig.embedVersion, pluginConfig.embedPackagePath);
-                // Use openclaw bank
-                console.log(`[Hindsight] Using bank: ${BANK_NAME}`);
-                client.setBankId(BANK_NAME);
-                // Set bank mission
-                if (pluginConfig.bankMission) {
-                    console.log(`[Hindsight] Setting bank mission...`);
-                    await client.setBankMission(pluginConfig.bankMission);
+                if (usingExternalApi && externalApi.apiUrl) {
+                    // External API mode - check health, skip daemon startup
+                    console.log('[Hindsight] External API mode - skipping local daemon...');
+                    await checkExternalApiHealth(externalApi.apiUrl);
+                    // Initialize client (CLI commands will use external API via env vars)
+                    console.log('[Hindsight] Creating HindsightClient...');
+                    client = new HindsightClient(llmConfig.provider, llmConfig.apiKey, llmConfig.model, pluginConfig.embedVersion, pluginConfig.embedPackagePath);
+                    // Set default bank (will be overridden per-request when dynamic bank IDs are enabled)
+                    const defaultBankId = deriveBankId(undefined, pluginConfig);
+                    console.log(`[Hindsight] Default bank: ${defaultBankId}`);
+                    client.setBankId(defaultBankId);
+                    // Note: Bank mission will be set per-bank when dynamic bank IDs are enabled
+                    // For now, set it on the default bank
+                    if (pluginConfig.bankMission && !pluginConfig.dynamicBankId) {
+                        console.log(`[Hindsight] Setting bank mission...`);
+                        await client.setBankMission(pluginConfig.bankMission);
+                    }
+                    isInitialized = true;
+                    console.log('[Hindsight] ✓ Ready (external API mode)');
+                }
+                else {
+                    // Local daemon mode - start hindsight-embed daemon
+                    console.log('[Hindsight] Creating HindsightEmbedManager...');
+                    embedManager = new HindsightEmbedManager(apiPort, llmConfig.provider, llmConfig.apiKey, llmConfig.model, llmConfig.baseUrl, pluginConfig.daemonIdleTimeout, pluginConfig.embedVersion, pluginConfig.embedPackagePath);
+                    // Start the embedded server
+                    console.log('[Hindsight] Starting embedded server...');
+                    await embedManager.start();
+                    // Initialize client
+                    console.log('[Hindsight] Creating HindsightClient...');
+                    client = new HindsightClient(llmConfig.provider, llmConfig.apiKey, llmConfig.model, pluginConfig.embedVersion, pluginConfig.embedPackagePath);
+                    // Set default bank (will be overridden per-request when dynamic bank IDs are enabled)
+                    const defaultBankId = deriveBankId(undefined, pluginConfig);
+                    console.log(`[Hindsight] Default bank: ${defaultBankId}`);
+                    client.setBankId(defaultBankId);
+                    // Note: Bank mission will be set per-bank when dynamic bank IDs are enabled
+                    // For now, set it on the default bank
+                    if (pluginConfig.bankMission && !pluginConfig.dynamicBankId) {
+                        console.log(`[Hindsight] Setting bank mission...`);
+                        await client.setBankMission(pluginConfig.bankMission);
+                    }
+                    isInitialized = true;
+                    console.log('[Hindsight] ✓ Ready');
                 }
-                isInitialized = true;
-                console.log('[Hindsight] ✓ Ready');
             }
             catch (error) {
                 console.error('[Hindsight] Initialization error:', error);
@@ -194,7 +327,7 @@ export default function (api) {
         api.registerService({
             id: 'hindsight-memory',
             async start() {
-                console.log('[Hindsight] Service start called - checking daemon health...');
+                console.log('[Hindsight] Service start called...');
                 // Wait for background init if still pending
                 if (initPromise) {
                     try {
@@ -205,40 +338,83 @@ export default function (api) {
                         // Continue to health check below
                     }
                 }
-                // Check if daemon is actually healthy (handles SIGUSR1 restart case)
-                if (embedManager && isInitialized) {
-                    const healthy = await embedManager.checkHealth();
-                    if (healthy) {
-                        console.log('[Hindsight] Daemon is healthy');
-                        return;
+                // External API mode: check external API health
+                if (usingExternalApi) {
+                    const externalApi = detectExternalApi(pluginConfig);
+                    if (externalApi.apiUrl && isInitialized) {
+                        try {
+                            await checkExternalApiHealth(externalApi.apiUrl);
+                            console.log('[Hindsight] External API is healthy');
+                            return;
+                        }
+                        catch (error) {
+                            console.error('[Hindsight] External API health check failed:', error);
+                            // Reset state for reinitialization attempt
+                            client = null;
+                            isInitialized = false;
+                        }
+                    }
+                }
+                else {
+                    // Local daemon mode: check daemon health (handles SIGUSR1 restart case)
+                    if (embedManager && isInitialized) {
+                        const healthy = await embedManager.checkHealth();
+                        if (healthy) {
+                            console.log('[Hindsight] Daemon is healthy');
+                            return;
+                        }
+                        console.log('[Hindsight] Daemon is not responding - reinitializing...');
+                        // Reset state for reinitialization
+                        embedManager = null;
+                        client = null;
+                        isInitialized = false;
                     }
-                    console.log('[Hindsight] Daemon is not responding - reinitializing...');
-                    // Reset state for reinitialization
-                    embedManager = null;
-                    client = null;
-                    isInitialized = false;
                 }
-                // Reinitialize if needed (fresh start or recovery from dead daemon)
+                // Reinitialize if needed (fresh start or recovery)
                 if (!isInitialized) {
-                    console.log('[Hindsight] Reinitializing daemon...');
-                    const pluginConfig = getPluginConfig(api);
-                    const llmConfig = detectLLMConfig(pluginConfig);
-                    const apiPort = pluginConfig.apiPort || 9077;
-                    embedManager = new HindsightEmbedManager(apiPort, llmConfig.provider, llmConfig.apiKey, llmConfig.model, llmConfig.baseUrl, pluginConfig.daemonIdleTimeout, pluginConfig.embedVersion, pluginConfig.embedPackagePath);
-                    await embedManager.start();
-                    client = new HindsightClient(llmConfig.provider, llmConfig.apiKey, llmConfig.model, pluginConfig.embedVersion, pluginConfig.embedPackagePath);
-                    client.setBankId(BANK_NAME);
-                    if (pluginConfig.bankMission) {
-                        await client.setBankMission(pluginConfig.bankMission);
+                    console.log('[Hindsight] Reinitializing...');
+                    const reinitPluginConfig = getPluginConfig(api);
+                    currentPluginConfig = reinitPluginConfig;
+                    const llmConfig = detectLLMConfig(reinitPluginConfig);
+                    const externalApi = detectExternalApi(reinitPluginConfig);
+                    const apiPort = reinitPluginConfig.apiPort || 9077;
+                    if (externalApi.apiUrl) {
+                        // External API mode
+                        usingExternalApi = true;
+                        process.env.HINDSIGHT_EMBED_API_URL = externalApi.apiUrl;
+                        if (externalApi.apiToken) {
+                            process.env.HINDSIGHT_EMBED_API_TOKEN = externalApi.apiToken;
+                        }
+                        await checkExternalApiHealth(externalApi.apiUrl);
+                        client = new HindsightClient(llmConfig.provider, llmConfig.apiKey, llmConfig.model, reinitPluginConfig.embedVersion, reinitPluginConfig.embedPackagePath);
+                        const defaultBankId = deriveBankId(undefined, reinitPluginConfig);
+                        client.setBankId(defaultBankId);
+                        if (reinitPluginConfig.bankMission && !reinitPluginConfig.dynamicBankId) {
+                            await client.setBankMission(reinitPluginConfig.bankMission);
+                        }
+                        isInitialized = true;
+                        console.log('[Hindsight] Reinitialization complete (external API mode)');
+                    }
+                    else {
+                        // Local daemon mode
+                        embedManager = new HindsightEmbedManager(apiPort, llmConfig.provider, llmConfig.apiKey, llmConfig.model, llmConfig.baseUrl, reinitPluginConfig.daemonIdleTimeout, reinitPluginConfig.embedVersion, reinitPluginConfig.embedPackagePath);
+                        await embedManager.start();
+                        client = new HindsightClient(llmConfig.provider, llmConfig.apiKey, llmConfig.model, reinitPluginConfig.embedVersion, reinitPluginConfig.embedPackagePath);
+                        const defaultBankId = deriveBankId(undefined, reinitPluginConfig);
+                        client.setBankId(defaultBankId);
+                        if (reinitPluginConfig.bankMission && !reinitPluginConfig.dynamicBankId) {
+                            await client.setBankMission(reinitPluginConfig.bankMission);
+                        }
+                        isInitialized = true;
+                        console.log('[Hindsight] Reinitialization complete');
                     }
-                    isInitialized = true;
-                    console.log('[Hindsight] Reinitialization complete');
                 }
             },
             async stop() {
                 try {
                     console.log('[Hindsight] Service stopping...');
-                    if (embedManager) {
+                    // Only stop daemon if in local mode
+                    if (!usingExternalApi && embedManager) {
                         await embedManager.stop();
                         embedManager = null;
                     }
@@ -253,28 +429,46 @@ export default function (api) {
             },
         });
         console.log('[Hindsight] Plugin loaded successfully');
-        // Register agent_end hook for auto-retention
-        console.log('[Hindsight] Registering agent_end hook...');
-        // Store session key for retention
+        // Register agent hooks for auto-recall and auto-retention
+        console.log('[Hindsight] Registering agent hooks...');
+        // Store session key and context for retention
         let currentSessionKey;
+        let currentAgentContext;
         // Auto-recall: Inject relevant memories before agent processes the message
-        api.on('before_agent_start', async (context) => {
+        // Hook signature: (event, ctx) where event has {prompt, messages?} and ctx has agent context
+        api.on('before_agent_start', async (event, ctx) => {
             try {
-                // Capture session key
-                if (context.sessionKey) {
-                    currentSessionKey = context.sessionKey;
-                    console.log('[Hindsight] Captured session key:', currentSessionKey);
+                // Capture session key and context for use in agent_end
+                if (ctx?.sessionKey) {
+                    currentSessionKey = ctx.sessionKey;
                 }
+                currentAgentContext = ctx;
+                // Derive bank ID from context
+                const bankId = deriveBankId(ctx, pluginConfig);
+                console.log(`[Hindsight] before_agent_start - bank: ${bankId}, channel: ${ctx?.messageProvider}/${ctx?.channelId}`);
                 // Get the user's latest message for recall
-                let prompt = context.prompt;
+                // Prefer rawMessage (clean user text) over prompt (envelope-formatted)
+                let prompt = event.rawMessage ?? event.prompt;
                 if (!prompt || typeof prompt !== 'string' || prompt.length < 5) {
                     return; // Skip very short messages
                 }
-                // Extract actual message from Telegram format: [Telegram ... GMT+1] actual message
-                const telegramMatch = prompt.match(/\[Telegram[^\]]+\]\s*(.+)$/);
-                if (telegramMatch) {
-                    prompt = telegramMatch[1].trim();
+                // Strip envelope-formatted prompts from any channel
+                // The prompt may contain: System: lines, abort hints, [Channel ...] header, [from: ...] suffix
+                let cleaned = prompt;
+                // Remove leading "System: ..." lines (from prependSystemEvents)
+                cleaned = cleaned.replace(/^(?:System:.*\n)+\n?/, '');
+                // Remove session abort hint
+                cleaned = cleaned.replace(/^Note: The previous agent run was aborted[^\n]*\n\n/, '');
+                // Extract message after [ChannelName ...] envelope header
+                // Handles any channel: Telegram, Slack, Discord, WhatsApp, Signal, etc.
+                // Uses [\s\S]+ instead of .+ to support multiline messages
+                const envelopeMatch = cleaned.match(/\[[A-Z][A-Za-z]*(?:\s[^\]]+)?\]\s*([\s\S]+)$/);
+                if (envelopeMatch) {
+                    cleaned = envelopeMatch[1];
                 }
+                // Remove trailing [from: SenderName] metadata (group chats)
+                cleaned = cleaned.replace(/\n\[from:[^\]]*\]\s*$/, '');
+                prompt = cleaned.trim() || prompt;
                 if (prompt.length < 5) {
                     return; // Skip very short messages after extraction
                 }
@@ -285,16 +479,17 @@ export default function (api) {
                     return;
                 }
                 await clientGlobal.waitForReady();
-                const client = clientGlobal.getClient();
+                // Get client configured for this context's bank (async to handle mission setup)
+                const client = await clientGlobal.getClientForContext(ctx);
                 if (!client) {
                     console.log('[Hindsight] Client not initialized, skipping auto-recall');
                     return;
                 }
-                console.log('[Hindsight] Auto-recall for prompt:', prompt.substring(0, 50));
-                // Recall relevant memories (up to 512 tokens)
+                console.log(`[Hindsight] Auto-recall for bank ${bankId}, prompt: ${prompt.substring(0, 50)}`);
+                // Recall relevant memories
                 const response = await client.recall({
                     query: prompt,
-                    max_tokens: 512,
+                    max_tokens: 2048,
                 });
                 if (!response.results || response.results.length === 0) {
                     console.log('[Hindsight] No memories found for auto-recall');
@@ -308,7 +503,7 @@ ${memoriesJson}
 
 User message: ${prompt}
 </hindsight_memories>`;
-                console.log(`[Hindsight] Auto-recall: Injecting ${response.results.length} memories`);
+                console.log(`[Hindsight] Auto-recall: Injecting ${response.results.length} memories from bank ${bankId}`);
                 // Inject context before the user message
                 return { prependContext: contextMessage };
             }
@@ -317,9 +512,14 @@ User message: ${prompt}
                 return;
             }
         });
-        api.on('agent_end', async (event) => {
+        // Hook signature: (event, ctx) where event has {messages, success, error?, durationMs?}
+        api.on('agent_end', async (event, ctx) => {
             try {
-                console.log('[Hindsight Hook] agent_end triggered');
+                // Use context from this hook, or fall back to context captured in before_agent_start
+                const effectiveCtx = ctx || currentAgentContext;
+                // Derive bank ID from context
+                const bankId = deriveBankId(effectiveCtx, pluginConfig);
+                console.log(`[Hindsight Hook] agent_end triggered - bank: ${bankId}`);
                 // Check event success and messages
                 if (!event.success || !Array.isArray(event.messages) || event.messages.length === 0) {
                     console.log('[Hindsight Hook] Skipping: success:', event.success, 'messages:', event.messages?.length);
@@ -332,7 +532,8 @@ User message: ${prompt}
                     return;
                 }
                 await clientGlobal.waitForReady();
-                const client = clientGlobal.getClient();
+                // Get client configured for this context's bank (async to handle mission setup)
+                const client = await clientGlobal.getClientForContext(effectiveCtx);
                 if (!client) {
                     console.warn('[Hindsight] Client not initialized, skipping retain');
                     return;
@@ -359,8 +560,9 @@ User message: ${prompt}
                     console.log('[Hindsight Hook] Transcript too short, skipping');
                     return;
                 }
-                // Use session key as document ID
-                const documentId = currentSessionKey || 'default-session';
+                // Use unique document ID per conversation (sessionKey + timestamp)
+                // Static sessionKey (e.g. "agent:main:main") causes CASCADE delete of old memories
+                const documentId = `${effectiveCtx?.sessionKey || currentSessionKey || 'session'}-${Date.now()}`;
                 // Retain to Hindsight
                 await client.retain({
                     content: transcript,
@@ -368,15 +570,18 @@ User message: ${prompt}
                     metadata: {
                         retained_at: new Date().toISOString(),
                         message_count: event.messages.length,
+                        channel_type: effectiveCtx?.messageProvider,
+                        channel_id: effectiveCtx?.channelId,
+                        sender_id: effectiveCtx?.senderId,
                     },
                 });
-                console.log(`[Hindsight] Retained ${event.messages.length} messages for session ${documentId}`);
+                console.log(`[Hindsight] Retained ${event.messages.length} messages to bank ${bankId} for session ${documentId}`);
             }
             catch (error) {
                 console.error('[Hindsight] Error retaining messages:', error);
             }
         });
-        console.log('[Hindsight] Hook registered');
+        console.log('[Hindsight] Hooks registered');
     }
     catch (error) {
         console.error('[Hindsight] Plugin loading error:', error);

package/dist/types.d.ts

@@ -1,7 +1,7 @@
 export interface MoltbotPluginAPI {
     config: MoltbotConfig;
     registerService(config: ServiceConfig): void;
-    on(event: string, handler: (context: any) => void | Promise<void | {
+    on(event: string, handler: (event: any, ctx?: any) => void | Promise<void | {
         prependContext?: string;
     }>): void;
 }
@@ -34,6 +34,10 @@ export interface PluginConfig {
     llmModel?: string;
     llmApiKeyEnv?: string;
     apiPort?: number;
+    hindsightApiUrl?: string;
+    hindsightApiToken?: string;
+    dynamicBankId?: boolean;
+    bankIdPrefix?: string;
 }
 export interface ServiceConfig {
     id: string;

package/openclaw.plugin.json

@@ -46,6 +46,23 @@
         "type": "number",
         "description": "Port for the openclaw profile daemon (default: 9077)",
         "default": 9077
+      },
+      "hindsightApiUrl": {
+        "type": "string",
+        "description": "External Hindsight API URL (e.g. 'https://mcp.hindsight.devcraft.team'). When set, skips local daemon and connects directly to this API."
+      },
+      "hindsightApiToken": {
+        "type": "string",
+        "description": "API token for external Hindsight API authentication. Required if the external API has authentication enabled."
+      },
+      "dynamicBankId": {
+        "type": "boolean",
+        "description": "Enable per-channel memory banks. When true, memories are isolated by channel (e.g., slack-C123, telegram-456). When false, all channels share a single 'openclaw' bank.",
+        "default": true
+      },
+      "bankIdPrefix": {
+        "type": "string",
+        "description": "Optional prefix for bank IDs (e.g., 'prod' results in 'prod-slack-C123'). Useful for separating environments."
       }
     },
     "additionalProperties": false
@@ -86,6 +103,22 @@
     "apiPort": {
       "label": "API Port",
       "placeholder": "9077 (default)"
+    },
+    "hindsightApiUrl": {
+      "label": "External Hindsight API URL",
+      "placeholder": "e.g. https://mcp.hindsight.devcraft.team (leave empty for local daemon)"
+    },
+    "hindsightApiToken": {
+      "label": "External API Token",
+      "placeholder": "API token if external API requires authentication"
+    },
+    "dynamicBankId": {
+      "label": "Dynamic Bank IDs",
+      "placeholder": "true (isolate memories per channel)"
+    },
+    "bankIdPrefix": {
+      "label": "Bank ID Prefix",
+      "placeholder": "e.g., prod, staging (optional)"
     }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vectorize-io/hindsight-openclaw",
-  "version": "0.4.8",
+  "version": "0.4.10",
   "description": "Hindsight memory plugin for OpenClaw - biomimetic long-term memory with fact extraction",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",