twinclaw 1.1.7 → 1.2.0

package/dist/core/cli.js

@@ -164,12 +164,34 @@ export const handleVersionCli = async (argv) => {
 };
 /**
  * Handle the `start` command.
- * Starts the gateway.
+ * Starts the gateway in a new terminal window.
  */
-export const handleStartCli = async (argv) => {
-    console.log('[TwinClaw] Starting gateway...');
-    console.log('[TwinClaw] Use "twinclaw gateway start" for more options');
-    console.log('[TwinClaw] Use "twinclaw gateway install" to install as Windows service');
+export const handleStartCli = async (argv, isChatMode = false) => {
+    if (isChatMode) {
+        global.TWINCLAW_CHAT_MODE = true;
+    }
+    if (process.platform === 'win32') {
+        const { spawn } = await import('node:child_process');
+        console.log('[TwinClaw] Starting gateway in new window...');
+        const entryScript = process.execPath;
+        const appPath = process.argv[1] || process.argv[0];
+        const args = [
+            '/c',
+            'start',
+            '""',
+            'cmd.exe',
+            '/k',
+            `"${entryScript}" chat`
+        ];
+        spawn('cmd.exe', args, {
+            detached: true,
+            stdio: 'ignore',
+            windowsHide: false,
+        });
+        console.log('[TwinClaw] Gateway started in new terminal window.');
+        console.log('[TwinClaw] You can now use this terminal for other commands.');
+        return 0;
+    }
     return 0;
 };
 /**
@@ -239,6 +261,7 @@ export function handleUnknownCommand(argv) {
         'version',
         'start',
         'stop',
+        'chat',
         'help'
     ]);
     if (KNOWN_COMMANDS.has(command) || command.startsWith('--') || command.startsWith('-')) {

package/dist/core/onboarding.js

@@ -33,30 +33,25 @@ export function startBasicREPL(gateway) {
 }
 const WIZARD_SECTIONS = [
     {
-        id: 'runtime',
-        label: 'Runtime & Security',
+        id: 'channel',
+        label: 'STEP 1: Choose Your Messaging Channel',
+        fields: [], // Special handling for channel selection
+    },
+    {
+        id: 'security',
+        label: 'STEP 2: Security',
         fields: ['API_SECRET', 'API_PORT'],
     },
     {
         id: 'models',
-        label: 'Intelligence & Models',
+        label: 'STEP 3: AI Models',
         fields: ['OPENROUTER_API_KEY', 'MODAL_API_KEY', 'GEMINI_API_KEY', 'GROQ_API_KEY', 'GITHUB_TOKEN'],
     },
     {
         id: 'model_selection',
-        label: 'Select Models',
+        label: 'STEP 4: Select Models',
         fields: ['SELECT_MODELS'],
     },
-    {
-        id: 'messaging',
-        label: 'Messaging & Channels',
-        fields: ['TELEGRAM_BOT_TOKEN', 'TELEGRAM_USER_ID', 'WHATSAPP_PHONE_NUMBER'],
-    },
-    {
-        id: 'memory',
-        label: 'Memory & Workspace Defaults',
-        fields: ['EMBEDDING_PROVIDER'],
-    },
 ];
 const EMBEDDING_PROVIDERS = new Set(['openai', 'ollama']);
 const COPILOT_DEVICE_FLOW_TRIGGERS = new Set(['device', 'auth', 'login', 'copilot']);
@@ -719,100 +714,110 @@ async function promptFieldValue(field, currentValue, prompter, logger) {
 }
 async function collectInteractiveUpdates(existing, logger, prompter) {
     const workspaceDir = getWorkspaceDir();
-    logger.log('\nTwinClaw Onboarding Wizard v2.0');
-    logger.log('──────────────────────────────────────────────────');
-    logger.log(`Workspace: ${workspaceDir}`);
-    logger.log('Model keys, channel preferences, and workspace defaults will be configured.');
-    logger.log("Secret prompts are masked. Type '-' to clear an existing optional value.\n");
+    logger.log('\n═══════════════════════════════════════════════════════════');
+    logger.log('              🎉 Welcome to TwinClaw Setup!');
+    logger.log('═══════════════════════════════════════════════════════════');
+    logger.log(`\n📁 Workspace: ${workspaceDir}`);
     const updates = {};
     let candidate = cloneConfig(existing);
     for (const section of WIZARD_SECTIONS) {
-        while (true) {
-            logger.log(`\nSection: ${section.label}`);
+        logger.log('\n═══════════════════════════════════════════════════════════');
+        logger.log(`  ${section.label}`);
+        logger.log('═══════════════════════════════════════════════════════════\n');
+        if (section.id === 'channel') {
+            logger.log('How would you like to connect with TwinClaw?');
             logger.log('──────────────────────────────────────────────────');
-            for (const fieldKey of section.fields) {
-                const field = ONBOARD_FIELDS.find((item) => item.key === fieldKey);
-                if (!field) {
-                    continue;
+            logger.log('  1. Terminal Only (Chat directly in terminal)');
+            logger.log('  2. Telegram');
+            logger.log('  3. WhatsApp');
+            logger.log('  4. Both Telegram & WhatsApp');
+            const choice = await prompter.prompt('\nEnter number: ');
+            if (choice === '2' || choice === '4') {
+                const token = await promptFieldValue(ONBOARD_FIELDS.find(f => f.key === 'TELEGRAM_BOT_TOKEN'), '', prompter, logger);
+                if (token) {
+                    updates['TELEGRAM_BOT_TOKEN'] = token;
+                    candidate = applyUpdates(candidate, { 'TELEGRAM_BOT_TOKEN': token });
+                    const userId = await promptFieldValue(ONBOARD_FIELDS.find(f => f.key === 'TELEGRAM_USER_ID'), '', prompter, logger);
+                    if (userId) {
+                        updates['TELEGRAM_USER_ID'] = userId;
+                        candidate = applyUpdates(candidate, { 'TELEGRAM_USER_ID': userId });
+                    }
                 }
-                const current = readOnboardConfigValue(candidate, field.key);
-                const nextValue = await promptFieldValue(field, current, prompter, logger);
-                if (nextValue !== undefined) {
-                    updates[field.key] = nextValue;
-                    candidate = applyUpdates(candidate, { [field.key]: nextValue });
+            }
+            if (choice === '3' || choice === '4') {
+                const phone = await promptFieldValue(ONBOARD_FIELDS.find(f => f.key === 'WHATSAPP_PHONE_NUMBER'), '', prompter, logger);
+                if (phone) {
+                    updates['WHATSAPP_PHONE_NUMBER'] = phone;
+                    candidate = applyUpdates(candidate, { 'WHATSAPP_PHONE_NUMBER': phone });
                 }
             }
-            if (section.id === 'models' && !hasAnyModelKey(candidate)) {
-                logger.warn('\nAt least one model API key is required (OpenRouter, Modal, Gemini, or GitHub Copilot).');
+            continue;
+        }
+        if (section.id === 'models') {
+            logger.log('You need at least one AI model API key.');
+            logger.log('Free keys available at:');
+            logger.log('  - OpenRouter: https://openrouter.ai/keys');
+            logger.log('  - Google AI: https://aistudio.google.com/app/apikey');
+            logger.log('  - Modal: https://modal.com');
+        }
+        for (const fieldKey of section.fields) {
+            const field = ONBOARD_FIELDS.find((item) => item.key === fieldKey);
+            if (!field) {
                 continue;
             }
-            if (section.id === 'messaging') {
-                const telegramToken = (candidate.messaging.telegram.botToken ?? '').trim();
-                const telegramUserId = candidate.messaging.telegram.userId;
-                if (hasValue(telegramToken) && !telegramUserId) {
-                    logger.warn('\nTELEGRAM_USER_ID is required when TELEGRAM_BOT_TOKEN is provided.');
-                    continue;
-                }
-                if (!hasValue(telegramToken) && telegramUserId) {
-                    logger.warn('\nTELEGRAM_BOT_TOKEN is required when TELEGRAM_USER_ID is provided.');
-                    continue;
+            const current = readOnboardConfigValue(candidate, field.key);
+            const nextValue = await promptFieldValue(field, current, prompter, logger);
+            if (nextValue !== undefined) {
+                updates[field.key] = nextValue;
+                candidate = applyUpdates(candidate, { [field.key]: nextValue });
+            }
+        }
+        if (section.id === 'model_selection') {
+            // Special logic to ensure model selection was actually handled if skipped in loop
+            if (!updates['SELECT_MODELS']) {
+                const field = ONBOARD_FIELDS.find(f => f.key === 'SELECT_MODELS');
+                const nextValue = await promptFieldValue(field, '', prompter, logger);
+                if (nextValue) {
+                    updates['SELECT_MODELS'] = nextValue;
+                    candidate = applyUpdates(candidate, { 'SELECT_MODELS': nextValue });
                 }
             }
-            break;
+        }
+        if (section.id === 'models' && !hasAnyModelKey(candidate)) {
+            logger.warn('\nAt least one model API key is required (OpenRouter, Modal, Gemini).');
+            // Force retry this section
+            // In a real loop we'd handle this better, but for simplicity here:
+            const orKey = await promptFieldValue(ONBOARD_FIELDS.find(f => f.key === 'OPENROUTER_API_KEY'), '', prompter, logger);
+            if (orKey) {
+                updates['OPENROUTER_API_KEY'] = orKey;
+                candidate = applyUpdates(candidate, { 'OPENROUTER_API_KEY': orKey });
+            }
         }
     }
     while (true) {
+        logger.log('\n═══════════════════════════════════════════════════════════');
+        logger.log('                    ✅ Setup Complete!');
+        logger.log('═══════════════════════════════════════════════════════════');
         logger.log('\nSummary of Configuration:');
         logger.log('──────────────────────────────────────────────────');
         for (const field of ONBOARD_FIELDS) {
             const val = readOnboardConfigValue(candidate, field.key);
-            const displayVal = field.secret || SECRET_KEYS.has(field.key)
-                ? val
-                    ? '********'
-                    : '(not set)'
-                : val || '(not set)';
-            logger.log(`  ${field.label}: ${displayVal}`);
+            if (val || field.required) {
+                const displayVal = (field.secret || SECRET_KEYS.has(field.key)) ? (val ? '********' : '(not set)') : (val || '(not set)');
+                logger.log(`  ${field.label}: ${displayVal}`);
+            }
         }
         const choice = await prompter.prompt('\nConfirm configuration? [y]es, [n]o (cancel), [e]dit: ');
         const lower = choice.toLowerCase();
         if (lower === 'y' || lower === 'yes') {
-            if (!hasAnyModelKey(candidate)) {
-                logger.warn('\nAt least one model API key is required (OpenRouter, Modal, Gemini, or GitHub Copilot).');
-                continue;
-            }
             return updates;
         }
         if (lower === 'n' || lower === 'no') {
             throw new OnboardingCancelledError();
         }
         if (lower === 'e' || lower === 'edit') {
-            logger.log('\nSelect section to edit:');
-            WIZARD_SECTIONS.forEach((s, i) => {
-                logger.log(`  ${i + 1}. ${s.label}`);
-            });
-            const sectionIdxStr = await prompter.prompt('\nSection number: ');
-            const sectionIdx = Number.parseInt(sectionIdxStr, 10) - 1;
-            if (WIZARD_SECTIONS[sectionIdx]) {
-                const section = WIZARD_SECTIONS[sectionIdx];
-                logger.log(`\nEditing Section: ${section.label}`);
-                logger.log('──────────────────────────────────────────────────');
-                for (const fieldKey of section.fields) {
-                    const field = ONBOARD_FIELDS.find((item) => item.key === fieldKey);
-                    if (!field) {
-                        continue;
-                    }
-                    const current = readOnboardConfigValue(candidate, field.key);
-                    const nextValue = await promptFieldValue(field, current, prompter, logger);
-                    if (nextValue !== undefined) {
-                        updates[field.key] = nextValue;
-                        candidate = applyUpdates(candidate, { [field.key]: nextValue });
-                    }
-                }
-            }
-            else {
-                logger.warn('Invalid section number.');
-            }
-            continue;
+            // Simple re-run for now to keep it clean
+            return collectInteractiveUpdates(existing, logger, prompter);
         }
         logger.warn("Please enter 'y', 'n', or 'e'.");
     }
@@ -882,9 +887,9 @@ function printWarnings(warnings, logger) {
 }
 function printNextActions(logger) {
     logger.log('\nNext actions:');
-    logger.log('  1. node src/index.ts doctor');
-    logger.log('  2. node src/index.ts channels login whatsapp');
-    logger.log('  3. node src/index.ts pairing approve <channel> <CODE>');
+    logger.log('  1. twinclaw doctor');
+    logger.log('  2. twinclaw channels login whatsapp');
+    logger.log('  3. twinclaw pairing approve <channel> <CODE>');
 }
 export function parseOnboardArgs(args) {
     const parsed = {

package/dist/core/persona-cli.js

@@ -0,0 +1,78 @@
+import { getPersonaStateService } from '../services/persona-state.js';
+import { formatHelp } from './help-formatter.js';
+/**
+ * Handle 'persona' command.
+ * Allows viewing and updating the agent's soul, identity, and user context.
+ */
+export const handlePersonaCli = async (argv) => {
+    const service = getPersonaStateService();
+    const subcommand = argv[1];
+    if (!subcommand || subcommand === 'show' || subcommand === 'view') {
+        const state = await service.getState();
+        console.log(', TwinClaw, Persona, State, ');, console.log('──────────────────────────────────────────────────'));
+        console.log(`Revision: ${state.revision}`);
+        console.log(`Updated:  ${state.updatedAt}`);
+        console.log(', -- - SOUL-- - ');, console.log(state.soul || '(empty)'));
+        console.log(', -- - IDENTITY-- - ');, console.log(state.identity || '(empty)'));
+        console.log(', -- - USER, CONTEXT-- - ');, console.log(state.user || '(empty)'));
+        return 0;
+    }
+    if (subcommand === 'edit' || subcommand === 'update') {
+        const key = argv[2];
+        if (!['soul', 'identity', 'user'].includes(key)) {
+            console.error('Invalid document key. Use: soul, identity, or user.');
+            return 1;
+        }
+        const newContent = argv.slice(3).join(' ');
+        if (!newContent) {
+            console.error(`Please provide the new content for ${key}.`);
+            console.log(`Usage: twinclaw persona edit ${key} "your content here"`);
+            return 1;
+        }
+        try {
+            const currentState = await service.getState();
+            const result = await service.updateState({
+                expectedRevision: currentState.revision,
+                [key]: newContent,
+                // Keep other fields as is
+                soul: key === 'soul' ? newContent : currentState.soul,
+                identity: key === 'identity' ? newContent : currentState.identity,
+                user: key === 'user' ? newContent : currentState.user,
+            });
+            console.log(`✅ Successfully updated ${key}.`);
+            console.log(`New revision: ${result.state.revision}`);
+            return 0;
+        }
+        catch (err) {
+            console.error(`❌ Failed to update persona: ${err instanceof Error ? err.message : String(err)}`);
+            return 1;
+        }
+    }
+    if (subcommand === 'help' || argv.includes('--help') || argv.includes('-h')) {
+        console.log(formatHelp({
+            command: 'persona',
+            description: "View or modify the agent's core persona (soul, identity, user context).",
+            usage: 'twinclaw persona [subcommand] [args]',
+            sections: [
+                {
+                    title: 'Subcommands',
+                    content: {
+                        'show, view': 'Display current persona state (default)',
+                        'edit, update': 'Update a specific part of the persona'
+                    }
+                },
+                {
+                    title: 'Update Usage',
+                    content: {
+                        'twinclaw persona edit soul "text"': 'Update the agent soul',
+                        'twinclaw persona edit identity "text"': 'Update agent identity',
+                        'twinclaw persona edit user "text"': 'Update user context'
+                    }
+                }
+            ]
+        }));
+        return 0;
+    }
+    console.error(`Unknown persona subcommand: ${subcommand}`);
+    return 1;
+};

package/dist/index.js

@@ -67,6 +67,7 @@ const CLI_HANDLERS = [
     { command: ['version', '--version', '-v'], handler: handleVersionCli, priority: CLI_HANDLER_PRIORITY.VERSION, description: 'Show version' },
     { command: 'start', handler: handleStartCli, priority: CLI_HANDLER_PRIORITY.START_STOP, description: 'Start gateway' },
     { command: 'stop', handler: handleStopCli, priority: CLI_HANDLER_PRIORITY.START_STOP, description: 'Stop gateway' },
+    { command: 'chat', handler: async (args) => { return await handleStartCli(['start', ...args.slice(1)], true); }, priority: CLI_HANDLER_PRIORITY.START_STOP, description: 'Open terminal chat' },
     { command: 'secret', handler: handleSecretCommandCli, priority: CLI_HANDLER_PRIORITY.CONFIG, description: 'Manage secrets' },
     { command: 'config', handler: handleConfigCommandCli, priority: CLI_HANDLER_PRIORITY.CONFIG, description: 'Validate runtime config' },
     { command: 'pairing', handler: async (args) => { return await handlePairingCli(args, pairingService) ? 0 : 1; }, priority: CLI_HANDLER_PRIORITY.CONFIG, description: 'Manage pairings' },
@@ -122,7 +123,6 @@ async function tryAutoSetup() {
         printPreStartValidationFailure(postSetupValidation.blockingIssues);
         return false;
     }
-    console.log("\n[TwinClaw] Setup complete. Initializing Gateway...\n");
     return true;
 }
 async function main() {
@@ -137,11 +137,19 @@ async function main() {
     }
     // Sort handlers by priority
     const sortedHandlers = [...CLI_HANDLERS].sort((a, b) => b.priority - a.priority);
-    for (const def of sortedHandlers) {
-        const commands = Array.isArray(def.command) ? def.command : [def.command];
-        if (commands.includes(command)) {
-            const exitCode = await def.handler(argv);
-            process.exit(exitCode);
+    if (command) {
+        let commandHandled = false;
+        for (const def of sortedHandlers) {
+            const commands = Array.isArray(def.command) ? def.command : [def.command];
+            if (commands.includes(command)) {
+                commandHandled = true;
+                const exitCode = await def.handler(argv);
+                process.exit(exitCode);
+            }
+        }
+        if (!commandHandled && !command.startsWith('-')) {
+            handleUnknownCommand(argv);
+            process.exit(1);
         }
     }
     // Handle help flags early if no command matched
@@ -149,9 +157,6 @@ async function main() {
         await handleHelpCli(argv);
         process.exit(0);
     }
-    if (command && handleUnknownCommand(argv)) {
-        process.exit(1);
-    }
     checkAndMigrateWorkspace();
     // If no command provided, try to start the gateway
     if (!(await tryAutoSetup())) {
@@ -248,6 +253,9 @@ async function main() {
             deny: parseToolSelectors(getConfigValue('TOOLS_DENY')),
         },
     });
+    if (global.TWINCLAW_CHAT_MODE) {
+        startBasicREPL(gateway);
+    }
     const telegramBotToken = secretVault.readSecret('TELEGRAM_BOT_TOKEN') ?? getConfigValue('TELEGRAM_BOT_TOKEN');
     const twinClawConfig = await readConfig();
     const telegramUserIdRaw = getConfigValue('TELEGRAM_USER_ID');

package/dist/services/embedding-service.js

@@ -1,5 +1,6 @@
 import { getSecretVaultService } from './secret-vault.js';
 import { getConfigValue } from '../config/json-config.js';
+import { logThoughtThrottled } from '../utils/logger.js';
 const DEFAULT_OPENAI_URL = 'https://api.openai.com/v1/embeddings';
 const DEFAULT_OPENAI_MODEL = 'text-embedding-3-small';
 const DEFAULT_OLLAMA_URL = 'http://localhost:11434';
@@ -81,12 +82,14 @@ export class EmbeddingService {
         }
         return null;
     }
-    debugLog(message) {
+    async debugLog(message) {
         const debugFlag = process.env.DEBUG?.trim().toLowerCase();
         const debugEnabled = Boolean(debugFlag && debugFlag !== '0' && debugFlag !== 'false');
         if (debugEnabled) {
             console.warn(message);
         }
+        // Always log to thought log, but throttled to prevent spam
+        await logThoughtThrottled('embedding_error', message, 30000); // 30s throttle
     }
     getProviderOrder() {
         const configured = (getConfigValue('EMBEDDING_PROVIDER') ?? '').toLowerCase().trim();

package/dist/services/model-router.js

@@ -980,8 +980,23 @@ export class ModelRouter {
         this.metrics.lastError = scrubSensitiveText(message);
         this.metrics.lastFailureAt = new Date(this.nowFn()).toISOString();
     }
+    getApiKeyEnvName(provider) {
+        const providerKeyMap = {
+            'openai': 'OPENAI_API_KEY',
+            'anthropic': 'ANTHROPIC_API_KEY',
+            'google': 'GEMINI_API_KEY',
+            'openrouter': 'OPENROUTER_API_KEY',
+            'groq': 'GROQ_API_KEY',
+            'modal': 'MODAL_API_KEY',
+            'copilot': 'GITHUB_TOKEN',
+            'github': 'GITHUB_TOKEN',
+            'ollama': 'OLLAMA_API_KEY',
+        };
+        return providerKeyMap[provider.toLowerCase()] || 'MODAL_API_KEY';
+    }
     loadModelsFromConfig() {
         const configModels = [];
+        // Check if PRIMARY_MODEL is set - use config.models.primaryModel if available
         const primaryModelId = getConfigValue('PRIMARY_MODEL');
         const modalApiKey = getConfigValue('MODAL_API_KEY');
         const openRouterApiKey = getConfigValue('OPENROUTER_API_KEY');

package/dist/services/proactive-notifier.js

@@ -91,8 +91,9 @@ export class ProactiveNotifier {
             return;
         if (event.type !== 'add' && event.type !== 'change')
             return;
-        const normalizedPath = event.path.toLowerCase();
-        const isIgnoredFile = this.#fileAlertIgnoreSubstrings.some((segment) => normalizedPath.includes(segment.toLowerCase()));
+        // Normalize path for robust comparison (handles Windows backslashes)
+        const normalizedPath = event.path.replace(/\\/g, '/').toLowerCase();
+        const isIgnoredFile = this.#fileAlertIgnoreSubstrings.some((segment) => normalizedPath.includes(segment.replace(/\\/g, '/').toLowerCase()));
         if (isIgnoredFile) {
             await logThought(`[ProactiveNotifier] Ignored modification event for system file: ${event.path}`);
             return;

package/dist/services/semantic-memory.js

@@ -9,34 +9,42 @@ const TASK_HINT_PATTERN = /\b(todo|task|implement|fix|build|create|refactor|ship
 const MAX_RELATION_RECONCILIATION = 12;
 const MAX_GRAPH_TRAVERSAL_DEPTH = 2;
 export async function indexConversationTurn(sessionId, role, content) {
-    const normalized = content.trim();
-    if (!normalized) {
-        return;
-    }
-    const chunks = chunkText(normalized);
-    let previousNodeId = null;
-    for (const chunk of chunks) {
-        const taggedChunk = `${role.toUpperCase()}: ${chunk}`;
-        const embedding = await embeddingService.embedText(taggedChunk);
-        if (!embedding) {
-            continue;
+    try {
+        const normalized = content.trim();
+        if (!normalized) {
+            return;
         }
-        const memoryRowId = saveMemoryEmbedding(sessionId, taggedChunk, embedding);
-        const node = buildReasoningNode(sessionId, role, taggedChunk);
-        upsertReasoningNode(node);
-        linkMemoryProvenance(memoryRowId, node.nodeId, sessionId);
-        if (previousNodeId && previousNodeId !== node.nodeId) {
-            upsertReasoningEdge({
-                edgeId: stableId('edge', `${previousNodeId}|${node.nodeId}|derived_from`),
-                fromNodeId: previousNodeId,
-                toNodeId: node.nodeId,
-                relation: 'derived_from',
-                weight: 0.55,
-                provenance: `session:${sessionId}:turn-sequence`,
-            });
+        const chunks = chunkText(normalized);
+        let previousNodeId = null;
+        // Limit indexing to first 2 chunks to prevent long hangs during indexing
+        const limitedChunks = chunks.slice(0, 2);
+        for (const chunk of limitedChunks) {
+            const taggedChunk = `${role.toUpperCase()}: ${chunk}`;
+            const embedding = await embeddingService.embedText(taggedChunk);
+            if (!embedding) {
+                continue;
+            }
+            const memoryRowId = saveMemoryEmbedding(sessionId, taggedChunk, embedding);
+            const node = buildReasoningNode(sessionId, role, taggedChunk);
+            upsertReasoningNode(node);
+            linkMemoryProvenance(memoryRowId, node.nodeId, sessionId);
+            if (previousNodeId && previousNodeId !== node.nodeId) {
+                upsertReasoningEdge({
+                    edgeId: stableId('edge', `${previousNodeId}|${node.nodeId}|derived_from`),
+                    fromNodeId: previousNodeId,
+                    toNodeId: node.nodeId,
+                    relation: 'derived_from',
+                    weight: 0.55,
+                    provenance: `session:${sessionId}:turn-sequence`,
+                });
+            }
+            previousNodeId = node.nodeId;
+            reconcileClaimRelations(node);
         }
-        previousNodeId = node.nodeId;
-        reconcileClaimRelations(node);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        console.warn(`[SemanticMemory] Failed to index turn for session ${sessionId}: ${message}`);
     }
 }
 export async function retrieveEvidenceAwareMemoryContext(sessionId, prompt, topK = 5) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "twinclaw",
-  "version": "1.1.7",
+  "version": "1.2.0",
   "description": "Eagle-eyed agentic AI gateway with multi-modal hooks and proactive memory.",
   "main": "dist/index.js",
   "bin": {