fluxy-bot 0.15.1 → 0.15.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fluxy-bot",
-  "version": "0.15.1",
+  "version": "0.15.5",
   "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;
-  /** 'shared' = user's own number, 'dedicated' = Fluxy has its own number */
-  mode: 'shared' | 'dedicated';
-  /** The human/owner's phone number (used for role resolution in dedicated mode) */
-  humanPhone?: string;
+  /** '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

@@ -3,10 +3,16 @@
  *
  * Responsibilities:
  * - Manages channel providers (WhatsApp, Telegram, etc.)
- * - Resolves sender role (human vs customer)
+ * - Resolves sender role (admin vs customer) based on mode
  * - Routes inbound messages to the agent with appropriate system prompt
- * - Routes outbound messages from agent/API back to channels
- * - Manages parallel agent instances for customer conversations
+ * - Routes agent responses back to channels
+ * - Manages parallel agent instances for customer conversations (business mode)
+ *
+ * Modes:
+ * - channel: Just talk to me. Only self-chat (fromMe=true) triggers the agent.
+ *            All other messages are ignored — it's the user's personal WhatsApp.
+ * - business: Fluxy has its own number. Numbers in the admins array get the main
+ *             system prompt. Everyone else gets the customer support prompt.
  */
 
 import fs from 'fs';
@@ -19,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;
@@ -30,7 +37,11 @@ interface ChannelManagerOpts {
 interface ActiveAgentQuery {
   sender: string;
   channel: ChannelType;
-  abortController?: AbortController;
+}
+
+interface BufferedMessage {
+  role: 'user' | 'assistant';
+  content: string;
 }
 
 export class ChannelManager {
@@ -39,6 +50,8 @@ export class ChannelManager {
   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;
@@ -47,7 +60,7 @@ export class ChannelManager {
   /** Initialize channels based on config */
   async init(): Promise<void> {
     const config = loadConfig();
-    const channelConfigs = (config as any).channels as Record<string, ChannelConfig> | undefined;
+    const channelConfigs = config.channels;
 
     if (!channelConfigs?.whatsapp?.enabled) {
       log.info('[channels] WhatsApp not enabled — skipping');
@@ -56,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);
@@ -75,9 +88,8 @@ export class ChannelManager {
   async connectWhatsApp(): Promise<void> {
     let provider = this.providers.get('whatsapp');
     if (!provider) {
-      // Create provider on-demand if not initialized
       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);
@@ -148,27 +160,10 @@ export class ChannelManager {
     }
   }
 
-  /** Resolve sender role based on channel config */
-  private resolveRole(channel: ChannelType, sender: string, fromMe: boolean): SenderRole {
+  /** Get the channel config, re-reading from disk each time */
+  private getChannelConfig(channel: ChannelType): ChannelConfig | undefined {
     const config = loadConfig();
-    const channelConfigs = (config as any).channels as Record<string, ChannelConfig> | undefined;
-    const channelConfig = channelConfigs?.[channel];
-
-    if (!channelConfig) return 'customer';
-
-    if (channelConfig.mode === 'shared') {
-      // Shared number mode: fromMe messages are from the human
-      return fromMe ? 'human' : 'customer';
-    }
-
-    // Dedicated number mode: check if sender matches human's phone
-    if (channelConfig.humanPhone) {
-      const senderPhone = sender.replace(/@.*/, '').replace(/[^0-9]/g, '');
-      const humanPhone = channelConfig.humanPhone.replace(/[^0-9]/g, '');
-      if (senderPhone === humanPhone) return 'human';
-    }
-
-    return 'customer';
+    return config.channels?.[channel];
   }
 
   /** Handle an incoming message from any channel */
@@ -178,8 +173,44 @@ export class ChannelManager {
     senderName: string | undefined,
     text: string,
     fromMe: boolean,
+    isSelfChat: boolean,
   ) {
-    const role = this.resolveRole(channel, sender, fromMe);
+    const channelConfig = this.getChannelConfig(channel);
+    if (!channelConfig) return;
+
+    const mode = channelConfig.mode || 'channel';
+
+    // ── Channel mode: ONLY respond to self-chat ──
+    if (mode === 'channel') {
+      if (!fromMe || !isSelfChat) {
+        // Ignore everything except self-chat messages
+        return;
+      }
+
+      const message: InboundMessage = {
+        channel,
+        sender: sender.replace(/@.*/, ''),
+        senderName,
+        role: 'admin',
+        text,
+        rawSender: sender,
+      };
+
+      log.info(`[channels] Channel mode | self-chat | "${text.slice(0, 60)}"`);
+      await this.handleAdminMessage(message);
+      return;
+    }
+
+    // ── 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,
@@ -190,31 +221,43 @@ export class ChannelManager {
       rawSender: sender,
     };
 
-    log.info(`[channels] Inbound ${channel} | ${message.sender} | role=${role} | "${text.slice(0, 60)}"`);
+    log.info(`[channels] Business mode | ${message.sender} | role=${role} | "${text.slice(0, 60)}"`);
 
-    if (role === 'human') {
-      await this.handleHumanMessage(message);
+    if (role === 'admin') {
+      await this.handleAdminMessage(message);
     } else {
-      await this.handleCustomerMessage(message);
+      await this.handleCustomerMessage(message, channelConfig);
     }
   }
 
-  /** Handle message from the human/owner — mirrors to chat conversation */
-  private async handleHumanMessage(msg: InboundMessage) {
+  /** Resolve role in business mode — 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) {
+        const adminPhone = admin.replace(/[^0-9]/g, '');
+        if (senderPhone === adminPhone || senderPhone.endsWith(adminPhone) || adminPhone.endsWith(senderPhone)) {
+          return 'admin';
+        }
+      }
+    }
+
+    return 'customer';
+  }
+
+  /** Handle message from an admin — mirrors to chat conversation, uses main system prompt */
+  private async handleAdminMessage(msg: InboundMessage) {
     const { workerApi, broadcastFluxy, getModel } = this.opts;
     const model = getModel();
 
-    // Get or create the human's WhatsApp conversation (mirrored with chat)
+    // Get or create conversation (shared with chat for mirroring)
     let convId: string | undefined;
     try {
       const ctx = await workerApi('/api/context/current');
       if (ctx.conversationId) {
         convId = ctx.conversationId;
       } else {
-        const conv = await workerApi('/api/conversations', 'POST', {
-          title: `WhatsApp`,
-          model,
-        });
+        const conv = await workerApi('/api/conversations', 'POST', { title: 'WhatsApp', model });
         convId = conv.id;
         await workerApi('/api/context/set', 'POST', { conversationId: convId });
       }
@@ -240,7 +283,7 @@ export class ChannelManager {
       message: { role: 'user', content: msg.text, timestamp: new Date().toISOString() },
     });
 
-    // Fetch agent/user names and recent messages
+    // Fetch names and recent messages
     let botName = 'Fluxy', humanName = 'Human';
     let recentMessages: RecentMessage[] = [];
     try {
@@ -261,8 +304,8 @@ export class ChannelManager {
       }
     } catch {}
 
-    // Run agent with main system prompt (same as chat)
-    const channelContext = `[WhatsApp | ${msg.sender} | human]\n`;
+    // Channel context — tells the agent this is a WhatsApp message, respond naturally
+    const channelContext = `[WhatsApp | ${msg.sender} | admin]\n`;
 
     startFluxyAgentQuery(
       convId,
@@ -270,7 +313,7 @@ export class ChannelManager {
       model,
       (type, eventData) => {
         if (type === 'bot:response' && eventData.content) {
-          // Send response back via WhatsApp
+          // Send agent's response back via WhatsApp
           this.sendMessage(msg.channel, msg.rawSender, eventData.content).catch((err) => {
             log.warn(`[channels] Failed to send WhatsApp reply: ${err.message}`);
           });
@@ -299,13 +342,12 @@ 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
     if (this.activeAgents.size >= MAX_CONCURRENT_AGENTS && !this.activeAgents.has(agentKey)) {
-      // Queue the message
       log.info(`[channels] Max concurrent agents reached — queuing message from ${msg.sender}`);
       this.messageQueue.push(msg);
       return;
@@ -314,10 +356,10 @@ 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/user names
+    // Fetch agent name
     let botName = 'Fluxy', humanName = 'Human';
     try {
       const status = await workerApi('/api/onboard/status');
@@ -325,19 +367,60 @@ export class ChannelManager {
       humanName = status.userName || 'Human';
     } catch {}
 
-    // Build channel context
+    // 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) {
-          // Send response back via WhatsApp
+          // 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}`);
           });
@@ -345,40 +428,39 @@ export class ChannelManager {
 
         if (type === 'bot:done') {
           this.activeAgents.delete(agentKey);
-
-          if (eventData.usedFileTools) {
-            this.opts.restartBackend();
-          }
-
-          // Process queued messages
+          if (eventData.usedFileTools) this.opts.restartBackend();
           this.processQueue();
         }
       },
       undefined,
       undefined,
       { botName, humanName },
-      undefined,
-      supportPrompt,
+      recentMessages,
+      enrichedScript,
     );
   }
 
-  /** Load customer-facing system prompt from skills */
-  private loadSupportPrompt(): string | undefined {
-    // Look for SUPPORT.md in any skill directory
-    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;
   }
 
@@ -386,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

@@ -3,19 +3,21 @@
  */
 
 export type ChannelType = 'whatsapp' | 'telegram';
-export type SenderRole = 'human' | 'customer';
+export type SenderRole = 'admin' | 'customer';
 
 export interface ChannelConfig {
   enabled: boolean;
-  /** 'shared' = user's own number, 'dedicated' = Fluxy has its own number */
-  mode: 'shared' | 'dedicated';
-  /** The human/owner's phone number (used for role resolution in dedicated mode) */
-  humanPhone?: string;
+  /** '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 {
   channel: ChannelType;
-  /** Sender identifier (phone number / JID) */
+  /** Sender identifier (phone number) */
   sender: string;
   /** Sender display name if available */
   senderName?: string;
@@ -23,7 +25,7 @@ export interface InboundMessage {
   role: SenderRole;
   /** Message text content */
   text: string;
-  /** Raw sender JID (channel-specific format) */
+  /** Raw sender JID (channel-specific format, used for replies) */
   rawSender: string;
 }
 

package/supervisor/channels/whatsapp.ts

@@ -23,20 +23,25 @@ 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';
 
   private sock: WASocket | null = null;
   private connected = false;
-  private qrData: string | null = null; // raw QR string data
-  private qrSvg: string | null = null;  // SVG rendered QR
+  private qrData: string | null = null;
+  private qrSvg: string | null = null;
   private onMessage: OnWhatsAppMessage;
   private onStatusChange: (status: ChannelStatus) => void;
   private reconnectTimer: ReturnType<typeof setTimeout> | null = null;
   private intentionalDisconnect = false;
 
+  /** Maps LID JIDs to phone JIDs (WhatsApp uses LIDs internally for self-chat) */
+  private lidToPhoneMap = new Map<string, string>();
+  /** Our own phone JID (number@s.whatsapp.net) */
+  private ownPhoneJid: string | null = null;
+
   constructor(
     onMessage: OnWhatsAppMessage,
     onStatusChange: (status: ChannelStatus) => void,
@@ -110,6 +115,42 @@ export class WhatsAppChannel implements ChannelProvider {
 
   // ── Internal ──
 
+  /** Translate a JID from LID format to phone format if possible */
+  private translateJid(jid: string): string {
+    // If it's already a phone JID, return as-is
+    if (jid.endsWith('@s.whatsapp.net')) return jid;
+
+    // Check LID map
+    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;
+    }
+
+    return jid;
+  }
+
+  /** Build the LID-to-phone mapping from sock.user */
+  private buildLidMap() {
+    if (!this.sock?.user) return;
+
+    const user = this.sock.user;
+    // user.id is "phone:device@s.whatsapp.net" — extract phone
+    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}`);
+    }
+  }
+
   private async connectInternal(): Promise<void> {
     // Ensure auth directory exists
     fs.mkdirSync(AUTH_DIR, { recursive: true });
@@ -164,6 +205,7 @@ export class WhatsAppChannel implements ChannelProvider {
         this.connected = true;
         this.qrData = null;
         this.qrSvg = null;
+        this.buildLidMap();
         log.ok(`[whatsapp] Connected as ${sock.user?.id}`);
         this.emitStatus();
       }
@@ -207,12 +249,18 @@ export class WhatsAppChannel implements ChannelProvider {
         if (!text) continue;
 
         const fromMe = msg.key.fromMe || false;
-        const sender = msg.key.remoteJid || '';
+        const rawSender = msg.key.remoteJid || '';
+
+        // Translate LID JIDs to phone JIDs
+        const sender = this.translateJid(rawSender);
         const pushName = msg.pushName || undefined;
 
-        log.info(`[whatsapp] Message from ${sender} (fromMe=${fromMe}): ${text.slice(0, 80)}`);
+        // Detect self-chat: remoteJid matches our own phone number
+        const isSelfChat = this.ownPhoneJid !== null && sender === this.ownPhoneJid;
+
+        log.info(`[whatsapp] Message from ${sender} (raw=${rawSender}, 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

@@ -429,7 +429,7 @@ ${!connected ? '<script>setTimeout(()=>location.reload(),4000)</script>' : ''}
             // Enable WhatsApp in config
             const cfg = loadConfig();
             if (!cfg.channels) cfg.channels = {};
-            if (!cfg.channels.whatsapp) cfg.channels.whatsapp = { enabled: true, mode: 'shared' };
+            if (!cfg.channels.whatsapp) cfg.channels.whatsapp = { enabled: true, mode: 'channel' };
             cfg.channels.whatsapp.enabled = true;
             saveConfig(cfg);
 
@@ -480,7 +480,7 @@ ${!connected ? '<script>setTimeout(()=>location.reload(),4000)</script>' : ''}
         return;
       }
 
-      // POST /api/channels/whatsapp/configure — set mode + human phone
+      // POST /api/channels/whatsapp/configure — set mode + admins
       if (req.method === 'POST' && channelPath === '/api/channels/whatsapp/configure') {
         let body = '';
         req.on('data', (chunk: Buffer) => { body += chunk.toString(); });
@@ -489,9 +489,10 @@ ${!connected ? '<script>setTimeout(()=>location.reload(),4000)</script>' : ''}
             const data = JSON.parse(body);
             const cfg = loadConfig();
             if (!cfg.channels) cfg.channels = {};
-            if (!cfg.channels.whatsapp) cfg.channels.whatsapp = { enabled: true, mode: 'shared' };
+            if (!cfg.channels.whatsapp) cfg.channels.whatsapp = { enabled: true, mode: 'channel' };
             if (data.mode) cfg.channels.whatsapp.mode = data.mode;
-            if (data.humanPhone !== undefined) cfg.channels.whatsapp.humanPhone = data.humanPhone;
+            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,10 +202,49 @@ 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**.
 
+### CRITICAL: How WhatsApp Responses Work
+
+**Your text response IS the WhatsApp reply.** When you receive a message tagged with `[WhatsApp | ...]`, the supervisor takes whatever you respond with and sends it directly to WhatsApp. You do NOT need to use curl or `/api/channels/send` to reply — just respond normally as if you're talking to the person.
+
+**Do NOT use `/api/channels/send` to reply to incoming WhatsApp messages.** That endpoint is ONLY for proactive messages (during pulse, cron, or when you want to initiate a conversation). If you use it to reply, the person will get duplicate messages.
+
+**Adjust your style for WhatsApp:** Keep messages shorter and more conversational than chat. No markdown headers, no code blocks unless asked. Think texting, not email.
+
 ### Channel Config
 
 Your channel configuration is injected below (if any channels are configured). It comes from `~/.fluxy/config.json` — a file OUTSIDE your workspace that the supervisor manages.
@@ -220,8 +259,14 @@ Hi, I'd like to schedule an appointment.
 
 The format is: `[Channel | phone | role | name (optional)]`
 
-- **role=human**: This is YOUR human (the owner). 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=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. Follow the instructions from the active skill's SCRIPT.md (loaded as your system prompt).
+
+### WhatsApp Modes
+
+**Channel Mode** (default): Your human's own WhatsApp number. Only self-chat triggers you — messages from other people are completely ignored. This is "just talk to me" mode.
+
+**Business Mode**: Fluxy has its own dedicated number. Numbers in the `admins` array get admin access (main system prompt). Everyone else is a customer (support prompt).
 
 ### Setting Up WhatsApp
 
@@ -229,19 +274,26 @@ When your human asks to configure WhatsApp:
 1. Start the connection: `curl -s -X POST http://localhost:3000/api/channels/whatsapp/connect`
 2. Tell them to open the QR page: `http://localhost:3000/api/channels/whatsapp/qr-page` (or create a dashboard page that embeds it)
 3. They scan the QR with their WhatsApp app
-4. Once connected, configure the mode:
-   - **Shared number** (default): Your human's own WhatsApp. Messages they send to themselves trigger you.
-   - **Dedicated number**: A separate phone/SIM for you. Configure with: `curl -s -X POST http://localhost:3000/api/channels/whatsapp/configure -H "Content-Type: application/json" -d '{"mode":"dedicated","humanPhone":"+1234567890"}'`
+4. The default mode is **channel** (self-chat only)
+
+To switch to **business mode** with admin numbers:
+```bash
+curl -s -X POST http://localhost:3000/api/channels/whatsapp/configure \
+  -H "Content-Type: application/json" \
+  -d '{"mode":"business","admins":["+17865551234","+5511999887766"]}'
+```
 
-### Sending Messages
+### Sending Proactive Messages
 
-To send a WhatsApp message (during pulse, cron, or any time):
+To INITIATE a WhatsApp message (during pulse, cron, or when you want to reach out first):
 ```bash
 curl -s -X POST http://localhost:3000/api/channels/send \
   -H "Content-Type: application/json" \
   -d '{"channel":"whatsapp","to":"5511999888777","text":"Your appointment is confirmed for tomorrow at 2pm."}'
 ```
 
+**Remember:** This is ONLY for starting new conversations or sending unprompted messages. When replying to an incoming message, just respond normally — the supervisor handles delivery.
+
 ### Customer Conversation Logs
 
 When you finish a conversation with a **customer** via WhatsApp, save a summary to `whatsapp/{phone}.md`:
@@ -262,8 +314,8 @@ This is your memory of that customer. Next time they message, read their file fi
 | `/api/channels/whatsapp/connect` | POST | Start WhatsApp (triggers QR if needed) |
 | `/api/channels/whatsapp/disconnect` | POST | Disconnect WhatsApp |
 | `/api/channels/whatsapp/logout` | POST | Disconnect + delete credentials |
-| `/api/channels/whatsapp/configure` | POST | Set mode + human phone number |
-| `/api/channels/send` | POST | Send message via any channel |
+| `/api/channels/whatsapp/configure` | POST | Set mode + admins array |
+| `/api/channels/send` | POST | Send proactive message via any channel |
 
 All endpoints are on `http://localhost:3000`.
 

package/workspace/client/src/App.tsx

@@ -161,7 +161,7 @@ export default function App() {
             <Route path="*" element={<DashboardPage />} />
           </Routes>
         </DashboardLayout>
-        <WorkspaceTour />
+        <WorkspaceTour disabled={showOnboard} />
       </ErrorBoundary>
 
       {showOnboard && (

package/workspace/client/src/components/deleteme_onboarding/WorkspaceTour.tsx

@@ -14,8 +14,9 @@ import './tour-theme.css';
 
 const TOUR_KEY = 'fluxy_workspace_tour_done';
 
-export default function WorkspaceTour() {
+export default function WorkspaceTour({ disabled = false }: { disabled?: boolean }) {
   useEffect(() => {
+    if (disabled) return;
     const val = localStorage.getItem(TOUR_KEY);
     if (val === '1') return;
 
@@ -97,7 +98,7 @@ export default function WorkspaceTour() {
     }, 800);
 
     return () => clearTimeout(timer);
-  }, []);
+  }, [disabled]);
 
   return null;
 }

package/workspace/skills/whatsapp-support/{SUPPORT.md → SCRIPT.md}

@@ -11,12 +11,15 @@ You are a friendly and helpful assistant responding to a customer via WhatsApp.
 - Never reveal internal system details, file paths, or technical architecture.
 - Never run destructive commands or modify critical files during customer interactions.
 
+## CRITICAL: Response = Reply
+
+Your text response IS the WhatsApp reply. The supervisor sends whatever you respond with directly to the customer. Do NOT use curl or `/api/channels/send` to reply — just respond naturally. That endpoint is only for proactive messages.
+
 ## What You Can Do
 
 - Answer FAQs and general questions
 - Provide information from files in your workspace
 - Look up data from your backend API (`/app/api/*`)
-- Send follow-up messages via the channel API
 
 ## What You Should NOT Do
 

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"
-}