diff --git a/.cursorrules b/.cursorrules
index a59a791ca5..8b1fec999b 100644
--- a/.cursorrules
+++ b/.cursorrules
@@ -145,3 +145,16 @@ const logger = createScopedLogger("Rules");
 
 logger.log("Created rule", { userId });
 ```
+
+- This is how we import Prisma:
+
+```ts
+import prisma from "@/utils/prisma";
+```
+
+- If an import is a type then use `type` to import it:
+
+```ts
+import type { Action } from "@prisma/client";
+import { type Action, GroupItemType } from "@prisma/client";
+```
\ No newline at end of file
diff --git a/apps/web/__tests__/ai-find-snippets.test.ts b/apps/web/__tests__/ai-find-snippets.test.ts
index 5e99b3427e..fffd8d93ce 100644
--- a/apps/web/__tests__/ai-find-snippets.test.ts
+++ b/apps/web/__tests__/ai-find-snippets.test.ts
@@ -1,7 +1,6 @@
 import { describe, expect, test, vi } from "vitest";
 import { aiFindSnippets } from "@/utils/ai/snippets/find-snippets";
-import type { EmailForLLM } from "@/utils/ai/choose-rule/stringify-email";
-
+import type { EmailForLLM } from "@/utils/types";
 // pnpm test-ai ai-find-snippets
 
 const isAiTest = process.env.RUN_AI_TESTS === "true";
diff --git a/apps/web/__tests__/ai-process-user-request.test.ts b/apps/web/__tests__/ai-process-user-request.test.ts
new file mode 100644
index 0000000000..cf1eed9d58
--- /dev/null
+++ b/apps/web/__tests__/ai-process-user-request.test.ts
@@ -0,0 +1,536 @@
+import { describe, expect, test, vi } from "vitest";
+import stripIndent from "strip-indent";
+import { processUserRequest } from "@/utils/ai/assistant/process-user-request";
+import type { ParsedMessage, ParsedMessageHeaders } from "@/utils/types";
+import type { RuleWithRelations } from "@/utils/ai/rule/create-prompt-from-rule";
+import {
+  type Category,
+  type GroupItem,
+  type Prisma,
+  RuleType,
+} from "@prisma/client";
+import { GroupItemType, LogicalOperator } from "@prisma/client";
+
+// pnpm test-ai ai-process-user-request
+
+const isAiTest = process.env.RUN_AI_TESTS === "true";
+
+vi.mock("server-only", () => ({}));
+vi.mock("@/utils/gmail/mail", () => ({ replyToEmail: vi.fn() }));
+
+describe(
+  "processUserRequest",
+  {
+    timeout: 30_000,
+    skip: !isAiTest,
+  },
+  () => {
+    test("should fix a rule with incorrect AI instructions", async () => {
+      const rule = getRule({
+        name: "Partnership Rule",
+        instructions: "Match emails discussing business opportunities",
+      });
+
+      const originalEmail = getParsedMessage({
+        headers: {
+          from: "sales@company.com",
+          subject: "Special Offer for Your Business",
+        },
+        textPlain: stripIndent(`
+        Hi there,
+
+        We have an amazing product that could boost your revenue by 300%.
+        Special discount available this week only!
+
+        Let me know if you'd like a demo.
+
+        Best,
+        Sales Team
+      `),
+      });
+
+      const result = await processUserRequest({
+        user: getUser(),
+        rules: [rule],
+        messages: [
+          {
+            role: "user",
+            content: "This is a promotional email",
+          },
+        ],
+        originalEmail,
+        matchedRule: rule,
+        categories: null,
+        senderCategory: null,
+      });
+
+      expect(result).toBeDefined();
+
+      const toolCalls = result.steps.flatMap((step) => step.toolCalls);
+      const updateInstructionsToolCall = toolCalls.find(
+        (toolCall) => toolCall.toolName === "update_ai_instructions",
+      );
+
+      expect(updateInstructionsToolCall).toBeDefined();
+      expect(updateInstructionsToolCall?.args.ruleName).toBe(
+        "Partnership Rule",
+      );
+    });
+
+    test("should handle request to refine ai rule instructions", async () => {
+      const ruleSupport = getRule({
+        name: "Support Rule",
+        instructions: "Match technical support requests",
+      });
+      const ruleUrgent = getRule({
+        name: "Urgent Rule",
+        instructions: "Match urgent requests",
+      });
+
+      const originalEmail = getParsedMessage({
+        headers: {
+          from: "user@test.com",
+          subject: "Help with Login",
+        },
+        textPlain: stripIndent(`
+        Hello,
+
+        I can't log into my account. Can someone help?
+
+        Thanks,
+        User
+      `),
+      });
+
+      const result = await processUserRequest({
+        user: getUser(),
+        rules: [ruleSupport, ruleUrgent],
+        messages: [
+          {
+            role: "user",
+            content: "This isn't urgent.",
+          },
+        ],
+        originalEmail,
+        matchedRule: ruleUrgent,
+        categories: null,
+        senderCategory: null,
+      });
+
+      expect(result).toBeDefined();
+
+      const toolCalls = result.steps.flatMap((step) => step.toolCalls);
+
+      const toolCall = toolCalls.find(
+        (toolCall) => toolCall.toolName === "update_ai_instructions",
+      );
+
+      expect(toolCall).toBeDefined();
+    });
+
+    test("should fix static conditions when user indicates incorrect matching", async () => {
+      const rule = getRule({
+        name: "Receipt Rule",
+        from: "@amazon.com",
+        subject: "Order",
+      });
+
+      const originalEmail = getParsedMessage({
+        headers: {
+          from: "shipping@amazon.com",
+          subject: "Order #123 Has Shipped",
+        },
+        textPlain: stripIndent(`
+          Your order has shipped!
+          Tracking number: 1234567890
+          Expected delivery: Tomorrow
+        `),
+      });
+
+      const result = await processUserRequest({
+        user: getUser(),
+        rules: [rule],
+        messages: [
+          {
+            role: "user",
+            content: "This isn't a receipt, it's a shipping notification.",
+          },
+        ],
+        originalEmail,
+        matchedRule: rule,
+        categories: null,
+        senderCategory: null,
+      });
+
+      const toolCalls = result.steps.flatMap((step) => step.toolCalls);
+      const updateStaticConditionsToolCall = toolCalls.find(
+        (toolCall) => toolCall.toolName === "update_static_conditions",
+      );
+
+      expect(updateStaticConditionsToolCall).toBeDefined();
+      expect(updateStaticConditionsToolCall?.args.ruleName).toBe(
+        "Receipt Rule",
+      );
+      expect(
+        updateStaticConditionsToolCall?.args.staticConditions?.subject?.includes(
+          "shipping",
+        ) ||
+          updateStaticConditionsToolCall?.args.staticConditions?.subject?.includes(
+            "Shipped",
+          ),
+      ).toBe(true);
+    });
+
+    test("should fix group conditions when user reports incorrect matching", async () => {
+      const group = getGroup({
+        name: "Newsletters",
+        items: [
+          getGroupItem({
+            id: "1",
+            type: GroupItemType.FROM,
+            value: "david@hello.com",
+          }),
+          getGroupItem({
+            id: "2",
+            type: GroupItemType.FROM,
+            value: "@beehiiv.com",
+          }),
+        ],
+      });
+
+      const rule = getRule({
+        name: "Newsletter Rule",
+        group,
+      });
+
+      const originalEmail = getParsedMessage({
+        headers: {
+          from: "david@hello.com",
+          subject: "Question about your latest post",
+        },
+        textPlain: stripIndent(`
+          Hey there,
+
+          Thanks for reaching out about my article on microservices. You raised some 
+          really interesting points about the scalability challenges you're facing.
+
+          I actually dealt with a similar issue at my previous company. Would love to 
+          hop on a quick call to discuss it in more detail.
+
+          Best,
+          David
+        `),
+      });
+
+      const result = await processUserRequest({
+        user: getUser(),
+        rules: [rule],
+        messages: [
+          {
+            role: "user",
+            content: "This isn't a newsletter",
+          },
+        ],
+        originalEmail,
+        matchedRule: rule,
+        categories: null,
+        senderCategory: null,
+      });
+
+      const toolCalls = result.steps.flatMap((step) => step.toolCalls);
+      const removeFromGroupToolCall = toolCalls.find(
+        (toolCall) => toolCall.toolName === "remove_from_group",
+      );
+
+      expect(removeFromGroupToolCall).toBeDefined();
+      expect(removeFromGroupToolCall?.args.value).toBe("david@hello.com");
+    });
+
+    test("should suggest adding sender to group when identified as missing", async () => {
+      const group = getGroup({
+        name: "Newsletters",
+        items: [
+          getGroupItem({
+            type: GroupItemType.FROM,
+            value: "ainewsletter@substack.com",
+          }),
+          getGroupItem({
+            type: GroupItemType.FROM,
+            value: "milkroad@beehiiv.com",
+          }),
+        ],
+      });
+
+      const rule = getRule({
+        name: "Newsletter Rule",
+        group,
+      });
+
+      const originalEmail = getParsedMessage({
+        headers: {
+          from: "mattsnews@convertkit.com",
+          to: "me@ourcompany.com",
+          subject: "Weekly Developer Digest",
+        },
+        textPlain: stripIndent(`
+          This Week's Top Stories:
+          
+          1. The Future of TypeScript
+          2. React Server Components Deep Dive
+          3. Building Scalable Systems
+          
+          To unsubscribe, click here
+          Powered by ConvertKit
+        `),
+      });
+
+      const result = await processUserRequest({
+        user: getUser(),
+        rules: [rule],
+        messages: [
+          {
+            role: "user",
+            content: "This is a newsletter",
+          },
+        ],
+        originalEmail,
+        matchedRule: null, // Important: rule didn't match initially
+        categories: null,
+        senderCategory: null,
+      });
+
+      const toolCalls = result.steps.flatMap((step) => step.toolCalls);
+      const addToGroupToolCall = toolCalls.find(
+        (toolCall) => toolCall.toolName === "add_to_group",
+      );
+
+      expect(addToGroupToolCall).toBeDefined();
+      expect(addToGroupToolCall?.args.type).toBe("from");
+      expect(addToGroupToolCall?.args.value).toContain("convertkit.com");
+    });
+
+    test("should fix category filters when user indicates wrong categorization", async () => {
+      const marketingCategory = getCategory({
+        name: "Marketing",
+        description: "Marketing related emails",
+      });
+
+      const rule = getRule({
+        name: "Marketing Rule",
+        categoryFilterType: "INCLUDE",
+        categoryFilters: [marketingCategory],
+      });
+
+      const originalEmail = getParsedMessage({
+        headers: {
+          from: "marketing@company.com",
+          subject: "Special Offer",
+        },
+        textPlain: "Would you like to purchase our enterprise plan?",
+      });
+
+      const result = await processUserRequest({
+        user: getUser(),
+        rules: [rule],
+        messages: [
+          {
+            role: "user",
+            content: "This is actually a sales email, not marketing.",
+          },
+        ],
+        originalEmail,
+        matchedRule: rule,
+        categories: [
+          { id: "1", name: "Marketing" },
+          { id: "2", name: "Sales" },
+          { id: "3", name: "Newsletter" },
+        ],
+        senderCategory: "Marketing",
+      });
+
+      const toolCalls = result.steps.flatMap((step) => step.toolCalls);
+      const changeSenderCategoryToolCall = toolCalls.find(
+        (toolCall) => toolCall.toolName === "change_sender_category",
+      );
+
+      expect(changeSenderCategoryToolCall).toBeDefined();
+      expect(changeSenderCategoryToolCall?.args.category).toBe("Sales");
+    });
+
+    test("should handle complex rule fixes with multiple condition types", async () => {
+      const salesCategory = getCategory({
+        name: "Sales",
+        description: "Sales related emails",
+      });
+
+      const rule = getRule({
+        name: "Sales Rule",
+        instructions: "Match sales opportunities",
+        from: "@enterprise.com",
+        subject: "Business opportunity",
+        categoryFilters: [salesCategory],
+        categoryFilterType: "INCLUDE",
+      });
+
+      const originalEmail = getParsedMessage({
+        headers: {
+          from: "contact@enterprise.com",
+          subject: "Business opportunity - Act now!",
+        },
+        textPlain: "Make millions with this amazing opportunity!",
+      });
+
+      const result = await processUserRequest({
+        user: getUser(),
+        rules: [rule],
+        messages: [
+          {
+            role: "user",
+            content:
+              "This is a spam email pretending to be a business opportunity.",
+          },
+        ],
+        originalEmail,
+        matchedRule: rule,
+        categories: [
+          { id: "1", name: "Marketing" },
+          { id: "2", name: "Sales" },
+          { id: "3", name: "Newsletter" },
+        ],
+        senderCategory: "Marketing",
+      });
+
+      const toolCalls = result.steps.flatMap((step) => step.toolCalls);
+
+      const updateStaticConditionsToolCall = toolCalls.find(
+        (toolCall) => toolCall.toolName === "update_static_conditions",
+      );
+      const updateAiInstructionsToolCall = toolCalls.find(
+        (toolCall) => toolCall.toolName === "update_ai_instructions",
+      );
+
+      expect(
+        updateStaticConditionsToolCall || updateAiInstructionsToolCall,
+      ).toBeDefined();
+      if (updateStaticConditionsToolCall) {
+        expect(updateStaticConditionsToolCall.args.ruleName).toBe("Sales Rule");
+      }
+      if (updateAiInstructionsToolCall) {
+        expect(updateAiInstructionsToolCall.args.ruleName).toBe("Sales Rule");
+      }
+    });
+  },
+);
+
+function getRule(rule: Partial<RuleWithRelations>): RuleWithRelations {
+  return {
+    id: "1",
+    userId: "user1",
+    name: "Rule name",
+
+    conditionalOperator: LogicalOperator.AND,
+    // ai instructions
+    instructions: null,
+    // static conditions
+    from: null,
+    to: null,
+    subject: null,
+    body: null,
+    // group conditions
+    group: null,
+    groupId: null,
+    // category conditions
+    categoryFilters: [],
+    categoryFilterType: null,
+
+    // other
+    actions: [],
+    automate: true,
+    runOnThreads: true,
+    enabled: true,
+    type: RuleType.AI,
+    createdAt: new Date(),
+    updatedAt: new Date(),
+    ...rule,
+  };
+}
+
+function getParsedMessage(
+  message: Omit<Partial<ParsedMessage>, "headers"> & {
+    headers?: Partial<ParsedMessageHeaders>;
+  },
+): ParsedMessage {
+  return {
+    id: "id",
+    threadId: "thread-id",
+    snippet: "",
+    attachments: [],
+    historyId: "history-id",
+    sizeEstimate: 100,
+    internalDate: new Date().toISOString(),
+    inline: [],
+    textPlain: "",
+    ...message,
+    headers: {
+      from: "test@example.com",
+      to: "recipient@example.com",
+      subject: "",
+      date: new Date().toISOString(),
+      references: "",
+      "message-id": "message-id",
+      ...message.headers,
+    },
+  };
+}
+
+function getUser() {
+  return {
+    id: "user1",
+    aiModel: null,
+    aiProvider: null,
+    email: "user@test.com",
+    aiApiKey: null,
+    about: null,
+  };
+}
+
+type Group = Prisma.GroupGetPayload<{
+  select: {
+    id: true;
+    name: true;
+    items: { select: { id: true; type: true; value: true } };
+  };
+}>;
+
+function getGroup(group: Partial<Group>): Group {
+  return {
+    id: "id",
+    name: "Group name",
+    items: [],
+    ...group,
+  };
+}
+
+function getGroupItem(item: Partial<GroupItem>): GroupItem {
+  return {
+    id: "id",
+    value: "",
+    type: GroupItemType.FROM,
+    createdAt: new Date(),
+    updatedAt: new Date(),
+    groupId: "group1",
+    ...item,
+  };
+}
+
+function getCategory(category: Partial<Category>): Category {
+  return {
+    id: "id",
+    name: "",
+    description: null,
+    createdAt: new Date(),
+    updatedAt: new Date(),
+    userId: "user1",
+    ...category,
+  };
+}
diff --git a/apps/web/__tests__/ai-rule-fix.test.ts b/apps/web/__tests__/ai-rule-fix.test.ts
index 3ffe4ec43b..f9aa4d8c0c 100644
--- a/apps/web/__tests__/ai-rule-fix.test.ts
+++ b/apps/web/__tests__/ai-rule-fix.test.ts
@@ -1,7 +1,7 @@
 import { describe, expect, test, vi } from "vitest";
 import stripIndent from "strip-indent";
 import { aiRuleFix } from "@/utils/ai/rule/rule-fix";
-import type { EmailForLLM } from "@/utils/ai/choose-rule/stringify-email";
+import type { EmailForLLM } from "@/utils/types";
 
 // pnpm test-ai ai-rule-fix
 
@@ -41,7 +41,7 @@ describe.skipIf(!isAiTest)("aiRuleFix", () => {
     console.log(result);
 
     expect(result).toBeDefined();
-    expect(result.rule).toBe("actual_rule");
+    expect(result.ruleToFix).toBe("actual_rule");
     expect(result.fixedInstructions).toContain("sales");
     expect(result.fixedInstructions).not.toBe(rule.instructions);
     // The new instructions should be more specific to exclude sales pitches
@@ -81,7 +81,7 @@ describe.skipIf(!isAiTest)("aiRuleFix", () => {
     console.log(result);
 
     expect(result).toBeDefined();
-    expect(result.rule).toBe("correct_rule");
+    expect(result.ruleToFix).toBe("expected_rule");
     expect(result.fixedInstructions).toContain("technical");
     // The incorrect rule should be more specific to exclude feature requests
     expect(result.fixedInstructions.toLowerCase()).toMatch(
@@ -117,7 +117,7 @@ describe.skipIf(!isAiTest)("aiRuleFix", () => {
     console.log(result);
 
     expect(result).toBeDefined();
-    expect(result.rule).toBe("actual_rule");
+    expect(result.ruleToFix).toBe("actual_rule");
     expect(result.fixedInstructions).toContain("collaboration");
     // The fixed rule should exclude newsletters and automated updates
     expect(result.fixedInstructions.toLowerCase()).toMatch(
@@ -153,7 +153,7 @@ describe.skipIf(!isAiTest)("aiRuleFix", () => {
     console.log(result);
 
     expect(result).toBeDefined();
-    expect(result.rule).toBe("correct_rule");
+    expect(result.ruleToFix).toBe("expected_rule");
     expect(result.fixedInstructions).toContain("pric");
     // The fixed rule should be more inclusive of various pricing inquiries
     expect(result.fixedInstructions.toLowerCase()).toMatch(
diff --git a/apps/web/app/(app)/automation/ReportMistake.tsx b/apps/web/app/(app)/automation/ReportMistake.tsx
index fcd2e82f34..76badf219e 100644
--- a/apps/web/app/(app)/automation/ReportMistake.tsx
+++ b/apps/web/app/(app)/automation/ReportMistake.tsx
@@ -388,7 +388,6 @@ function RuleMismatch({
   rules: RulesResponse;
   onSelectExpectedRuleId: (ruleId: string | null) => void;
 }) {
-  console.log("🚀 ~ result:", result);
   return (
     <div>
       <Label name="matchedRule" label="Matched:" />
@@ -949,7 +948,6 @@ function RerunButton({
 }) {
   const [checking, setChecking] = useState(false);
   const [result, setResult] = useState<RunRulesResult>();
-  console.log("🚀 ~ result:", result);
 
   return (
     <>
diff --git a/apps/web/app/(app)/automation/create/page.tsx b/apps/web/app/(app)/automation/create/page.tsx
index ff1cfe0e38..b4bf59e8e1 100644
--- a/apps/web/app/(app)/automation/create/page.tsx
+++ b/apps/web/app/(app)/automation/create/page.tsx
@@ -20,6 +20,7 @@ import { examples } from "@/app/(app)/automation/create/examples";
 
 type Inputs = { prompt?: string };
 
+// not in use anymore
 export default function AutomationSettingsPage() {
   const router = useRouter();
   const {
diff --git a/apps/web/app/(app)/onboarding-old2/page.tsx b/apps/web/app/(app)/onboarding-old2/page.tsx
deleted file mode 100644
index a86a982677..0000000000
--- a/apps/web/app/(app)/onboarding-old2/page.tsx
+++ /dev/null
@@ -1,84 +0,0 @@
-"use client";
-
-import { Card } from "@/components/Card";
-import { Container } from "@/components/Container";
-import { Button } from "@/components/Button";
-import { PageHeading, SectionDescription } from "@/components/Typography";
-import { LabelItem } from "@/app/(app)/settings/LabelsSection";
-import { SubmitButtonWrapper } from "@/components/Form";
-
-const RECOMMENDED_LABELS = [
-  "Newsletter",
-  "Receipt",
-  "Calendar",
-  "Privacy policy update",
-  "Discount offering",
-];
-const OTHER_POTENTIAL_LABELS = [
-  "Server Down",
-  "Recruitment",
-  "Investment Opportunity",
-  "Support",
-  "Sales",
-  "Marketing",
-  "Product",
-  "Feedback",
-  "Bug",
-  "Feature Request",
-  "Complaint",
-  "Praise",
-  "Refund",
-  "Cancellation",
-  "Payment",
-  "Invoice",
-  "Reminder",
-  "Meeting",
-  "Event",
-  "Webinar",
-];
-
-// Send our ai the last 500 threads and have it return categories that are helpful
-
-export default function Onboarding() {
-  return (
-    <Container>
-      <div className="py-8">
-        <Card>
-          <PageHeading>Onboarding</PageHeading>
-          <div className="mt-2 max-w-prose">
-            <SectionDescription>
-              Inbox Zero categorizes emails to plan the right action. You can
-              customize categories in the settings to improve results.
-            </SectionDescription>
-          </div>
-
-          <div className="mt-4">
-            <div className="grid grid-cols-4 items-center gap-x-4 gap-y-6">
-              <div className="">Category</div>
-              <div className="col-span-3 flex items-center space-x-2">
-                <div className="">Enabled</div>
-                <div className="">Description</div>
-              </div>
-            </div>
-            {RECOMMENDED_LABELS.map((label) => (
-              <LabelItem
-                key={label}
-                label={{ id: label, name: label }}
-                register={() => {}}
-                watch={() => {}}
-                setValue={() => {}}
-                errors={{}}
-              />
-            ))}
-
-            <SubmitButtonWrapper>
-              <div className="ml-auto">
-                <Button>Next</Button>
-              </div>
-            </SubmitButtonWrapper>
-          </div>
-        </Card>
-      </div>
-    </Container>
-  );
-}
diff --git a/apps/web/app/api/ai/summarise/route.ts b/apps/web/app/api/ai/summarise/route.ts
index af86c02f1e..7c74e749be 100644
--- a/apps/web/app/api/ai/summarise/route.ts
+++ b/apps/web/app/api/ai/summarise/route.ts
@@ -20,9 +20,9 @@ export const POST = withError(async (request: Request) => {
   const body = summariseBody.parse(json);
 
   const prompt = emailToContent({
-    textHtml: body.textHtml || null,
-    textPlain: body.textPlain || null,
-    snippet: null,
+    textHtml: body.textHtml || undefined,
+    textPlain: body.textPlain || undefined,
+    snippet: "",
   });
 
   if (!prompt)
diff --git a/apps/web/app/api/google/webhook/process-history.ts b/apps/web/app/api/google/webhook/process-history.ts
index 1b16f16f3f..6fa09ef66a 100644
--- a/apps/web/app/api/google/webhook/process-history.ts
+++ b/apps/web/app/api/google/webhook/process-history.ts
@@ -22,6 +22,8 @@ import { categorizeSender } from "@/utils/categorize/senders/categorize";
 import { unwatchEmails } from "@/app/api/google/watch/controller";
 import { createScopedLogger } from "@/utils/logger";
 import { markMessageAsProcessing } from "@/utils/redis/message-processing";
+import { isAssistantEmail } from "@/utils/assistant/is-assistant-email";
+import { processAssistantEmail } from "@/utils/assistant/process-assistant-email";
 
 const logger = createScopedLogger("Process History");
 
@@ -198,10 +200,7 @@ export async function processHistoryForUser(
       });
 
       // important to save this or we can get into a loop with never receiving history
-      await prisma.user.update({
-        where: { email: account.user.email },
-        data: { lastSyncedHistoryId: historyId.toString() },
-      });
+      await updateLastSyncedHistoryId(account.user.email, historyId.toString());
     }
 
     logger.info("Completed processing history", { decodedData });
@@ -264,8 +263,7 @@ async function processHistory(options: ProcessHistoryOptions) {
     const inboxMessages = historyMessages.filter(
       (m) =>
         m.message?.labelIds?.includes(GmailLabel.INBOX) &&
-        !m.message?.labelIds?.includes(GmailLabel.DRAFT) &&
-        !m.message?.labelIds?.includes(GmailLabel.SENT),
+        !m.message?.labelIds?.includes(GmailLabel.DRAFT),
     );
     const uniqueMessages = uniqBy(inboxMessages, (m) => m.message?.id);
 
@@ -282,7 +280,14 @@ async function processHistory(options: ProcessHistoryOptions) {
           email,
           messageId: m.message?.id,
           threadId: m.message?.threadId,
-          error,
+          error:
+            error instanceof Error
+              ? {
+                  message: error.message,
+                  stack: error.stack,
+                  name: error.name,
+                }
+              : String(error),
         });
       }
     }
@@ -290,16 +295,16 @@ async function processHistory(options: ProcessHistoryOptions) {
 
   const lastSyncedHistoryId = history[history.length - 1].id;
 
-  await prisma.user.update({
-    where: { email },
-    data: { lastSyncedHistoryId },
-  });
+  await updateLastSyncedHistoryId(email, lastSyncedHistoryId);
 }
 
 async function processHistoryItem(
-  m: gmail_v1.Schema$HistoryMessageAdded | gmail_v1.Schema$HistoryLabelAdded,
+  {
+    message,
+  }: gmail_v1.Schema$HistoryMessageAdded | gmail_v1.Schema$HistoryLabelAdded,
   {
     gmail,
+    email: userEmail,
     user,
     accessToken,
     hasColdEmailAccess,
@@ -308,21 +313,16 @@ async function processHistoryItem(
     rules,
   }: ProcessHistoryOptions,
 ) {
-  const message = m.message;
   const messageId = message?.id;
   const threadId = message?.threadId;
 
-  if (!messageId) return;
-  if (!threadId) return;
+  if (!messageId || !threadId) return;
 
-  const isFree = await markMessageAsProcessing({
-    userEmail: user.email!,
-    messageId,
-  });
+  const isFree = await markMessageAsProcessing({ userEmail, messageId });
 
   if (!isFree) {
     logger.info("Skipping. Message already being processed.", {
-      email: user.email,
+      email: userEmail,
       messageId,
       threadId,
     });
@@ -330,7 +330,7 @@ async function processHistoryItem(
   }
 
   logger.info("Getting message", {
-    email: user.email,
+    email: userEmail,
     messageId,
     threadId,
   });
@@ -349,7 +349,7 @@ async function processHistoryItem(
     // if the rule has already been executed, skip
     if (hasExistingRule) {
       logger.info("Skipping. Rule already exists.", {
-        email: user.email,
+        email: userEmail,
         messageId,
         threadId,
       });
@@ -358,6 +358,42 @@ async function processHistoryItem(
 
     const message = parseMessage(gmailMessage);
 
+    const isForAssistant = isAssistantEmail({
+      userEmail,
+      emailToCheck: message.headers.to,
+    });
+
+    if (isForAssistant) {
+      logger.info("Passing through assistant email.", {
+        email: userEmail,
+        messageId,
+        threadId,
+      });
+      return processAssistantEmail({
+        message,
+        userEmail,
+        userId: user.id,
+        gmail,
+      });
+    }
+
+    const isFromAssistant = isAssistantEmail({
+      userEmail,
+      emailToCheck: message.headers.from,
+    });
+
+    if (isFromAssistant) {
+      logger.info("Skipping. Assistant email.", {
+        email: userEmail,
+        messageId,
+        threadId,
+      });
+      return;
+    }
+
+    // skip SENT emails that are not assistant emails
+    if (message.labelIds?.includes(GmailLabel.SENT)) return;
+
     const blocked = await blockUnsubscribedEmails({
       from: message.headers.from,
       userId: user.id,
@@ -367,7 +403,7 @@ async function processHistoryItem(
 
     if (blocked) {
       logger.info("Skipping. Blocked unsubscribed email.", {
-        email: user.email,
+        email: userEmail,
         messageId,
         threadId,
       });
@@ -384,7 +420,7 @@ async function processHistoryItem(
 
     if (shouldRunBlocker) {
       logger.info("Running cold email blocker...", {
-        email: user.email,
+        email: userEmail,
         messageId,
         threadId,
       });
@@ -398,11 +434,7 @@ async function processHistoryItem(
         },
       );
 
-      const content = emailToContent({
-        textHtml: message.textHtml || null,
-        textPlain: message.textPlain || null,
-        snippet: message.snippet,
-      });
+      const content = emailToContent(message);
 
       const response = await runColdEmailBlocker({
         hasPreviousEmail,
@@ -419,7 +451,7 @@ async function processHistoryItem(
 
       if (response.isColdEmail) {
         logger.info("Skipping. Cold email detected.", {
-          email: user.email,
+          email: userEmail,
           messageId,
           threadId,
         });
@@ -442,7 +474,7 @@ async function processHistoryItem(
 
     if (hasAutomationRules && hasAiAutomationAccess) {
       logger.info("Running rules...", {
-        email: user.email,
+        email: userEmail,
         messageId,
         threadId,
       });
@@ -459,7 +491,7 @@ async function processHistoryItem(
     // gmail bug or snoozed email: https://stackoverflow.com/questions/65290987/gmail-api-getmessage-method-returns-404-for-message-gotten-from-listhistory-meth
     if (error.message === "Requested entity was not found.") {
       logger.info("Message not found", {
-        email: user.email,
+        email: userEmail,
         messageId,
         threadId,
       });
@@ -482,3 +514,14 @@ function shouldRunColdEmailBlocker(
     !isThread
   );
 }
+
+async function updateLastSyncedHistoryId(
+  email: string,
+  lastSyncedHistoryId?: string | null,
+) {
+  if (!lastSyncedHistoryId) return;
+  await prisma.user.update({
+    where: { email },
+    data: { lastSyncedHistoryId },
+  });
+}
diff --git a/apps/web/package.json b/apps/web/package.json
index aeae0184eb..a25931f429 100644
--- a/apps/web/package.json
+++ b/apps/web/package.json
@@ -79,6 +79,7 @@
     "crisp-sdk-web": "^1.0.25",
     "date-fns": "^3.6.0",
     "diff": "^7.0.0",
+    "email-reply-parser": "^1.9.2",
     "encoding": "^0.1.13",
     "eslint": "^8.57.1",
     "eslint-config-next": "14.2.15",
@@ -97,7 +98,6 @@
     "next-auth": "5.0.0-beta.25",
     "next-axiom": "^1.9.1",
     "next-sanity": "9",
-    "node-email-reply-parser": "^0.1.4",
     "nodemailer": "^6.9.16",
     "novel": "0.3.1",
     "nuqs": "^2.2.3",
@@ -135,6 +135,7 @@
     "@inboxzero/eslint-config": "workspace:*",
     "@testing-library/react": "^16.1.0",
     "@types/diff": "^6.0.0",
+    "@types/email-reply-parser": "^1.4.2",
     "@types/he": "^1.2.3",
     "@types/html-to-text": "^9.0.4",
     "@types/lodash": "^4.17.13",
diff --git a/apps/web/utils/actions/ai-rule.ts b/apps/web/utils/actions/ai-rule.ts
index b89804bfbb..3394b444cd 100644
--- a/apps/web/utils/actions/ai-rule.ts
+++ b/apps/web/utils/actions/ai-rule.ts
@@ -2,13 +2,8 @@
 
 import { setUser } from "@sentry/nextjs";
 import { auth } from "@/app/api/auth/[...nextauth]/auth";
-import prisma, { isDuplicateError, isNotFoundError } from "@/utils/prisma";
-import {
-  RuleType,
-  ExecutedRuleStatus,
-  type Action,
-  ActionType,
-} from "@prisma/client";
+import prisma, { isNotFoundError } from "@/utils/prisma";
+import { ExecutedRuleStatus } from "@prisma/client";
 import { getGmailClient } from "@/utils/gmail/client";
 import { aiCreateRule } from "@/utils/ai/rule/create-rule";
 import {
@@ -47,6 +42,8 @@ import { aiFindSnippets } from "@/utils/ai/snippets/find-snippets";
 import { aiRuleFix } from "@/utils/ai/rule/rule-fix";
 import { labelVisibility } from "@/utils/gmail/constants";
 import type { CreateOrUpdateRuleSchemaWithCategories } from "@/utils/ai/rule/create-rule-schema";
+import { safeCreateRule, safeUpdateRule } from "@/utils/rule/rule";
+import { getUserCategoriesForNames } from "@/utils/category.server";
 
 const logger = createScopedLogger("ai-rule");
 
@@ -223,140 +220,6 @@ export const createAutomationAction = withActionInstrumentation<
   return await safeCreateRule(result, userId, groupIdResult, null);
 });
 
-async function createRule(
-  result: CreateOrUpdateRuleSchemaWithCategories,
-  userId: string,
-  groupId: string | null,
-  categoryIds: string[] | null,
-) {
-  return prisma.rule.create({
-    data: {
-      name: result.name,
-      userId,
-      actions: { createMany: { data: result.actions } },
-      automate: shouldAutomate(result.actions),
-      runOnThreads: shouldRunOnThreads(result.condition),
-      conditionalOperator: result.condition.conditionalOperator,
-      instructions: result.condition.aiInstructions,
-      from: result.condition.static?.from,
-      to: result.condition.static?.to,
-      subject: result.condition.static?.subject,
-      groupId,
-      categoryFilterType: result.condition.categories?.categoryFilterType,
-      categoryFilters: categoryIds
-        ? {
-            connect: categoryIds.map((id) => ({
-              id,
-            })),
-          }
-        : undefined,
-    },
-  });
-}
-
-async function updateRule(
-  ruleId: string,
-  result: CreateOrUpdateRuleSchemaWithCategories,
-  userId: string,
-  groupId: string | null,
-  categoryIds: string[] | null,
-) {
-  return prisma.rule.update({
-    where: { id: ruleId },
-    data: {
-      name: result.name,
-      userId,
-      actions: {
-        deleteMany: {},
-        createMany: { data: result.actions },
-      },
-      automate: shouldAutomate(result.actions),
-      runOnThreads: shouldRunOnThreads(result.condition),
-      conditionalOperator: result.condition.conditionalOperator,
-      instructions: result.condition.aiInstructions,
-      from: result.condition.static?.from,
-      to: result.condition.static?.to,
-      subject: result.condition.static?.subject,
-      groupId,
-      categoryFilterType: result.condition.categories?.categoryFilterType,
-      categoryFilters: categoryIds
-        ? {
-            set: categoryIds.map((id) => ({
-              id,
-            })),
-          }
-        : undefined,
-    },
-  });
-}
-
-async function safeCreateRule(
-  result: CreateOrUpdateRuleSchemaWithCategories,
-  userId: string,
-  groupId: string | null,
-  categoryIds: string[] | null,
-) {
-  try {
-    const rule = await createRule(result, userId, groupId, categoryIds);
-    return { id: rule.id };
-  } catch (error) {
-    if (isDuplicateError(error, "name")) {
-      // if rule name already exists, create a new rule with a unique name
-      const rule = await createRule(
-        { ...result, name: `${result.name} - ${Date.now()}` },
-        userId,
-        groupId,
-        categoryIds,
-      );
-      return { id: rule.id };
-    }
-
-    logger.error("Error creating rule", {
-      userId,
-      error:
-        error instanceof Error
-          ? { message: error.message, stack: error.stack, name: error.name }
-          : error,
-    });
-
-    return { error: "Error creating rule." };
-  }
-}
-
-async function safeUpdateRule(
-  ruleId: string,
-  result: CreateOrUpdateRuleSchemaWithCategories,
-  userId: string,
-  groupId: string | null,
-  categoryIds: string[] | null,
-) {
-  try {
-    const rule = await updateRule(ruleId, result, userId, groupId, categoryIds);
-    return { id: rule.id };
-  } catch (error) {
-    if (isDuplicateError(error, "name")) {
-      // if rule name already exists, create a new rule with a unique name
-      const rule = await createRule(
-        { ...result, name: `${result.name} - ${Date.now()}` },
-        userId,
-        groupId,
-        categoryIds,
-      );
-      return { id: rule.id };
-    }
-
-    logger.error("Error updating rule", {
-      userId,
-      error:
-        error instanceof Error
-          ? { message: error.message, stack: error.stack, name: error.name }
-          : error,
-    });
-
-    return { error: "Error updating rule." };
-  }
-}
-
 async function getGroupId(
   result: CreateOrUpdateRuleSchemaWithCategories,
   userId: string,
@@ -422,23 +285,6 @@ async function getGroupId(
   return groupId;
 }
 
-const getUserCategoriesForNames = async (userId: string, names: string[]) => {
-  if (!names.length) return [];
-
-  const categories = await prisma.category.findMany({
-    where: { userId, name: { in: names } },
-    select: { id: true },
-  });
-  if (categories.length !== names.length) {
-    logger.warn("Not all categories were found", {
-      requested: names.length,
-      found: categories.length,
-      names,
-    });
-  }
-  return categories.map((c) => c.id);
-};
-
 export const setRuleAutomatedAction = withActionInstrumentation(
   "setRuleAutomated",
   async ({ ruleId, automate }: { ruleId: string; automate: boolean }) => {
@@ -493,15 +339,7 @@ export const approvePlanAction = withActionInstrumentation(
 
     await executeAct({
       gmail,
-      email: {
-        messageId: executedRule.messageId,
-        threadId: executedRule.threadId,
-        from: message.headers.from,
-        subject: message.headers.subject,
-        references: message.headers.references,
-        replyTo: message.headers["reply-to"],
-        headerMessageId: message.headers["message-id"] || "",
-      },
+      email: message,
       executedRule,
       userEmail: session.user.email,
     });
@@ -791,12 +629,12 @@ export const saveRulesPromptAction = withActionInstrumentation(
         continue;
       }
 
-      const categoryIds = await getUserCategoriesForNames(
+      await safeCreateRule(
+        rule,
         session.user.id,
+        groupIdResult,
         rule.condition.categories?.categoryFilters || [],
       );
-
-      await safeCreateRule(rule, session.user.id, groupIdResult, categoryIds);
     }
 
     // update rules prompt for user
@@ -820,27 +658,6 @@ export const saveRulesPromptAction = withActionInstrumentation(
   },
 );
 
-function shouldAutomate(actions: Pick<Action, "type">[]) {
-  const types = new Set(actions.map((action) => action.type));
-
-  // don't automate replies, forwards, and send emails
-  if (
-    types.has(ActionType.REPLY) ||
-    types.has(ActionType.FORWARD) ||
-    types.has(ActionType.SEND_EMAIL)
-  ) {
-    return false;
-  }
-
-  return true;
-}
-
-// run on threads for static, group, and smart category rules
-// user can enable to run on threads for ai rules themselves
-function shouldRunOnThreads(condition?: { aiInstructions?: string }) {
-  return !condition?.aiInstructions;
-}
-
 /**
  * Generates a rules prompt based on the user's recent email activity and labels.
  * This function:
@@ -901,14 +718,7 @@ export const generateRulesPromptAction = withActionInstrumentation(
       )
     ).filter(isDefined);
     const lastSentEmails = lastSentMessages?.map((message) => {
-      return emailToContent(
-        {
-          textHtml: message.textHtml || null,
-          textPlain: message.textPlain || null,
-          snippet: message.snippet || null,
-        },
-        { maxLength: 500 },
-      );
+      return emailToContent(message, { maxLength: 500 });
     });
 
     const snippetsResult = await aiFindSnippets({
@@ -918,11 +728,7 @@ export const generateRulesPromptAction = withActionInstrumentation(
         replyTo: message.headers["reply-to"],
         cc: message.headers.cc,
         subject: message.headers.subject,
-        content: emailToContent({
-          textHtml: message.textHtml || null,
-          textPlain: message.textPlain || null,
-          snippet: message.snippet,
-        }),
+        content: emailToContent(message),
       })),
     });
 
@@ -997,9 +803,9 @@ export const reportAiMistakeAction = withActionInstrumentation(
     if (!user) return { error: "User not found" };
 
     const content = emailToContent({
-      textHtml: email.textHtml || null,
-      textPlain: email.textPlain || null,
-      snippet: email.snippet,
+      textHtml: email.textHtml || undefined,
+      textPlain: email.textPlain || undefined,
+      snippet: email.snippet || "",
     });
 
     const result = await aiRuleFix({
@@ -1017,7 +823,8 @@ export const reportAiMistakeAction = withActionInstrumentation(
     if (!result) return { error: "Error fixing rule" };
 
     return {
-      ruleId: result.rule === "actual_rule" ? actualRuleId : expectedRuleId,
+      ruleId:
+        result.ruleToFix === "actual_rule" ? actualRuleId : expectedRuleId,
       fixedInstructions: result.fixedInstructions,
     };
   },
diff --git a/apps/web/utils/actions/categorize-email.ts b/apps/web/utils/actions/categorize-email.ts
index a525cac35f..3283c6b424 100644
--- a/apps/web/utils/actions/categorize-email.ts
+++ b/apps/web/utils/actions/categorize-email.ts
@@ -32,7 +32,11 @@ export const categorizeEmailAction = withActionInstrumentation(
     } = categorizeBodyWithHtml.safeParse(unsafeData);
     if (!success) return { error: parseError.message };
 
-    const content = emailToContent(data);
+    const content = emailToContent({
+      textHtml: data.textHtml || undefined,
+      textPlain: data.textPlain || undefined,
+      snippet: data.snippet || "",
+    });
 
     const unsubscribeLink = findUnsubscribeLink(data.textHtml);
     const hasPreviousEmail = await hasPreviousEmailsFromSender(gmail, data);
diff --git a/apps/web/utils/actions/categorize.ts b/apps/web/utils/actions/categorize.ts
index aa45565e6e..b505efd94c 100644
--- a/apps/web/utils/actions/categorize.ts
+++ b/apps/web/utils/actions/categorize.ts
@@ -11,7 +11,10 @@ import prisma, { isDuplicateError } from "@/utils/prisma";
 import { withActionInstrumentation } from "@/utils/actions/middleware";
 import { defaultCategory } from "@/utils/categories";
 import { auth } from "@/app/api/auth/[...nextauth]/auth";
-import { categorizeSender } from "@/utils/categorize/senders/categorize";
+import {
+  categorizeSender,
+  updateCategoryForSender,
+} from "@/utils/categorize/senders/categorize";
 import { validateUserAndAiAccess } from "@/utils/user/validate";
 import { isActionError } from "@/utils/error";
 import {
@@ -140,9 +143,10 @@ export const changeSenderCategoryAction = withActionInstrumentation(
     });
     if (!category) return { error: "Category not found" };
 
-    await prisma.newsletter.update({
-      where: { email_userId: { email: sender, userId: session.user.id } },
-      data: { categoryId },
+    await updateCategoryForSender({
+      userId: session.user.id,
+      sender,
+      categoryId,
     });
 
     revalidatePath("/smart-categories");
diff --git a/apps/web/utils/actions/cold-email.ts b/apps/web/utils/actions/cold-email.ts
index a2e0e7e8e7..d230ccd194 100644
--- a/apps/web/utils/actions/cold-email.ts
+++ b/apps/web/utils/actions/cold-email.ts
@@ -122,9 +122,9 @@ async function checkColdEmail(
       : false;
 
   const content = emailToContent({
-    textHtml: body.textHtml || null,
-    textPlain: body.textPlain || null,
-    snippet: body.snippet,
+    textHtml: body.textHtml || undefined,
+    textPlain: body.textPlain || undefined,
+    snippet: body.snippet || "",
   });
 
   const response = await isColdEmail({
diff --git a/apps/web/utils/actions/group.ts b/apps/web/utils/actions/group.ts
index d89e84aff0..ae04445882 100644
--- a/apps/web/utils/actions/group.ts
+++ b/apps/web/utils/actions/group.ts
@@ -27,6 +27,7 @@ import { aiGenerateGroupItems } from "@/utils/ai/group/create-group";
 import type { UserAIFields } from "@/utils/llms/types";
 import { withActionInstrumentation } from "@/utils/actions/middleware";
 import { createScopedLogger } from "@/utils/logger";
+import { addGroupItem, deleteGroupItem } from "@/utils/group/group-item";
 
 const logger = createScopedLogger("Group Action");
 
@@ -349,11 +350,20 @@ async function regenerateReceiptGroup(
 async function createGroupItems(
   data: { groupId: string; type: GroupItemType; value: string }[],
 ) {
+  const uniqueItems = uniqBy(data, (item) => `${item.value}-${item.type}`);
   try {
-    return await prisma.groupItem.createMany({ data });
+    return await prisma.groupItem.createMany({ data: uniqueItems });
   } catch (error) {
-    if (isDuplicateError(error))
-      captureException(error, { extra: { items: data } });
+    if (isDuplicateError(error)) {
+      // Create items one by one, skipping duplicates
+      for (const item of uniqueItems) {
+        try {
+          await prisma.groupItem.create({ data: item });
+        } catch (error) {
+          if (!isDuplicateError(error)) throw error;
+        }
+      }
+    }
 
     throw error;
   }
@@ -401,7 +411,7 @@ export const addGroupItemAction = withActionInstrumentation(
     if (group.userId !== session.user.id)
       return { error: "You don't have permission to add items to this group" };
 
-    await prisma.groupItem.create({ data });
+    await addGroupItem(data);
 
     revalidatePath("/automation");
   },
@@ -413,9 +423,7 @@ export const deleteGroupItemAction = withActionInstrumentation(
     const session = await auth();
     if (!session?.user.id) return { error: "Not logged in" };
 
-    await prisma.groupItem.delete({
-      where: { id, group: { userId: session.user.id } },
-    });
+    await deleteGroupItem({ id, userId: session.user.id });
 
     revalidatePath("/automation");
   },
diff --git a/apps/web/utils/actions/rule.ts b/apps/web/utils/actions/rule.ts
index c8485005e0..ff5edd709c 100644
--- a/apps/web/utils/actions/rule.ts
+++ b/apps/web/utils/actions/rule.ts
@@ -20,10 +20,10 @@ import { aiFindExampleMatches } from "@/utils/ai/example-matches/find-example-ma
 import { withActionInstrumentation } from "@/utils/actions/middleware";
 import { flattenConditions } from "@/utils/condition";
 import { LogicalOperator } from "@prisma/client";
-import { createPromptFromRule } from "@/utils/ai/rule/create-prompt-from-rule";
 import {
-  updateRulePromptOnRuleChange,
-  appendRulePrompt,
+  updatePromptFileOnRuleUpdated,
+  updateRuleInstructionsAndPromptFile,
+  updatePromptFileOnRuleCreated,
 } from "@/utils/rule/prompt-file";
 import { generatePromptOnDeleteRule } from "@/utils/ai/rule/generate-prompt-on-delete-rule";
 import { sanitizeActionFields } from "@/utils/action-item";
@@ -85,9 +85,7 @@ export const createRuleAction = withActionInstrumentation(
         include: { actions: true, categoryFilters: true, group: true },
       });
 
-      const prompt = createPromptFromRule(rule);
-
-      await appendRulePrompt(session.user.id, prompt);
+      await updatePromptFileOnRuleCreated(session.user.id, rule);
 
       revalidatePath("/automation");
 
@@ -208,7 +206,7 @@ export const updateRuleAction = withActionInstrumentation(
       ]);
 
       // update prompt file
-      await updateRulePromptOnRuleChange(
+      await updatePromptFileOnRuleUpdated(
         session.user.id,
         currentRule,
         updatedRule,
@@ -247,18 +245,12 @@ export const updateRuleInstructionsAction = withActionInstrumentation(
     });
     if (!currentRule) return { error: "Rule not found" };
 
-    const updatedRule = await prisma.rule.update({
-      where: { id: body.id, userId: session.user.id },
-      data: { instructions: body.instructions },
-      include: { actions: true, categoryFilters: true, group: true },
-    });
-
-    // update prompt file
-    await updateRulePromptOnRuleChange(
-      session.user.id,
+    await updateRuleInstructionsAndPromptFile({
+      userId: session.user.id,
+      ruleId: body.id,
+      instructions: body.instructions,
       currentRule,
-      updatedRule,
-    );
+    });
 
     revalidatePath(`/automation/rule/${body.id}`);
     revalidatePath("/automation");
diff --git a/apps/web/utils/ai/actions.ts b/apps/web/utils/ai/actions.ts
index 0e8029a92c..3a2bd296c1 100644
--- a/apps/web/utils/ai/actions.ts
+++ b/apps/web/utils/ai/actions.ts
@@ -1,11 +1,16 @@
 import type { gmail_v1 } from "@googleapis/gmail";
-import { draftEmail, forwardEmail, sendEmail } from "@/utils/gmail/mail";
+import {
+  draftEmail,
+  forwardEmail,
+  replyToEmail,
+  sendEmail,
+} from "@/utils/gmail/mail";
 import {
   ActionType,
   type ExecutedRule,
   type ExecutedAction,
 } from "@prisma/client";
-import type { PartialRecord } from "@/utils/types";
+import type { ParsedMessage, PartialRecord } from "@/utils/types";
 import {
   archiveThread,
   getOrCreateLabel,
@@ -18,17 +23,25 @@ import { callWebhook } from "@/utils/webhook";
 
 const logger = createScopedLogger("ai-actions");
 
-export type EmailForAction = {
-  threadId: string;
-  messageId: string;
-  references?: string;
-  headerMessageId: string;
-  subject: string;
-  from: string;
-  cc?: string;
-  bcc?: string;
-  replyTo?: string;
-};
+// export type EmailForAction = {
+//   threadId: string;
+//   messageId: string;
+//   references?: string;
+//   headerMessageId: string;
+//   subject: string;
+//   from: string;
+//   cc?: string;
+//   bcc?: string;
+//   replyTo?: string;
+//   date: string;
+//   textPlain: string;
+//   textHtml?: string;
+// };
+
+export type EmailForAction = Pick<
+  ParsedMessage,
+  "threadId" | "id" | "headers" | "textPlain" | "textHtml" | "attachments"
+>;
 
 export type ActionItem = {
   id: ExecutedAction["id"];
@@ -307,13 +320,13 @@ const draft: ActionFunction<any> = async (
   await draftEmail(gmail, {
     replyToEmail: {
       threadId: email.threadId,
-      references: email.references,
-      headerMessageId: email.headerMessageId,
+      references: email.headers.references,
+      headerMessageId: email.headers["message-id"] || "",
     },
-    to: args.to || email.replyTo || email.from,
-    cc: email.cc,
-    bcc: email.bcc,
-    subject: email.subject,
+    to: args.to || email.headers["reply-to"] || email.headers.from,
+    cc: email.headers.cc,
+    bcc: email.headers.bcc,
+    subject: email.headers.subject,
     messageText: args.content,
     attachments: args.attachments,
   });
@@ -346,24 +359,12 @@ const reply: ActionFunction<any> = async (
   email,
   args: {
     content: string;
-    cc: string; // TODO - do we allow the ai to adjust this?
-    bcc: string;
+    cc?: string;
+    bcc?: string;
     attachments?: Attachment[];
   },
 ) => {
-  await sendEmail(gmail, {
-    replyToEmail: {
-      threadId: email.threadId,
-      references: email.references,
-      headerMessageId: email.headerMessageId,
-    },
-    to: email.replyTo || email.from,
-    cc: args.cc,
-    bcc: args.bcc,
-    subject: email.subject,
-    messageText: args.content,
-    attachments: args.attachments,
-  });
+  await replyToEmail(gmail, email, args.content, email.headers.from);
 };
 
 const forward: ActionFunction<any> = async (
@@ -378,7 +379,7 @@ const forward: ActionFunction<any> = async (
 ) => {
   // We may need to make sure the AI isn't adding the extra forward content on its own
   await forwardEmail(gmail, {
-    messageId: email.messageId,
+    messageId: email.id,
     to: args.to,
     cc: args.cc,
     bcc: args.bcc,
@@ -403,12 +404,12 @@ const call_webhook: ActionFunction<any> = async (
   await callWebhook(userEmail, args.url, {
     email: {
       threadId: email.threadId,
-      messageId: email.messageId,
-      subject: email.subject,
-      from: email.from,
-      cc: email.cc,
-      bcc: email.bcc,
-      headerMessageId: email.headerMessageId,
+      messageId: email.id,
+      subject: email.headers.subject,
+      from: email.headers.from,
+      cc: email.headers.cc,
+      bcc: email.headers.bcc,
+      headerMessageId: email.headers["message-id"] || "",
     },
     executedRule: {
       id: executedRule.id,
diff --git a/apps/web/utils/ai/assistant/process-user-request.ts b/apps/web/utils/ai/assistant/process-user-request.ts
new file mode 100644
index 0000000000..0af01e0758
--- /dev/null
+++ b/apps/web/utils/ai/assistant/process-user-request.ts
@@ -0,0 +1,568 @@
+import { tool } from "ai";
+import { z } from "zod";
+import { chatCompletionTools } from "@/utils/llms";
+import { createScopedLogger } from "@/utils/logger";
+import {
+  type Category,
+  GroupItemType,
+  LogicalOperator,
+  type Rule,
+  type User,
+} from "@prisma/client";
+import type { UserAIFields } from "@/utils/llms/types";
+import type { RuleWithRelations } from "@/utils/ai/rule/create-prompt-from-rule";
+import { isDefined, type ParsedMessage } from "@/utils/types";
+import {
+  createRuleSchema,
+  type CreateRuleSchemaWithCategories,
+  getCreateRuleSchemaWithCategories,
+} from "@/utils/ai/rule/create-rule-schema";
+import { addGroupItem, deleteGroupItem } from "@/utils/group/group-item";
+import {
+  addRuleCategories,
+  partialUpdateRule,
+  removeRuleCategories,
+  safeCreateRule,
+} from "@/utils/rule/rule";
+import { updateCategoryForSender } from "@/utils/categorize/senders/categorize";
+import { findSenderByEmail } from "@/utils/sender";
+import { getEmailForLLM } from "@/utils/ai/choose-rule/get-email-from-message";
+import { stringifyEmailSimple } from "@/utils/ai/choose-rule/stringify-email";
+import {
+  updatePromptFileOnRuleCreated,
+  updatePromptFileOnRuleUpdated,
+} from "@/utils/rule/prompt-file";
+
+const logger = createScopedLogger("ai-fix-rules");
+
+export async function processUserRequest({
+  user,
+  rules,
+  originalEmail,
+  messages,
+  matchedRule,
+  categories,
+  senderCategory,
+}: {
+  user: Pick<User, "id" | "email" | "about"> & UserAIFields;
+  rules: RuleWithRelations[];
+  originalEmail: ParsedMessage | null;
+  messages: { role: "assistant" | "user"; content: string }[];
+  matchedRule: RuleWithRelations | null;
+  categories: Pick<Category, "id" | "name">[] | null;
+  senderCategory: string | null;
+}) {
+  const userRules = rulesToXML(rules);
+
+  const system = `You are an email management assistant that helps users manage their email rules.
+You can fix rules using these specific operations:
+
+1. Edit Rule Components:
+- Change conditional operator (AND/OR logic)
+- Modify AI instructions
+- Update static conditions (from, to, subject, body)
+- Add or remove categories
+
+2. Manage Groups:
+- Add items to groups (email addresses or subject patterns)
+- Remove items from groups
+- Never mix static conditions with group conditions
+
+3. Create New Rules:
+- Create new rules when existing ones cannot be modified to fit the need
+
+When fixing rules:
+- Make one precise change at a time
+- Prefer minimal changes that solve the problem
+- Only add AI instructions if simpler conditions won't suffice
+- Keep rules general and maintainable
+
+Rule matching logic:
+- All static conditions (from, to, subject, body) use AND logic - meaning all conditions must match
+- Top level conditions (static, group, category, AI instructions) can use either AND or OR logic, controlled by the conditionalOperator setting
+
+Best practices:
+- For static conditions, use email patterns (e.g., '@company.com') when matching multiple addresses
+- For groups, collect similar items that are likely to appear together (e.g., newsletter senders, receipt subject patterns)
+- Only use subject patterns if they are likely to be recurring (e.g., "Your Monthly Statement", "Order Confirmation")
+- IMPORTANT: do not create new rules unless absolutely necessary and the user has asked for it.
+
+Always end by using the reply tool to explain what changes were made.`;
+
+  const prompt = `${
+    originalEmail
+      ? `<matched_rule>
+${matchedRule ? ruleToXML(matchedRule) : "No rule matched"}
+</matched_rule>`
+      : ""
+  }
+
+${!matchedRule ? userRules : ""}
+
+${
+  user.about
+    ? `<user_about>
+  ${user.about}
+</user_about>`
+    : ""
+}
+
+${
+  originalEmail
+    ? `<original_email>
+${stringifyEmailSimple(getEmailForLLM(originalEmail))}
+</original_email>`
+    : ""
+}
+
+${
+  originalEmail && categories?.length
+    ? `<sender_category>
+${senderCategory || "No category"}
+</sender_category>`
+    : ""
+}`;
+
+  const allMessages = [
+    {
+      role: "system" as const,
+      content: system,
+    },
+    {
+      role: "user" as const,
+      content: prompt,
+    },
+    ...(messages || []),
+  ];
+
+  logger.trace("Input", { allMessages });
+
+  const createdRules = new Map<string, RuleWithRelations>();
+  const updatedRules = new Map<string, RuleWithRelations>();
+
+  async function updateRule(ruleName: string, rule: Partial<Rule>) {
+    try {
+      const updatedRule = await partialUpdateRule(ruleName, rule);
+      updatedRules.set(updatedRule.id, updatedRule);
+      return { success: true };
+    } catch (error) {
+      return {
+        error: "Failed to update rule",
+        message: error instanceof Error ? error.message : String(error),
+      };
+    }
+  }
+
+  const result = await chatCompletionTools({
+    userAi: user,
+    messages: allMessages,
+    tools: {
+      create_rule: tool({
+        description: "Create a new rule",
+        parameters: (categories
+          ? getCreateRuleSchemaWithCategories(
+              categories.map((c) => c.name) as [string, ...string[]],
+            )
+          : createRuleSchema
+        )
+          // Simplify rule creation to not include groups
+          .extend({
+            condition: createRuleSchema.shape.condition.omit({ group: true }),
+          }),
+        execute: async ({ name, condition, actions }) => {
+          logger.info("Create Rule", { name, condition, actions });
+
+          const conditions =
+            condition as CreateRuleSchemaWithCategories["condition"];
+
+          const groupId = null;
+
+          try {
+            const rule = await safeCreateRule(
+              { name, condition, actions },
+              user.id,
+              groupId,
+              conditions.categories?.categoryFilters || [],
+            );
+
+            if ("error" in rule) {
+              return {
+                error: "Failed to create rule",
+                message: rule.error,
+              };
+            }
+
+            createdRules.set(rule.id, rule);
+
+            return { success: true };
+          } catch (error) {
+            return {
+              error: "Failed to create rule",
+              message: error instanceof Error ? error.message : String(error),
+            };
+          }
+        },
+      }),
+      list_rules: tool({
+        description: "",
+        parameters: z.object({}),
+        execute: async () => userRules,
+      }),
+      update_conditional_operator: tool({
+        description: "Update the conditional operator of a rule",
+        parameters: z.object({
+          ruleName: z.string().describe("The exact name of the rule to edit"),
+          conditionalOperator: z
+            .enum([LogicalOperator.AND, LogicalOperator.OR])
+            .describe("The new conditional operator"),
+        }),
+        execute: async ({ ruleName, conditionalOperator }) => {
+          logger.info("Edit Conditional Operator", {
+            ruleName,
+            conditionalOperator,
+          });
+
+          return updateRule(ruleName, { conditionalOperator });
+        },
+      }),
+      update_ai_instructions: tool({
+        description: "Update the AI instructions of a rule",
+        parameters: z.object({
+          ruleName: z.string().describe("The exact name of the rule to edit"),
+          aiInstructions: z.string().describe("The new AI instructions"),
+        }),
+        execute: async ({ ruleName, aiInstructions }) => {
+          logger.info("Edit AI Instructions", { ruleName, aiInstructions });
+
+          return updateRule(ruleName, { instructions: aiInstructions });
+        },
+      }),
+      update_static_conditions: tool({
+        description: "Update the static conditions of a rule",
+        parameters: z.object({
+          ruleName: z.string().describe("The exact name of the rule to edit"),
+          staticConditions: createRuleSchema.shape.condition.shape.static,
+        }),
+        execute: async ({ ruleName, staticConditions }) => {
+          logger.info("Edit Static Conditions", { ruleName, staticConditions });
+
+          return updateRule(ruleName, {
+            from: staticConditions?.from,
+            to: staticConditions?.to,
+            subject: staticConditions?.subject,
+          });
+        },
+      }),
+      add_to_group: tool({
+        description: "Add a group item",
+        parameters: z.object({
+          groupName: z
+            .string()
+            .describe("The name of the group to add the group item to"),
+          type: z
+            .enum(["from", "subject"])
+            .describe("The type of the group item to add"),
+          value: z
+            .string()
+            .describe(
+              "The value of the group item to add. e.g. '@company.com', 'matt@company.com', 'Receipt from'",
+            ),
+        }),
+        execute: async ({ groupName, type, value }) => {
+          logger.info("Add To Group", { groupName, type, value });
+
+          const group = rules.find((r) => r.group?.name === groupName)?.group;
+          const groupId = group?.id;
+
+          if (!groupId) {
+            logger.error("Group not found", { groupName });
+            return { error: "Group not found" };
+          }
+
+          const groupItemType = getGroupItemType(type);
+
+          if (!groupItemType) {
+            logger.error("Invalid group item type", { type });
+            return { error: "Invalid group item type" };
+          }
+
+          await addGroupItem({ groupId, type: groupItemType, value });
+
+          return { success: true };
+        },
+      }),
+      ...(matchedRule?.group
+        ? {
+            remove_from_group: tool({
+              description: "Remove a group item ",
+              parameters: z.object({
+                type: z
+                  .enum(["from", "subject"])
+                  .describe("The type of the group item to remove"),
+                value: z
+                  .string()
+                  .describe("The value of the group item to remove"),
+              }),
+              execute: async ({ type, value }) => {
+                logger.info("Remove From Group", { type, value });
+
+                const groupItemType = getGroupItemType(type);
+
+                if (!groupItemType) {
+                  logger.error("Invalid group item type", { type });
+                  return { error: "Invalid group item type" };
+                }
+
+                const groupItem = matchedRule?.group?.items?.find(
+                  (item) => item.type === groupItemType && item.value === value,
+                );
+
+                if (!groupItem) {
+                  logger.error("Group item not found", { type, value });
+                  return { error: "Group item not found" };
+                }
+
+                await deleteGroupItem({
+                  id: groupItem.id,
+                  userId: user.id,
+                });
+
+                return { success: true };
+              },
+            }),
+          }
+        : {}),
+      ...(categories
+        ? {
+            update_sender_category: getUpdateCategoryTool(user.id, categories),
+            add_categories: tool({
+              description: "Add categories to a rule",
+              parameters: z.object({
+                ruleName: z
+                  .string()
+                  .describe("The exact name of the rule to edit"),
+                categories: z
+                  .array(z.string())
+                  .describe("The categories to add"),
+              }),
+              execute: async (options) => {
+                try {
+                  logger.info("Add Rule Categories", options);
+
+                  const { ruleName } = options;
+
+                  const rule = rules.find((r) => r.name === ruleName);
+
+                  if (!rule) {
+                    logger.error("Rule not found", { ruleName });
+                    return { error: "Rule not found" };
+                  }
+
+                  const categoryIds = options.categories
+                    .map((c) => categories.find((cat) => cat.name === c))
+                    .filter(isDefined)
+                    .map((c) => c.id);
+
+                  const updatedRule = await addRuleCategories(
+                    rule.id,
+                    categoryIds,
+                  );
+
+                  updatedRules.set(updatedRule.id, updatedRule);
+
+                  return { success: true };
+                } catch (error) {
+                  return {
+                    error: "Failed to add categories to rule",
+                    message:
+                      error instanceof Error ? error.message : String(error),
+                  };
+                }
+              },
+            }),
+            remove_categories: tool({
+              description: "Remove categories from a rule",
+              parameters: z.object({
+                ruleName: z
+                  .string()
+                  .describe("The exact name of the rule to edit"),
+                categories: z
+                  .array(z.string())
+                  .describe("The categories to remove"),
+              }),
+              execute: async (options) => {
+                try {
+                  logger.info("Remove Rule Categories", options);
+
+                  const { ruleName } = options;
+
+                  const rule = rules.find((r) => r.name === ruleName);
+
+                  if (!rule) {
+                    logger.error("Rule not found", { ruleName });
+                    return { error: "Rule not found" };
+                  }
+
+                  const categoryIds = options.categories
+                    .map((c) => categories.find((cat) => cat.name === c))
+                    .filter(isDefined)
+                    .map((c) => c.id);
+
+                  const updatedRule = await removeRuleCategories(
+                    rule.id,
+                    categoryIds,
+                  );
+
+                  updatedRules.set(updatedRule.id, updatedRule);
+
+                  return { success: true };
+                } catch (error) {
+                  return {
+                    error: "Failed to remove categories from rule",
+                    message:
+                      error instanceof Error ? error.message : String(error),
+                  };
+                }
+              },
+            }),
+          }
+        : {}),
+      reply: tool({
+        description: "Send an email reply to the user",
+        parameters: z.object({
+          content: z.string().describe("The content of the reply"),
+        }),
+        // no execute function - invoking it will terminate the agent
+      }),
+    },
+    maxSteps: 5,
+    label: "Fix Rule",
+    userEmail: user.email || "",
+  });
+
+  const toolCalls = result.steps.flatMap((step) => step.toolCalls);
+
+  logger.trace("Tool Calls", { toolCalls });
+
+  // Upon completion, check what changes were made and make sure the prompt file is updated
+
+  // Update prompt file for newly created rules
+  for (const rule of createdRules.values()) {
+    await updatePromptFileOnRuleCreated(user.id, rule);
+  }
+
+  // Update prompt file for modified rules
+  for (const rule of updatedRules.values()) {
+    await updatePromptFileOnRuleUpdated(user.id, rule, rule);
+  }
+
+  return result;
+}
+
+const getUpdateCategoryTool = (
+  userId: string,
+  categories: Pick<Category, "id" | "name">[],
+) =>
+  tool({
+    description: "Update the category of a sender",
+    parameters: z.object({
+      sender: z.string().describe("The sender to update"),
+      category: z
+        .enum([
+          ...(categories.map((c) => c.name) as [string, ...string[]]),
+          "none",
+        ])
+        .describe("The name of the category to assign"),
+    }),
+    execute: async ({ sender, category }) => {
+      logger.info("Update Category", { sender, category });
+
+      const existingSender = await findSenderByEmail({
+        userId,
+        email: sender,
+      });
+
+      const cat = categories.find((c) => c.name === category);
+
+      if (!cat) {
+        logger.error("Category not found", { category });
+        return { error: "Category not found" };
+      }
+
+      await updateCategoryForSender({
+        userId,
+        sender: existingSender?.email || sender,
+        categoryId: cat.id,
+      });
+      return { success: true };
+    },
+  });
+
+function ruleToXML(rule: RuleWithRelations) {
+  return `<rule>
+  <rule_name>${rule.name}</rule_name>
+  <conditions>
+    <conditional_operator>${rule.conditionalOperator}</conditional_operator>
+    ${rule.instructions ? `<ai_instructions>${rule.instructions}</ai_instructions>` : ""}
+    ${
+      hasStaticConditions(rule)
+        ? `<static_conditions>
+      ${rule.from ? `<from>${rule.from}</from>` : ""}
+      ${rule.to ? `<to>${rule.to}</to>` : ""}
+      ${rule.subject ? `<subject>${rule.subject}</subject>` : ""}
+      ${rule.body ? `<body>${rule.body}</body>` : ""}
+    </static_conditions>`
+        : ""
+    }
+    ${
+      rule.group
+        ? `<group_condition>
+      <group>${rule.group.name}</group>
+      <group_items>
+        ${
+          rule.group.items
+            ? rule.group.items
+                .map(
+                  (item) =>
+                    `<item>
+  <type>${item.type}</type>
+  <value>${item.value}</value>
+</item>`,
+                )
+                .join("\n      ")
+            : "No group items"
+        }
+      </group_items>
+    </group_condition>`
+        : ""
+    }
+    ${
+      hasCategoryConditions(rule)
+        ? `<category_conditions>
+      ${rule.categoryFilterType ? `<filter_type>${rule.categoryFilterType}</filter_type>` : ""}
+      ${rule.categoryFilters?.map((category) => `<category>${category.name}</category>`).join("\n      ")}
+    </category_conditions>`
+        : ""
+    }
+  </conditions>
+</rule>`;
+}
+
+function rulesToXML(rules: RuleWithRelations[]) {
+  return `<user_rules>
+${rules.map((rule) => ruleToXML(rule)).join("\n")}
+</user_rules>`;
+}
+
+function hasStaticConditions(rule: RuleWithRelations) {
+  return rule.from || rule.to || rule.subject || rule.body;
+}
+
+function hasCategoryConditions(rule: RuleWithRelations) {
+  return rule.categoryFilters && rule.categoryFilters.length > 0;
+}
+
+function getGroupItemType(type: string) {
+  if (type === "from") return GroupItemType.FROM;
+  if (type === "subject") return GroupItemType.SUBJECT;
+}
diff --git a/apps/web/utils/ai/choose-rule/ai-choose-args.ts b/apps/web/utils/ai/choose-rule/ai-choose-args.ts
index 73b0da66d5..85a97acad9 100644
--- a/apps/web/utils/ai/choose-rule/ai-choose-args.ts
+++ b/apps/web/utils/ai/choose-rule/ai-choose-args.ts
@@ -2,11 +2,12 @@ import { z } from "zod";
 import type { UserAIFields } from "@/utils/llms/types";
 import type { Action, User } from "@prisma/client";
 import { chatCompletionTools, withRetry } from "@/utils/llms";
+import { stringifyEmail } from "@/utils/ai/choose-rule/stringify-email";
 import {
   type EmailForLLM,
-  stringifyEmail,
-} from "@/utils/ai/choose-rule/stringify-email";
-import { type RuleWithActions, isDefined } from "@/utils/types";
+  type RuleWithActions,
+  isDefined,
+} from "@/utils/types";
 import { createScopedLogger } from "@/utils/logger";
 import { InvalidToolArgumentsError } from "ai";
 
diff --git a/apps/web/utils/ai/choose-rule/ai-choose-rule.ts b/apps/web/utils/ai/choose-rule/ai-choose-rule.ts
index 64fdfd7502..e1f47547da 100644
--- a/apps/web/utils/ai/choose-rule/ai-choose-rule.ts
+++ b/apps/web/utils/ai/choose-rule/ai-choose-rule.ts
@@ -3,7 +3,7 @@ import type { UserAIFields } from "@/utils/llms/types";
 import { chatCompletionObject } from "@/utils/llms";
 import type { User } from "@prisma/client";
 import { stringifyEmail } from "@/utils/ai/choose-rule/stringify-email";
-import type { EmailForLLM } from "@/utils/ai/choose-rule/stringify-email";
+import type { EmailForLLM } from "@/utils/types";
 import { createScopedLogger } from "@/utils/logger";
 
 const logger = createScopedLogger("ai-choose-rule");
diff --git a/apps/web/utils/ai/choose-rule/get-email-from-message.ts b/apps/web/utils/ai/choose-rule/get-email-from-message.ts
index d8670b18c2..76f7497f13 100644
--- a/apps/web/utils/ai/choose-rule/get-email-from-message.ts
+++ b/apps/web/utils/ai/choose-rule/get-email-from-message.ts
@@ -1,25 +1,12 @@
-import type { ParsedMessage } from "@/utils/types";
+import type { ParsedMessage, EmailForLLM } from "@/utils/types";
 import { emailToContent } from "@/utils/mail";
 
-export function getEmailFromMessage(message: ParsedMessage) {
+export function getEmailForLLM(message: ParsedMessage): EmailForLLM {
   return {
     from: message.headers.from,
-    to: message.headers.to,
-    subject: message.headers.subject,
-    headerMessageId: message.headers["message-id"] || "",
-    messageId: message.id,
-    snippet: message.snippet,
-    textHtml: message.textHtml || null,
-    textPlain: message.textPlain || null,
-    threadId: message.threadId,
-    cc: message.headers.cc || undefined,
-    date: message.headers.date,
-    references: message.headers.references,
     replyTo: message.headers["reply-to"],
-    content: emailToContent({
-      textHtml: message.textHtml || null,
-      textPlain: message.textPlain || null,
-      snippet: message.snippet || null,
-    }),
+    cc: message.headers.cc,
+    subject: message.headers.subject,
+    content: emailToContent(message),
   };
 }
diff --git a/apps/web/utils/ai/choose-rule/match-rules.ts b/apps/web/utils/ai/choose-rule/match-rules.ts
index 5c4216160a..22ea045c51 100644
--- a/apps/web/utils/ai/choose-rule/match-rules.ts
+++ b/apps/web/utils/ai/choose-rule/match-rules.ts
@@ -16,7 +16,7 @@ import {
 } from "@prisma/client";
 import prisma from "@/utils/prisma";
 import { aiChooseRule } from "@/utils/ai/choose-rule/ai-choose-rule";
-import { getEmailFromMessage } from "@/utils/ai/choose-rule/get-email-from-message";
+import { getEmailForLLM } from "@/utils/ai/choose-rule/get-email-from-message";
 import { isReplyInThread } from "@/utils/thread";
 import type { UserAIFields } from "@/utils/llms/types";
 import { createScopedLogger } from "@/utils/logger";
@@ -198,7 +198,7 @@ async function findMatchingRuleWithReasons(
 
   if (potentialMatches?.length) {
     const result = await aiChooseRule({
-      email: getEmailFromMessage(message),
+      email: getEmailForLLM(message),
       rules: potentialMatches,
       user,
     });
diff --git a/apps/web/utils/ai/choose-rule/run-rules.ts b/apps/web/utils/ai/choose-rule/run-rules.ts
index c15496d198..13c28ed403 100644
--- a/apps/web/utils/ai/choose-rule/run-rules.ts
+++ b/apps/web/utils/ai/choose-rule/run-rules.ts
@@ -14,7 +14,7 @@ import type { ActionItem } from "@/utils/ai/actions";
 import { findMatchingRule } from "@/utils/ai/choose-rule/match-rules";
 import { getActionItemsWithAiArgs } from "@/utils/ai/choose-rule/ai-choose-args";
 import { executeAct } from "@/utils/ai/choose-rule/execute";
-import { getEmailFromMessage } from "@/utils/ai/choose-rule/get-email-from-message";
+import { getEmailForLLM } from "@/utils/ai/choose-rule/get-email-from-message";
 import prisma from "@/utils/prisma";
 import { createScopedLogger } from "@/utils/logger";
 import type { MatchReason } from "@/utils/ai/choose-rule/types";
@@ -74,7 +74,7 @@ async function runRule(
   matchReasons: MatchReason[] | undefined,
   isTest: boolean,
 ) {
-  const email = getEmailFromMessage(message);
+  const email = getEmailForLLM(message);
 
   // get action items with args
   const actionItems = await getActionItemsWithAiArgs({
@@ -89,8 +89,8 @@ async function runRule(
     : await saveExecutedRule(
         {
           userId: user.id,
-          threadId: email.threadId,
-          messageId: email.messageId,
+          threadId: message.threadId,
+          messageId: message.id,
         },
         {
           rule,
@@ -106,7 +106,7 @@ async function runRule(
       gmail,
       userEmail: user.email || "",
       executedRule,
-      email,
+      email: message,
     });
   }
 
diff --git a/apps/web/utils/ai/choose-rule/stringify-email.ts b/apps/web/utils/ai/choose-rule/stringify-email.ts
index 490eceff1f..f865d9554f 100644
--- a/apps/web/utils/ai/choose-rule/stringify-email.ts
+++ b/apps/web/utils/ai/choose-rule/stringify-email.ts
@@ -1,14 +1,8 @@
 import { removeExcessiveWhitespace, truncate } from "@/utils/string";
-
-export type EmailForLLM = {
-  from: string;
-  replyTo?: string;
-  cc?: string;
-  subject: string;
-  content: string;
-};
+import type { EmailForLLM } from "@/utils/types";
 
 export function stringifyEmail(email: EmailForLLM, maxLength: number) {
+  // TODO: not sure we need to do truncate/removeExcessiveWhitespace here as `emailToContent` will do this. but need to make sure it's always called
   const emailParts = [
     `<from>${email.from}</from>`,
     email.replyTo && `<replyTo>${email.replyTo}</replyTo>`,
@@ -19,3 +13,13 @@ export function stringifyEmail(email: EmailForLLM, maxLength: number) {
 
   return emailParts.filter(Boolean).join("\n");
 }
+
+export function stringifyEmailSimple(email: EmailForLLM) {
+  const emailParts = [
+    `<from>${email.from}</from>`,
+    `<subject>${email.subject}</subject>`,
+    `<body>${email.content}</body>`,
+  ];
+
+  return emailParts.filter(Boolean).join("\n");
+}
diff --git a/apps/web/utils/ai/rule/create-prompt-from-rule.ts b/apps/web/utils/ai/rule/create-prompt-from-rule.ts
index 42da6d1fa0..6433a717c2 100644
--- a/apps/web/utils/ai/rule/create-prompt-from-rule.ts
+++ b/apps/web/utils/ai/rule/create-prompt-from-rule.ts
@@ -2,14 +2,24 @@ import {
   type Action,
   type Rule,
   type Category,
-  type Group,
   ActionType,
+  type Prisma,
 } from "@prisma/client";
 
 export type RuleWithRelations = Rule & {
   actions: Action[];
   categoryFilters?: Category[];
-  group?: Group | null;
+  group?:
+    | (Prisma.GroupGetPayload<{
+        select: { id: true; name: true };
+      }> & {
+        items?:
+          | Prisma.GroupItemGetPayload<{
+              select: { id: true; type: true; value: true };
+            }>[]
+          | null;
+      })
+    | null;
 };
 
 export function createPromptFromRule(rule: RuleWithRelations): string {
diff --git a/apps/web/utils/ai/rule/create-rule-schema.ts b/apps/web/utils/ai/rule/create-rule-schema.ts
index 953467aa08..7e7e69e09f 100644
--- a/apps/web/utils/ai/rule/create-rule-schema.ts
+++ b/apps/web/utils/ai/rule/create-rule-schema.ts
@@ -18,13 +18,13 @@ const conditionSchema = z
       .string()
       .optional()
       .describe(
-        "Instructions for the AI to determine when to apply this rule. For example: 'Apply this rule to emails about product updates' or 'Use this rule for messages discussing project deadlines'. Be specific about the email content or characteristics that should trigger this rule. Leave blank if using static conditions or groups.",
+        "Instructions for the AI to determine when to apply this rule. For example: 'Apply this rule to emails about product updates' or 'Use this rule for messages discussing project deadlines'. Be specific about the email content or characteristics that should trigger this rule.",
       ),
     static: z
       .object({
         from: z.string().optional().describe("The from email address to match"),
         to: z.string().optional().describe("The to email address to match"),
-        subject: z.string().optional().describe("The subject to match."),
+        subject: z.string().optional().describe("The subject to match"),
       })
       .optional()
       .describe(
@@ -122,7 +122,7 @@ export const getCreateRuleSchemaWithCategories = (
 };
 
 type CreateRuleSchema = z.infer<typeof createRuleSchema>;
-type CreateRuleSchemaWithCategories = CreateRuleSchema & {
+export type CreateRuleSchemaWithCategories = CreateRuleSchema & {
   condition: CreateRuleSchema["condition"] & {
     categories?: {
       categoryFilterType: CategoryFilterType;
diff --git a/apps/web/utils/ai/rule/rule-fix.ts b/apps/web/utils/ai/rule/rule-fix.ts
index 2801cf73d6..55dc531f16 100644
--- a/apps/web/utils/ai/rule/rule-fix.ts
+++ b/apps/web/utils/ai/rule/rule-fix.ts
@@ -1,8 +1,6 @@
 import { z } from "zod";
-import {
-  type EmailForLLM,
-  stringifyEmail,
-} from "@/utils/ai/choose-rule/stringify-email";
+import { stringifyEmail } from "@/utils/ai/choose-rule/stringify-email";
+import type { EmailForLLM } from "@/utils/types";
 import { chatCompletionObject } from "@/utils/llms";
 import type { UserAIFields } from "@/utils/llms/types";
 import type { Rule, User } from "@prisma/client";
@@ -11,7 +9,7 @@ import { createScopedLogger } from "@/utils/logger";
 const logger = createScopedLogger("AI Rule Fix");
 
 export type RuleFixResponse = {
-  rule: "actual_rule" | "expected_rule";
+  ruleToFix: "actual_rule" | "expected_rule";
   fixedInstructions: string;
 };
 
@@ -84,55 +82,56 @@ Please provide the fixed rule.`;
   logger.trace("ai-rule-fix", { res });
 
   return {
-    rule: res.rule ?? (actualRule === null ? "expected_rule" : "actual_rule"),
+    ruleToFix:
+      res.rule ?? (actualRule === null ? "expected_rule" : "actual_rule"),
     fixedInstructions: res.fixedInstructions,
   };
 }
 
 // But messy. May refactor this in the future into 3 functions above
 function getRuleFixPromptConfig(
-  incorrectRule: Pick<Rule, "instructions"> | null,
-  correctRule: Pick<Rule, "instructions"> | null,
+  actualRule: Pick<Rule, "instructions"> | null,
+  expectedRule: Pick<Rule, "instructions"> | null,
 ): {
   problem: string;
   schema: z.ZodSchema;
   examples: string[];
 } {
-  if (incorrectRule && correctRule) {
+  if (actualRule && expectedRule) {
     return {
       problem: `Here is the rule it matched against:
 <actual_rule>
-${incorrectRule.instructions}
+${actualRule.instructions}
 </actual_rule>
 
 Here is the rule it was expected to match:
 <expected_rule>
-${correctRule.instructions}
+${expectedRule.instructions}
 </expected_rule>
 
 Based on the email content, determine which rule needs fixing and provide its improved version. The fixed rule should correctly handle the email while maintaining the original rule's intent.`,
       schema: z.object({
-        rule: z.enum(["actual_rule", "expected_rule"]),
+        ruleToFix: z.enum(["actual_rule", "expected_rule"]),
         fixedInstructions: z.string().describe("The updated instructions"),
       }),
       examples: [
         `{
-  "rule": "actual_rule",
+  "ruleToFix": "actual_rule",
   "fixedInstructions": "Apply this rule to emails reporting technical issues, bugs, or website problems, but DO NOT apply this to technical newsletters."
 }`,
         `{
-  "rule": "expected_rule",
+  "ruleToFix": "expected_rule",
   "fixedInstructions": "Match cold emails from recruiters about job opportunities, but exclude automated job alerts or marketing emails from job boards."
 }`,
       ],
     };
   }
 
-  if (incorrectRule) {
+  if (actualRule) {
     return {
       problem: `Here is the rule it matched against that it shouldn't have matched:
 <rule>
-${incorrectRule.instructions}
+${actualRule.instructions}
 </rule>`,
       schema: z.object({
         fixedInstructions: z.string().describe("The updated instructions"),
@@ -145,11 +144,11 @@ ${incorrectRule.instructions}
     };
   }
 
-  if (correctRule) {
+  if (expectedRule) {
     return {
       problem: `Here is the rule it should have matched:
 <expected_rule>
-${correctRule.instructions}
+${expectedRule.instructions}
 </expected_rule>`,
       schema: z.object({
         fixedInstructions: z.string().describe("The updated instructions"),
diff --git a/apps/web/utils/ai/snippets/find-snippets.ts b/apps/web/utils/ai/snippets/find-snippets.ts
index 4d0720a364..91189fb3e3 100644
--- a/apps/web/utils/ai/snippets/find-snippets.ts
+++ b/apps/web/utils/ai/snippets/find-snippets.ts
@@ -1,8 +1,6 @@
 import { z } from "zod";
-import {
-  type EmailForLLM,
-  stringifyEmail,
-} from "@/utils/ai/choose-rule/stringify-email";
+import { stringifyEmail } from "@/utils/ai/choose-rule/stringify-email";
+import type { EmailForLLM } from "@/utils/types";
 import { chatCompletionObject } from "@/utils/llms";
 import type { UserAIFields } from "@/utils/llms/types";
 import type { User } from "@prisma/client";
diff --git a/apps/web/utils/assistant/is-assistant-email.test.ts b/apps/web/utils/assistant/is-assistant-email.test.ts
new file mode 100644
index 0000000000..5af7d84031
--- /dev/null
+++ b/apps/web/utils/assistant/is-assistant-email.test.ts
@@ -0,0 +1,84 @@
+import { describe, it, expect } from "vitest";
+import { isAssistantEmail } from "./is-assistant-email";
+
+describe("isAssistantEmail", () => {
+  it("should return true when recipient is user's assistant email", () => {
+    const result = isAssistantEmail({
+      userEmail: "john@example.com",
+      emailToCheck: "john+assistant@example.com",
+    });
+    expect(result).toBe(true);
+  });
+
+  it("should return false when recipient is not user's assistant email", () => {
+    const result = isAssistantEmail({
+      userEmail: "john@example.com",
+      emailToCheck: "jane+assistant@example.com",
+    });
+    expect(result).toBe(false);
+  });
+
+  it("should return false when recipient has different format", () => {
+    const result = isAssistantEmail({
+      userEmail: "john@example.com",
+      emailToCheck: "john@example.com",
+    });
+    expect(result).toBe(false);
+  });
+
+  it("should handle email addresses with multiple dots", () => {
+    const result = isAssistantEmail({
+      userEmail: "john.middle.doe@sub.example.com",
+      emailToCheck: "john.middle.doe+assistant@sub.example.com",
+    });
+    expect(result).toBe(true);
+  });
+
+  it("should handle recipient email with display name and angle brackets", () => {
+    const result = isAssistantEmail({
+      userEmail: "john@example.com",
+      emailToCheck: "John Doe <john+assistant@example.com>",
+    });
+    expect(result).toBe(true);
+  });
+
+  it("should reject malicious suffix injection", () => {
+    const result = isAssistantEmail({
+      userEmail: "john@example.com",
+      emailToCheck: "john+assistant@evil.com+assistant@example.com",
+    });
+    expect(result).toBe(false);
+  });
+
+  it("should reject multiple plus signs", () => {
+    const result = isAssistantEmail({
+      userEmail: "john@example.com",
+      emailToCheck: "john+evil+assistant@example.com",
+    });
+    expect(result).toBe(false);
+  });
+
+  it("should reject assistant in wrong position", () => {
+    const result = isAssistantEmail({
+      userEmail: "john@example.com",
+      emailToCheck: "john+evilassistant@example.com",
+    });
+    expect(result).toBe(false);
+  });
+
+  it("should reject case manipulation", () => {
+    const result = isAssistantEmail({
+      userEmail: "john@example.com",
+      emailToCheck: "john+ASSISTANT@example.com",
+    });
+    expect(result).toBe(false);
+  });
+
+  it("should match valid assistant email with number", () => {
+    const result = isAssistantEmail({
+      userEmail: "john@example.com",
+      emailToCheck: "john+assistant42@example.com",
+    });
+    expect(result).toBe(true);
+  });
+});
diff --git a/apps/web/utils/assistant/is-assistant-email.ts b/apps/web/utils/assistant/is-assistant-email.ts
new file mode 100644
index 0000000000..18e4973159
--- /dev/null
+++ b/apps/web/utils/assistant/is-assistant-email.ts
@@ -0,0 +1,18 @@
+import { extractEmailAddress } from "@/utils/email";
+
+const ASSISTANT_SUFFIX = "assistant";
+
+export function isAssistantEmail({
+  userEmail,
+  emailToCheck,
+}: {
+  userEmail: string;
+  emailToCheck: string;
+}): boolean {
+  const [localPart, domain] = userEmail.split("@");
+  const extractedEmailToCheck = extractEmailAddress(emailToCheck);
+  const pattern = new RegExp(
+    `^${localPart}\\+${ASSISTANT_SUFFIX}\\d*@${domain}$`,
+  );
+  return pattern.test(extractedEmailToCheck);
+}
diff --git a/apps/web/utils/assistant/process-assistant-email.ts b/apps/web/utils/assistant/process-assistant-email.ts
new file mode 100644
index 0000000000..ff9ba41798
--- /dev/null
+++ b/apps/web/utils/assistant/process-assistant-email.ts
@@ -0,0 +1,225 @@
+import type { gmail_v1 } from "@googleapis/gmail";
+import type { MessageWithPayload, ParsedMessage } from "@/utils/types";
+import { createScopedLogger } from "@/utils/logger";
+import { getMessageByRfc822Id } from "@/utils/gmail/message";
+import { processUserRequest } from "@/utils/ai/assistant/process-user-request";
+import { extractEmailAddress } from "@/utils/email";
+import prisma from "@/utils/prisma";
+import { emailToContent, parseMessage } from "@/utils/mail";
+import { replyToEmail } from "@/utils/gmail/mail";
+import { getThread } from "@/utils/gmail/thread";
+import { isAssistantEmail } from "@/utils/assistant/is-assistant-email";
+import { GmailLabel } from "@/utils/gmail/label";
+
+const logger = createScopedLogger("process-assistant-email");
+
+export async function processAssistantEmail({
+  userEmail,
+  userId,
+  message,
+  gmail,
+}: {
+  userEmail: string;
+  userId: string;
+  message: ParsedMessage;
+  gmail: gmail_v1.Gmail;
+}) {
+  if (!verifyUserSentEmail(message, userEmail)) {
+    logger.error("Unauthorized assistant access attempt", {
+      userEmail: userEmail,
+      from: message.headers.from,
+      to: message.headers.to,
+    });
+    throw new Error("Unauthorized assistant access attempt");
+  }
+
+  logger.info("Processing assistant email", { messageId: message.id });
+
+  // 1. get thread
+  // 2. get first message in thread to the personal assistant
+  // 3. get the referenced message from that message
+
+  const thread = await getThread(message.threadId, gmail);
+  const threadMessages = thread?.messages
+    ?.map((m) => parseMessage(m as MessageWithPayload))
+    .filter((m) => !m.labelIds?.includes(GmailLabel.DRAFT));
+
+  if (!threadMessages?.length) {
+    logger.error("No thread messages found", { messageId: message.id });
+    await replyToEmail(
+      gmail,
+      message,
+      "Something went wrong. I couldn't read any messages.",
+    );
+    return;
+  }
+
+  const firstMessageToAssistant = threadMessages.find((m) =>
+    isAssistantEmail({
+      userEmail,
+      emailToCheck: m.headers.to,
+    }),
+  );
+
+  if (!firstMessageToAssistant) {
+    logger.error("No first message to assistant found", {
+      messageId: message.id,
+    });
+    await replyToEmail(
+      gmail,
+      message,
+      "Something went wrong. I couldn't find the first message to the personal assistant.",
+    );
+    return;
+  }
+
+  const originalMessageId = firstMessageToAssistant.headers["in-reply-to"];
+  const originalMessage = await getOriginalMessage(originalMessageId, gmail);
+
+  const [user, executedRule, senderCategory] = await Promise.all([
+    prisma.user.findUnique({
+      where: { email: userEmail },
+      select: {
+        id: true,
+        email: true,
+        about: true,
+        aiProvider: true,
+        aiModel: true,
+        aiApiKey: true,
+        rules: {
+          include: {
+            actions: true,
+            categoryFilters: true,
+            group: {
+              select: {
+                id: true,
+                name: true,
+                items: {
+                  select: {
+                    id: true,
+                    type: true,
+                    value: true,
+                  },
+                },
+              },
+            },
+          },
+        },
+        categories: true,
+      },
+    }),
+    originalMessage
+      ? prisma.executedRule.findUnique({
+          where: {
+            unique_user_thread_message: {
+              userId,
+              threadId: originalMessage.threadId,
+              messageId: originalMessage.id,
+            },
+          },
+          select: {
+            rule: {
+              include: {
+                actions: true,
+                categoryFilters: true,
+                group: true,
+              },
+            },
+          },
+        })
+      : null,
+    originalMessage
+      ? prisma.newsletter.findUnique({
+          where: {
+            email_userId: {
+              userId,
+              email: originalMessage.headers.from,
+            },
+          },
+          select: {
+            category: { select: { name: true } },
+          },
+        })
+      : null,
+  ]);
+
+  if (!user) {
+    logger.error("User not found", { userEmail });
+    return;
+  }
+
+  const firstMessageToAssistantDate = new Date(
+    firstMessageToAssistant.headers.date,
+  );
+
+  const messages = threadMessages
+    .filter((m) => new Date(m.headers.date) >= firstMessageToAssistantDate)
+    .map((m) => {
+      const isAssistant = isAssistantEmail({
+        userEmail,
+        emailToCheck: m.headers.from,
+      });
+      const isFirstMessageToAssistant = m.id === firstMessageToAssistant.id;
+
+      let content = "";
+
+      // use subject if first message
+      if (isFirstMessageToAssistant && !originalMessage) {
+        content += `Subject: ${m.headers.subject}\n\n`;
+      }
+
+      content += emailToContent(m, {
+        extractReply: true,
+        removeForwarded: isFirstMessageToAssistant,
+      });
+
+      return {
+        role: isAssistant ? "assistant" : "user",
+        content,
+      } as const;
+    });
+
+  const result = await processUserRequest({
+    user,
+    rules: user.rules,
+    originalEmail: originalMessage,
+    messages,
+    matchedRule: executedRule?.rule || null,
+    categories: user.categories.length ? user.categories : null,
+    senderCategory: senderCategory?.category?.name ?? null,
+  });
+
+  const toolCalls = result.steps.flatMap((step) => step.toolCalls);
+  const lastToolCall = toolCalls[toolCalls.length - 1];
+
+  if (lastToolCall?.toolName === "reply") {
+    await replyToEmail(
+      gmail,
+      message,
+      lastToolCall.args.content,
+      replaceName(message.headers.to, "Assistant"),
+    );
+  }
+}
+
+function verifyUserSentEmail(message: ParsedMessage, userEmail: string) {
+  return (
+    extractEmailAddress(message.headers.from).toLowerCase() ===
+    userEmail.toLowerCase()
+  );
+}
+
+function replaceName(email: string, name: string) {
+  const emailAddress = extractEmailAddress(email);
+  return `${name} <${emailAddress}>`;
+}
+
+async function getOriginalMessage(
+  originalMessageId: string | undefined,
+  gmail: gmail_v1.Gmail,
+) {
+  if (!originalMessageId) return null;
+  const originalMessage = await getMessageByRfc822Id(originalMessageId, gmail);
+  if (!originalMessage) return null;
+  return parseMessage(originalMessage);
+}
diff --git a/apps/web/utils/categorize/senders/categorize.ts b/apps/web/utils/categorize/senders/categorize.ts
index 99e75a7ecc..8324d2d46e 100644
--- a/apps/web/utils/categorize/senders/categorize.ts
+++ b/apps/web/utils/categorize/senders/categorize.ts
@@ -100,6 +100,26 @@ export async function updateSenderCategory({
   };
 }
 
+export async function updateCategoryForSender({
+  userId,
+  sender,
+  categoryId,
+}: {
+  userId: string;
+  sender: string;
+  categoryId: string;
+}) {
+  await prisma.newsletter.upsert({
+    where: { email_userId: { email: sender, userId } },
+    update: { categoryId },
+    create: {
+      email: sender,
+      userId,
+      categoryId,
+    },
+  });
+}
+
 // TODO: what if user doesn't have all these categories set up?
 // Use static rules to categorize senders if we can, before sending to LLM
 function preCategorizeSendersWithStaticRules(
diff --git a/apps/web/utils/category.server.ts b/apps/web/utils/category.server.ts
index 6f2a1e43fe..84d1c6f96c 100644
--- a/apps/web/utils/category.server.ts
+++ b/apps/web/utils/category.server.ts
@@ -27,3 +27,23 @@ export const getUserCategoriesWithRules = async (userId: string) => {
   });
   return categories;
 };
+
+export const getUserCategoriesForNames = async (
+  userId: string,
+  names: string[],
+) => {
+  if (!names.length) return [];
+
+  const categories = await prisma.category.findMany({
+    where: { userId, name: { in: names } },
+    select: { id: true },
+  });
+  if (categories.length !== names.length) {
+    console.warn("Not all categories were found", {
+      requested: names.length,
+      found: categories.length,
+      names,
+    });
+  }
+  return categories.map((c) => c.id);
+};
diff --git a/apps/web/utils/email.test.ts b/apps/web/utils/email.test.ts
index 73976df322..0e9c90ac5f 100644
--- a/apps/web/utils/email.test.ts
+++ b/apps/web/utils/email.test.ts
@@ -43,6 +43,40 @@ describe("email utils", () => {
         "john.doe@gmail.com",
       );
     });
+
+    it("handles nested angle brackets", () => {
+      expect(
+        extractEmailAddress("Hacker <fake@email.com> <real@email.com>"),
+      ).toBe("real@email.com");
+    });
+
+    it("handles malformed angle brackets", () => {
+      expect(extractEmailAddress("Bad <<not@an@email>>")).toBe("");
+    });
+
+    it("extracts valid email when mixed with invalid ones", () => {
+      expect(
+        extractEmailAddress("Test <not@valid@email> <valid@email.com>"),
+      ).toBe("valid@email.com");
+    });
+
+    it("handles empty angle brackets", () => {
+      expect(extractEmailAddress("Test <>")).toBe("");
+    });
+
+    it("handles multiple @ symbols", () => {
+      expect(extractEmailAddress("Test <user@@domain.com>")).toBe("");
+    });
+
+    it("validates email format", () => {
+      expect(extractEmailAddress("Test <notanemail>")).toBe("");
+    });
+
+    it("extracts raw email when no valid bracketed email exists", () => {
+      expect(extractEmailAddress("Test <invalid> valid@email.com")).toBe(
+        "valid@email.com",
+      );
+    });
   });
 
   describe("extractDomainFromEmail", () => {
diff --git a/apps/web/utils/email.ts b/apps/web/utils/email.ts
index 6601fce72f..043bcebd6e 100644
--- a/apps/web/utils/email.ts
+++ b/apps/web/utils/email.ts
@@ -14,8 +14,23 @@ export function extractNameFromEmail(email: string) {
 
 // Converts "John Doe <john.doe@gmail>" to "john.doe@gmail"
 export function extractEmailAddress(email: string): string {
-  const match = email.match(/<(.*)>/);
-  return match ? match[1] : email;
+  // Standard email pattern that matches common email formats
+  // Allows:
+  // - Letters, numbers, dots, and plus signs in local part
+  // - Standard domain formats
+  // - Case insensitive
+  // - Emails anywhere within text
+  const emailPattern = /[a-zA-Z0-9.+]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/i;
+
+  // Try last bracketed content first
+  const match = email.match(/<([^<>]+)>$/);
+  if (match && emailPattern.test(match[1].trim())) {
+    return match[1].trim();
+  }
+
+  // Fall back to finding any email in the string
+  const rawMatch = email.match(emailPattern);
+  return rawMatch ? rawMatch[0] : "";
 }
 
 // Converts "Name <hey@domain.com>" to "domain.com"
diff --git a/apps/web/utils/gmail/mail.ts b/apps/web/utils/gmail/mail.ts
index 267240bba0..bc4fb034c2 100644
--- a/apps/web/utils/gmail/mail.ts
+++ b/apps/web/utils/gmail/mail.ts
@@ -11,6 +11,7 @@ import {
   forwardEmailSubject,
   forwardEmailText,
 } from "@/utils/gmail/forward";
+import type { ParsedMessage } from "@/utils/types";
 
 export const sendEmailBody = z.object({
   replyToEmail: z
@@ -48,8 +49,10 @@ const createMail = async (options: Mail.Options) => {
 
 const createRawMailMessage = async (
   body: Omit<SendEmailBody, "attachments"> & { attachments?: Attachment[] },
+  from?: string,
 ) => {
   return await createMail({
+    from,
     to: body.to,
     cc: body.cc,
     bcc: body.bcc,
@@ -81,8 +84,12 @@ const createRawMailMessage = async (
 
 // https://developers.google.com/gmail/api/guides/sending
 // https://www.labnol.org/google-api-service-account-220405
-export async function sendEmail(gmail: gmail_v1.Gmail, body: SendEmailBody) {
-  const raw = await createRawMailMessage(body);
+export async function sendEmail(
+  gmail: gmail_v1.Gmail,
+  body: SendEmailBody,
+  from?: string,
+) {
+  const raw = await createRawMailMessage(body, from);
 
   const result = await gmail.users.messages.send({
     userId: "me",
@@ -95,6 +102,78 @@ export async function sendEmail(gmail: gmail_v1.Gmail, body: SendEmailBody) {
   return result;
 }
 
+export async function replyToEmail(
+  gmail: gmail_v1.Gmail,
+  message: Pick<
+    ParsedMessage,
+    "threadId" | "headers" | "textPlain" | "textHtml"
+  >,
+  reply: string,
+  from?: string,
+) {
+  const quotedDate = formatEmailDate(new Date(message.headers.date));
+  const quotedHeader = `On ${quotedDate}, ${message.headers.from} wrote:`;
+
+  // Detect text direction from original message
+  const textDirection = detectTextDirection(message.textPlain || "");
+  const dirAttribute = `dir="${textDirection}"`;
+
+  // Format plain text version with proper quoting
+  const quotedContent = message.textPlain
+    ?.split("\n")
+    .map((line) => `> ${line}`)
+    .join("\n");
+  const plainText = `${reply}\n\n${quotedHeader}\n\n${quotedContent}`;
+
+  // Format HTML version with Gmail-style quote formatting
+  const htmlContent = `
+    <div ${dirAttribute}>${reply.replace(/\n/g, "<br>")}</div>
+    <br>
+    <div class="gmail_quote">
+      <div ${dirAttribute} class="gmail_attr">${quotedHeader}</div>
+      <blockquote class="gmail_quote" 
+        style="margin:0px 0px 0px 0.8ex;border-left:1px solid rgb(204,204,204);padding-left:1ex">
+        ${message.textHtml || message.textPlain?.replace(/\n/g, "<br>")}
+      </blockquote>
+    </div>
+  `.trim();
+
+  return sendEmail(
+    gmail,
+    {
+      to: message.headers["reply-to"] || message.headers.from,
+      subject: message.headers.subject,
+      messageText: plainText,
+      messageHtml: htmlContent,
+      replyToEmail: {
+        threadId: message.threadId,
+        headerMessageId: message.headers["message-id"] || "",
+        references: message.headers.references,
+      },
+    },
+    from,
+  );
+}
+
+function detectTextDirection(text: string): "ltr" | "rtl" {
+  // Basic RTL detection - checks for RTL characters at the start of the text
+  const rtlRegex =
+    /[\u0591-\u07FF\u200F\u202B\u202E\uFB1D-\uFDFD\uFE70-\uFEFC]/;
+  return rtlRegex.test(text.trim().charAt(0)) ? "rtl" : "ltr";
+}
+
+function formatEmailDate(date: Date): string {
+  return date.toLocaleString("en-US", {
+    weekday: "short",
+    year: "numeric",
+    month: "short",
+    day: "numeric",
+    hour: "numeric",
+    minute: "numeric",
+    hour12: true,
+  });
+}
+
 export async function forwardEmail(
   gmail: gmail_v1.Gmail,
   options: {
diff --git a/apps/web/utils/gmail/message.ts b/apps/web/utils/gmail/message.ts
index 637f46b57f..770763d5c5 100644
--- a/apps/web/utils/gmail/message.ts
+++ b/apps/web/utils/gmail/message.ts
@@ -24,6 +24,31 @@ export async function getMessage(
   return message.data as MessageWithPayload;
 }
 
+export async function getMessageByRfc822Id(
+  rfc822MessageId: string,
+  gmail: gmail_v1.Gmail,
+) {
+  // Search for message using RFC822 Message-ID header
+  // Remove any < > brackets if present
+  const cleanMessageId = rfc822MessageId.replace(/[<>]/g, "");
+
+  const response = await gmail.users.messages.list({
+    userId: "me",
+    q: `rfc822msgid:${cleanMessageId}`,
+    maxResults: 1,
+  });
+
+  const message = response.data.messages?.[0];
+  if (!message?.id) {
+    console.error("No message found for RFC822 Message-ID", {
+      rfc822MessageId,
+    });
+    return null;
+  }
+
+  return getMessage(message.id, gmail);
+}
+
 export async function getMessagesBatch(
   messageIds: string[],
   accessToken: string,
diff --git a/apps/web/utils/group/group-item.ts b/apps/web/utils/group/group-item.ts
new file mode 100644
index 0000000000..fdcee6c947
--- /dev/null
+++ b/apps/web/utils/group/group-item.ts
@@ -0,0 +1,29 @@
+import prisma, { isDuplicateError } from "@/utils/prisma";
+import type { GroupItemType } from "@prisma/client";
+import { captureException } from "@/utils/error";
+
+export async function addGroupItem(data: {
+  groupId: string;
+  type: GroupItemType;
+  value: string;
+}) {
+  try {
+    return await prisma.groupItem.create({ data });
+  } catch (error) {
+    if (isDuplicateError(error)) {
+      captureException(error, { extra: { items: data } });
+    } else {
+      throw error;
+    }
+  }
+}
+
+export async function deleteGroupItem({
+  id,
+  userId,
+}: {
+  id: string;
+  userId: string;
+}) {
+  await prisma.groupItem.delete({ where: { id, group: { userId } } });
+}
diff --git a/apps/web/utils/llms/index.ts b/apps/web/utils/llms/index.ts
index e37e60aff0..0c2da2178b 100644
--- a/apps/web/utils/llms/index.ts
+++ b/apps/web/utils/llms/index.ts
@@ -1,6 +1,7 @@
 import type { z } from "zod";
 import {
   APICallError,
+  type CoreMessage,
   type CoreTool,
   generateObject,
   generateText,
@@ -198,22 +199,32 @@ export async function chatCompletionStream({
 
 type ChatCompletionToolsArgs = {
   userAi: UserAIFields;
-  prompt: string;
-  system?: string;
   tools: Record<string, CoreTool>;
   maxSteps?: number;
   label: string;
   userEmail: string;
-};
+} & (
+  | {
+      system?: string;
+      prompt: string;
+      messages?: never;
+    }
+  | {
+      system?: never;
+      prompt?: never;
+      messages: CoreMessage[];
+    }
+);
 
-export async function chatCompletionTools<T>(options: ChatCompletionToolsArgs) {
+export async function chatCompletionTools(options: ChatCompletionToolsArgs) {
   return withBackupModel(chatCompletionToolsInternal, options);
 }
 
 async function chatCompletionToolsInternal({
   userAi,
-  prompt,
   system,
+  prompt,
+  messages,
   tools,
   maxSteps,
   label,
@@ -226,8 +237,9 @@ async function chatCompletionToolsInternal({
       model: llmModel,
       tools,
       toolChoice: "required",
-      prompt,
       system,
+      prompt,
+      messages,
       maxSteps,
       experimental_telemetry: { isEnabled: true },
     });
diff --git a/apps/web/utils/logger.ts b/apps/web/utils/logger.ts
index bdf00153d7..1878b96fa5 100644
--- a/apps/web/utils/logger.ts
+++ b/apps/web/utils/logger.ts
@@ -40,7 +40,7 @@ export function createScopedLogger(scope: string) {
       console.warn(formatMessage("warn", message, args)),
 
     trace: (message: string, ...args: unknown[]) => {
-      if (process.env.NODE_ENV === "development") {
+      if (process.env.NODE_ENV !== "production") {
         console.log(formatMessage("trace", message, args));
       }
     },
@@ -56,7 +56,7 @@ function createAxiomLogger(scope: string) {
     warn: (message: string, args?: Record<string, unknown>) =>
       log.warn(message, { scope, ...args }),
     trace: (message: string, args?: Record<string, unknown>) => {
-      if (process.env.NODE_ENV === "development") {
+      if (process.env.NODE_ENV !== "production") {
         log.debug(message, { scope, ...args });
       }
     },
diff --git a/apps/web/utils/mail.ts b/apps/web/utils/mail.ts
index 33a8c649f1..ea66090b92 100644
--- a/apps/web/utils/mail.ts
+++ b/apps/web/utils/mail.ts
@@ -1,22 +1,23 @@
 import "server-only";
 import parse from "gmail-api-parse-message";
-import replyParser from "node-email-reply-parser";
+import EmailReplyParser from "email-reply-parser";
 import { convert } from "html-to-text";
 import type {
   ThreadWithPayloadMessages,
   MessageWithPayload,
   ParsedMessage,
 } from "@/utils/types";
-import { truncate } from "@/utils/string";
+import { removeExcessiveWhitespace, truncate } from "@/utils/string";
 
 export function parseMessage(message: MessageWithPayload): ParsedMessage {
   return parse(message);
 }
 
 // if the email content contains a lot of replies this parses it and finds the content from the last message
-export function parseReply(content: string) {
-  const email = replyParser(content);
-  return email.getVisibleText();
+function parseReply(plainText: string) {
+  const parser = new EmailReplyParser().read(plainText);
+  const result = parser.getVisibleText();
+  return result;
 }
 
 export function parseMessages(thread: ThreadWithPayloadMessages) {
@@ -46,23 +47,6 @@ function htmlToText(html: string, removeLinks = true, removeImages = true) {
   return text;
 }
 
-// extract replies can sometimes return no content.
-// as we don't run ai on threads with multiple messages, 'extractReply' can be disabled for now
-function parseEmail(
-  html: string,
-  extractReply = false,
-  maxLength: number | null = 2000,
-) {
-  // 1. remove replies
-  // 2. remove html
-  // 3. truncate
-
-  const text = htmlToText(extractReply ? parseReply(html) : html);
-  const truncatedText = maxLength === null ? text : truncate(text, maxLength);
-
-  return truncatedText;
-}
-
 export function getEmailClient(messageId: string) {
   if (messageId.includes("mail.gmail.com")) return "gmail";
   if (messageId.includes("we.are.superhuman.com")) return "superhuman";
@@ -73,18 +57,62 @@ export function getEmailClient(messageId: string) {
   return emailClient;
 }
 
+function removeForwardedContent(text: string): string {
+  const forwardPatterns = [
+    // Gmail style
+    /(?:\r?\n|\r)?(?:-{3,}|_{3,})\s*Forwarded message\s*(?:-{3,}|_{3,})/i,
+    // Simple forward markers
+    /(?:\r?\n|\r)?(?:-{3,}|_{3,})\s*Forward(?:ed)?(?:\s*message)?(?:-{3,}|_{3,})/i,
+    // Email headers
+    /(?:\r?\n|\r)?From:[\s\S]*?Subject:/m,
+    // iOS/Mac style
+    /(?:\r?\n|\r)?Begin forwarded message:/im,
+    // Outlook style
+    /(?:\r?\n|\r)?Original Message/i,
+  ];
+
+  for (const pattern of forwardPatterns) {
+    const parts = text.split(pattern);
+    if (parts.length > 1) {
+      // Take content before the forward marker and clean it
+      return removeExcessiveWhitespace(parts[0]);
+    }
+  }
+
+  return text;
+}
+
 export function emailToContent(
-  email: {
-    textHtml: string | null;
-    textPlain: string | null;
-    snippet: string | null;
-  },
-  options?: { maxLength: number },
+  email: Pick<ParsedMessage, "textHtml" | "textPlain" | "snippet">,
+  {
+    maxLength = 2000,
+    extractReply = false,
+    removeForwarded = false,
+  }: {
+    maxLength?: number;
+    extractReply?: boolean;
+    removeForwarded?: boolean;
+  } = {},
 ): string {
-  const content =
-    (email.textHtml && parseEmail(email.textHtml, false, options?.maxLength)) ||
-    email.textPlain ||
-    email.snippet;
+  let content = "";
+
+  if (email.textHtml) {
+    content = htmlToText(email.textHtml);
+  } else if (email.textPlain) {
+    content = email.textPlain;
+  } else if (email.snippet) {
+    content = email.snippet;
+  }
+
+  if (extractReply) {
+    content = parseReply(content);
+  }
+
+  if (removeForwarded) {
+    content = removeForwardedContent(content);
+  }
+
+  content = removeExcessiveWhitespace(content);
 
-  return content || "";
+  return maxLength ? truncate(content, maxLength) : content;
 }
diff --git a/apps/web/utils/rule/prompt-file.ts b/apps/web/utils/rule/prompt-file.ts
index 69dcc0edbf..087c4e7616 100644
--- a/apps/web/utils/rule/prompt-file.ts
+++ b/apps/web/utils/rule/prompt-file.ts
@@ -1,8 +1,19 @@
-import type { RuleWithRelations } from "@/utils/ai/rule/create-prompt-from-rule";
+import {
+  createPromptFromRule,
+  type RuleWithRelations,
+} from "@/utils/ai/rule/create-prompt-from-rule";
 import { generatePromptOnUpdateRule } from "@/utils/ai/rule/generate-prompt-on-update-rule";
 import prisma from "@/utils/prisma";
 
-export async function updateRulePromptOnRuleChange(
+export async function updatePromptFileOnRuleCreated(
+  userId: string,
+  rule: RuleWithRelations,
+) {
+  const prompt = createPromptFromRule(rule);
+  await appendRulePrompt(userId, prompt);
+}
+
+export async function updatePromptFileOnRuleUpdated(
   userId: string,
   currentRule: RuleWithRelations,
   updatedRule: RuleWithRelations,
@@ -32,7 +43,32 @@ export async function updateRulePromptOnRuleChange(
   });
 }
 
-export async function appendRulePrompt(userId: string, rulePrompt: string) {
+export async function updateRuleInstructionsAndPromptFile({
+  userId,
+  ruleId,
+  instructions,
+  currentRule,
+}: {
+  userId: string;
+  ruleId: string;
+  instructions: string;
+  currentRule: RuleWithRelations | null;
+}) {
+  const updatedRule = await prisma.rule.update({
+    where: { id: ruleId, userId },
+    data: { instructions },
+    include: { actions: true, categoryFilters: true, group: true },
+  });
+
+  // update prompt file
+  if (currentRule) {
+    await updatePromptFileOnRuleUpdated(userId, currentRule, updatedRule);
+  } else {
+    await appendRulePrompt(userId, instructions);
+  }
+}
+
+async function appendRulePrompt(userId: string, rulePrompt: string) {
   const user = await prisma.user.findUnique({
     where: { id: userId },
     select: { rulesPrompt: true },
diff --git a/apps/web/utils/rule/rule.ts b/apps/web/utils/rule/rule.ts
new file mode 100644
index 0000000000..bc797f5717
--- /dev/null
+++ b/apps/web/utils/rule/rule.ts
@@ -0,0 +1,243 @@
+import type { CreateOrUpdateRuleSchemaWithCategories } from "@/utils/ai/rule/create-rule-schema";
+import prisma, { isDuplicateError } from "@/utils/prisma";
+import { createScopedLogger } from "@/utils/logger";
+import {
+  type Action,
+  ActionType,
+  type Prisma,
+  type Rule,
+} from "@prisma/client";
+import { getUserCategoriesForNames } from "@/utils/category.server";
+
+const logger = createScopedLogger("rule");
+
+export function partialUpdateRule(ruleId: string, data: Partial<Rule>) {
+  return prisma.rule.update({
+    where: { id: ruleId },
+    data,
+    include: { actions: true, categoryFilters: true, group: true },
+  });
+}
+
+export async function safeCreateRule(
+  result: CreateOrUpdateRuleSchemaWithCategories,
+  userId: string,
+  groupId?: string | null,
+  categoryNames?: string[] | null,
+) {
+  const categoryIds = await getUserCategoriesForNames(
+    userId,
+    categoryNames || [],
+  );
+
+  try {
+    const rule = await createRule(result, userId, groupId, categoryNames);
+    return rule;
+  } catch (error) {
+    if (isDuplicateError(error, "name")) {
+      // if rule name already exists, create a new rule with a unique name
+      const rule = await createRule(
+        { ...result, name: `${result.name} - ${Date.now()}` },
+        userId,
+        groupId,
+        categoryIds,
+      );
+      return rule;
+    }
+
+    logger.error("Error creating rule", {
+      userId,
+      error:
+        error instanceof Error
+          ? { message: error.message, stack: error.stack, name: error.name }
+          : error,
+    });
+
+    return { error: "Error creating rule." };
+  }
+}
+
+export async function safeUpdateRule(
+  ruleId: string,
+  result: CreateOrUpdateRuleSchemaWithCategories,
+  userId: string,
+  groupId?: string | null,
+  categoryIds?: string[] | null,
+) {
+  try {
+    const rule = await updateRule(ruleId, result, userId, groupId, categoryIds);
+    return { id: rule.id };
+  } catch (error) {
+    if (isDuplicateError(error, "name")) {
+      // if rule name already exists, create a new rule with a unique name
+      const rule = await createRule(
+        { ...result, name: `${result.name} - ${Date.now()}` },
+        userId,
+        groupId,
+        categoryIds,
+      );
+      return { id: rule.id };
+    }
+
+    logger.error("Error updating rule", {
+      userId,
+      error:
+        error instanceof Error
+          ? { message: error.message, stack: error.stack, name: error.name }
+          : error,
+    });
+
+    return { error: "Error updating rule." };
+  }
+}
+
+async function createRule(
+  result: CreateOrUpdateRuleSchemaWithCategories,
+  userId: string,
+  groupId?: string | null,
+  categoryIds?: string[] | null,
+) {
+  return prisma.rule.create({
+    data: {
+      name: result.name,
+      userId,
+      actions: {
+        createMany: {
+          data: mapActionFields(result.actions),
+        },
+      },
+      automate: shouldAutomate(result.actions),
+      runOnThreads: shouldRunOnThreads(result.condition),
+      conditionalOperator: result.condition.conditionalOperator,
+      instructions: result.condition.aiInstructions,
+      from: result.condition.static?.from,
+      to: result.condition.static?.to,
+      subject: result.condition.static?.subject,
+      groupId,
+      categoryFilterType: result.condition.categories?.categoryFilterType,
+      categoryFilters: categoryIds
+        ? {
+            connect: categoryIds.map((id) => ({
+              id,
+            })),
+          }
+        : undefined,
+    },
+    include: { actions: true, categoryFilters: true, group: true },
+  });
+}
+
+async function updateRule(
+  ruleId: string,
+  result: CreateOrUpdateRuleSchemaWithCategories,
+  userId: string,
+  groupId?: string | null,
+  categoryIds?: string[] | null,
+) {
+  return prisma.rule.update({
+    where: { id: ruleId },
+    data: {
+      name: result.name,
+      userId,
+      // NOTE: this is safe for now as `Action` doesn't have relations
+      // but if we add relations to `Action`, we would need to `update` here instead of `deleteMany` and `createMany` to avoid cascading deletes
+      actions: {
+        deleteMany: {},
+        createMany: { data: mapActionFields(result.actions) },
+      },
+      automate: shouldAutomate(result.actions),
+      runOnThreads: shouldRunOnThreads(result.condition),
+      conditionalOperator: result.condition.conditionalOperator,
+      instructions: result.condition.aiInstructions,
+      from: result.condition.static?.from,
+      to: result.condition.static?.to,
+      subject: result.condition.static?.subject,
+      groupId,
+      categoryFilterType: result.condition.categories?.categoryFilterType,
+      categoryFilters: categoryIds
+        ? {
+            set: categoryIds.map((id) => ({
+              id,
+            })),
+          }
+        : undefined,
+    },
+  });
+}
+
+function shouldAutomate(actions: Pick<Action, "type">[]) {
+  const types = new Set(actions.map((action) => action.type));
+
+  // don't automate replies, forwards, and send emails
+  if (
+    types.has(ActionType.REPLY) ||
+    types.has(ActionType.FORWARD) ||
+    types.has(ActionType.SEND_EMAIL)
+  ) {
+    return false;
+  }
+
+  return true;
+}
+
+// run on threads for static, group, and smart category rules
+// user can enable to run on threads for ai rules themselves
+function shouldRunOnThreads(condition?: { aiInstructions?: string }) {
+  return !condition?.aiInstructions;
+}
+
+export async function addRuleCategories(ruleId: string, categoryIds: string[]) {
+  const rule = await prisma.rule.findUnique({
+    where: { id: ruleId },
+    include: { categoryFilters: true },
+  });
+
+  if (!rule) throw new Error("Rule not found");
+
+  const existingIds = rule.categoryFilters.map((c) => c.id) || [];
+  const newIds = [...new Set([...existingIds, ...categoryIds])];
+
+  return prisma.rule.update({
+    where: { id: ruleId },
+    data: { categoryFilters: { set: newIds.map((id) => ({ id })) } },
+    include: { actions: true, categoryFilters: true, group: true },
+  });
+}
+
+export async function removeRuleCategories(
+  ruleId: string,
+  categoryIds: string[],
+) {
+  const rule = await prisma.rule.findUnique({
+    where: { id: ruleId },
+    include: { categoryFilters: true },
+  });
+
+  if (!rule) throw new Error("Rule not found");
+
+  const existingIds = rule.categoryFilters.map((c) => c.id) || [];
+  const newIds = existingIds.filter((id) => !categoryIds.includes(id));
+
+  return prisma.rule.update({
+    where: { id: ruleId },
+    data: { categoryFilters: { set: newIds.map((id) => ({ id })) } },
+    include: { actions: true, categoryFilters: true, group: true },
+  });
+}
+
+function mapActionFields(
+  actions: CreateOrUpdateRuleSchemaWithCategories["actions"],
+) {
+  return actions.map(
+    (a): Prisma.ActionCreateManyRuleInput => ({
+      type: a.type,
+      label: a.fields?.label,
+      to: a.fields?.to,
+      cc: a.fields?.cc,
+      bcc: a.fields?.bcc,
+      subject: a.fields?.subject,
+      content: a.fields?.content,
+      url: a.fields?.webhookUrl,
+    }),
+  );
+}
diff --git a/apps/web/utils/sender.ts b/apps/web/utils/sender.ts
new file mode 100644
index 0000000000..27832ba8a9
--- /dev/null
+++ b/apps/web/utils/sender.ts
@@ -0,0 +1,29 @@
+import prisma from "@/utils/prisma";
+import { extractEmailAddress } from "@/utils/email";
+
+export async function findSenderByEmail({
+  userId,
+  email,
+}: {
+  userId: string;
+  email: string;
+}) {
+  const extractedEmail = extractEmailAddress(email);
+  if (!extractedEmail) return null;
+
+  const newsletter = await prisma.newsletter.findFirst({
+    where: {
+      userId,
+      email: { contains: extractedEmail },
+    },
+  });
+
+  if (!newsletter) return null;
+  if (
+    newsletter.email !== extractedEmail ||
+    newsletter.email.endsWith(`<${extractedEmail}>`)
+  )
+    return null;
+
+  return newsletter;
+}
diff --git a/apps/web/utils/types.ts b/apps/web/utils/types.ts
index c9aab65447..34fb1074ac 100644
--- a/apps/web/utils/types.ts
+++ b/apps/web/utils/types.ts
@@ -92,9 +92,19 @@ export interface ParsedMessageHeaders {
   from: string;
   to: string;
   cc?: string;
+  bcc?: string;
   date: string;
   "message-id"?: string;
   "reply-to"?: string;
+  "in-reply-to"?: string;
   references?: string;
   "list-unsubscribe"?: string;
 }
+
+export type EmailForLLM = {
+  from: string;
+  replyTo?: string;
+  cc?: string;
+  subject: string;
+  content: string;
+};
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 10b94cf799..d502a78a1d 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -282,6 +282,9 @@ importers:
       diff:
         specifier: ^7.0.0
         version: 7.0.0
+      email-reply-parser:
+        specifier: ^1.9.2
+        version: 1.9.2
       encoding:
         specifier: ^0.1.13
         version: 0.1.13
@@ -336,9 +339,6 @@ importers:
       next-sanity:
         specifier: '9'
         version: 9.4.7(@sanity/client@6.24.1)(@sanity/icons@3.5.6(react@18.3.1))(@sanity/types@3.68.3(@types/react@18.3.12))(@sanity/ui@2.10.12(@emotion/is-prop-valid@1.2.2)(react-dom@18.3.1(react@18.3.1))(react-is@18.3.1)(react@18.3.1)(styled-components@6.1.13(react-dom@18.3.1(react@18.3.1))(react@18.3.1)))(next@14.2.15(@babel/core@7.26.0)(@opentelemetry/api@1.9.0)(@playwright/test@1.49.1)(react-dom@18.3.1(react@18.3.1))(react@18.3.1))(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(sanity@3.68.3(@emotion/is-prop-valid@1.2.2)(@types/babel__core@7.20.5)(@types/node@22.10.2)(@types/react@18.3.12)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(styled-components@6.1.13(react-dom@18.3.1(react@18.3.1))(react@18.3.1))(terser@5.37.0))(styled-components@6.1.13(react-dom@18.3.1(react@18.3.1))(react@18.3.1))(svelte@4.2.12)
-      node-email-reply-parser:
-        specifier: ^0.1.4
-        version: 0.1.4
       nodemailer:
         specifier: ^6.9.16
         version: 6.9.16
@@ -445,6 +445,9 @@ importers:
       '@types/diff':
         specifier: ^6.0.0
         version: 6.0.0
+      '@types/email-reply-parser':
+        specifier: ^1.4.2
+        version: 1.4.2
       '@types/he':
         specifier: ^1.2.3
         version: 1.2.3
@@ -4400,6 +4403,7 @@ packages:
 
   '@sanity/block-tools@3.68.3':
     resolution: {integrity: sha512-XptqCO8yoj69fdao/goS69ITJatN6YD7aLOus6T5V13I62lFBdjmZS9nBJ7i1DxchKDbsUyuyw1aPcqoECsedA==}
+    deprecated: Renamed - use `@portabletext/block-tools` instead. `@sanity/block-tools` will no longer receive updates.
 
   '@sanity/browserslist-config@1.0.5':
     resolution: {integrity: sha512-so+/UtCge8t1jq509hH0otbbptRz0zM/Aa0dh5MhMD7HGT6n2igWIL2VWH/9QR9e77Jn3dJsjz23mW1WCxT+sg==}
@@ -5437,6 +5441,9 @@ packages:
     resolution: {integrity: sha512-g2FXjlDX/cYuc5CiQvyU/6kkbP1JtmGzh0obW50zD7OKeILVL0NSpPWLXVfqoAGQjom2/SLLx9zHq0KXvD6mbw==}
     deprecated: This is a stub types definition. dotenv provides its own type definitions, so you do not need this installed.
 
+  '@types/email-reply-parser@1.4.2':
+    resolution: {integrity: sha512-kmMoK9WMX4zXf3c0D3tkWHDl0E50V2dv6fVirdTQd/mkvE/Jixh0DZAh3kBgpltr1eaWM3W+kAf4A2c2Z2iU2A==}
+
   '@types/eslint-scope@3.7.7':
     resolution: {integrity: sha512-MzMFlSLBqNF2gcHWO0G1vP/YQyfvrxZ0bF+u7mzUdZ1/xK4A4sru+nraZz5i3iEIk1l1uyicaDVTB4QbbEkAYg==}
 
@@ -7203,6 +7210,15 @@ packages:
   electron-to-chromium@1.5.73:
     resolution: {integrity: sha512-8wGNxG9tAG5KhGd3eeA0o6ixhiNdgr0DcHWm85XPCphwZgD1lIEoi6t3VERayWao7SF7AAZTw6oARGJeVjH8Kg==}
 
+  email-reply-parser@1.9.2:
+    resolution: {integrity: sha512-Q7eliFRNicYtOJew4QTrt+Dgp+BQNfkAQzFWjr+VdzRBGgP5kenog8m6vC1u0FMcQx0H64K81TFGW3zps3zxmQ==}
+    engines: {node: '>= 10.0.0'}
+    peerDependencies:
+      re2: 1.21.4
+    peerDependenciesMeta:
+      re2:
+        optional: true
+
   emoji-regex@10.3.0:
     resolution: {integrity: sha512-QpLs9D9v9kArv4lfDEgg1X/gN5XLnf/A6l9cs8SPZLRZR3ZkY9+kwIQTxm+fsSej5UMYGE8fdoaZVIBlqG0XTw==}
 
@@ -7548,10 +7564,6 @@ packages:
     resolution: {integrity: sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag==}
     engines: {node: '>=4.0'}
 
-  esrever@0.2.0:
-    resolution: {integrity: sha512-1e9YJt6yQkyekt2BUjTky7LZWWVyC2cIpgdnsTAvMcnzXIZvlW/fTMPkxBcZoYhgih4d+EC+iw+yv9GIkz7vrw==}
-    hasBin: true
-
   estraverse@4.3.0:
     resolution: {integrity: sha512-39nnKffWz8xN1BU/2c79n9nB9HDzo0niYUqx6xyqUnyoAnQyyWpOTdZEeiCch8BBu515t4wp9ZmgVfVhn9EBpw==}
     engines: {node: '>=4.0'}
@@ -8892,6 +8904,7 @@ packages:
 
   lodash.get@4.4.2:
     resolution: {integrity: sha512-z+Uw/vLuy6gQe8cfaFWD7p0wVv8fJl3mbzXh33RS+0oW2wvUqiRXiQ69gLWSLpgB5/6sU+r6BlQR0MBILadqTQ==}
+    deprecated: This package is deprecated. Use the optional chaining (?.) operator instead.
 
   lodash.isplainobject@4.0.6:
     resolution: {integrity: sha512-oSXzaWypCMHkPC3NvBEaPHf0KsA5mvPrOPgQWDsbg8n7orZ290M0BmC/jgRZ4vcJ6DTAhjrsSYgdsW/F+MFOBA==}
@@ -9507,10 +9520,6 @@ packages:
     resolution: {integrity: sha512-/jKZoMpw0F8GRwl4/eLROPA3cfcXtLApP0QzLmUT/HuPCZWyB7IY9ZrMeKw2O/nFIqPQB3PVM9aYm0F312AXDQ==}
     engines: {node: '>=10.5.0'}
 
-  node-email-reply-parser@0.1.4:
-    resolution: {integrity: sha512-rXiLvb9J8RRNYEf/Ftf2vx+HEjZjB16ONY5Qd9PAFdN0OESkgvGINbtlgIvdIjVeZ1jPPoK/b90sx+lP1CIvqA==}
-    engines: {node: '>= 14.0.0'}
-
   node-fetch@2.6.12:
     resolution: {integrity: sha512-C/fGU2E8ToujUivIO0H+tpQ6HWo4eEmchoPIoXtxCrVghxdKq+QOHqEZW7tuP3KlV3bC8FRMO5nMCC7Zm1VP6g==}
     engines: {node: 4.x || >=6.0.0}
@@ -18143,6 +18152,8 @@ snapshots:
     dependencies:
       dotenv: 16.4.7
 
+  '@types/email-reply-parser@1.4.2': {}
+
   '@types/eslint-scope@3.7.7':
     dependencies:
       '@types/eslint': 9.6.1
@@ -20130,6 +20141,8 @@ snapshots:
 
   electron-to-chromium@1.5.73: {}
 
+  email-reply-parser@1.9.2: {}
+
   emoji-regex@10.3.0: {}
 
   emoji-regex@8.0.0: {}
@@ -20878,8 +20891,6 @@ snapshots:
     dependencies:
       estraverse: 5.3.0
 
-  esrever@0.2.0: {}
-
   estraverse@4.3.0: {}
 
   estraverse@5.3.0: {}
@@ -23250,11 +23261,6 @@ snapshots:
 
   node-domexception@1.0.0: {}
 
-  node-email-reply-parser@0.1.4:
-    dependencies:
-      esrever: 0.2.0
-      lodash: 4.17.21
-
   node-fetch@2.6.12(encoding@0.1.13):
     dependencies:
       whatwg-url: 5.0.0