fluxy-bot 0.15.2 → 0.15.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fluxy-bot",
-  "version": "0.15.2",
+  "version": "0.15.6",
   "releaseNotes": [
     "1. react router implemented",
     "2. new workspace design",

package/shared/config.ts

@@ -3,10 +3,12 @@ import { paths, DATA_DIR } from './paths.js';
 
 export interface ChannelConfig {
   enabled: boolean;
-  /** 'channel' = just talk to me (self-chat only), 'business' = admin/customer support */
+  /** 'channel' = just talk to me (self-chat only), 'business' = admin/customer mode */
   mode: 'channel' | 'business';
   /** Phone numbers with admin access (owner, secretary, etc.) — business mode only */
   admins?: string[];
+  /** Active skill for customer-facing mode (folder name in workspace/skills/) */
+  skill?: string;
 }
 
 export interface BotConfig {

package/supervisor/channels/manager.ts

@@ -25,6 +25,7 @@ import { WhatsAppChannel } from './whatsapp.js';
 import type { ChannelConfig, ChannelProvider, ChannelStatus, ChannelType, InboundMessage, SenderRole } from './types.js';
 
 const MAX_CONCURRENT_AGENTS = 5;
+const MAX_BUFFER_MESSAGES = 30;
 
 interface ChannelManagerOpts {
   broadcastFluxy: (type: string, data: any) => void;
@@ -38,12 +39,19 @@ interface ActiveAgentQuery {
   channel: ChannelType;
 }
 
+interface BufferedMessage {
+  role: 'user' | 'assistant';
+  content: string;
+}
+
 export class ChannelManager {
   private providers = new Map<ChannelType, ChannelProvider>();
   private opts: ChannelManagerOpts;
   private activeAgents = new Map<string, ActiveAgentQuery>();
   private messageQueue: InboundMessage[] = [];
   private statusListeners: ((status: ChannelStatus) => void)[] = [];
+  /** In-memory conversation history per customer (keyed by "channel:phone") */
+  private customerBuffers = new Map<string, BufferedMessage[]>();
 
   constructor(opts: ChannelManagerOpts) {
     this.opts = opts;
@@ -61,7 +69,7 @@ export class ChannelManager {
 
     log.info('[channels] Initializing WhatsApp channel...');
     const whatsapp = new WhatsAppChannel(
-      (sender, senderName, text, fromMe) => this.handleInboundMessage('whatsapp', sender, senderName, text, fromMe),
+      (sender, senderName, text, fromMe, isSelfChat) => this.handleInboundMessage('whatsapp', sender, senderName, text, fromMe, isSelfChat),
       (status) => this.handleStatusChange(status),
     );
     this.providers.set('whatsapp', whatsapp);
@@ -81,7 +89,7 @@ export class ChannelManager {
     let provider = this.providers.get('whatsapp');
     if (!provider) {
       const whatsapp = new WhatsAppChannel(
-        (sender, senderName, text, fromMe) => this.handleInboundMessage('whatsapp', sender, senderName, text, fromMe),
+        (sender, senderName, text, fromMe, isSelfChat) => this.handleInboundMessage('whatsapp', sender, senderName, text, fromMe, isSelfChat),
         (status) => this.handleStatusChange(status),
       );
       this.providers.set('whatsapp', whatsapp);
@@ -165,16 +173,17 @@ export class ChannelManager {
     senderName: string | undefined,
     text: string,
     fromMe: boolean,
+    isSelfChat: boolean,
   ) {
     const channelConfig = this.getChannelConfig(channel);
     if (!channelConfig) return;
 
     const mode = channelConfig.mode || 'channel';
 
-    // ── Channel mode: only respond to self-chat (fromMe=true) ──
+    // ── Channel mode: ONLY respond to self-chat ──
     if (mode === 'channel') {
-      if (!fromMe) {
-        // Ignore messages from other people — this is the user's personal WhatsApp
+      if (!fromMe || !isSelfChat) {
+        // Ignore everything except self-chat messages
         return;
       }
 
@@ -192,8 +201,16 @@ export class ChannelManager {
       return;
     }
 
-    // ── Business mode: resolve role based on admins array ──
-    const role = this.resolveBusinessRole(channelConfig, sender, fromMe);
+    // ── Business mode: only respond to INCOMING messages (fromMe=false) ──
+    // fromMe=true means either:
+    //   - Fluxy's own sent replies (would cause loops)
+    //   - User typing on Fluxy's WhatsApp Web (not intended for the bot)
+    // Both should be ignored.
+    if (fromMe) {
+      return;
+    }
+
+    const role = this.resolveBusinessRole(channelConfig, sender);
 
     const message: InboundMessage = {
       channel,
@@ -209,16 +226,12 @@ export class ChannelManager {
     if (role === 'admin') {
       await this.handleAdminMessage(message);
     } else {
-      await this.handleCustomerMessage(message);
+      await this.handleCustomerMessage(message, channelConfig);
     }
   }
 
   /** Resolve role in business mode — check admins array */
-  private resolveBusinessRole(config: ChannelConfig, sender: string, fromMe: boolean): SenderRole {
-    // fromMe is always admin (the number Fluxy is connected with)
-    if (fromMe) return 'admin';
-
-    // Check admins array
+  private resolveBusinessRole(config: ChannelConfig, sender: string): SenderRole {
     if (config.admins?.length) {
       const senderPhone = sender.replace(/@.*/, '').replace(/[^0-9]/g, '');
       for (const admin of config.admins) {
@@ -329,8 +342,8 @@ export class ChannelManager {
     );
   }
 
-  /** Handle message from a customer — runs support agent in parallel */
-  private async handleCustomerMessage(msg: InboundMessage) {
+  /** Handle message from a customer — runs support agent in parallel with conversation context */
+  private async handleCustomerMessage(msg: InboundMessage, channelConfig: ChannelConfig) {
     const agentKey = `${msg.channel}:${msg.sender}`;
 
     // Check concurrent limit
@@ -343,8 +356,8 @@ export class ChannelManager {
     const { workerApi, getModel } = this.opts;
     const model = getModel();
 
-    // Load support system prompt from skill
-    const supportPrompt = this.loadSupportPrompt();
+    // Load the active skill's SCRIPT.md as the customer-facing system prompt
+    const scriptPrompt = this.loadActiveScript(channelConfig);
 
     // Fetch agent name
     let botName = 'Fluxy', humanName = 'Human';
@@ -354,17 +367,60 @@ export class ChannelManager {
       humanName = status.userName || 'Human';
     } catch {}
 
+    // Get or create conversation buffer for this customer
+    let buffer = this.customerBuffers.get(agentKey);
+    if (!buffer) {
+      buffer = [];
+      this.customerBuffers.set(agentKey, buffer);
+    }
+
+    // Add the new user message to the buffer
+    buffer.push({ role: 'user', content: msg.text });
+
+    // Trim buffer to max size
+    if (buffer.length > MAX_BUFFER_MESSAGES) {
+      buffer.splice(0, buffer.length - MAX_BUFFER_MESSAGES);
+    }
+
+    // Build recent messages for context (everything except the last one, which is the current message)
+    const recentMessages: RecentMessage[] = buffer.length > 1
+      ? buffer.slice(0, -1).map((m) => ({ role: m.role, content: m.content }))
+      : [];
+
+    // Also load long-term memory from whatsapp/{phone}.md if it exists
+    let customerMemory = '';
+    try {
+      const memoryPath = path.join(WORKSPACE_DIR, 'whatsapp', `${msg.sender}.md`);
+      if (fs.existsSync(memoryPath)) {
+        customerMemory = fs.readFileSync(memoryPath, 'utf-8').trim();
+      }
+    } catch {}
+
     const channelContext = `[WhatsApp | ${msg.sender} | customer${msg.senderName ? ` | ${msg.senderName}` : ''}]\n`;
-    const convId = `channel-${agentKey}-${Date.now()}`;
+
+    // Stable convId per customer (not per message)
+    const convId = `channel-${agentKey}`;
 
     this.activeAgents.set(agentKey, { sender: msg.sender, channel: msg.channel });
 
+    // Build an enriched script prompt with customer memory if available
+    let enrichedScript = scriptPrompt;
+    if (customerMemory && enrichedScript) {
+      enrichedScript += `\n\n---\n# Customer History (${msg.sender})\n\n${customerMemory}`;
+    }
+
     startFluxyAgentQuery(
       convId,
       channelContext + msg.text,
       model,
       (type, eventData) => {
         if (type === 'bot:response' && eventData.content) {
+          // Add assistant response to the buffer
+          buffer!.push({ role: 'assistant', content: eventData.content });
+          if (buffer!.length > MAX_BUFFER_MESSAGES) {
+            buffer!.splice(0, buffer!.length - MAX_BUFFER_MESSAGES);
+          }
+
           this.sendMessage(msg.channel, msg.rawSender, eventData.content).catch((err) => {
             log.warn(`[channels] Failed to send customer reply: ${err.message}`);
           });
@@ -379,27 +435,32 @@ export class ChannelManager {
       undefined,
       undefined,
       { botName, humanName },
-      undefined,
-      supportPrompt,
+      recentMessages,
+      enrichedScript,
     );
   }
 
-  /** Load customer-facing system prompt from skills */
-  private loadSupportPrompt(): string | undefined {
-    const skillsDir = path.join(WORKSPACE_DIR, 'skills');
+  /** Load SCRIPT.md from the active skill configured for this channel */
+  private loadActiveScript(channelConfig: ChannelConfig): string | undefined {
+    const skillName = channelConfig.skill;
+    if (!skillName) {
+      log.warn('[channels] No active skill configured — customer will get no script');
+      return undefined;
+    }
+
+    const scriptPath = path.join(WORKSPACE_DIR, 'skills', skillName, 'SCRIPT.md');
     try {
-      for (const entry of fs.readdirSync(skillsDir, { withFileTypes: true })) {
-        if (!entry.isDirectory()) continue;
-        const supportPath = path.join(skillsDir, entry.name, 'SUPPORT.md');
-        if (fs.existsSync(supportPath)) {
-          const content = fs.readFileSync(supportPath, 'utf-8').trim();
-          if (content) {
-            log.info(`[channels] Loaded support prompt from skill: ${entry.name}`);
-            return content;
-          }
+      if (fs.existsSync(scriptPath)) {
+        const content = fs.readFileSync(scriptPath, 'utf-8').trim();
+        if (content) {
+          log.info(`[channels] Loaded SCRIPT.md from skill: ${skillName}`);
+          return content;
         }
       }
-    } catch {}
+      log.warn(`[channels] SCRIPT.md not found in skill: ${skillName}`);
+    } catch (err: any) {
+      log.warn(`[channels] Failed to load SCRIPT.md from ${skillName}: ${err.message}`);
+    }
     return undefined;
   }
 
@@ -407,8 +468,10 @@ export class ChannelManager {
   private processQueue() {
     while (this.messageQueue.length > 0 && this.activeAgents.size < MAX_CONCURRENT_AGENTS) {
       const queued = this.messageQueue.shift()!;
+      const config = this.getChannelConfig(queued.channel);
+      if (!config) continue;
       log.info(`[channels] Processing queued message from ${queued.sender}`);
-      this.handleCustomerMessage(queued);
+      this.handleCustomerMessage(queued, config);
     }
   }
 }

package/supervisor/channels/types.ts

@@ -7,10 +7,12 @@ export type SenderRole = 'admin' | 'customer';
 
 export interface ChannelConfig {
   enabled: boolean;
-  /** 'channel' = just talk to me (self-chat only), 'business' = admin/customer support */
+  /** 'channel' = just talk to me (self-chat only), 'business' = admin/customer mode */
   mode: 'channel' | 'business';
   /** Phone numbers with admin access (owner, secretary, etc.) — business mode only */
   admins?: string[];
+  /** Active skill for customer-facing mode (folder name in workspace/skills/) */
+  skill?: string;
 }
 
 export interface InboundMessage {

package/supervisor/channels/whatsapp.ts

@@ -23,7 +23,7 @@ import type { ChannelProvider, ChannelStatus, ChannelType } from './types.js';
 const AUTH_DIR = path.join(DATA_DIR, 'channels', 'whatsapp', 'auth');
 
 /** Callback when a new message arrives */
-export type OnWhatsAppMessage = (sender: string, senderName: string | undefined, text: string, fromMe: boolean) => void;
+export type OnWhatsAppMessage = (sender: string, senderName: string | undefined, text: string, fromMe: boolean, isSelfChat: boolean) => void;
 
 export class WhatsAppChannel implements ChannelProvider {
   readonly type: ChannelType = 'whatsapp';
@@ -120,18 +120,11 @@ export class WhatsAppChannel implements ChannelProvider {
     // If it's already a phone JID, return as-is
     if (jid.endsWith('@s.whatsapp.net')) return jid;
 
-    // Check LID map
+    // Check LID map (only contains our own LID, mapped during connection)
     const mapped = this.lidToPhoneMap.get(jid);
     if (mapped) return mapped;
 
-    // If it's a LID JID and we know our own phone, and this looks like a self-chat LID
-    // LID JIDs typically end with @lid or have a long numeric format
-    if (this.ownPhoneJid && (jid.includes('@lid') || jid.match(/^\d{15,}@/))) {
-      log.info(`[whatsapp] Unmapped LID ${jid} — assuming self-chat, using own phone JID`);
-      this.lidToPhoneMap.set(jid, this.ownPhoneJid);
-      return this.ownPhoneJid;
-    }
-
+    // Unknown LID — don't guess. Return as-is so isSelfChat stays false.
     return jid;
   }
 
@@ -144,11 +137,18 @@ export class WhatsAppChannel implements ChannelProvider {
     const phone = user.id.split(':')[0];
     this.ownPhoneJid = `${phone}@s.whatsapp.net`;
 
-    // user.lid (if available) is the LID JID
-    if ((user as any).lid) {
-      this.lidToPhoneMap.set((user as any).lid, this.ownPhoneJid);
-      log.info(`[whatsapp] LID map: ${(user as any).lid} → ${this.ownPhoneJid}`);
+    // user.lid (if available) is the LID JID — map it and variations
+    const lid = (user as any).lid;
+    if (lid) {
+      // Map the exact LID
+      this.lidToPhoneMap.set(lid, this.ownPhoneJid);
+      // Also map the numeric part without @lid suffix (remoteJid may use @lid format)
+      const lidNum = lid.split(':')[0].split('@')[0];
+      this.lidToPhoneMap.set(`${lidNum}@lid`, this.ownPhoneJid);
+      log.info(`[whatsapp] LID map: ${lid} (and ${lidNum}@lid) → ${this.ownPhoneJid}`);
     }
+
+    log.info(`[whatsapp] Own phone JID: ${this.ownPhoneJid}`);
   }
 
   private async connectInternal(): Promise<void> {
@@ -250,14 +250,25 @@ export class WhatsAppChannel implements ChannelProvider {
 
         const fromMe = msg.key.fromMe || false;
         const rawSender = msg.key.remoteJid || '';
+        const participant = msg.key.participant || '';
+
+        // Debug: log all available sender fields to find the actual sender
+        log.info(`[whatsapp] DEBUG msg.key: remoteJid=${rawSender} fromMe=${fromMe} participant=${participant}`);
+        log.info(`[whatsapp] DEBUG pushName=${msg.pushName || 'none'} verifiedBizName=${(msg as any).verifiedBizName || 'none'}`);
+
+        // The actual sender JID — use participant if available (newer protocol), fallback to remoteJid
+        const actualSender = participant || rawSender;
 
         // Translate LID JIDs to phone JIDs
-        const sender = this.translateJid(rawSender);
+        const sender = this.translateJid(actualSender);
         const pushName = msg.pushName || undefined;
 
-        log.info(`[whatsapp] Message from ${sender} (raw=${rawSender}, fromMe=${fromMe}): ${text.slice(0, 80)}`);
+        // Detect self-chat: remoteJid matches our own phone number AND no participant field
+        const isSelfChat = !participant && this.ownPhoneJid !== null && this.translateJid(rawSender) === this.ownPhoneJid;
+
+        log.info(`[whatsapp] Message from ${sender} (raw=${rawSender}, participant=${participant}, fromMe=${fromMe}, selfChat=${isSelfChat}): ${text.slice(0, 80)}`);
 
-        this.onMessage(sender, pushName, text, fromMe);
+        this.onMessage(sender, pushName, text, fromMe, isSelfChat);
       }
     });
   }

package/supervisor/fluxy-agent.ts

@@ -7,7 +7,7 @@ import { query, type SDKMessage, type SDKUserMessage } from '@anthropic-ai/claud
 import fs from 'fs';
 import path from 'path';
 import { log } from '../shared/logger.js';
-import { PKG_DIR, WORKSPACE_DIR } from '../shared/paths.js';
+import { WORKSPACE_DIR } from '../shared/paths.js';
 import type { SavedFile } from './file-saver.js';
 import { getClaudeAccessToken } from '../worker/claude-auth.js';
 
@@ -178,29 +178,23 @@ export async function startFluxyAgentQuery(
   const sdkPrompt: string | AsyncIterable<SDKUserMessage> =
     attachments?.length ? buildMultiPartPrompt(prompt, attachments, savedFiles) : plainPrompt;
 
+  // Auto-discover skills — inject SKILL.md contents into system prompt (no SDK plugin system needed)
   try {
-    // Auto-discover all skill plugins in workspace/skills/ — any folder with a valid plugin.json is loaded
-    // Skills use a flat structure on disk (SKILL.md at the root), but the SDK expects
-    // skills/{name}/SKILL.md — we bridge the gap with symlinks created on discovery.
-    const skillsDir = path.join(PKG_DIR, 'workspace', 'skills');
-    const plugins: { type: 'local'; path: string }[] = [];
+    const skillsDir = path.join(WORKSPACE_DIR, 'skills');
+    const skillContents: string[] = [];
     try {
       for (const entry of fs.readdirSync(skillsDir, { withFileTypes: true })) {
-        if (entry.isDirectory() && fs.existsSync(path.join(skillsDir, entry.name, '.claude-plugin', 'plugin.json'))) {
-          plugins.push({ type: 'local' as const, path: path.join(skillsDir, entry.name) });
-
-          // Bridge flat SKILL.md → nested path the SDK expects (via symlink)
-          const skillName = entry.name;
-          const flatSkillMd = path.join(skillsDir, skillName, 'SKILL.md');
-          const sdkDir = path.join(skillsDir, skillName, 'skills', skillName);
-          const sdkSkillMd = path.join(sdkDir, 'SKILL.md');
-          if (fs.existsSync(flatSkillMd) && !fs.existsSync(sdkSkillMd)) {
-            fs.mkdirSync(sdkDir, { recursive: true });
-            fs.symlinkSync(flatSkillMd, sdkSkillMd);
-          }
+        if (!entry.isDirectory()) continue;
+        const skillMd = path.join(skillsDir, entry.name, 'SKILL.md');
+        if (fs.existsSync(skillMd)) {
+          const content = fs.readFileSync(skillMd, 'utf-8').trim();
+          if (content) skillContents.push(`## Skill: ${entry.name}\n\n${content}`);
         }
       }
     } catch {}
+    if (skillContents.length) {
+      enrichedPrompt += `\n\n---\n# Installed Skills\n\n${skillContents.join('\n\n---\n\n')}`;
+    }
 
     // Load MCP server config from workspace/MCP.json if it exists
     // Format: { "server-name": { command, args, env }, ... } (object, not array)
@@ -231,7 +225,6 @@ export async function startFluxyAgentQuery(
         maxTurns: 50,
         abortController,
         systemPrompt: enrichedPrompt,
-        plugins: plugins.length ? plugins : undefined,
         mcpServers,
         stderr: (chunk: string) => { stderrBuf += chunk; },
         env: {

package/supervisor/index.ts

@@ -403,20 +403,57 @@ export async function startSupervisor() {
         const status = channelManager.getStatus('whatsapp');
         const connected = status?.connected || false;
         res.writeHead(200);
+        const confettiHTML = Array.from({ length: 30 }, (_, i) => {
+          const colors = ['#04D1FE', '#AF27E3', '#FB4072', '#4ade80', '#facc15', '#818cf8'];
+          const color = colors[Math.floor(Math.random() * colors.length)];
+          const left = Math.random() * 100;
+          const delay = i * 0.04;
+          const drift = (Math.random() - 0.5) * 120;
+          const duration = 1.8 + Math.random() * 0.8;
+          return `<div class="confetti-dot" style="left:${left}%;background:${color};animation-delay:${delay}s;animation-duration:${duration}s;--drift:${drift}px"></div>`;
+        }).join('');
+
         res.end(`<!DOCTYPE html><html><head><meta charset="UTF-8"><meta name="viewport" content="width=device-width,initial-scale=1">
 <title>WhatsApp QR</title>
+<link rel="preconnect" href="https://fonts.googleapis.com">
+<link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+<link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600&family=Space+Grotesk:wght@600;700&display=swap" rel="stylesheet">
 <style>
-  body{background:#222122;color:#fff;font-family:system-ui,-apple-system,sans-serif;display:flex;flex-direction:column;align-items:center;justify-content:center;height:100dvh;margin:0}
-  .qr-container{background:#fff;border-radius:16px;padding:24px;max-width:300px}
-  .qr-container svg{width:100%;height:auto}
-  .status{margin-top:20px;font-size:14px;opacity:0.7}
-  .connected{color:#4ade80;font-size:18px;font-weight:600}
+  *{margin:0;padding:0;box-sizing:border-box}
+  body{background:#212121;color:#f5f5f5;font-family:'Inter',system-ui,-apple-system,sans-serif;display:flex;flex-direction:column;align-items:center;justify-content:center;height:100dvh;margin:0;overflow:hidden}
+  .container{display:flex;flex-direction:column;align-items:center;max-width:360px;width:100%;padding:0 20px}
+
+  .qr-card{background:#2a2a2a;border:1px solid rgba(255,255,255,0.08);border-radius:20px;padding:28px;width:100%;box-shadow:0 0 0 1px rgba(175,39,227,0.1),0 0 20px -5px rgba(175,39,227,0.15);animation:fade-up .5s ease-out both}
+  .qr-inner{background:#fff;border-radius:12px;padding:16px}
+  .qr-inner svg{width:100%;height:auto;display:block}
+
+  .scan-hint{margin-top:20px;font-size:13px;color:#666;text-align:center;animation:fade-up .5s ease-out .2s both}
+
+  .confetti-wrap{position:fixed;top:0;left:0;width:100%;height:100%;pointer-events:none;overflow:hidden}
+  .confetti-dot{position:absolute;width:8px;height:8px;border-radius:50%;top:-10px;animation:confetti-fall 2s ease-out forwards}
+  @keyframes confetti-fall{0%{opacity:1;transform:translateY(0) translateX(0) rotate(0) scale(1)}100%{opacity:0;transform:translateY(100vh) translateX(var(--drift)) rotate(360deg) scale(.5)}}
+
+  .video-wrap{margin-bottom:8px;animation:pop-in .5s cubic-bezier(.34,1.56,.64,1) forwards}
+  .video-wrap video{width:200px;object-fit:contain}
+  @keyframes pop-in{0%{transform:scale(0);opacity:0}100%{transform:scale(1);opacity:1}}
+
+  .text-wrap{text-align:center;animation:fade-up .5s ease-out .3s both}
+  .title{font-family:'Space Grotesk',sans-serif;font-size:22px;font-weight:700;background:linear-gradient(135deg,#04D1FE,#AF27E3,#FB4072);-webkit-background-clip:text;-webkit-text-fill-color:transparent;background-clip:text;margin-bottom:8px}
+  .subtitle{font-size:14px;color:#999;line-height:1.5}
+
+  .loading{font-size:14px;color:#999;animation:pulse 2s ease-in-out infinite}
+  @keyframes pulse{0%,100%{opacity:.5}50%{opacity:1}}
+  @keyframes fade-up{0%{opacity:0;transform:translateY(10px)}100%{opacity:1;transform:translateY(0)}}
 </style></head><body>
+<div class="container">
 ${connected
-  ? '<div class="connected">Connected!</div><p class="status">WhatsApp is linked. You can close this page.</p>'
+  ? `<div class="confetti-wrap">${confettiHTML}</div>
+<div class="video-wrap"><video autoplay muted playsinline><source src="/fluxy_happy_reappearing.mov" type='video/mp4; codecs="hvc1"'><source src="/fluxy_happy_reappearing.webm" type="video/webm"></video></div>
+<div class="text-wrap"><div class="title">Connected!</div><p class="subtitle">WhatsApp is linked. You can close this page.</p></div>`
   : qr
-    ? `<div class="qr-container">${qr}</div><p class="status">Scan with WhatsApp to link</p>`
-    : '<p class="status">Starting WhatsApp... Refresh in a moment.</p>'}
+    ? `<div class="qr-card"><div class="qr-inner">${qr}</div></div><p class="scan-hint">Scan with WhatsApp to link</p>`
+    : '<p class="loading">Starting WhatsApp... Refresh in a moment.</p>'}
+</div>
 ${!connected ? '<script>setTimeout(()=>location.reload(),4000)</script>' : ''}
 </body></html>`);
         return;
@@ -492,6 +529,7 @@ ${!connected ? '<script>setTimeout(()=>location.reload(),4000)</script>' : ''}
             if (!cfg.channels.whatsapp) cfg.channels.whatsapp = { enabled: true, mode: 'channel' };
             if (data.mode) cfg.channels.whatsapp.mode = data.mode;
             if (data.admins !== undefined) cfg.channels.whatsapp.admins = data.admins;
+            if (data.skill !== undefined) cfg.channels.whatsapp.skill = data.skill;
             saveConfig(cfg);
             res.writeHead(200);
             res.end(JSON.stringify({ ok: true, config: cfg.channels.whatsapp }));

package/worker/prompts/fluxy-system-prompt.txt

@@ -202,6 +202,37 @@ Complex cron tasks can have detailed instruction files in `tasks/{cron-id}.md`.
 
 ---
 
+## Skills
+
+Skills live in `skills/` — each skill is a folder with instructions and resources:
+
+```
+skills/
+  whatsapp-clinic/
+    SKILL.md          # Instructions for you (how to use this skill)
+    SCRIPT.md         # Customer-facing prompt (loaded as system prompt in business mode)
+    files/            # RAG documents, FAQs, etc.
+```
+
+Only ONE skill can be active for customer-facing mode at a time. The active skill is set in the channel config (`channels.whatsapp.skill`). When your human asks to switch skills, update the config:
+```bash
+curl -s -X POST http://localhost:3000/api/channels/whatsapp/configure \
+  -H "Content-Type: application/json" -d '{"skill":"whatsapp-clinic"}'
+```
+
+**IMPORTANT: When editing skill files, always use the full path inside the skill directory.**
+- Correct: `skills/whatsapp-clinic/SCRIPT.md`
+- Wrong: `SCRIPT.md` (this writes to workspace root!)
+
+Your installed skills and their SKILL.md contents are injected below in your context. If your human asks you to update a skill's behavior or script, edit the files INSIDE `skills/{skill-name}/`.
+
+**Separation of concerns:**
+- `MYSELF.md`, `MYHUMAN.md`, `MEMORY.md` — about YOU and your human. Always yours.
+- `skills/{name}/SCRIPT.md` — business logic for customer interactions. Belongs to the skill.
+- `whatsapp/{phone}.md` — customer conversation logs. Your memory of each customer.
+
+---
+
 ## Channels (WhatsApp, Telegram, etc.)
 
 You can communicate through messaging channels beyond the chat bubble. Currently supported: **WhatsApp**.
@@ -229,7 +260,7 @@ Hi, I'd like to schedule an appointment.
 The format is: `[Channel | phone | role | name (optional)]`
 
 - **role=admin**: This is your human or an authorized admin. Use your normal personality, full capabilities, main system prompt.
-- **role=customer**: This is someone else messaging. You're in **support mode** — follow the instructions from your active skill's SUPPORT.md.
+- **role=customer**: This is someone else messaging. Follow the instructions from the active skill's SCRIPT.md (loaded as your system prompt).
 
 ### WhatsApp Modes
 

package/workspace/skills/whatsapp-support/.claude-plugin/plugin.json

@@ -1,5 +0,0 @@
-{
-  "name": "whatsapp-support",
-  "description": "WhatsApp customer support skill — handles incoming customer messages with a friendly support persona",
-  "version": "0.1.0"
-}