twinclaw 1.2.9 → 1.3.0

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

@@ -0,0 +1,281 @@
+var _a;
+import { logThought } from '../utils/logger.js';
+import { checkFirstInteraction, loadUserMemory, saveUserMemory, getDefaultUserMemory, } from '../services/user-memory.js';
+export class SelfSetupAgent {
+    #userId;
+    #phase = 'detecting';
+    #discoveryAnswers = {};
+    #discoveryQuestionIndex = 0;
+    #messageCount = 0;
+    static DISCOVERY_QUESTIONS = [
+        {
+            category: 'professional',
+            question: "What do you do? (Role, company, industry)",
+            field: 'role',
+        },
+        {
+            category: 'professional',
+            question: "What are you working on right now? (Current projects)",
+            field: 'currentProject',
+        },
+        {
+            category: 'professional',
+            question: "What tools do you use daily? (Tech stack, platforms)",
+            field: 'tools',
+        },
+        {
+            category: 'personal',
+            question: "What do you like to do outside of work?",
+            field: 'interests',
+        },
+        {
+            category: 'communication',
+            question: "How do you like information presented? (Brief vs detailed, casual vs formal)",
+            field: 'communicationPreference',
+        },
+        {
+            category: 'communication',
+            question: "What frustrates you about AI assistants?",
+            field: 'frustrations',
+        },
+        {
+            category: 'goals',
+            question: "What are you trying to achieve? (Short and long term)",
+            field: 'goals',
+        },
+        {
+            category: 'technical',
+            question: "How technical should I be with you?",
+            field: 'technicalLevel',
+        },
+    ];
+    constructor(userId) {
+        this.#userId = userId;
+    }
+    get userId() {
+        return this.#userId;
+    }
+    get phase() {
+        return this.#phase;
+    }
+    isComplete() {
+        return this.#phase === 'completed';
+    }
+    processFirstMessage(userMessage) {
+        this.#messageCount++;
+        if (this.#phase === 'detecting') {
+            return this.#startWarmIntro();
+        }
+        if (this.#phase === 'warm_intro') {
+            return this.#handleWarmIntroResponse(userMessage);
+        }
+        if (this.#phase === 'discovery') {
+            return this.#handleDiscoveryResponse(userMessage);
+        }
+        if (this.#phase === 'synthesis') {
+            return this.#handleSynthesisResponse(userMessage);
+        }
+        if (this.#phase === 'completed') {
+            return {
+                text: "Setup is complete! How can I help you today?",
+                phase: this.#phase,
+                isComplete: true,
+                needsMoreInfo: false,
+            };
+        }
+        return {
+            text: "I'm not sure what to do next. Let me start over.",
+            phase: this.#phase,
+            isComplete: false,
+            needsMoreInfo: true,
+        };
+    }
+    #startWarmIntro() {
+        this.#phase = 'warm_intro';
+        logThought(`[SelfSetupAgent] Starting warm intro for user: ${this.#userId}`);
+        return {
+            text: `Hey! I'm noticing this is our first conversation. 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 coffee chat where I learn what makes you tick. Cool?
+
+To start - what do you do, and what kind of thing are you looking to build?`,
+            phase: this.#phase,
+            isComplete: false,
+            needsMoreInfo: true,
+        };
+    }
+    #handleWarmIntroResponse(userMessage) {
+        this.#discoveryAnswers.role = userMessage;
+        this.#phase = 'discovery';
+        this.#discoveryQuestionIndex = 0;
+        return this.#askNextDiscoveryQuestion();
+    }
+    #askNextDiscoveryQuestion() {
+        const question = _a.DISCOVERY_QUESTIONS[this.#discoveryQuestionIndex];
+        if (!question) {
+            return this.#moveToSynthesis();
+        }
+        const questionText = question.question;
+        return {
+            text: questionText,
+            phase: this.#phase,
+            isComplete: false,
+            needsMoreInfo: true,
+        };
+    }
+    #handleDiscoveryResponse(userMessage) {
+        const question = _a.DISCOVERY_QUESTIONS[this.#discoveryQuestionIndex];
+        if (question) {
+            const field = question.field;
+            this.#discoveryAnswers[field] = userMessage;
+        }
+        this.#discoveryQuestionIndex++;
+        if (this.#discoveryQuestionIndex >= _a.DISCOVERY_QUESTIONS.length) {
+            return this.#moveToSynthesis();
+        }
+        return this.#askNextDiscoveryQuestion();
+    }
+    #moveToSynthesis() {
+        this.#phase = 'synthesis';
+        const answers = this.#discoveryAnswers;
+        const synthesis = this.#buildSynthesis(answers);
+        return {
+            text: `${synthesis}
+
+Did I get that right? Anything I should adjust or add?`,
+            phase: this.#phase,
+            isComplete: false,
+            needsMoreInfo: true,
+        };
+    }
+    #buildSynthesis(answers) {
+        const insights = [];
+        if (answers.role) {
+            insights.push(`You're working as ${answers.role}`);
+        }
+        if (answers.currentProject) {
+            insights.push(`currently focused on ${answers.currentProject}`);
+        }
+        if (answers.tools && answers.tools.length > 0) {
+            insights.push(`using tools like ${answers.tools}`);
+        }
+        if (answers.interests) {
+            insights.push(`into ${answers.interests} outside work`);
+        }
+        let preference = 'contextual';
+        if (answers.communicationPreference) {
+            if (answers.communicationPreference.includes('brief')) {
+                preference = 'brief';
+            }
+            else if (answers.communicationPreference.includes('detail')) {
+                preference = 'comprehensive';
+            }
+        }
+        insights.push(`prefer ${preference} communication`);
+        if (answers.goals) {
+            insights.push(`your goals include ${answers.goals}`);
+        }
+        const synthesis = insights.join('. ');
+        return `Alright, here's what I'm picking up:\n- ${insights.join('\n- ')}`;
+    }
+    #handleSynthesisResponse(userMessage) {
+        const lowerResponse = userMessage.toLowerCase();
+        if (lowerResponse.includes('yes') || lowerResponse.includes('right') || lowerResponse.includes('correct') || lowerResponse.includes('yep')) {
+            return this.#completeSetup();
+        }
+        return this.#completeSetup();
+    }
+    #completeSetup() {
+        this.#phase = 'file_creation';
+        const memory = this.#buildUserMemory();
+        saveUserMemory(this.#userId, memory);
+        this.#phase = 'completed';
+        logThought(`[SelfSetupAgent] Completed setup for user: ${this.#userId}`);
+        return {
+            text: `Cool, I've saved all this so I don't forget. I created a few quick reference files:
+- Your profile & preferences
+- How you like me to communicate
+- What you're currently working on
+- Quick facts I can reference
+
+These will help me be consistent and actually useful. I'll update them as I learn more about you.
+
+We're all set! From now on, I'll:
+✓ Remember our conversations and what matters to you
+✓ Adapt my style to what works for you
+✓ Keep track of your projects and goals
+✓ Update my notes as things change
+
+If I ever seem off-base or forget something important, just call me out. Ready to jump in?`,
+            phase: this.#phase,
+            isComplete: true,
+            needsMoreInfo: false,
+        };
+    }
+    #buildUserMemory() {
+        const defaultMemory = getDefaultUserMemory();
+        const answers = this.#discoveryAnswers;
+        defaultMemory.profile.identity.role = answers.role;
+        defaultMemory.profile.identity.technicalLevel = this.#mapTechnicalLevel(answers.technicalLevel);
+        defaultMemory.profile.professionalBackground.currentFocus = answers.currentProject;
+        if (answers.tools) {
+            defaultMemory.profile.professionalBackground.toolsAndPlatforms = Array.isArray(answers.tools)
+                ? answers.tools
+                : [answers.tools];
+        }
+        defaultMemory.profile.personalContext.interests = answers.interests ? [answers.interests] : [];
+        if (answers.communicationPreference) {
+            defaultMemory.profile.communicationStyle.detailLevel = this.#mapDetailLevel(answers.communicationPreference);
+        }
+        if (answers.frustrations) {
+            defaultMemory.profile.communicationStyle.frustrations = Array.isArray(answers.frustrations)
+                ? answers.frustrations
+                : [answers.frustrations];
+        }
+        if (answers.goals) {
+            defaultMemory.profile.goals.shortTerm = [answers.goals];
+        }
+        return defaultMemory;
+    }
+    #mapTechnicalLevel(level) {
+        if (!level)
+            return undefined;
+        const lower = level.toLowerCase();
+        if (lower.includes('expert') || lower.includes('advanced'))
+            return 'expert';
+        if (lower.includes('beginner') || lower.includes('new'))
+            return 'beginner';
+        return 'intermediate';
+    }
+    #mapDetailLevel(pref) {
+        if (!pref)
+            return undefined;
+        const lower = pref.toLowerCase();
+        if (lower.includes('brief') || lower.includes('short'))
+            return 'brief';
+        if (lower.includes('detail') || lower.includes('comprehensive'))
+            return 'comprehensive';
+        return 'contextual';
+    }
+    cancel() {
+        this.#phase = 'cancelled';
+        logThought(`[SelfSetupAgent] Setup cancelled for user: ${this.#userId}`);
+    }
+    getState() {
+        return {
+            phase: this.#phase,
+            messageCount: this.#messageCount,
+            answersCount: Object.keys(this.#discoveryAnswers).length,
+        };
+    }
+}
+_a = SelfSetupAgent;
+export function createSelfSetupAgent(userId) {
+    if (!checkFirstInteraction(userId)) {
+        return null;
+    }
+    return new SelfSetupAgent(userId);
+}
+export function getExistingUserMemory(userId) {
+    return loadUserMemory(userId);
+}

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,6 +168,24 @@ 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) {
+            const response = existingAgent.processFirstMessage(normalizedText);
+            if (response.isComplete) {
+                this.#selfSetupAgents.delete(userId);
+                if (response.isComplete && !response.needsMoreInfo) {
+                    return response.text;
+                }
+            }
+            return response.text;
+        }
+        const newAgent = createSelfSetupAgent(userId);
+        if (newAgent) {
+            this.#selfSetupAgents.set(userId, newAgent);
+            const response = newAgent.processFirstMessage(normalizedText);
+            return response.text;
+        }
         return this.processText(sessionId, normalizedText);
     }
     async processText(sessionId, text) {
@@ -174,6 +197,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 +224,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 +493,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

@@ -1009,7 +1009,41 @@ export class ModelRouter {
     }
     loadModelsFromConfig() {
         const configModels = [];
-        // Check if PRIMARY_MODEL is set - use config.models.primaryModel if available
+        // First, check if config.models.definitions has any models (from model picker)
+        // If so, use those instead of hardcoded fallbacks
+        const definitionsJson = getConfigValue('MODEL_DEFINITIONS');
+        if (definitionsJson) {
+            try {
+                const definitions = JSON.parse(definitionsJson);
+                if (definitions && definitions.length > 0) {
+                    const primaryModel = getConfigValue('PRIMARY_MODEL') ?? '';
+                    // Sort models so primary is first, then the rest
+                    const sortedDefinitions = [...definitions].sort((a, b) => {
+                        if (a.id === primaryModel)
+                            return -1;
+                        if (b.id === primaryModel)
+                            return 1;
+                        return 0;
+                    });
+                    for (const def of sortedDefinitions) {
+                        configModels.push({
+                            id: def.id,
+                            model: def.model,
+                            baseURL: def.baseURL,
+                            apiKeyEnvName: def.apiKeyEnvName,
+                        });
+                    }
+                    // If we have models from definitions, return them
+                    if (configModels.length > 0) {
+                        return configModels;
+                    }
+                }
+            }
+            catch {
+                // 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');

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.0",
   "description": "Eagle-eyed agentic AI gateway with multi-modal hooks and proactive memory.",
   "main": "dist/index.js",
   "bin": {