feat: Add Slack Events integration, Dockerfiles, and Hugging Face deployment config

Dockerfile

@@ -0,0 +1,14 @@
+FROM node:20-alpine AS builder
+WORKDIR /app
+COPY package*.json ./
+RUN npm ci
+COPY . .
+RUN npm run build
+
+FROM node:20-alpine
+WORKDIR /app
+COPY package*.json ./
+RUN npm ci --only=production
+COPY --from=builder /app/dist ./dist
+EXPOSE 7860
+CMD ["node", "dist/index.js"]

Dockerfile.node

@@ -0,0 +1,15 @@
+FROM node:20-alpine AS builder
+WORKDIR /app
+COPY package*.json ./
+RUN npm ci
+COPY . .
+RUN npm run build
+
+FROM node:20-alpine
+WORKDIR /app
+COPY package*.json ./
+RUN npm ci --only=production
+COPY --from=builder /app/dist ./dist
+# If we need the .env in production, it will be loaded from env_file in docker-compose
+EXPOSE 3000
+CMD ["node", "dist/index.js"]

package.json

@@ -6,7 +6,7 @@
   "scripts": {
     "build": "tsc",
     "dev": "ts-node-dev --respawn --transpile-only src/index.ts",
-    "trigger:dev": "npx trigger.dev@latest dev",
+    "trigger:dev": "npx trigger.dev@3.3.17 dev",
     "typecheck": "tsc --noEmit",
     "lint": "eslint . --ext .ts"
   },

src/discovery/trigger-tasks/manual-discovery.ts

@@ -118,12 +118,21 @@ async function processManualCompany(
     return "new";
   }
 
-  const decisionMakers = linkedin?.decisionMakers ?? [];
-  const contactsSaved = await enrichContacts(saved.id, domain, decisionMakers);
+  const contactsSaved = await enrichContacts(
+    saved.id,
+    domain,
+    normalized.name,
+    normalized.employee_count,
+    industry,
+    website.text.slice(0, 300),
+    website.html,
+    normalized.linkedin_url,
+    "manual-" + saved.id
+  );
 
   await db.from("companies").update({ status: "profiled" }).eq("id", saved.id);
 
-  if (contactsSaved > 0) {
+  if (contactsSaved.length > 0) {
     const { profilingTask } = await import("../../profiling/trigger-tasks/profiling-router");
     await profilingTask.trigger({
       company_id: saved.id,

src/index.ts

@@ -0,0 +1,206 @@
+import http from "http";
+import crypto from "crypto";
+import querystring from "querystring";
+import { handleSlackCommand, type SlackCommand } from "./slack/slack-commands";
+import { getEnv } from "./shared/config/env";
+import { logger } from "./shared/utils/logger";
+
+// Initialize environment
+const env = getEnv();
+const PORT = process.env.PORT ? parseInt(process.env.PORT, 10) : 3000;
+
+/**
+ * Verify Slack request signature to ensure it comes from Slack.
+ */
+function verifySlackSignature(
+  timestamp: string,
+  rawBody: string,
+  signature: string,
+  signingSecret: string
+): boolean {
+  if (!signingSecret) {
+    logger.warn("SLACK_SIGNING_SECRET is not configured. Skipping signature verification.");
+    return true;
+  }
+
+  // Prevent replay attacks (5 minute threshold)
+  const fiveMinutesAgo = Math.floor(Date.now() / 1000) - 60 * 5;
+  if (parseInt(timestamp, 10) < fiveMinutesAgo) {
+    logger.warn("Slack request timestamp is too old. Potential replay attack.");
+    return false;
+  }
+
+  const sigBaseString = `v0:${timestamp}:${rawBody}`;
+  const mySignature = "v0=" + crypto
+    .createHmac("sha256", signingSecret)
+    .update(sigBaseString, "utf8")
+    .digest("hex");
+
+  try {
+    return crypto.timingSafeEqual(Buffer.from(mySignature, "utf8"), Buffer.from(signature, "utf8"));
+  } catch (err) {
+    return false;
+  }
+}
+
+// Start HTTP Server
+const server = http.createServer((req, res) => {
+  if (req.method === "POST" && req.url === "/slack/commands") {
+    let body = "";
+
+    req.on("data", (chunk) => {
+      body += chunk.toString();
+    });
+
+    req.on("end", async () => {
+      const timestamp = req.headers["x-slack-request-timestamp"] as string;
+      const signature = req.headers["x-slack-signature"] as string;
+      const signingSecret = env.SLACK_SIGNING_SECRET;
+
+      // Verify signature
+      if (signingSecret && (!timestamp || !signature || !verifySlackSignature(timestamp, body, signature, signingSecret))) {
+        logger.error("Slack signature verification failed.");
+        res.writeHead(401, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: "Unauthorized request signature" }));
+        return;
+      }
+
+      try {
+        const parsed = querystring.parse(body);
+
+        const commandStr = parsed.command as string;
+        const textStr = (parsed.text as string) || "";
+        const userIdStr = parsed.user_id as string;
+        const channelIdStr = parsed.channel_id as string;
+
+        logger.info({ command: commandStr, text: textStr, userId: userIdStr }, "📬 Received Slack command");
+
+        const cmd: SlackCommand = {
+          command: commandStr,
+          text: textStr,
+          userId: userIdStr,
+          channelId: channelIdStr,
+        };
+
+        // Call the command handler
+        const replyText = await handleSlackCommand(cmd);
+
+        // Send response back to Slack
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(
+          JSON.stringify({
+            response_type: "in_channel", // Make it visible in the channel
+            text: replyText,
+          })
+        );
+      } catch (err: any) {
+        logger.error({ err }, "Error processing Slack command");
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(
+          JSON.stringify({
+            response_type: "ephemeral",
+            text: `❌ Error executing command: ${err.message || err}`,
+          })
+        );
+      }
+    });
+  } else if (req.method === "POST" && req.url === "/slack/events") {
+    let body = "";
+
+    req.on("data", (chunk) => {
+      body += chunk.toString();
+    });
+
+    req.on("end", async () => {
+      const timestamp = req.headers["x-slack-request-timestamp"] as string;
+      const signature = req.headers["x-slack-signature"] as string;
+      const signingSecret = env.SLACK_SIGNING_SECRET;
+
+      // Verify signature
+      if (signingSecret && (!timestamp || !signature || !verifySlackSignature(timestamp, body, signature, signingSecret))) {
+        logger.error("Slack event signature verification failed.");
+        res.writeHead(401, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: "Unauthorized request signature" }));
+        return;
+      }
+
+      try {
+        const payload = JSON.parse(body);
+
+        // 1. Handle URL Verification Challenge from Slack
+        if (payload.type === "url_verification") {
+          logger.info("Handling Slack URL verification challenge");
+          res.writeHead(200, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ challenge: payload.challenge }));
+          return;
+        }
+
+        // 2. Handle Event Callback
+        if (payload.type === "event_callback") {
+          const event = payload.event;
+          if (event) {
+            // Ignore bot messages to prevent infinite loops
+            const isBot = event.bot_id || event.subtype === "bot_message" || !event.user;
+            if (isBot) {
+              res.writeHead(200);
+              res.end();
+              return;
+            }
+
+            const channelType = event.channel_type;
+            const eventType = event.type;
+
+            // We handle DMs (message.im or channel ID starts with 'D') or direct mentions (app_mention)
+            const isDM = eventType === "message" && (channelType === "im" || event.channel.startsWith("D"));
+            const isMention = eventType === "app_mention";
+
+            if (isDM || isMention) {
+              let text = event.text || "";
+
+              // Strip bot tag if it's a mention
+              if (isMention) {
+                text = text.replace(/<@U[A-Z0-9]+>/g, "").trim();
+              }
+
+              const userId = event.user;
+              const channelId = event.channel;
+              const threadTs = event.thread_ts || event.ts;
+
+              logger.info(
+                { eventType, channelId, userId, text },
+                "💬 Received natural language chatbot event"
+              );
+
+              // Respond HTTP 200 OK to Slack immediately to prevent retries (timeout threshold is 3s)
+              res.writeHead(200);
+              res.end();
+
+              // Route to natural language agent in background
+              const { handleSlackChat } = await import("./slack/slack-agent");
+              handleSlackChat(text, userId, channelId, threadTs).catch((err) => {
+                logger.error({ err }, "Error in handleSlackChat background worker");
+              });
+              return;
+            }
+          }
+        }
+
+        // Default response for unhandled events
+        res.writeHead(200);
+        res.end();
+      } catch (err: any) {
+        logger.error({ err }, "Error processing Slack event");
+        res.writeHead(500, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: err.message || err }));
+      }
+    });
+  } else {
+    // Healthcheck or default route
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ status: "healthy", service: "slack-command-listener" }));
+  }
+});
+
+server.listen(PORT, "0.0.0.0", () => {
+  logger.info(`🔌 Slack Command Listener server running on port ${PORT}`);
+});

src/profiling/python-service/Dockerfile.python

@@ -0,0 +1,7 @@
+FROM python:3.11-slim
+WORKDIR /app
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+COPY . .
+EXPOSE 8000
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]

src/profiling/python-service/config.py

@@ -21,5 +21,6 @@ class Settings(BaseSettings):
 
     class Config:
         env_file = "../../../.env"
+        extra = "ignore"
 
 settings = Settings()

src/profiling/python-service/main.py

@@ -145,4 +145,4 @@ async def profile_company(request: ProfileRequest, _auth: bool = Depends(verify_
 
 if __name__ == "__main__":
     import uvicorn
-    uvicorn.run("main:app", host="0.0.0.0", port=8000, reload=True)
+    uvicorn.run("main:app", host="0.0.0.0", port=8000, reload=False)

src/profiling/python-service/nvidia_client.py

@@ -229,10 +229,15 @@ def _safe_parse_json(text: str) -> Optional[dict]:
 
 async def _log_trace(trace_id, operation, model, result, success, company_id):
     try:
-        from supabase import create_client
-        sb = create_client(settings.SUPABASE_URL, settings.SUPABASE_SERVICE_ROLE_KEY)
-        
-        sb.table("llm_traces").insert({
+        import httpx
+        url = f"{settings.SUPABASE_URL}/rest/v1/llm_traces"
+        headers = {
+            "apikey": settings.SUPABASE_SERVICE_ROLE_KEY,
+            "Authorization": f"Bearer {settings.SUPABASE_SERVICE_ROLE_KEY}",
+            "Content-Type": "application/json",
+            "Prefer": "return=minimal"
+        }
+        payload = {
             "trace_id": trace_id,
             "operation": operation,
             "model": model,
@@ -244,7 +249,9 @@ async def _log_trace(trace_id, operation, model, result, success, company_id):
             "success": success,
             "fallback_used": result.get("fallback_used", True) if result else True,
             "company_id": company_id,
-        }).execute()
+        }
+        async with httpx.AsyncClient() as client:
+            await client.post(url, json=payload, headers=headers)
     except Exception as e:
         logger.debug(f"Trace log failed (non-critical): {e}")
 

src/profiling/python-service/profiler.py

@@ -10,7 +10,7 @@ Key differences from v1:
 """
 
 import logging
-from nvidia_client import call_with_consistency, MODELS
+from nvidia_client import call_with_consistency
 from hallucination_guard import validate_profile_grounded
 
 logger = logging.getLogger(__name__)

src/profiling/python-service/requirements.txt

@@ -1,8 +1,7 @@
-fastapi==0.111.0
-uvicorn[standard]==0.30.0
-httpx==0.27.0
-pydantic==2.7.0
-pydantic-settings==2.2.0
-python-dotenv==1.0.1
-openai==1.30.0
-supabase==2.4.0
+fastapi
+uvicorn[standard]
+httpx
+pydantic
+pydantic-settings
+python-dotenv
+openai

src/profiling/python-service/scorer.py

@@ -12,7 +12,7 @@ So: LLM extracts signals, code does math.
 """
 
 import logging
-from nvidia_client import call_llm, MODELS
+from nvidia_client import call_llm
 
 logger = logging.getLogger(__name__)
 
@@ -113,7 +113,7 @@ async def _extract_signals(data, profile, contacts, trace_id) -> dict:
             operation="score",
             system_prompt=SYSTEM_PROMPT,
             user_prompt=prompt,
-            model=MODELS["FAST"],  # 8B model — signal extraction is simple
+            model_index=2,  # 8B model — signal extraction is simple
             temperature=0.1,
             max_tokens=400,
             json_mode=True,

src/profiling/trigger-tasks/profiling-router.ts

@@ -23,38 +23,96 @@ export const profilingTask = task({
     logger.info({ company_id, domain }, "🧠 Profiling started");
 
     try {
-      // ── Call Python AI Service ──────────────────────────────
+      // 1. Fetch company data from Supabase
+      const { data: company, error: companyErr } = await db
+        .from("companies")
+        .select("*")
+        .eq("id", company_id)
+        .single();
+
+      if (companyErr || !company) {
+        throw new Error(`Company not found: ${companyErr?.message}`);
+      }
+
+      // 2. Fetch contacts from Supabase
+      const { data: contacts, error: contactsErr } = await db
+        .from("contacts")
+        .select("*")
+        .eq("company_id", company_id);
+
+      if (contactsErr) {
+        throw new Error(`Failed to fetch contacts: ${contactsErr.message}`);
+      }
+
+      // 3. Structure payload and call Python AI Service
       const response = await axios.post(
         `${env.PYTHON_AI_SERVICE_URL}/profile`,
-        { company_id, domain, name, region, source },
+        {
+          company: {
+            id: company.id,
+            name: company.name,
+            industry: company.industry || "",
+            employee_count: company.employee_count,
+            description: company.description || "",
+            website_text: company.description || "", // Using description as website excerpt fallback
+            linkedin_description: "",
+            tech_stack: company.tech_stack || [],
+            ai_job_count: (company.growth_signals || []).filter((s: any) => s.type === "job_post").length,
+            pain_signals: company.pain_signals || [],
+            service_match: company.service_match,
+          },
+          contacts: (contacts || []).map((c: any) => ({
+            full_name: c.full_name,
+            email: c.email,
+            email_verified: c.email_verified,
+            linkedin_personal_url: c.linkedin_personal_url || c.linkedin_url,
+            social_profiles: c.social_profiles || {},
+          })),
+          trace_id: company.trace_id || `trace-${company_id.slice(0, 8)}`,
+        },
         {
           headers: {
             "Content-Type": "application/json",
-            "x-service-secret": env.PYTHON_AI_SERVICE_SECRET,
+            "Authorization": `Bearer ${env.PYTHON_AI_SERVICE_SECRET}`,
           },
           timeout: 120_000, // 2 min timeout for LLM
         }
       );
 
-      const result = response.data;
+      const { profile, score, validation, meta } = response.data;
+      const totalScore = score?.total_score ?? 0;
+      const tier = score?.tier ?? "archive";
+      const needs_human_review = !(validation?.score_valid ?? true);
+
       logger.info(
-        { company_id, score: result.total_score, tier: result.tier },
+        { company_id, score: totalScore, tier },
         "✅ Profiling complete"
       );
 
+      // Save profile and score in DB
+      await db.from("lead_profiles").upsert({
+        company_id,
+        ...profile,
+      }, { onConflict: "company_id" });
+
+      await db.from("lead_scores").upsert({
+        company_id,
+        ...score,
+      }, { onConflict: "company_id" });
+
       // ── Route based on score tier ───────────────────────────
-      await routeByTier(company_id, result, db, env);
+      await routeByTier(company_id, { total_score: totalScore, tier, needs_human_review }, db, env);
 
       // ── Audit log ───────────────────────────────────────────
       auditLog("lead_profiled", "company", {
         company_id,
         domain,
-        score: result.total_score,
-        tier: result.tier,
-        is_fallback: result.is_fallback,
+        score: totalScore,
+        tier,
+        is_fallback: meta?.is_fallback ?? false,
       });
 
-      return result;
+      return response.data;
     } catch (err: unknown) {
       // ── Python service unavailable → fallback ───────────────
       if (axios.isAxiosError(err) && !err.response) {
@@ -146,12 +204,15 @@ async function notifySlack(
 
     const channelId = type === "review" ? env.SLACK_REVIEW_CHANNEL_ID : env.SLACK_ALERT_CHANNEL_ID;
 
-    await axios.post("https://slack.com/api/chat.postMessage", {
+    const res = await axios.post("https://slack.com/api/chat.postMessage", {
       channel: channelId,
       ...message,
     }, {
       headers: { Authorization: `Bearer ${env.SLACK_BOT_TOKEN}` },
     });
+    if (res.data && res.data.ok === false) {
+      logger.warn({ error: res.data.error }, "Slack API responded with error. Make sure to invite the bot to the channel!");
+    }
   } catch (err) {
     logger.warn({ err }, "Slack notification failed — non-critical");
   }

src/shared/supabase/client.ts

@@ -8,7 +8,6 @@ export function getSupabaseClient() {
     const env = getEnv();
     _client = createClient(env.SUPABASE_URL, env.SUPABASE_SERVICE_ROLE_KEY, {
       auth: { persistSession: false },
-      db: { schema: "public" },
     });
   }
   return _client;

src/slack/slack-agent.ts

@@ -0,0 +1,319 @@
+import { callLLM, MODELS } from "../shared/llm/nvidia-client";
+import { getSupabaseClient } from "../shared/supabase/client";
+import { manualDiscoveryTask } from "../discovery/trigger-tasks/manual-discovery";
+import { logger } from "../shared/utils/logger";
+import axios from "axios";
+import { getEnv } from "../shared/config/env";
+
+const env = getEnv();
+
+// Helper to post messages back to Slack
+async function replyToSlack(channelId: string, text: string, threadTs?: string): Promise<void> {
+  try {
+    await axios.post(
+      "https://slack.com/api/chat.postMessage",
+      {
+        channel: channelId,
+        text,
+        thread_ts: threadTs,
+      },
+      {
+        headers: { Authorization: `Bearer ${env.SLACK_BOT_TOKEN}` },
+        timeout: 5000,
+      }
+    );
+  } catch (err) {
+    logger.error({ err }, "Failed to reply to Slack");
+  }
+}
+
+// ─── Intent System Prompt ──────────────────────────────────────
+
+const AGENT_SYSTEM_PROMPT = `You are "Lead Finder AI", an intelligent Slack Chatbot assistant.
+Your job is to parse the user's natural language request (in English, Urdu, or Roman Urdu) and map it to a structured action.
+
+You must respond ONLY with a valid JSON object matching this schema:
+{
+  "intent": "discover" | "leads" | "lead_detail" | "status" | "pause" | "resume" | "quota" | "chat",
+  "params": {
+    "region": "US" | "UK" | "AU" | "UAE" | "SA" | "SG" (optional),
+    "industry": string (optional),
+    "maxCompanies": number (optional),
+    "companyName": string (optional),
+    "quotaAmount": number (optional),
+    "quotaPermanent": boolean (optional)
+  },
+  "explanation": "A very brief, friendly sentence in Roman Urdu explaining what you understood and what you are doing (e.g. 'Ji bilkul! Main abhi US ke dental leads dhoondta hoon.' or 'Bilkul, ye rahi aaj ki leads summary:')"
+}
+
+Intents mapping rules:
+1. "discover": Manual trigger of search/enrichment/scoring.
+   - Example: "aj US me SaaS leads dhoondo", "manual run UK dental", "dental leads US", "UK clinical leads nikal do", "discover dental UAE"
+   - Default region to US if not specified. Default maxCompanies to 10 if not specified.
+2. "leads": Today's qualified leads list.
+   - Example: "aj ki leads dikhao", "show today's leads", "aj kya mila?", "today leads summary", "leads"
+3. "lead_detail": Profile/score details about a specific company.
+   - Example: "clickup ki details do", "show lead clickup", "clickup ka batao", "lead detail of Google"
+   - Extract company name into companyName.
+4. "status": System config status (quota, pause/run mode, coordinates).
+   - Example: "status batao", "system kaisa chal raha?", "running status", "check status"
+5. "pause": Pauses automatic CRON daily runs.
+   - Example: "pause system", "automatic run rok do", "pause auto mode", "stop runs"
+6. "resume": Resumes automatic CRON daily runs.
+   - Example: "resume system", "auto runs start kar do", "resume run"
+7. "quota": Changes daily lead quota.
+   - Example: "quota 15 kar do", "set today's quota to 20", "set permanent quota to 50"
+   - Extract quotaAmount and quotaPermanent.
+8. "chat": General greetings, small talk, questions about how you work, or how to use you.
+   - Example: "hello", "hi", "tum kon ho?", "how do you work?", "help me"
+
+Respond ONLY with raw JSON. Do not include markdown code block syntax or explanation outside JSON.`;
+
+// ─── Main Chatbot handler ──────────────────────────────────────
+
+export async function handleSlackChat(
+  userText: string,
+  userId: string,
+  channelId: string,
+  threadTs?: string
+): Promise<void> {
+  const cleanText = userText.trim();
+  logger.info({ userId, cleanText }, "🤖 AI Chatbot processing message");
+
+  // Call the LLM to parse the intent
+  const llmRes = await callLLM({
+    operation: "slack_intent_classification",
+    modelIndex: MODELS.LLAMA_70B, // Use LLaMA 70B for highly accurate intent mapping
+    systemPrompt: AGENT_SYSTEM_PROMPT,
+    userPrompt: cleanText,
+    jsonMode: true,
+    traceId: `slack-chat-${Date.now()}`,
+  });
+
+  if (!llmRes.parsed) {
+    await replyToSlack(
+      channelId,
+      "Maaf kijiye ga, mujhe aap ki baat samajh nahi aayi. Kya aap dobara keh sakte hain? (Greetings, /discover, /leads waghaira ke liye pooch sakte hain)",
+      threadTs
+    );
+    return;
+  }
+
+  const { intent, params, explanation } = llmRes.parsed as {
+    intent: string;
+    params: any;
+    explanation: string;
+  };
+
+  logger.info({ intent, params }, "🎯 Decoded intent");
+
+  // Respond with explanation first so user knows we are on it
+  if (explanation && intent !== "chat") {
+    await replyToSlack(channelId, `💬 *Lead Finder AI:* ${explanation}`, threadTs);
+  }
+
+  const db = getSupabaseClient();
+
+  try {
+    switch (intent) {
+      case "discover": {
+        const region = params?.region || "US";
+        const industry = params?.industry || "SaaS";
+        const maxCompanies = params?.maxCompanies || 10;
+
+        await manualDiscoveryTask.trigger({
+          region: region.toUpperCase(),
+          industry,
+          maxCompanies,
+          triggeredBy: `slack-chat:${userId}`,
+        });
+
+        await replyToSlack(
+          channelId,
+          `🚀 **Manual Discovery Triggered!**\n• *Region:* ${region.toUpperCase()}\n• *Industry:* ${industry}\n• *Max Leads:* ${maxCompanies}\n\nJaise hi leads ready honge, main isi channel me card deliver kar dunga!`,
+          threadTs
+        );
+        break;
+      }
+
+      case "leads": {
+        const today = new Date();
+        today.setHours(0, 0, 0, 0);
+
+        const { data: leads } = await db
+          .from("lead_scores")
+          .select(`
+            total_score, tier,
+            companies (name, domain, industry, city, service_match),
+            contacts (full_name, email, email_verified, linkedin_personal_url)
+          `)
+          .gte("created_at", today.toISOString())
+          .order("total_score", { ascending: false });
+
+        if (!leads?.length) {
+          await replyToSlack(channelId, "📋 Aaj ke din abhi tak koi leads qualified nahi huin.", threadTs);
+          break;
+        }
+
+        const lines = leads.map((l: any, i: number) => {
+          const emoji = l.tier === "hot" ? "🔥" : l.tier === "warm" ? "✅" : "📋";
+          const email = l.contacts?.email_verified ? "📧✓" : l.contacts?.email ? "📧" : "—";
+          const li = l.contacts?.linkedin_personal_url ? "💼" : "—";
+          return `${emoji} *${l.total_score}* | *${l.companies?.name ?? "?"}* | ${l.companies?.industry ?? "?"} | ${l.companies?.city ?? "?"} | ${email} ${li}`;
+        });
+
+        const reply = `*Today's Leads Summary (${leads.length}):*\n\n` +
+          `Score | Company | Industry | City | Channels\n` +
+          `─`.repeat(40) + `\n` +
+          lines.join("\n") +
+          `\n\nAap kisi bhi company ki details pooch sakte hain (e.g. "ClickUp ki details do").`;
+
+        await replyToSlack(channelId, reply, threadTs);
+        break;
+      }
+
+      case "lead_detail": {
+        const companySearch = params?.companyName || "";
+        if (!companySearch) {
+          await replyToSlack(channelId, "Mujhe company ka naam batayein taake main detail nikal sakoon.", threadTs);
+          break;
+        }
+
+        const { data: companies } = await db
+          .from("companies")
+          .select("*")
+          .ilike("name", `%${companySearch.trim()}%`)
+          .limit(1);
+
+        if (!companies?.length) {
+          await replyToSlack(channelId, `❌ Mujhe "${companySearch}" naam ki koi company database me nahi mili.`, threadTs);
+          break;
+        }
+
+        const company = companies[0];
+        const { data: contacts } = await db.from("contacts").select("*").eq("company_id", company.id);
+        const { data: scores } = await db.from("lead_scores").select("*").eq("company_id", company.id).limit(1);
+        const { data: profiles } = await db.from("lead_profiles").select("*").eq("company_id", company.id).limit(1);
+
+        const score = scores?.[0];
+        const profile = profiles?.[0];
+        const contact = contacts?.[0];
+
+        const channels: string[] = [];
+        if (contact?.email) channels.push(`📧 ${contact.email} ${contact.email_verified ? "✓" : "(unverified)"}`);
+        if (contact?.linkedin_personal_url) channels.push(`💼 <${contact.linkedin_personal_url}|LinkedIn>`);
+
+        const responseText = `*🏢 ${company.name}* (Domain: ${company.domain})\n` +
+          `• *Location:* ${company.city ?? "?"}, ${company.country ?? "?"}\n` +
+          `• *Industry:* ${company.industry ?? "?"} · *Employees:* ${company.employee_count ?? "?"}\n` +
+          `• *Service Match:* ${company.service_match ?? "—"}\n\n` +
+          `*📊 AI Scoring: ${score?.total_score ?? "?"}/100 — ${score?.tier?.toUpperCase() ?? "?"}*\n` +
+          `  - Fit: ${score?.company_fit ?? "?"}/25 · AI Readiness: ${score?.ai_readiness ?? "?"}/20\n` +
+          `  - Service Fit: ${score?.service_match_score ?? "?"}/20 · Contact: ${score?.decision_maker ?? "?"}/20\n\n` +
+          `*🧠 Profile Summary:*\n_${profile?.profile_summary ?? "No profile summary available."}_\n\n` +
+          `*🎯 Personalized Outreach Angle:*\n_"${profile?.outreach_angle ?? "—"}"_\n\n` +
+          `*👤 Decision Maker:* ${contact?.full_name ?? "?"} (${contact?.title ?? "?"})\n` +
+          `  - Channels: ${channels.join(" | ") || "None found"}`;
+
+        await replyToSlack(channelId, responseText, threadTs);
+        break;
+      }
+
+      case "status": {
+        const { data: autoConfig } = await db.from("system_config").select("value").eq("key", "auto_mode").single();
+        const paused = autoConfig?.value?.paused ?? false;
+
+        const { data: quotaConfig } = await db.from("system_config").select("value").eq("key", "daily_quota").single();
+        const quota = quotaConfig?.value;
+
+        const { data: territory } = await db.from("system_config").select("value").eq("key", "current_territory").single();
+        const pos = territory?.value;
+
+        const { data: todayRuns } = await db
+          .from("discovery_runs")
+          .select("status, leads_qualified")
+          .gte("ran_at", new Date(new Date().setHours(0, 0, 0, 0)).toISOString());
+
+        const todayLeads = todayRuns?.reduce((sum: number, r: any) => sum + (r.leads_qualified ?? 0), 0) ?? 0;
+
+        const reply = `⚙️ **System Status Report**\n` +
+          `• *Auto Runs Status:* ${paused ? "⏸️ PAUSED" : "▶️ RUNNING"}\n` +
+          `• *Daily Quota:* ${(quota as any)?.today_override ?? (quota as any)?.default ?? 10} leads/day\n` +
+          `• *Qualified Today:* ${todayLeads} leads\n` +
+          `• *Active Territory:* ${(pos as any)?.countryCode ?? "?"} city#${(pos as any)?.cityIndex ?? 0}\n` +
+          `• *Runs Executed Today:* ${todayRuns?.length ?? 0}`;
+
+        await replyToSlack(channelId, reply, threadTs);
+        break;
+      }
+
+      case "pause": {
+        await db.from("system_config").update({
+          value: { enabled: true, paused: true, paused_by: "slack-chat" },
+          updated_at: new Date().toISOString(),
+        }).eq("key", "auto_mode");
+
+        await replyToSlack(channelId, "⏸️ **System Paused!** Daily automatic runs ko rok diya gaya hai. Jab tak aap resume nahi karenge, automatic process nahi chale ga.", threadTs);
+        break;
+      }
+
+      case "resume": {
+        await db.from("system_config").update({
+          value: { enabled: true, paused: false, paused_by: null },
+          updated_at: new Date().toISOString(),
+        }).eq("key", "auto_mode");
+
+        await replyToSlack(channelId, "▶️ **System Resumed!** Automatic runs dubara schedule par start ho gayi hain.", threadTs);
+        break;
+      }
+
+      case "quota": {
+        const num = params?.quotaAmount;
+        if (!num || isNaN(num) || num < 1 || num > 100) {
+          await replyToSlack(channelId, "Usage: 'quota 15 kar do' (max 100)", threadTs);
+          break;
+        }
+
+        const permanent = !!params?.quotaPermanent;
+        const key = "daily_quota";
+        const { data: config } = await db.from("system_config").select("value").eq("key", key).single();
+        const val = config?.value || { default: 10, today_override: null };
+
+        if (permanent) {
+          val.default = num;
+          val.today_override = null;
+        } else {
+          val.today_override = num;
+        }
+
+        await db.from("system_config").update({
+          value: val,
+          updated_at: new Date().toISOString()
+        }).eq("key", key);
+
+        await replyToSlack(
+          channelId,
+          permanent
+            ? `✅ **Daily Quota permanently set to ${num} leads/day!**`
+            : `✅ **Today's Quota set to ${num} leads!** Kal automatic default par wapas chala jaye ga.`,
+          threadTs
+        );
+        break;
+      }
+
+      case "chat": {
+        // Chatbot replies using LLM in Roman Urdu directly
+        await replyToSlack(channelId, `💬 ${explanation}`, threadTs);
+        break;
+      }
+
+      default: {
+        await replyToSlack(channelId, "Mujhe aap ka naya command samajh nahi aaya. Kya aap explain kar sakte hain?", threadTs);
+      }
+    }
+    logger.info({ intent }, "🤖 Chatbot action completed successfully");
+  } catch (err: any) {
+    logger.error({ err, intent }, "Error executing Slack AI Chatbot action");
+    await replyToSlack(channelId, `❌ Action fail ho gaya: ${err.message || err}`, threadTs);
+  }
+}

src/slack/slack-commands.ts

@@ -16,10 +16,10 @@
  *   /quota [number] always → permanent change
  */
 
-import { getSupabaseClient } from "../../shared/supabase/client";
-import { setQuotaOverride, isSystemPaused } from "../../discovery/lib/territory-manager";
+import { getSupabaseClient } from "../shared/supabase/client";
+import { setQuotaOverride, isSystemPaused } from "../discovery/lib/territory-manager";
 import { sendClarifyingQuestions } from "./slack-service";
-import { logger } from "../../shared/utils/logger";
+import { logger } from "../shared/utils/logger";
 
 export interface SlackCommand {
   command: string;
@@ -63,7 +63,7 @@ async function handleDiscover(args: string, cmd: SlackCommand): Promise<string>
 
   if (params.region && params.industry) {
     // Direct run — no questions needed
-    const { manualDiscoveryTask } = await import("../../discovery/trigger-tasks/manual-discovery");
+    const { manualDiscoveryTask } = await import("../discovery/trigger-tasks/manual-discovery");
     await manualDiscoveryTask.trigger({
       region: params.region.toUpperCase(),
       industry: params.industry,

src/slack/slack-service.ts

@@ -9,9 +9,9 @@
  */
 
 import axios from "axios";
-import { getEnv } from "../../shared/config/env";
-import { getSupabaseClient } from "../../shared/supabase/client";
-import { logger } from "../../shared/utils/logger";
+import { getEnv } from "../shared/config/env";
+import { getSupabaseClient } from "../shared/supabase/client";
+import { logger } from "../shared/utils/logger";
 
 // ─── Slack API helper ────────────────────────────────────────
 

src/trigger.ts

@@ -3,6 +3,6 @@
  * This file must export all tasks for Trigger.dev to discover them.
  */
 
-export { autoDiscoveryTask, autoDiscoverySchedule } from "./discovery/trigger-tasks/auto-discovery";
+export { dailyScheduler, dailyDigestTask } from "./discovery/trigger-tasks/auto-discovery";
 export { manualDiscoveryTask } from "./discovery/trigger-tasks/manual-discovery";
 export { profilingTask } from "./profiling/trigger-tasks/profiling-router";

trigger.config.ts

@@ -1,7 +1,15 @@
 import type { TriggerConfig } from "@trigger.dev/sdk/v3";
+import dotenv from "dotenv";
+
+// Load environment variables from .env
+dotenv.config();
 
 export const config: TriggerConfig = {
   project: process.env.TRIGGER_DEV_PROJECT_ID!,
+  maxDuration: 3600, // 1 hour max default duration for tasks
+  build: {
+    external: ["playwright", "playwright-core"],
+  },
   retries: {
     enabledInDev: true,
     default: {
@@ -13,3 +21,5 @@ export const config: TriggerConfig = {
   },
   dirs: ["./src/discovery/trigger-tasks"],
 };
+
+