twinclaw 1.2.9 → 1.3.1

package/dist/agents/self-setup-agent.js

@@ -0,0 +1,207 @@
+import { logThought } from '../utils/logger.js';
+import { checkFirstInteraction, loadUserMemory, saveUserMemory, getDefaultUserMemory, } from '../services/user-memory.js';
+const ONBOARDING_SYSTEM_PROMPT = `You are having a natural conversation to get to know the user better. Your goal is to learn about them in a friendly, casual way - like two people chatting over coffee.
+
+Topics to naturally explore (one at a time, naturally):
+- What they do for work/study
+- What they're currently working on or interested in
+- What tools/tech they use
+- What they like to do outside of work
+- How they prefer to communicate (brief vs detailed, technical vs simple)
+- What their goals are
+
+Guidelines:
+- Be conversational and warm, not robotic
+- Ask one question at a time, building on what they share
+- Don't use numbered lists or formal questionnaires
+- If they share multiple things, acknowledge them naturally before asking follow-ups
+- When you feel you've learned enough (after 3-5 exchanges), ask if they'd like you to remember this info
+
+Important: Extract key information from their responses and include it in your response as a JSON comment like:
+<!-- INFO: {"role": "developer", "interests": "AI, music", "goals": "building automation"} -->
+
+This JSON will be automatically parsed to save their profile. Use these keys:
+- role (what they do)
+- company (where they work)
+- currentProject (what they're working on)
+- tools (comma-separated list of tools they use)
+- interests (what they like doing)
+- communicationPreference (brief, detailed, or contextual)
+- frustrations (what frustrates them about AI)
+- goals (what they're trying to achieve)
+- technicalLevel (beginner, intermediate, or expert)`;
+export class SelfSetupAgent {
+    #userId;
+    #phase = 'idle';
+    #conversationTurn = 0;
+    #extractedInfo = {};
+    #confirmed = false;
+    constructor(userId) {
+        this.#userId = userId;
+    }
+    get userId() {
+        return this.#userId;
+    }
+    get phase() {
+        return this.#phase;
+    }
+    isComplete() {
+        return this.#phase === 'completed';
+    }
+    getSystemPrompt() {
+        return ONBOARDING_SYSTEM_PROMPT;
+    }
+    getConversationHistory() {
+        return [
+            {
+                role: 'system',
+                content: ONBOARDING_SYSTEM_PROMPT,
+            },
+        ];
+    }
+    processLLMResponse(llmText) {
+        this.#conversationTurn++;
+        const extracted = this.#extractInfo(llmText);
+        if (extracted) {
+            this.#extractedInfo = { ...this.#extractedInfo, ...extracted };
+        }
+        if (this.#conversationTurn >= 4 && !this.#confirmed) {
+            this.#phase = 'confirming';
+            return {
+                text: llmText,
+                phase: this.#phase,
+                isComplete: false,
+                needsMoreInfo: true,
+                extractedInfo: this.#extractedInfo,
+            };
+        }
+        if (this.#confirmed) {
+            return this.#completeSetup();
+        }
+        this.#phase = 'learning';
+        return {
+            text: llmText,
+            phase: this.#phase,
+            isComplete: false,
+            needsMoreInfo: true,
+            extractedInfo: this.#extractedInfo,
+        };
+    }
+    confirmAndSave() {
+        this.#confirmed = true;
+        return this.#completeSetup();
+    }
+    skipOrDecline() {
+        this.#phase = 'completed';
+        return {
+            text: "No problem! Whenever you're ready to share more about yourself, just let me know. How can I help you today?",
+            phase: this.#phase,
+            isComplete: true,
+            needsMoreInfo: false,
+        };
+    }
+    #completeSetup() {
+        if (Object.keys(this.#extractedInfo).length > 0) {
+            const memory = getDefaultUserMemory();
+            if (this.#extractedInfo.role) {
+                memory.profile.identity.role = String(this.#extractedInfo.role);
+            }
+            if (this.#extractedInfo.company) {
+                memory.profile.identity.company = String(this.#extractedInfo.company);
+            }
+            if (this.#extractedInfo.currentProject) {
+                memory.profile.professionalBackground.currentFocus = String(this.#extractedInfo.currentProject);
+            }
+            if (this.#extractedInfo.tools) {
+                const tools = String(this.#extractedInfo.tools).split(',').map(t => t.trim()).filter(Boolean);
+                memory.profile.professionalBackground.toolsAndPlatforms = tools;
+            }
+            if (this.#extractedInfo.interests) {
+                memory.profile.personalContext.interests = String(this.#extractedInfo.interests).split(',').map(t => t.trim()).filter(Boolean);
+            }
+            if (this.#extractedInfo.goals) {
+                memory.profile.goals.shortTerm = [String(this.#extractedInfo.goals)];
+            }
+            if (this.#extractedInfo.technicalLevel) {
+                const level = String(this.#extractedInfo.technicalLevel).toLowerCase();
+                if (level.includes('beginner')) {
+                    memory.profile.identity.technicalLevel = 'beginner';
+                }
+                else if (level.includes('expert') || level.includes('advanced')) {
+                    memory.profile.identity.technicalLevel = 'expert';
+                }
+                else {
+                    memory.profile.identity.technicalLevel = 'intermediate';
+                }
+            }
+            if (this.#extractedInfo.communicationPreference) {
+                const pref = String(this.#extractedInfo.communicationPreference).toLowerCase();
+                if (pref.includes('brief')) {
+                    memory.profile.communicationStyle.detailLevel = 'brief';
+                }
+                else if (pref.includes('detail')) {
+                    memory.profile.communicationStyle.detailLevel = 'comprehensive';
+                }
+                else {
+                    memory.profile.communicationStyle.detailLevel = 'contextual';
+                }
+            }
+            if (this.#extractedInfo.frustrations) {
+                memory.profile.communicationStyle.frustrations = [String(this.#extractedInfo.frustrations)];
+            }
+            saveUserMemory(this.#userId, memory);
+            logThought(`[SelfSetupAgent] Saved user profile for: ${this.#userId}`);
+        }
+        this.#phase = 'completed';
+        return {
+            text: `Got it! I've saved what you shared about yourself. I'll use this to tailor my responses to you.
+
+From now on, I'll:
+✓ Remember what matters to you
+✓ Adapt my communication style to your preferences  
+✓ Keep track of your projects and goals
+
+If anything changes or you want to update your info, just let me know. Ready to dive in!`,
+            phase: this.#phase,
+            isComplete: true,
+            needsMoreInfo: false,
+            extractedInfo: this.#extractedInfo,
+        };
+    }
+    #extractInfo(text) {
+        const infoMatch = text.match(/<!--\s*INFO:\s*(\{[^}]+\})\s*-->/);
+        if (!infoMatch) {
+            return null;
+        }
+        try {
+            return JSON.parse(infoMatch[1]);
+        }
+        catch {
+            logThought(`[SelfSetupAgent] Failed to parse extracted info: ${infoMatch[1]}`);
+            return null;
+        }
+    }
+    getState() {
+        return {
+            phase: this.#phase,
+            turn: this.#conversationTurn,
+            extractedCount: Object.keys(this.#extractedInfo).length,
+        };
+    }
+}
+export function createSelfSetupAgent(userId) {
+    if (!checkFirstInteraction(userId)) {
+        return null;
+    }
+    return new SelfSetupAgent(userId);
+}
+export function getExistingUserMemory(userId) {
+    return loadUserMemory(userId);
+}
+export function getOrCreateAgent(userId, existing) {
+    if (existing && existing.phase !== 'completed') {
+        return existing;
+    }
+    const newAgent = createSelfSetupAgent(userId);
+    return newAgent ?? existing;
+}

package/dist/config/json-config.js

@@ -631,6 +631,9 @@ export function getConfigValue(key, sensitive = false) {
         case 'GITHUB_TOKEN':
             jsonValue = config.models.githubToken;
             break;
+        case 'MODEL_DEFINITIONS':
+            jsonValue = JSON.stringify(config.models.definitions ?? []);
+            break;
         case 'TELEGRAM_BOT_TOKEN':
             jsonValue = config.messaging.telegram.botToken;
             break;

package/dist/config/model-catalog.js

@@ -265,6 +265,89 @@ export const STATIC_MODEL_CATALOG = [
         pricing: 'Included with Copilot',
         description: 'GitHub Copilot model',
     })),
+    // Modal Custom Models
+    {
+        id: 'modal-zai-glm-5-fp8',
+        name: 'GLM-5-FP8',
+        provider: 'modal',
+        model: 'zai-org/GLM-5-FP8',
+        contextLength: 128000,
+        supportsStreaming: true,
+        pricing: 'Custom endpoint',
+        description: 'Custom Modal model'
+    },
+    // Groq Models
+    {
+        id: 'groq-qwen3-32b',
+        name: 'Qwen 3 32B',
+        provider: 'groq',
+        model: 'qwen/qwen3-32b',
+        contextLength: 32768,
+        supportsStreaming: true,
+        pricing: 'Free tier available',
+        description: 'Fast inference with Groq'
+    },
+    {
+        id: 'groq-kimi-k2',
+        name: 'Kimi K2 Instruct',
+        provider: 'groq',
+        model: 'moonshotai/kimi-k2-instruct-0905',
+        contextLength: 32768,
+        supportsStreaming: true,
+        pricing: 'Free tier available',
+        description: 'Fast inference with Groq'
+    },
+    // OpenRouter Free Models
+    {
+        id: 'openrouter-stepfun-flash',
+        name: 'StepFun Flash (Free)',
+        provider: 'openrouter',
+        model: 'stepfun/step-3.5-flash:free',
+        contextLength: 32000,
+        supportsStreaming: true,
+        pricing: 'Free',
+        description: 'Free model via OpenRouter'
+    },
+    {
+        id: 'openrouter-trinity-large',
+        name: 'Trinity Large (Free)',
+        provider: 'openrouter',
+        model: 'arcee-ai/trinity-large-preview:free',
+        contextLength: 32000,
+        supportsStreaming: true,
+        pricing: 'Free',
+        description: 'Free model via OpenRouter'
+    },
+    {
+        id: 'openrouter-trinity-mini',
+        name: 'Trinity Mini (Free)',
+        provider: 'openrouter',
+        model: 'arcee-ai/trinity-mini:free',
+        contextLength: 32000,
+        supportsStreaming: true,
+        pricing: 'Free',
+        description: 'Free model via OpenRouter'
+    },
+    {
+        id: 'openrouter-qwen-vl',
+        name: 'Qwen VL (Free)',
+        provider: 'openrouter',
+        model: 'qwen/qwen3-vl-30b-a3b-thinking',
+        contextLength: 32000,
+        supportsStreaming: true,
+        pricing: 'Free',
+        description: 'Free vision model via OpenRouter'
+    },
+    {
+        id: 'openrouter-gpt-oss',
+        name: 'GPT OSS (Free)',
+        provider: 'openrouter',
+        model: 'openai/gpt-oss-120b:free',
+        contextLength: 32000,
+        supportsStreaming: true,
+        pricing: 'Free',
+        description: 'Free model via OpenRouter'
+    },
     // GitHub Models catalog entries can also be fetched dynamically
     // Modal Custom Models (user-specific - will be added dynamically)
 ];

package/dist/core/gateway.js

@@ -1,6 +1,9 @@
 import { randomUUID } from 'node:crypto';
+import fs from 'node:fs/promises';
+import path from 'path';
 import { createSession, getSessionMessages, saveMessage } from '../services/db.js';
 import { ModelRouter } from '../services/model-router.js';
+import { getIdentityDir } from '../config/workspace.js';
 import { indexConversationTurn, retrieveEvidenceAwareMemoryContext, } from '../services/semantic-memory.js';
 import { OrchestrationService } from '../services/orchestration-service.js';
 import { assembleContext } from './context-assembly.js';
@@ -8,6 +11,7 @@ import { LaneExecutor } from './lane-executor.js';
 import { PolicyEngine } from '../services/policy-engine.js';
 import { logThought } from '../utils/logger.js';
 import { ContextLifecycleOrchestrator } from '../services/context-lifecycle.js';
+import { createSelfSetupAgent } from '../agents/self-setup-agent.js';
 const DEFAULT_MAX_TOOL_ROUNDS = 6;
 const DEFAULT_IDENTICAL_TOOL_CALL_LIMIT = 3;
 const DEFAULT_DELEGATION_MIN_SCORE = 2;
@@ -89,6 +93,7 @@ export class Gateway {
     #contextLifecycle;
     #toolPolicy;
     #degradationCounts = new Map();
+    #selfSetupAgents = new Map();
     constructor(registry, options = {}) {
         this.#router = options.router ?? new ModelRouter();
         this.#orchestration = options.orchestration ?? new OrchestrationService();
@@ -163,8 +168,46 @@ export class Gateway {
             return 'I could not find any text content to process.';
         }
         const sessionId = `${message.platform}:${message.senderId}`;
+        const userId = message.senderId;
+        const existingAgent = this.#selfSetupAgents.get(userId);
+        if (existingAgent && !existingAgent.isComplete()) {
+            return this.#runOnboardingConversation(existingAgent, normalizedText, sessionId);
+        }
+        const newAgent = createSelfSetupAgent(userId);
+        if (newAgent) {
+            this.#selfSetupAgents.set(userId, newAgent);
+            return this.#runOnboardingConversation(newAgent, normalizedText, sessionId);
+        }
         return this.processText(sessionId, normalizedText);
     }
+    async #runOnboardingConversation(agent, userMessage, sessionId) {
+        const messages = [
+            { role: 'system', content: agent.getSystemPrompt() },
+            ...agent.getConversationHistory(),
+            { role: 'user', content: userMessage },
+        ];
+        try {
+            const response = await this.#router.createChatCompletion(messages, undefined, { sessionId });
+            if (!response.content) {
+                return "I'm having trouble thinking right now. Let's try again.";
+            }
+            const result = agent.processLLMResponse(response.content);
+            if (result.isComplete && !result.needsMoreInfo) {
+                this.#selfSetupAgents.delete(agent.userId);
+                return result.text;
+            }
+            if (result.phase === 'confirming') {
+                const confirmMessage = result.text + "\n\nWould you like me to remember this? (yes/no or just tell me more)";
+                return confirmMessage;
+            }
+            return result.text;
+        }
+        catch (err) {
+            const errorMsg = err instanceof Error ? err.message : String(err);
+            logThought(`[SelfSetupAgent] LLM error: ${errorMsg}`);
+            return "I'm having trouble continuing our conversation. Let's try again - what would you like to talk about?";
+        }
+    }
     async processText(sessionId, text) {
         const normalizedText = text.trim();
         if (!normalizedText) {
@@ -174,6 +217,17 @@ export class Gateway {
         const historyRows = getSessionMessages(sessionId);
         const conversationHistory = toConversationHistory(historyRows);
         const historyPlan = this.#contextLifecycle.planHistoryWindow(conversationHistory);
+        const isFirstInteraction = historyRows.length === 0;
+        let setupPrompt = '';
+        if (isFirstInteraction) {
+            const userMdPath = path.join(getIdentityDir(), 'user.md');
+            try {
+                await fs.access(userMdPath);
+            }
+            catch {
+                setupPrompt = this.#getPersonaSetupPrompt();
+            }
+        }
         await this.#persistTurn(sessionId, 'user', normalizedText);
         const memoryRetrieval = await retrieveEvidenceAwareMemoryContext(sessionId, normalizedText, historyPlan.memoryTopK);
         const memoryContext = memoryRetrieval.context;
@@ -190,6 +244,7 @@ export class Gateway {
         const messages = [
             { role: 'system', content: compactSystemPrompt.content },
             ...historyPlan.hotHistory,
+            ...(setupPrompt ? [{ role: 'system', content: setupPrompt }] : []),
             { role: 'user', content: normalizedText },
         ];
         return this.#runConversationLoop(sessionId, messages);
@@ -458,4 +513,59 @@ export class Gateway {
         }
         return content;
     }
+    #getPersonaSetupPrompt() {
+        return `
+## First Interaction - Persona Setup
+
+This appears to be your first conversation with me. Before we dive into anything, I'd love to take a few minutes to get to know you better so I can be actually helpful (not just generic AI helpful).
+
+Think of this as a quick chat where I learn what makes you tick.
+
+Start by introducing yourself warmly and asking me 2-3 questions about:
+- What do you do? (Role, industry, company)
+- What are you working on right now?
+- How do you like information presented? (Brief vs detailed, casual vs formal)
+- What frustrates you about AI assistants?
+- What platforms or tools do you use that I might integrate with?
+
+After I respond, synthesize what you learn and create/update the user.md file in my identity directory with:
+- User name and how they'd like to be addressed
+- Role/industry/company
+- Communication preferences
+- Current projects or goals
+- Tools and platforms they use
+- Anything they want me to know or avoid
+
+The user.md file should follow this format:
+
+\`\`\`markdown
+# User Profile
+
+## Basic Info
+- **Name:** [what they want to be called]
+- **Role:** [job title/position]
+- **Company/Context:** [where they work/study]
+- **Technical Level:** [beginner/intermediate/expert]
+
+## Communication Preferences
+- **Formality:** [casual/professional/mix]
+- **Detail Level:** [brief/comprehensive/contextual]
+- **Tone:** [direct/exploratory/friendly]
+
+## Current Context
+- **Active Projects:** [what they're working on]
+- **Goals:** [what they're trying to achieve]
+- **Tools:** [daily tech stack, platforms]
+
+## Important to Remember
+- [things they explicitly mention caring about]
+- [frustrations they mention]
+
+## Learned Facts
+- [interesting facts from our conversation]
+\`\`\`
+
+Tell me once you've saved this. Then we'll be ready to dive in!
+`;
+    }
 }

package/dist/core/onboarding.js

@@ -8,7 +8,7 @@ import { isValidApiPort, isValidE164LikePhone, isValidProviderModelFormat, } fro
 import { createSession } from '../services/db.js';
 import { logThought } from '../utils/logger.js';
 import { getGitHubCopilotService } from '../services/github-copilot-service.js';
-import { getModelCatalogService } from '../services/model-catalog-service.js';
+import { getModelCatalogService, initializeModelCatalog } from '../services/model-catalog-service.js';
 import { PROVIDER_INFO } from '../config/model-catalog.js';
 const rl = readline.createInterface({
     input: process.stdin,
@@ -1214,6 +1214,8 @@ async function restoreConfigSnapshot(configPath, snapshot) {
     await writeFile(configPath, snapshot, { encoding: 'utf8', mode: 0o600 });
 }
 export async function runSetupWizard(options = {}) {
+    // Initialize model catalog (fetch GitHub models)
+    await initializeModelCatalog();
     const logger = options.logger ?? console;
     const configPath = getConfigPath(options.configPathOverride);
     const baseConfig = await readConfig(options.configPathOverride);

package/dist/index.js

@@ -19,6 +19,7 @@ import { SttService } from './services/stt-service.js';
 import { TtsService } from './services/tts-service.js';
 import { QueueService } from './services/queue-service.js';
 import { ModelRouter } from './services/model-router.js';
+import { initializeModelCatalog } from './services/model-catalog-service.js';
 import { IncidentManager } from './services/incident-manager.js';
 import { RuntimeBudgetGovernor } from './services/runtime-budget-governor.js';
 import { LocalStateBackupService } from './services/local-state-backup.js';
@@ -240,6 +241,8 @@ async function main() {
         return 'allowlist';
     }
     const runtimeBudgetGovernor = new RuntimeBudgetGovernor();
+    // Initialize model catalog (fetch GitHub models in background)
+    initializeModelCatalog().catch(err => console.warn('[ModelCatalog] Init failed:', err));
     const modelRouter = new ModelRouter({ budgetGovernor: runtimeBudgetGovernor });
     const gateway = new Gateway(skillRegistry, {
         policyEngine,

package/dist/interfaces/telegram_handler.js

@@ -1,6 +1,8 @@
 import TelegramBot from 'node-telegram-bot-api';
 import os from 'node:os';
 import path from 'node:path';
+import { readConfig, writeConfig } from '../config/json-config.js';
+import { getModelCatalogService } from '../services/model-catalog-service.js';
 /** Minimum ms delay between processing successive messages (human-like pacing). */
 const RATE_LIMIT_MS = 1500;
 const TELEGRAM_COMMANDS = [
@@ -128,20 +130,63 @@ _All systems operational_
                 break;
             case '/models':
             case '/model':
-                if (args.startsWith('set ') && args.length > 4) {
-                    const modelId = args.substring(4).trim();
-                    await this.#bot.sendMessage(chatId, `To change model to *${modelId}*, run:\n\n\`/key set modal ${modelId}\`\n\n_Or use: twinclaw config edit_`, { parse_mode: 'Markdown' });
+                if (args.startsWith('list')) {
+                    const catalog = getModelCatalogService().getAllModels();
+                    const config = await readConfig();
+                    const currentPrimary = config.models.primaryModel || 'not set';
+                    let modelList = `📦 *Available Models*\n\nCurrent: *${currentPrimary}*\n\n`;
+                    const providerGroups = new Map();
+                    for (const model of catalog) {
+                        const models = providerGroups.get(model.provider) || [];
+                        models.push(model);
+                        providerGroups.set(model.provider, models);
+                    }
+                    let num = 1;
+                    for (const [provider, models] of providerGroups) {
+                        modelList += `*${provider.toUpperCase()}:*\n`;
+                        for (const m of models.slice(0, 5)) {
+                            const isCurrent = m.model === currentPrimary || m.id === currentPrimary;
+                            modelList += `${num}. ${m.name}${isCurrent ? ' ✅' : ''}\n`;
+                            num++;
+                        }
+                        if (models.length > 5)
+                            modelList += `  ...and ${models.length - 5} more\n`;
+                        modelList += '\n';
+                    }
+                    modelList += '_To switch: /model set <number>_';
+                    await this.#bot.sendMessage(chatId, modelList, { parse_mode: 'Markdown' });
+                }
+                else if (args.startsWith('set ') && args.length > 4) {
+                    const modelIdOrNum = args.substring(4).trim();
+                    const catalog = getModelCatalogService().getAllModels();
+                    let newModelId = modelIdOrNum;
+                    if (/^\d+$/.test(modelIdOrNum)) {
+                        const idx = parseInt(modelIdOrNum, 10) - 1;
+                        if (idx >= 0 && idx < catalog.length) {
+                            newModelId = `${catalog[idx].provider}/${catalog[idx].model}`;
+                        }
+                        else {
+                            await this.#bot.sendMessage(chatId, `❌ Invalid model number. Use /model list to see available models.`);
+                            break;
+                        }
+                    }
+                    const config = await readConfig();
+                    config.models.primaryModel = newModelId;
+                    await writeConfig(config);
+                    await this.#bot.sendMessage(chatId, `✅ *Model updated!*\n\nNew primary model: *${newModelId}*\n\nRestart TwinClaw for changes to take effect.`, { parse_mode: 'Markdown' });
                 }
                 else {
+                    const config = await readConfig();
+                    const currentPrimary = config.models.primaryModel || 'not set';
                     await this.#bot.sendMessage(chatId, `📦 *Models*
 
-Use *twinclaw config* to manage models.
+Current: *${currentPrimary}*
 
 Commands:
 • /model list - List available models
-• /model set <id> - Set primary model
+• /model set <number> - Set primary model
 
-_Or run: twinclaw config model_
+Example: /model set 1
 `, { parse_mode: 'Markdown' });
                 }
                 break;

package/dist/interfaces/whatsapp_handler.js

@@ -6,7 +6,8 @@ import path from 'node:path';
 import fs from 'node:fs/promises';
 import { randomUUID } from 'node:crypto';
 import { logThought } from '../utils/logger.js';
-import { getConfigValue } from '../config/json-config.js';
+import { getConfigValue, readConfig, writeConfig } from '../config/json-config.js';
+import { getModelCatalogService } from '../services/model-catalog-service.js';
 const { Client, LocalAuth, MessageMedia } = WAWebJS;
 const RATE_LIMIT_MS = 1500;
 const WHATSAPP_COMMANDS = [
@@ -70,8 +71,10 @@ export class WhatsAppHandler {
         this.#registerListeners();
     }
     // ── Command Handlers ─────────────────────────────────────────────────────────
-    async handleCommand(chatId, command) {
-        const cmd = command.toLowerCase().trim();
+    async handleCommand(chatId, command, fullText) {
+        const parts = command.toLowerCase().trim().split(' ');
+        const cmd = parts[0];
+        const args = fullText ? fullText.substring(cmd.length).trim() : '';
         switch (cmd) {
             case '/start':
             case '/menu':
@@ -103,12 +106,65 @@ _All systems operational_
                 break;
             case '/models':
             case '/model':
-                await this.sendText(chatId, `📦 *Models*
+                if (args.startsWith('list')) {
+                    const catalog = getModelCatalogService().getAllModels();
+                    const config = await readConfig();
+                    const currentPrimary = config.models.primaryModel || 'not set';
+                    let modelList = `📦 *Available Models*\n\nCurrent: ${currentPrimary}\n\n`;
+                    const providerGroups = new Map();
+                    for (const model of catalog) {
+                        const models = providerGroups.get(model.provider) || [];
+                        models.push(model);
+                        providerGroups.set(model.provider, models);
+                    }
+                    let num = 1;
+                    for (const [provider, models] of providerGroups) {
+                        modelList += `*${provider.toUpperCase()}:*\n`;
+                        for (const m of models.slice(0, 5)) {
+                            const isCurrent = m.model === currentPrimary || m.id === currentPrimary;
+                            modelList += `${num}. ${m.name}${isCurrent ? ' ✅' : ''}\n`;
+                            num++;
+                        }
+                        if (models.length > 5)
+                            modelList += `  ...and ${models.length - 5} more\n`;
+                        modelList += '\n';
+                    }
+                    modelList += '_To switch: /model set <number>_';
+                    await this.sendText(chatId, modelList);
+                }
+                else if (args.startsWith('set ') && args.length > 4) {
+                    const modelIdOrNum = args.substring(4).trim();
+                    const catalog = getModelCatalogService().getAllModels();
+                    let newModelId = modelIdOrNum;
+                    if (/^\d+$/.test(modelIdOrNum)) {
+                        const idx = parseInt(modelIdOrNum, 10) - 1;
+                        if (idx >= 0 && idx < catalog.length) {
+                            newModelId = `${catalog[idx].provider}/${catalog[idx].model}`;
+                        }
+                        else {
+                            await this.sendText(chatId, '❌ Invalid model number. Use /model list to see available models.');
+                            break;
+                        }
+                    }
+                    const config = await readConfig();
+                    config.models.primaryModel = newModelId;
+                    await writeConfig(config);
+                    await this.sendText(chatId, `✅ *Model updated!*\n\nNew primary model: ${newModelId}\n\nRestart TwinClaw for changes to take effect.`);
+                }
+                else {
+                    const config = await readConfig();
+                    const currentPrimary = config.models.primaryModel || 'not set';
+                    await this.sendText(chatId, `📦 *Models*
+
+Current: ${currentPrimary}
 
-Use *twinclaw config* to manage models.
+Commands:
+• /model list - List available models
+• /model set <number> - Set primary model
 
-Or run: *twinclaw config model* in terminal
+Example: /model set 1
 `);
+                }
                 break;
             case '/keys':
             case '/key':
@@ -246,8 +302,8 @@ Run: *twinclaw channels* in terminal
                 const text = msg.body;
                 // Handle commands
                 if (text.trim().startsWith('/')) {
-                    const command = text.trim().split(' ')[0];
-                    await this.handleCommand(msg.from, command);
+                    const command = text.trim();
+                    await this.handleCommand(msg.from, command, text.trim());
                     return;
                 }
                 await this.onMessage?.(base);

package/dist/services/model-catalog-service.js

@@ -1,6 +1,9 @@
 import { STATIC_MODEL_CATALOG } from '../config/model-catalog.js';
 import { getSecretVaultService } from './secret-vault.js';
+import { getGitHubCopilotService } from './github-copilot-service.js';
 const GITHUB_CATALOG_URL = 'https://models.github.ai/catalog/models';
+const OPENROUTER_API_URL = 'https://openrouter.ai/api/v1/models';
+const GROQ_API_URL = 'https://api.groq.com/openai/v1/models';
 const CACHE_TTL_MS = 60 * 60 * 1000; // 1 hour
 function isRecord(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
@@ -55,8 +58,134 @@ function toGitHubModelEntry(value) {
     }
     return entry;
 }
+const GITHUB_COPILOT_TOKEN_URL = 'https://api.github.com/copilot_internal/v2/token';
+async function exchangeForCopilotToken(githubToken) {
+    try {
+        const response = await fetch(GITHUB_COPILOT_TOKEN_URL, {
+            method: 'GET',
+            headers: {
+                'Authorization': `token ${githubToken}`,
+                'Accept': 'application/json'
+            }
+        });
+        if (!response.ok) {
+            console.warn('[ModelCatalog] Failed to exchange for Copilot token:', response.status);
+            return null;
+        }
+        const data = await response.json();
+        return data.token || null;
+    }
+    catch (error) {
+        console.warn('[ModelCatalog] Error exchanging for Copilot token:', error);
+        return null;
+    }
+}
+async function fetchOpenRouterFreeModels(apiKey) {
+    if (!apiKey)
+        return [];
+    try {
+        const response = await fetch(OPENROUTER_API_URL, {
+            headers: {
+                'Authorization': `Bearer ${apiKey}`,
+                'HTTP-Referer': 'https://twinclaw.ai',
+                'X-Title': 'TwinClaw'
+            }
+        });
+        if (!response.ok) {
+            console.warn('[ModelCatalog] Failed to fetch OpenRouter models:', response.status);
+            return [];
+        }
+        const data = await response.json();
+        const models = data.data || [];
+        return models
+            .filter(m => m.pricing?.prompt === '0' && m.pricing?.completion === '0')
+            .map(m => ({
+            id: `openrouter-${m.id.replace(/[^a-z0-9]/gi, '-')}`,
+            name: m.name || m.id,
+            provider: 'openrouter',
+            model: m.id,
+            contextLength: m.context_length || 32000,
+            supportsStreaming: true,
+            pricing: 'Free',
+            description: m.description || `Free model via OpenRouter (${m.architecture?.modality || 'text'})`
+        }));
+    }
+    catch (error) {
+        console.warn('[ModelCatalog] Error fetching OpenRouter models:', error);
+        return [];
+    }
+}
+async function fetchGroqModels(apiKey) {
+    if (!apiKey)
+        return [];
+    try {
+        const response = await fetch(GROQ_API_URL, {
+            headers: {
+                'Authorization': `Bearer ${apiKey}`,
+                'Content-Type': 'application/json'
+            }
+        });
+        if (!response.ok) {
+            console.warn('[ModelCatalog] Failed to fetch Groq models:', response.status);
+            return [];
+        }
+        const data = await response.json();
+        const models = data.data || [];
+        return models
+            .filter(m => m.active)
+            .map(m => ({
+            id: `groq-${m.id.replace(/[^a-z0-9-]/gi, '-')}`,
+            name: m.id,
+            provider: 'groq',
+            model: m.id,
+            contextLength: m.context_window || 32768,
+            supportsStreaming: true,
+            pricing: 'Free (with rate limits)',
+            description: `Free model on Groq (${(m.context_window / 1000).toFixed(0)}K context)`
+        }));
+    }
+    catch (error) {
+        console.warn('[ModelCatalog] Error fetching Groq models:', error);
+        return [];
+    }
+}
 class ModelCatalogService {
     githubCache = null;
+    openRouterCache = null;
+    groqCache = null;
+    async fetchProviderModels(forceRefresh = false) {
+        const vault = getSecretVaultService();
+        const openRouterKey = vault.readSecret('OPENROUTER_API_KEY') || getSecretVaultService().readSecret('OPENROUTER_API_KEY');
+        const groqKey = vault.readSecret('GROQ_API_KEY') || getSecretVaultService().readSecret('GROQ_API_KEY');
+        // Fetch OpenRouter free models
+        if (!forceRefresh && this.openRouterCache) {
+            const elapsed = Date.now() - this.openRouterCache.timestamp;
+            if (elapsed < CACHE_TTL_MS) {
+                // Cache still valid
+            }
+            else {
+                this.openRouterCache = null;
+            }
+        }
+        if (!this.openRouterCache && openRouterKey) {
+            const models = await fetchOpenRouterFreeModels(openRouterKey);
+            this.openRouterCache = { data: models, timestamp: Date.now() };
+        }
+        // Fetch Groq models
+        if (!forceRefresh && this.groqCache) {
+            const elapsed = Date.now() - this.groqCache.timestamp;
+            if (elapsed < CACHE_TTL_MS) {
+                // Cache still valid
+            }
+            else {
+                this.groqCache = null;
+            }
+        }
+        if (!this.groqCache && groqKey) {
+            const models = await fetchGroqModels(groqKey);
+            this.groqCache = { data: models, timestamp: Date.now() };
+        }
+    }
     async fetchGitHubModels(forceRefresh = false) {
         if (!forceRefresh && this.githubCache) {
             const elapsed = Date.now() - this.githubCache.timestamp;
@@ -64,18 +193,39 @@ class ModelCatalogService {
                 return this.githubCache.data;
             }
         }
-        const vault = getSecretVaultService();
-        const githubToken = vault.readSecret('GITHUB_TOKEN');
-        if (!githubToken) {
-            console.warn('[ModelCatalog] GITHUB_TOKEN not found in vault. Cannot fetch GitHub models.');
-            return [];
+        // Try to get Copilot token from GitHubCopilotService
+        let copilotToken = null;
+        try {
+            const copilotService = getGitHubCopilotService();
+            const auth = copilotService.getAuth();
+            if (auth?.copilotToken) {
+                copilotToken = auth.copilotToken;
+            }
+        }
+        catch {
+            // GitHubCopilotService not initialized yet
+        }
+        // Fallback to GitHub OAuth token from vault
+        if (!copilotToken) {
+            const vault = getSecretVaultService();
+            const githubToken = vault.readSecret('GITHUB_TOKEN');
+            if (!githubToken) {
+                console.warn('[ModelCatalog] No GitHub token available. Cannot fetch GitHub models.');
+                return [];
+            }
+            // For GitHub OAuth token, we need to exchange it for Copilot token
+            copilotToken = await exchangeForCopilotToken(githubToken);
+            if (!copilotToken) {
+                console.warn('[ModelCatalog] Failed to get Copilot token. Cannot fetch GitHub models.');
+                return [];
+            }
         }
         try {
             const response = await fetch(GITHUB_CATALOG_URL, {
                 method: 'GET',
                 headers: {
-                    'Authorization': `Bearer ${githubToken}`,
-                    'Accept': 'application/vnd.github.v3+json',
+                    'Authorization': `Bearer ${copilotToken}`,
+                    'Accept': 'application/vnd.github+json',
                     'X-GitHub-Api-Version': '2022-11-28'
                 }
             });
@@ -128,10 +278,14 @@ class ModelCatalogService {
     }
     getAllModels() {
         const githubModels = this.getGitHubModelsCatalog();
-        return [...STATIC_MODEL_CATALOG, ...githubModels];
+        const openRouterModels = this.openRouterCache?.data || [];
+        const groqModels = this.groqCache?.data || [];
+        return [...STATIC_MODEL_CATALOG, ...githubModels, ...openRouterModels, ...groqModels];
     }
     clearCache() {
         this.githubCache = null;
+        this.openRouterCache = null;
+        this.groqCache = null;
     }
     slugify(text, fallback = 'model') {
         const slug = text
@@ -151,4 +305,5 @@ export function getModelCatalogService() {
 export async function initializeModelCatalog() {
     const service = getModelCatalogService();
     await service.fetchGitHubModels();
+    await service.fetchProviderModels();
 }

package/dist/services/model-router.js

@@ -1,6 +1,6 @@
 import { randomUUID } from 'node:crypto';
 import { MODEL_SLOT_IDS, } from '../types/model-routing.js';
-import { scrubSensitiveText } from '../utils/logger.js';
+import { scrubSensitiveText, logThought } from '../utils/logger.js';
 import { getModelRoutingSetting, listModelRoutingEvents, saveModelRoutingEvent, saveModelRoutingSetting, } from './db-model-routing.js';
 import { getSecretVaultService } from './secret-vault.js';
 import { getGitHubCopilotService } from './github-copilot-service.js';
@@ -434,11 +434,18 @@ export class ModelRouter {
     }
     async getApiKey(config) {
         const envName = config.apiKeyEnvName;
+        const providerId = this.resolveProviderId(config);
         const key = getSecretVaultService().readSecret(envName);
         if (!key) {
-            console.warn(`Warning: API key ${envName} is not set in environment.`);
+            const configKey = getConfigValue(envName);
+            if (configKey) {
+                logThought(`[Router] Using API key from config for ${providerId}: ${envName.slice(0, 8)}...`);
+                return configKey;
+            }
+            console.warn(`[Router] Warning: API key ${envName} is not set in environment or config (provider: ${providerId}).`);
             return '';
         }
+        logThought(`[Router] Using API key from vault for ${providerId}: ${envName.slice(0, 8)}...`);
         if (envName !== 'GITHUB_TOKEN') {
             return key;
         }
@@ -1009,7 +1016,71 @@ export class ModelRouter {
     }
     loadModelsFromConfig() {
         const configModels = [];
-        // Check if PRIMARY_MODEL is set - use config.models.primaryModel if available
+        const definitionsJson = getConfigValue('MODEL_DEFINITIONS');
+        const primaryModel = getConfigValue('PRIMARY_MODEL');
+        logThought(`[Router] loadModelsFromConfig: PRIMARY_MODEL=${primaryModel}, MODEL_DEFINITIONS present=${!!definitionsJson}`);
+        // First, check if config.models.definitions has any models (from model picker)
+        // If so, use those instead of hardcoded fallbacks
+        if (definitionsJson) {
+            try {
+                const definitions = JSON.parse(definitionsJson);
+                if (definitions && definitions.length > 0) {
+                    const primaryModel = getConfigValue('PRIMARY_MODEL') ?? '';
+                    // Normalize model ID for comparison (modal/zai-glm-5-fp8 -> modal-zai-glm-5-fp8)
+                    const normalizeId = (id) => id.replace('/', '-').toLowerCase();
+                    const normalizedPrimary = normalizeId(primaryModel);
+                    // Sort models so primary is first, then the rest
+                    const sortedDefinitions = [...definitions].sort((a, b) => {
+                        const aNorm = normalizeId(a.id);
+                        const bNorm = normalizeId(b.id);
+                        if (aNorm === normalizedPrimary)
+                            return -1;
+                        if (bNorm === normalizedPrimary)
+                            return 1;
+                        return 0;
+                    });
+                    for (const def of sortedDefinitions) {
+                        configModels.push({
+                            id: def.id,
+                            model: def.model,
+                            baseURL: def.baseURL,
+                            apiKeyEnvName: def.apiKeyEnvName,
+                        });
+                    }
+                    // Even with definitions, add fallback providers in case primary fails
+                    // This ensures we have working alternatives if the user's primary model fails
+                    const groqApiKey = getConfigValue('GROQ_API_KEY');
+                    const openRouterApiKey = getConfigValue('OPENROUTER_API_KEY');
+                    const existingIds = new Set(configModels.map(m => m.id));
+                    // Add Groq as fallback if not already in definitions
+                    if (groqApiKey && !existingIds.has('groq-qwen3-32b') && !existingIds.has(MODEL_SLOT_IDS.FALLBACK_1)) {
+                        configModels.push({
+                            id: MODEL_SLOT_IDS.FALLBACK_1,
+                            model: 'qwen/qwen3-32b',
+                            baseURL: 'https://api.groq.com/openai/v1/chat/completions',
+                            apiKeyEnvName: 'GROQ_API_KEY',
+                        });
+                    }
+                    // Add OpenRouter free model as secondary fallback
+                    if (openRouterApiKey && !existingIds.has('openrouter-arcee-ai-trinity-mini-free') && !existingIds.has(MODEL_SLOT_IDS.FALLBACK_2)) {
+                        configModels.push({
+                            id: MODEL_SLOT_IDS.FALLBACK_2,
+                            model: 'arcee-ai/trinity-mini:free',
+                            baseURL: 'https://openrouter.ai/api/v1/chat/completions',
+                            apiKeyEnvName: 'OPENROUTER_API_KEY',
+                        });
+                    }
+                    logThought(`[Router] Loaded ${configModels.length} models from definitions. PRIMARY: ${primaryModel}`);
+                    // Return all models including fallbacks
+                    return configModels;
+                }
+            }
+            catch (e) {
+                logThought(`[Router] Failed to load definitions: ${e}`);
+                // JSON parse failed, fall through to legacy logic
+            }
+        }
+        // Legacy logic: 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');
@@ -1124,6 +1195,7 @@ export class ModelRouter {
                 apiKeyEnvName: 'MODAL_API_KEY',
             });
         }
+        logThought(`[Router] Final loaded models (${configModels.length}): ${configModels.map(m => `${m.id}->${m.model.split('/').pop()}`).join(', ')}`);
         return configModels;
     }
 }

package/dist/services/user-memory.js

@@ -0,0 +1,192 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { getWorkspaceDir } from '../config/workspace.js';
+import { logThought } from '../utils/logger.js';
+function getUserMemoryDir(userId) {
+    const sanitizedUserId = userId.replace(/[^a-zA-Z0-9_-]/g, '_');
+    return path.join(getWorkspaceDir(), 'memory', 'users', sanitizedUserId);
+}
+function ensureUserMemoryDir(userId) {
+    const dir = getUserMemoryDir(userId);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    return dir;
+}
+export function hasUserMemory(userId) {
+    const dir = getUserMemoryDir(userId);
+    const profilePath = path.join(dir, 'user_profile.md');
+    return fs.existsSync(profilePath);
+}
+export function loadUserMemory(userId) {
+    const dir = getUserMemoryDir(userId);
+    const profilePath = path.join(dir, 'user_profile.md');
+    const interactionPath = path.join(dir, 'interaction_style.md');
+    const contextPath = path.join(dir, 'current_context.md');
+    const hooksPath = path.join(dir, 'reference_hooks.md');
+    if (!fs.existsSync(profilePath)) {
+        return null;
+    }
+    const profile = loadYamlFrontMatter(profilePath) || getDefaultProfile();
+    const interactionStyle = loadYamlFrontMatter(interactionPath) || getDefaultInteractionStyle();
+    const currentContext = loadYamlFrontMatter(contextPath) || getDefaultCurrentContext();
+    const referenceHooks = loadYamlFrontMatter(hooksPath) || getDefaultReferenceHooks();
+    return {
+        profile: profile || getDefaultProfile(),
+        interactionStyle,
+        currentContext,
+        referenceHooks,
+    };
+}
+export function saveUserMemory(userId, memory) {
+    const dir = ensureUserMemoryDir(userId);
+    const profilePath = path.join(dir, 'user_profile.md');
+    const interactionPath = path.join(dir, 'interaction_style.md');
+    const contextPath = path.join(dir, 'current_context.md');
+    const hooksPath = path.join(dir, 'reference_hooks.md');
+    memory.profile.lastUpdated = new Date().toISOString();
+    writeYamlFrontMatter(profilePath, memory.profile);
+    writeYamlFrontMatter(interactionPath, memory.interactionStyle);
+    writeYamlFrontMatter(contextPath, memory.currentContext);
+    writeYamlFrontMatter(hooksPath, memory.referenceHooks);
+    logThought(`[UserMemory] Saved memory for user: ${userId}`);
+}
+export function updateUserProfile(userId, updates) {
+    const existing = loadUserMemory(userId);
+    if (!existing) {
+        const defaultMemory = getDefaultUserMemory();
+        defaultMemory.profile = { ...defaultMemory.profile, ...updates };
+        saveUserMemory(userId, defaultMemory);
+        return;
+    }
+    existing.profile = { ...existing.profile, ...updates };
+    saveUserMemory(userId, existing);
+}
+export function checkFirstInteraction(userId) {
+    return !hasUserMemory(userId);
+}
+function loadYamlFrontMatter(filePath) {
+    try {
+        const content = fs.readFileSync(filePath, 'utf-8');
+        const match = content.match(/^---\n([\s\S]*?)\n---/);
+        if (!match) {
+            return null;
+        }
+        const yamlContent = match[1];
+        return parseYamlSimple(yamlContent);
+    }
+    catch {
+        return null;
+    }
+}
+function writeYamlFrontMatter(filePath, data) {
+    const yamlContent = stringifyYamlSimple(data);
+    const content = `---\n${yamlContent}---\n`;
+    fs.writeFileSync(filePath, content, 'utf-8');
+}
+function parseYamlSimple(yaml) {
+    const result = {};
+    const lines = yaml.split('\n');
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith('#'))
+            continue;
+        const colonIndex = trimmed.indexOf(':');
+        if (colonIndex === -1)
+            continue;
+        const key = trimmed.slice(0, colonIndex).trim();
+        let value = trimmed.slice(colonIndex + 1).trim();
+        if (typeof value === 'string') {
+            if (value.startsWith('[') && value.endsWith(']')) {
+                value = value.slice(1, -1).split(',').map(s => s.trim()).filter(Boolean);
+            }
+            else if (value === 'true') {
+                value = true;
+            }
+            else if (value === 'false') {
+                value = false;
+            }
+        }
+        result[key] = value;
+    }
+    return result;
+}
+function stringifyYamlSimple(data, indent = 0) {
+    if (data === null || data === undefined)
+        return '';
+    if (typeof data === 'string')
+        return data || '';
+    if (typeof data === 'boolean' || typeof data === 'number')
+        return String(data);
+    if (Array.isArray(data))
+        return `[${data.join(', ')}]`;
+    if (typeof data === 'object') {
+        const lines = [];
+        const prefix = '  '.repeat(indent);
+        for (const [key, value] of Object.entries(data)) {
+            if (value === null || value === undefined)
+                continue;
+            if (typeof value === 'object' && !Array.isArray(value)) {
+                lines.push(`${prefix}${key}:`);
+                lines.push(stringifyYamlSimple(value, indent + 1));
+            }
+            else {
+                lines.push(`${prefix}${key}: ${stringifyYamlSimple(value)}`);
+            }
+        }
+        return lines.join('\n');
+    }
+    return String(data);
+}
+function getDefaultProfile() {
+    return {
+        identity: {},
+        professionalBackground: {},
+        personalContext: {},
+        communicationStyle: {},
+        goals: { shortTerm: [], longTerm: [] },
+        painPoints: [],
+    };
+}
+function getDefaultInteractionStyle() {
+    return {
+        communicationGuidelines: {},
+        dos: [],
+        donts: [],
+        responsePatterns: {},
+        contextAwareness: {},
+    };
+}
+function getDefaultCurrentContext() {
+    return {
+        activeProjects: [],
+        recentConversations: [],
+        ongoingThreads: [],
+        changedSinceLastTime: [],
+    };
+}
+function getDefaultReferenceHooks() {
+    return {
+        conversationalAnchors: [],
+        keyFacts: [],
+        namesAndEntities: {},
+        insideReferences: [],
+    };
+}
+export function getDefaultUserMemory() {
+    return {
+        profile: getDefaultProfile(),
+        interactionStyle: getDefaultInteractionStyle(),
+        currentContext: getDefaultCurrentContext(),
+        referenceHooks: getDefaultReferenceHooks(),
+    };
+}
+export function listUsersWithMemory() {
+    const usersDir = path.join(getWorkspaceDir(), 'memory', 'users');
+    if (!fs.existsSync(usersDir)) {
+        return [];
+    }
+    return fs.readdirSync(usersDir, { withFileTypes: true })
+        .filter(dirent => dirent.isDirectory())
+        .map(dirent => dirent.name);
+}

package/package.json

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