@operor/cli 0.1.0

package/src/start.ts

@@ -0,0 +1,573 @@
+import fs from 'fs';
+import type { Skill, Tool } from '@operor/core';
+import { readConfig } from './config.js';
+import { applyLLMOverride } from './commands/llm-override.js';
+
+export async function startOperor(): Promise<void> {
+  const config = readConfig();
+
+  if (!config.LLM_PROVIDER || !config.CHANNEL) {
+    console.error('Missing configuration. Run "operor setup" first.');
+    process.exit(1);
+  }
+
+  console.log('[Operor] Starting...');
+
+  // Dynamic imports to avoid requiring all deps upfront
+  const { Operor, LLMIntentClassifier, AgentLoader } = await import('@operor/core');
+  const { AIProvider } = await import('@operor/llm');
+
+  // Setup memory store (before LLM so we can load persisted model settings)
+  let memory: any;
+  if (config.MEMORY_TYPE === 'sqlite') {
+    const { SQLiteMemory } = await import('@operor/memory');
+    memory = new SQLiteMemory(config.MEMORY_DB_PATH || './operor.db');
+    console.log('[Operor] Using SQLite memory store');
+  }
+
+  // Load persisted model settings (override env vars if stored)
+  let llmProvider = config.LLM_PROVIDER as 'openai' | 'anthropic' | 'google' | 'groq' | 'ollama';
+  let llmModel = config.LLM_MODEL;
+  let llmApiKey = config.LLM_API_KEY;
+  if (memory?.getSetting) {
+    try {
+      const storedProvider = await memory.getSetting('llm_provider');
+      const storedModel = await memory.getSetting('llm_model');
+      if (storedProvider) llmProvider = storedProvider as any;
+      if (storedModel) llmModel = storedModel;
+      // Load stored API key for the active provider
+      const storedKey = await memory.getSetting(`llm_apikey_${llmProvider}`);
+      if (storedKey) llmApiKey = storedKey;
+    } catch { /* getSetting not available */ }
+  }
+
+  // Setup LLM (needed for both completion and intent classification)
+  const llm = new AIProvider({
+    provider: llmProvider,
+    apiKey: llmApiKey,
+    model: llmModel,
+  });
+
+  // Load stored API keys for other providers
+  if (memory?.getSetting) {
+    for (const p of ['openai', 'anthropic', 'google', 'groq', 'ollama']) {
+      if (p === llmProvider) continue;
+      try {
+        const k = await memory.getSetting(`llm_apikey_${p}`);
+        if (k) llm.setApiKey(p, k);
+      } catch { /* ignore */ }
+    }
+  }
+
+  // Setup intent classifier
+  let intentClassifier: any;
+  if (config.INTENT_CLASSIFIER === 'llm') {
+    intentClassifier = new LLMIntentClassifier(llm);
+    console.log('[Operor] Using LLM intent classification');
+  }
+
+  // Setup Knowledge Base runtime (if enabled)
+  let kbRuntime: any;
+  let embedder: any;
+  if (config.KB_ENABLED === 'true') {
+    try {
+      const {
+        SQLiteKnowledgeStore,
+        EmbeddingService,
+        TextChunker,
+        IngestionPipeline,
+        RetrievalPipeline,
+        QueryRewriter,
+        UrlIngestor,
+        SiteCrawler,
+        FileIngestor,
+      } = await import('@operor/knowledge');
+
+      embedder = new EmbeddingService({
+        provider: (config.KB_EMBEDDING_PROVIDER || 'openai') as any,
+        apiKey: config.KB_EMBEDDING_API_KEY || config.LLM_API_KEY,
+        model: config.KB_EMBEDDING_MODEL,
+      });
+
+      const kbStore = new SQLiteKnowledgeStore(
+        config.KB_DB_PATH || './knowledge.db',
+        embedder.dimensions,
+      );
+      await kbStore.initialize();
+
+      const chunker = new TextChunker({
+        chunkSize: config.KB_CHUNK_SIZE ? parseInt(config.KB_CHUNK_SIZE) : undefined,
+        chunkOverlap: config.KB_CHUNK_OVERLAP ? parseInt(config.KB_CHUNK_OVERLAP) : undefined,
+      });
+      const ingestion = new IngestionPipeline(kbStore, embedder, chunker);
+
+      // Setup optional LLM query rewriter (Layer 4)
+      let queryRewriter: InstanceType<typeof QueryRewriter> | undefined;
+      try {
+        const rewriteModel = llm.getModel();
+        queryRewriter = new QueryRewriter({ model: rewriteModel });
+      } catch {
+        // LLM not available for rewriting — layers 1-3 still work
+      }
+
+      const retrieval = new RetrievalPipeline(kbStore, embedder, {
+        faqThreshold: 0.85,
+        queryRewriter,
+        fusionStrategy: (config.FUSION_STRATEGY as 'rrf' | 'weighted') || 'rrf',
+      });
+
+      // Create ingestors for URL, site, and file ingestion
+      const crawl4aiUrl = config.CRAWL4AI_URL || undefined;
+      const urlIngestor = new UrlIngestor(ingestion, { crawl4aiUrl });
+      const siteCrawler = new SiteCrawler(ingestion, { crawl4aiUrl });
+      const fileIngestor = new FileIngestor(ingestion);
+
+      // Wrap in KnowledgeBaseRuntime interface
+      kbRuntime = {
+        ingestFaq: async (question: string, answer: string, metadata?: Record<string, any>) => {
+          const result = await ingestion.ingestFaq(question, answer, metadata);
+          return { id: result.id, existingMatch: (result as any).existingMatch };
+        },
+        listDocuments: async () => {
+          return await kbStore.listDocuments();
+        },
+        deleteDocument: async (id: string) => {
+          return await kbStore.deleteDocument(id);
+        },
+        retrieve: async (query: string) => {
+          return await retrieval.retrieve(query);
+        },
+        getStats: async () => {
+          return await kbStore.getStats();
+        },
+        ingestUrl: async (url: string) => {
+          const doc = await urlIngestor.ingestUrl(url);
+          const faqCount = doc.metadata?.faqCount;
+          const chunks = faqCount ?? (kbStore.getChunkCount ? kbStore.getChunkCount(doc.id) : 0);
+          return { id: doc.id, title: doc.title, chunks, faqCount };
+        },
+        ingestSite: async (url: string, options?: { maxDepth?: number; maxPages?: number; onProgress?: (crawled: number, total: number, url: string) => void }) => {
+          const docs = await siteCrawler.crawlSite(url, {
+            ...options,
+            onProgress: options?.onProgress,
+          });
+          const totalChunks = docs.reduce((sum, doc) => {
+            const count = kbStore.getChunkCount ? kbStore.getChunkCount(doc.id) : 0;
+            return sum + count;
+          }, 0);
+          return { documents: docs.length, chunks: totalChunks };
+        },
+        ingestFile: async (buffer: Buffer, fileName: string) => {
+          // Write buffer to temp file, ingest, then clean up
+          const { writeFile, unlink } = await import('fs/promises');
+          const { join } = await import('path');
+          const { tmpdir } = await import('os');
+          const tempPath = join(tmpdir(), `operor-${Date.now()}-${fileName}`);
+          await writeFile(tempPath, buffer);
+          try {
+            const doc = await fileIngestor.ingestFile(tempPath, fileName);
+            const chunkCount = kbStore.getChunkCount ? kbStore.getChunkCount(doc.id) : 0;
+            return { id: doc.id, title: doc.title, chunks: chunkCount };
+          } finally {
+            await unlink(tempPath).catch(() => {}); // Clean up temp file
+          }
+        },
+        rebuild: async () => {
+          return await ingestion.rebuild();
+        },
+      };
+
+      console.log('[Operor] Knowledge Base enabled');
+    } catch (error: any) {
+      console.error(`[Operor] Failed to initialize Knowledge Base: ${error.message}`);
+    }
+  }
+
+  // Setup Training Copilot (if enabled)
+  let copilotHandler: any;
+  let copilotTracker: any;
+  if (config.COPILOT_ENABLED !== 'false' && kbRuntime) {
+    try {
+      const {
+        SQLiteCopilotStore,
+        UnansweredQueryTracker,
+        QueryClusterer,
+        SuggestionEngine,
+        CopilotCommandHandler,
+        DigestScheduler,
+        DEFAULT_COPILOT_CONFIG,
+      } = await import('@operor/copilot');
+
+      const copilotConfig = {
+        ...DEFAULT_COPILOT_CONFIG,
+        enabled: true,
+        trackingThreshold: config.COPILOT_TRACKING_THRESHOLD ? parseFloat(config.COPILOT_TRACKING_THRESHOLD) : DEFAULT_COPILOT_CONFIG.trackingThreshold,
+        clusterThreshold: config.COPILOT_CLUSTER_THRESHOLD ? parseFloat(config.COPILOT_CLUSTER_THRESHOLD) : DEFAULT_COPILOT_CONFIG.clusterThreshold,
+        digestIntervalMs: config.COPILOT_DIGEST_INTERVAL ? parseInt(config.COPILOT_DIGEST_INTERVAL) : DEFAULT_COPILOT_CONFIG.digestIntervalMs,
+        digestMaxItems: config.COPILOT_DIGEST_MAX_ITEMS ? parseInt(config.COPILOT_DIGEST_MAX_ITEMS) : DEFAULT_COPILOT_CONFIG.digestMaxItems,
+        autoSuggest: config.COPILOT_AUTO_SUGGEST !== 'false',
+      };
+
+      // Reuse the same embedder dimensions from KB
+      const copilotStore = new SQLiteCopilotStore(
+        config.COPILOT_DB_PATH || './copilot.db',
+        embedder.dimensions,
+      );
+      await copilotStore.initialize();
+
+      const clusterer = new QueryClusterer(copilotStore, embedder, {
+        clusterThreshold: copilotConfig.clusterThreshold,
+      });
+
+      copilotTracker = new UnansweredQueryTracker(
+        copilotStore,
+        copilotConfig,
+        embedder,
+        clusterer,
+      );
+
+      // SuggestionEngine wraps the LLM for generating draft answers
+      const suggestionEngine = copilotConfig.autoSuggest
+        ? new SuggestionEngine(
+            { generateText: (opts: any) => llm.complete([
+              ...(opts.system ? [{ role: 'system' as const, content: opts.system }] : []),
+              { role: 'user' as const, content: opts.prompt },
+            ]) },
+            kbRuntime,
+          )
+        : undefined;
+
+      copilotHandler = new CopilotCommandHandler(
+        copilotStore,
+        suggestionEngine,
+        kbRuntime,
+        clusterer,
+      );
+
+      // Start digest scheduler if training mode whitelist is configured
+      const adminPhones = config.TRAINING_MODE_WHITELIST?.split(',').map((p: string) => p.trim()).filter(Boolean) || [];
+      if (adminPhones.length > 0) {
+        const digest = new DigestScheduler(copilotStore, copilotConfig, async (phone: string, text: string) => {
+          try {
+            if (provider && typeof provider.sendMessage === 'function') {
+              await provider.sendMessage(phone, text);
+            }
+          } catch (err: any) {
+            console.warn('[Copilot] Failed to send digest:', err?.message);
+          }
+        });
+        digest.start(adminPhones);
+      }
+
+      console.log('[Operor] Training Copilot enabled');
+    } catch (error: any) {
+      console.error(`[Operor] Failed to initialize Training Copilot: ${error.message}`);
+      console.error('[Operor]    /review commands will not be available. Try running "pnpm install" if packages are missing.');
+    }
+  }
+
+  // Setup Analytics (enabled by default)
+  let analyticsCollector: any;
+  let analyticsStore: any;
+  if (config.ANALYTICS_ENABLED !== 'false') {
+    try {
+      const { SQLiteAnalyticsStore, AnalyticsCollector } = await import('@operor/analytics');
+      analyticsStore = new SQLiteAnalyticsStore(config.ANALYTICS_DB_PATH || './analytics.db');
+      await analyticsStore.initialize();
+      analyticsCollector = new AnalyticsCollector(analyticsStore, { debug: true });
+      console.log('[Operor] Analytics enabled');
+    } catch (error: any) {
+      console.error(`[Operor] Failed to initialize Analytics: ${error.message}`);
+    }
+  }
+
+  // Build training whitelist — DB is source of truth, env var is bootstrap seed
+  let trainingWhitelist: string[] = config.TRAINING_MODE_WHITELIST?.split(',').map(p => p.trim()).filter(Boolean) || [];
+
+  if (config.TRAINING_MODE_ENABLED === 'true' && memory?.getSetting) {
+    try {
+      const stored = await memory.getSetting('training_whitelist');
+      if (stored) {
+        trainingWhitelist = stored.split(',').map((p: string) => p.trim()).filter(Boolean);
+      } else if (trainingWhitelist.length > 0) {
+        // Seed DB from env var on first run
+        await memory.setSetting('training_whitelist', trainingWhitelist.join(','));
+      }
+    } catch {
+      // getSetting not available — fall back to env var
+    }
+  }
+
+  // Pre-load skills module for injection into Operor (avoids circular dep: core cannot import skills)
+  let skillsModule: any;
+  try {
+    skillsModule = await import('@operor/skills');
+  } catch {
+    // skills package not available — catalog commands will show "not available"
+  }
+
+  // Detect agents directory early so Operor can persist frontmatter changes
+  const agentsDir = `${process.cwd()}/agents`;
+  const hasAgentsDir = fs.existsSync(agentsDir);
+
+  // Create Operor instance
+  const os = new Operor({
+    debug: true,
+    llmProvider: llm,
+    ...(memory && { memory }),
+    ...(intentClassifier && { intentClassifier }),
+    ...(kbRuntime && { kb: kbRuntime }),
+    ...(copilotHandler && { copilotHandler }),
+    ...(copilotTracker && { copilotTracker }),
+    ...(analyticsCollector && { analyticsCollector }),
+    ...(analyticsStore && { analyticsStore }),
+    ...(skillsModule && { skillsModule }),
+    ...(hasAgentsDir && { agentsDir }),
+    ...(config.TRAINING_MODE_ENABLED === 'true' && {
+      trainingMode: {
+        enabled: true,
+        whitelist: trainingWhitelist,
+      },
+    }),
+  });
+
+  // Setup provider
+  let provider: any;
+  if (config.CHANNEL === 'whatsapp') {
+    const { BaileysProvider } = await import('@operor/provider-baileys');
+    provider = new BaileysProvider({
+      groupMode: (config.WHATSAPP_GROUP_MODE as any) || 'mention-only',
+    });
+  } else if (config.CHANNEL === 'telegram') {
+    const { TelegramProvider } = await import('@operor/provider-telegram');
+    provider = new TelegramProvider({ botToken: config.TELEGRAM_BOT_TOKEN! });
+  } else if (config.CHANNEL === 'wati') {
+    const { WatiProvider } = await import('@operor/provider-wati');
+    provider = new WatiProvider({
+      apiToken: config.WATI_API_TOKEN!,
+      tenantId: config.WATI_TENANT_ID!,
+      webhookPort: config.WATI_WEBHOOK_PORT ? parseInt(config.WATI_WEBHOOK_PORT) : undefined,
+    });
+  } else {
+    const { MockProvider } = await import('@operor/provider-mock');
+    provider = new MockProvider();
+  }
+  os.addProvider(provider);
+
+  // Setup MCP skills from mcp.json
+  let skillManager: any;
+  const skillInstances: Skill[] = [];
+  let loadSkillsConfig: any;
+  try {
+    const skillsMod = await import('@operor/skills');
+    loadSkillsConfig = skillsMod.loadSkillsConfig;
+    const { SkillManager } = skillsMod;
+    const skillsConfig = loadSkillsConfig();
+    skillManager = new SkillManager();
+    const mcpSkills = await skillManager.initialize(skillsConfig);
+    for (const skill of mcpSkills) {
+      os.addSkill(skill);
+      skillInstances.push(skill);
+    }
+    if (mcpSkills.length > 0) {
+      console.log(`[Operor] ${mcpSkills.length} MCP skill(s) loaded`);
+    }
+  } catch (error: any) {
+    // Graceful if mcp.json doesn't exist or skills fail to load
+    if (config.SKILLS_ENABLED === 'true') {
+      console.warn(`[Operor] Failed to load MCP skills: ${error.message}`);
+    }
+  }
+
+  // Collect all tools from skills
+  const allTools: Tool[] = skillInstances.flatMap((skill) => Object.values(skill.tools));
+
+  // Helper: get prompt skill name+content for an agent (filtered by skills list)
+  const getPromptSkills = (agentSkillNames?: string[]): Array<{name: string, content: string}> => {
+    return skillInstances
+      .filter((s): s is any => typeof (s as any).getContent === 'function')
+      .filter((s) => !agentSkillNames || agentSkillNames.includes(s.name))
+      .map((s) => ({ name: s.name, content: (s as any).getContent() }));
+  };
+
+  // Track per-agent tool arrays so we can mutate them in-place on hot-reload
+  const agentToolsMap = new Map<string, Tool[]>();
+
+  let definitions: Awaited<ReturnType<InstanceType<typeof AgentLoader>['loadAll']>> = [];
+
+  if (hasAgentsDir) {
+    // File-based agent definitions
+    const loader = new AgentLoader(process.cwd());
+    definitions = await loader.loadAll();
+
+    if (definitions.length === 0) {
+      console.error('[Operor] agents/ directory found but no valid agent definitions. Check INSTRUCTIONS.md files.');
+      process.exit(1);
+    }
+
+    for (const def of definitions) {
+      // Filter tools for this agent based on its skills list
+      const agentTools: Tool[] = def.config.skills
+        ? skillInstances
+            .filter((skill) => def.config.skills!.includes(skill.name))
+            .flatMap((skill) => Object.values(skill.tools))
+        : allTools;
+
+      agentToolsMap.set(def.config.name, agentTools);
+
+      const agent = os.createAgent({
+        ...def.config,
+        tools: agentTools,
+      });
+
+      // Override agent.process with LLM using the file-based systemPrompt
+      applyLLMOverride(agent, llm, agentTools, {
+        systemPrompt: def.systemPrompt,
+        kbRuntime,
+        useKB: def.config.knowledgeBase,
+        guardrails: def.config.guardrails,
+        promptSkills: getPromptSkills(def.config.skills),
+      });
+
+      console.log(
+        `[Operor] Loaded agent: ${def.config.name}` +
+        (def.config.channels ? ` (channels: ${def.config.channels.join(', ')})` : '') +
+        (def.config.skills ? ` (skills: ${def.config.skills.join(', ')})` : '') +
+        (def.config.knowledgeBase ? ' (KB)' : '') +
+        (def.config.priority ? ` (priority: ${def.config.priority})` : '')
+      );
+    }
+
+    console.log(`[Operor] Loaded ${definitions.length} agent(s) from agents/ directory`);
+  } else {
+    // Fallback: single agent (backward compatible)
+    const agent = os.createAgent({
+      name: 'support',
+      purpose: 'Customer support agent',
+      personality: 'Friendly, helpful, and professional',
+      triggers: ['*'],
+      tools: allTools,
+    });
+
+    agentToolsMap.set('support', allTools);
+    applyLLMOverride(agent, llm, allTools, { kbRuntime, promptSkills: getPromptSkills() });
+    console.log('[Operor] Using default single-agent mode');
+  }
+
+  // --- Hot-reload MCP skills on mcp.json change ---
+  const reloadSkills = async () => {
+    if (!skillManager || !loadSkillsConfig) return;
+
+    console.log('[Operor] \uD83D\uDD04 Reloading MCP skills...');
+    try {
+      // 1. Re-read mcp.json
+      const newConfig = loadSkillsConfig();
+
+      // 2. Remove old skills from Operor (closes MCP clients)
+      for (const skill of skillInstances) {
+        await os.removeSkill(skill.name);
+      }
+
+      // 3. Reset SkillManager internal state
+      await skillManager.closeAll();
+
+      // 4. Initialize new skills
+      const newSkills = await skillManager.initialize(newConfig);
+
+      // 5. Update skillInstances in-place
+      skillInstances.splice(0, skillInstances.length, ...newSkills);
+
+      // 6. Add new skills to Operor (double-init guarded)
+      for (const skill of newSkills) {
+        await os.addSkill(skill);
+      }
+
+      // 7. Rebuild allTools in-place so existing closures see the change
+      const freshTools: Tool[] = skillInstances.flatMap((skill) => Object.values(skill.tools));
+      allTools.splice(0, allTools.length, ...freshTools);
+
+      // 8. Rebuild each agent's tools array in-place
+      for (const def of definitions) {
+        const agentTools = agentToolsMap.get(def.config.name);
+        if (!agentTools) continue;
+        const newAgentTools: Tool[] = def.config.skills
+          ? skillInstances
+              .filter((skill) => def.config.skills!.includes(skill.name))
+              .flatMap((skill) => Object.values(skill.tools))
+          : freshTools;
+        agentTools.splice(0, agentTools.length, ...newAgentTools);
+      }
+
+      // Also update fallback single-agent if no definitions
+      if (definitions.length === 0) {
+        const fallbackTools = agentToolsMap.get('support');
+        if (fallbackTools) {
+          fallbackTools.splice(0, fallbackTools.length, ...freshTools);
+        }
+      }
+
+      // 9. Re-apply LLM override for agents whose prompt skill content may have changed
+      for (const def of definitions) {
+        const agentTools = agentToolsMap.get(def.config.name);
+        if (!agentTools) continue;
+        const agent = os.getAgents().find((a: any) => a.getConfig?.().name === def.config.name || a.config?.name === def.config.name);
+        if (agent) {
+          applyLLMOverride(agent, llm, agentTools, {
+            systemPrompt: def.systemPrompt,
+            kbRuntime,
+            useKB: def.config.knowledgeBase,
+            guardrails: def.config.guardrails,
+            promptSkills: getPromptSkills(def.config.skills),
+          });
+        }
+      }
+
+      console.log(`[Operor] \u2705 Reloaded ${newSkills.length} skill(s)`);
+    } catch (error: any) {
+      console.error(`[Operor] \u274C Failed to reload MCP skills: ${error.message}`);
+    }
+  };
+
+  // Start
+  await os.start();
+  console.log('[Operor] Running. Press Ctrl+C to stop.');
+
+  // Watch mcp.json for changes and hot-reload skills
+  const mcpJsonPath = `${process.cwd()}/mcp.json`;
+  if (fs.existsSync(mcpJsonPath) && loadSkillsConfig) {
+    let reloadTimer: ReturnType<typeof setTimeout> | null = null;
+    fs.watch(mcpJsonPath, () => {
+      if (reloadTimer) clearTimeout(reloadTimer);
+      reloadTimer = setTimeout(() => {
+        reloadTimer = null;
+        reloadSkills().catch((err) => {
+          console.error(`[Operor] Skill reload error: ${err.message}`);
+        });
+      }, 500);
+    });
+    console.log('[Operor] Watching mcp.json for changes');
+  }
+
+  // Graceful shutdown — close MCP skills
+  const shutdown = async () => {
+    console.log('\n[Operor] Shutting down...');
+    if (skillManager) {
+      await skillManager.closeAll();
+    }
+    await os.stop();
+    process.exit(0);
+  };
+
+  process.on('SIGINT', shutdown);
+  process.on('SIGTERM', shutdown);
+
+  // For mock provider, simulate a test message
+  if (config.CHANNEL === 'mock') {
+    setTimeout(() => {
+      provider.simulateIncomingMessage(
+        '+1234567890',
+        'Hi, I need help with my order #1001'
+      );
+    }, 2000);
+  }
+}

package/src/utils.ts

@@ -0,0 +1,6 @@
+/**
+ * Format current time as HH:MM:SS timestamp
+ */
+export function formatTimestamp(): string {
+  return new Date().toLocaleTimeString('en-US', { hour12: false });
+}

package/templates/agents/_defaults/SOUL.md

@@ -0,0 +1,20 @@
+# Default Agent Soul
+
+## Core Principles
+
+- Be helpful, accurate, and respectful
+- Respond promptly and stay on topic
+- When unsure, ask for clarification rather than guessing
+- Protect customer privacy at all times
+
+## Boundaries
+
+- Only discuss topics within your defined scope
+- Escalate to a human when the situation requires judgment beyond your capabilities
+- Never fabricate information — use your integrations to look up real data
+
+## Tone
+
+- Professional and friendly
+- Clear and concise — avoid unnecessary verbosity
+- Adapt to the customer's communication style

package/templates/agents/_defaults/USER.md

@@ -0,0 +1,16 @@
+# Business Owner Profile
+
+**Name:** (Your name)
+**Business:** (Your business name)
+**Timezone:** (e.g., America/New_York)
+**Language:** English
+
+## Preferences
+
+- **Response style:** (concise / detailed / casual / formal)
+- **Escalation preference:** (email / phone / in-app)
+- **Operating hours:** (e.g., Mon-Fri 9am-6pm EST)
+
+## Notes
+
+Add any business-specific context here that agents should be aware of — seasonal policies, current promotions, known issues, etc.

package/templates/agents/customer-support/IDENTITY.md

@@ -0,0 +1,6 @@
+# Customer Support Agent Identity
+
+**Name:** Support Agent
+**Emoji:** 🎧
+**Nature:** Helpful, patient, solution-oriented
+**Vibe:** Like a knowledgeable friend who works at the store — approachable, efficient, and genuinely wants to help you out.