From 7ceee974a9f2b5f0c1687be081faeb823f2c2bed Mon Sep 17 00:00:00 2001
From: Eliezer Steinbock <3090527+elie222@users.noreply.github.com>
Date: Sun, 19 Oct 2025 12:33:58 +0300
Subject: [PATCH 01/40] wip: move to multi rule system

---
 .../assistant/FixWithChat.tsx                 |  33 +-
 .../assistant/ProcessResultDisplay.tsx        |  15 +-
 .../assistant/ProcessRules.tsx                |  32 +-
 .../assistant/TestCustomEmailForm.tsx         |   6 +-
 .../api/user/executed-rules/batch/route.ts    |   7 +-
 apps/web/prisma/schema.prisma                 |  11 +-
 apps/web/utils/actions/ai-rule.ts             |  34 +-
 .../utils/ai/choose-rule/ai-choose-rule.ts    | 297 +++++++++++----
 apps/web/utils/ai/choose-rule/match-rules.ts  | 168 +++++----
 apps/web/utils/ai/choose-rule/run-rules.ts    | 339 ++++++------------
 .../assistant/process-assistant-email.ts      |  14 +-
 .../web/utils/webhook/process-history-item.ts |  20 +-
 12 files changed, 531 insertions(+), 445 deletions(-)

diff --git a/apps/web/app/(app)/[emailAccountId]/assistant/FixWithChat.tsx b/apps/web/app/(app)/[emailAccountId]/assistant/FixWithChat.tsx
index e863bd0ffd..04749db116 100644
--- a/apps/web/app/(app)/[emailAccountId]/assistant/FixWithChat.tsx
+++ b/apps/web/app/(app)/[emailAccountId]/assistant/FixWithChat.tsx
@@ -27,11 +27,11 @@ import { Badge } from "@/components/ui/badge";
 export function FixWithChat({
   setInput,
   message,
-  result,
+  results,
 }: {
   setInput: (input: string) => void;
   message: ParsedMessage;
-  result: RunRulesResult | null;
+  results: RunRulesResult[];
 }) {
   const { data, isLoading, error } = useRules();
   const { isModalOpen, setIsModalOpen } = useModal();
@@ -53,7 +53,7 @@ export function FixWithChat({
     if (selectedRuleId === NEW_RULE_ID) {
       input = getFixMessage({
         message,
-        result,
+        results,
         expectedRuleName: NEW_RULE_ID,
         explanation,
       });
@@ -62,7 +62,7 @@ export function FixWithChat({
 
       input = getFixMessage({
         message,
-        result,
+        results,
         expectedRuleName: expectedRule?.name ?? null,
         explanation,
       });
@@ -105,7 +105,7 @@ export function FixWithChat({
         <LoadingContent loading={isLoading} error={error}>
           {data && !showExplanation ? (
             <RuleMismatch
-              result={result}
+              results={results}
               rules={data}
               onSelectExpectedRuleId={handleRuleSelect}
             />
@@ -165,14 +165,15 @@ export function FixWithChat({
   );
 }
 
+// TODO: tag rule like in Cursor so we don't need to show the email contents
 function getFixMessage({
   message,
-  result,
+  results,
   expectedRuleName,
   explanation,
 }: {
   message: ParsedMessage;
-  result: RunRulesResult | null;
+  results: RunRulesResult[];
   expectedRuleName: string | null;
   explanation?: string;
 }) {
@@ -191,10 +192,14 @@ Email details:
 *Subject*: ${message.headers.subject}
 *Content*: ${getMessageContent()}
 
-Current rule applied: ${result?.rule?.name || "No rule"}
+Current rules applied and the reasons they were chosen:
 
-Reason the rule was chosen:
-${result?.reason || "-"}
+${results
+  .map(
+    (r) => `- Rule: ${r.rule?.name || "No rule"}
+- Reason: ${r.reason}`,
+  )
+  .join("\n")}
 
 ${
   expectedRuleName === NEW_RULE_ID
@@ -206,11 +211,11 @@ ${
 }
 
 function RuleMismatch({
-  result,
+  results,
   rules,
   onSelectExpectedRuleId,
 }: {
-  result: RunRulesResult | null;
+  results: RunRulesResult[];
   rules: RulesResponse;
   onSelectExpectedRuleId: (ruleId: string | null) => void;
 }) {
@@ -218,8 +223,8 @@ function RuleMismatch({
     <div>
       <Label name="matchedRule" label="Matched:" />
       <div className="mt-1">
-        {result ? (
-          <ProcessResultDisplay result={result} />
+        {results.length > 0 ? (
+          <ProcessResultDisplay results={results} />
         ) : (
           <p>No rule matched</p>
         )}
diff --git a/apps/web/app/(app)/[emailAccountId]/assistant/ProcessResultDisplay.tsx b/apps/web/app/(app)/[emailAccountId]/assistant/ProcessResultDisplay.tsx
index fca9f6a93d..c51b1fbbd9 100644
--- a/apps/web/app/(app)/[emailAccountId]/assistant/ProcessResultDisplay.tsx
+++ b/apps/web/app/(app)/[emailAccountId]/assistant/ProcessResultDisplay.tsx
@@ -11,17 +11,18 @@ import { ActionType } from "@prisma/client";
 import { useRuleDialog } from "./RuleDialog";
 
 export function ProcessResultDisplay({
-  result,
+  results,
   prefix,
 }: {
-  result: RunRulesResult;
+  results: RunRulesResult[];
   prefix?: string;
 }) {
   const { ruleDialog, RuleDialogComponent } = useRuleDialog();
 
-  if (!result) return null;
+  if (!results.length) return null;
 
-  if (!result.rule) {
+  if (results.length === 1 && results[0].rule === null) {
+    const result = results[0];
     return (
       <HoverCard
         className="w-auto max-w-3xl"
@@ -51,7 +52,7 @@ export function ProcessResultDisplay({
     ruleDialog.onOpen({ ruleId });
   };
 
-  return (
+  return results.map((result) => (
     <>
       <HoverCard
         className="w-auto max-w-5xl"
@@ -61,13 +62,13 @@ export function ProcessResultDisplay({
       >
         <Badge color="green">
           {prefix ? prefix : ""}
-          {result.rule.name}
+          {result.rule?.name}
           <EyeIcon className="ml-1.5 size-3.5 opacity-70" />
         </Badge>
       </HoverCard>
       <RuleDialogComponent />
     </>
-  );
+  ));
 }
 
 function ActionSummaryCard({
diff --git a/apps/web/app/(app)/[emailAccountId]/assistant/ProcessRules.tsx b/apps/web/app/(app)/[emailAccountId]/assistant/ProcessRules.tsx
index da35f02dee..8f5e51a0cd 100644
--- a/apps/web/app/(app)/[emailAccountId]/assistant/ProcessRules.tsx
+++ b/apps/web/app/(app)/[emailAccountId]/assistant/ProcessRules.tsx
@@ -125,26 +125,28 @@ export function ProcessRulesContent({ testMode }: { testMode: boolean }) {
   const [isRunningAll, setIsRunningAll] = useState(false);
   const [currentPageLimit, setCurrentPageLimit] = useState(testMode ? 1 : 10);
   const [isRunning, setIsRunning] = useState<Record<string, boolean>>({});
-  const [results, setResults] = useState<Record<string, RunRulesResult>>({});
+  const [resultsMap, setResultsMap] = useState<
+    Record<string, RunRulesResult[]>
+  >({});
   const handledThreadsRef = useRef(new Set<string>());
 
   // Merge existing rules with results
   const allResults = useMemo(() => {
-    const merged = { ...results };
+    const merged = { ...resultsMap };
     if (existingRules?.rulesMap) {
       for (const [messageId, rule] of Object.entries(existingRules.rulesMap)) {
         if (!merged[messageId]) {
-          merged[messageId] = {
-            rule: rule.rule,
-            actionItems: rule.actionItems,
-            reason: rule.reason,
+          merged[messageId] = rule.map((r) => ({
+            rule: r.rule,
+            actionItems: r.actionItems,
+            reason: r.reason,
             existing: true,
-          };
+          }));
         }
       }
     }
     return merged;
-  }, [results, existingRules]);
+  }, [resultsMap, existingRules]);
 
   const onRun = useCallback(
     async (message: Message, rerun?: boolean) => {
@@ -162,7 +164,7 @@ export function ProcessRulesContent({ testMode }: { testMode: boolean }) {
           description: result.serverError,
         });
       } else if (result?.data) {
-        setResults((prev) => ({ ...prev, [message.id]: result.data! }));
+        setResultsMap((prev) => ({ ...prev, [message.id]: result.data! }));
       }
       setIsRunning((prev) => ({ ...prev, [message.id]: false }));
     },
@@ -296,7 +298,7 @@ export function ProcessRulesContent({ testMode }: { testMode: boolean }) {
                     message={message}
                     userEmail={userEmail}
                     isRunning={isRunning[message.id]}
-                    result={allResults[message.id]}
+                    results={allResults[message.id]}
                     onRun={(rerun) => onRun(message, rerun)}
                     testMode={testMode}
                     setInput={setInput}
@@ -332,7 +334,7 @@ function ProcessRulesRow({
   message,
   userEmail,
   isRunning,
-  result,
+  results,
   onRun,
   testMode,
   setInput,
@@ -340,7 +342,7 @@ function ProcessRulesRow({
   message: Message;
   userEmail: string;
   isRunning: boolean;
-  result: RunRulesResult;
+  results: RunRulesResult[];
   onRun: (rerun?: boolean) => void;
   testMode: boolean;
   setInput: (input: string) => void;
@@ -363,15 +365,15 @@ function ProcessRulesRow({
             labelIds={message.labelIds}
           />
           <div className="ml-4 flex items-center gap-1">
-            {result ? (
+            {results ? (
               <>
                 <div className="flex max-w-xs flex-col justify-center gap-0.5 whitespace-nowrap">
-                  <ProcessResultDisplay result={result} />
+                  <ProcessResultDisplay results={results} />
                 </div>
                 <FixWithChat
                   setInput={setInput}
                   message={message}
-                  result={result}
+                  results={results}
                 />
                 <Button
                   variant="outline"
diff --git a/apps/web/app/(app)/[emailAccountId]/assistant/TestCustomEmailForm.tsx b/apps/web/app/(app)/[emailAccountId]/assistant/TestCustomEmailForm.tsx
index 2b61203abc..3a04bc4b02 100644
--- a/apps/web/app/(app)/[emailAccountId]/assistant/TestCustomEmailForm.tsx
+++ b/apps/web/app/(app)/[emailAccountId]/assistant/TestCustomEmailForm.tsx
@@ -17,7 +17,7 @@ import { zodResolver } from "@hookform/resolvers/zod";
 import { useAccount } from "@/providers/EmailAccountProvider";
 
 export const TestCustomEmailForm = () => {
-  const [testResult, setTestResult] = useState<RunRulesResult | undefined>();
+  const [testResults, setTestResult] = useState<RunRulesResult[]>();
   const { emailAccountId } = useAccount();
 
   const {
@@ -60,9 +60,9 @@ export const TestCustomEmailForm = () => {
           Test
         </Button>
       </form>
-      {testResult && (
+      {testResults && (
         <div className="mt-4">
-          <ProcessResultDisplay result={testResult} />
+          <ProcessResultDisplay results={testResults} />
         </div>
       )}
     </div>
diff --git a/apps/web/app/api/user/executed-rules/batch/route.ts b/apps/web/app/api/user/executed-rules/batch/route.ts
index ebdd5f68a5..c0d8bcc6b7 100644
--- a/apps/web/app/api/user/executed-rules/batch/route.ts
+++ b/apps/web/app/api/user/executed-rules/batch/route.ts
@@ -32,10 +32,13 @@ async function getData({
   });
 
   // Convert to a map for easy lookup by messageId
-  const rulesMap: Record<string, (typeof executedRules)[0]> = {};
+  const rulesMap: Record<string, typeof executedRules> = {};
 
   for (const executedRule of executedRules) {
-    rulesMap[executedRule.messageId] = executedRule;
+    if (!rulesMap[executedRule.messageId]) {
+      rulesMap[executedRule.messageId] = [];
+    }
+    rulesMap[executedRule.messageId].push(executedRule);
   }
 
   return { rulesMap };
diff --git a/apps/web/prisma/schema.prisma b/apps/web/prisma/schema.prisma
index 9129aacf84..5c61117420 100644
--- a/apps/web/prisma/schema.prisma
+++ b/apps/web/prisma/schema.prisma
@@ -119,9 +119,9 @@ model EmailAccount {
   personaAnalysis           Json? // ai analysis of the user's persona
   role                      String? // the role confirmed by the user - previously `User.surveyRole`
 
-  statsEmailFrequency   Frequency         @default(WEEKLY)
-  summaryEmailFrequency Frequency         @default(WEEKLY)
-  lastSummaryEmailAt    DateTime?
+  statsEmailFrequency        Frequency         @default(WEEKLY)
+  summaryEmailFrequency      Frequency         @default(WEEKLY)
+  lastSummaryEmailAt         DateTime?
   coldEmailBlocker      ColdEmailSetting? // @deprecated
   coldEmailDigest       Boolean           @default(false) // @deprecated
   coldEmailPrompt       String? // @deprecated
@@ -487,7 +487,8 @@ model ExecutedRule {
   actionItems      ExecutedAction[]
   scheduledActions ScheduledAction[]
 
-  @@unique([emailAccountId, threadId, messageId], name: "unique_emailAccount_thread_message")
+  @@index([emailAccountId, threadId, messageId, ruleId])
+  @@index([emailAccountId, messageId])
   @@index([emailAccountId, status, createdAt])
 }
 
@@ -658,7 +659,7 @@ model EmailMessage {
   messageId       String
   date            DateTime // date of the email
   from            String
-  fromName        String?  // sender's display name
+  fromName        String? // sender's display name
   fromDomain      String
   to              String
   unsubscribeLink String?
diff --git a/apps/web/utils/actions/ai-rule.ts b/apps/web/utils/actions/ai-rule.ts
index 4f0078a2e3..5d6a692821 100644
--- a/apps/web/utils/actions/ai-rule.ts
+++ b/apps/web/utils/actions/ai-rule.ts
@@ -40,7 +40,7 @@ export const runRulesAction = actionClient
     async ({
       ctx: { emailAccountId, provider, logger: ctxLogger },
       parsedInput: { messageId, threadId, rerun, isTest },
-    }): Promise<RunRulesResult> => {
+    }): Promise<RunRulesResult[]> => {
       const logger = ctxLogger.with({ messageId, threadId });
 
       const emailAccount = await getEmailAccountWithAi({ emailAccountId });
@@ -56,14 +56,12 @@ export const runRulesAction = actionClient
 
       const fetchExecutedRule = !isTest && !rerun;
 
-      const executedRule = fetchExecutedRule
-        ? await prisma.executedRule.findUnique({
+      const executedRules = fetchExecutedRule
+        ? await prisma.executedRule.findMany({
             where: {
-              unique_emailAccount_thread_message: {
-                emailAccountId,
-                threadId,
-                messageId,
-              },
+              emailAccountId,
+              threadId,
+              messageId,
             },
             select: {
               id: true,
@@ -72,17 +70,17 @@ export const runRulesAction = actionClient
               rule: true,
             },
           })
-        : null;
+        : [];
 
-      if (executedRule) {
+      if (executedRules.length > 0) {
         logger.info("Skipping. Rule already exists.");
 
-        return {
+        return executedRules.map((executedRule) => ({
           rule: executedRule.rule,
           actionItems: executedRule.actionItems,
           reason: executedRule.reason,
           existing: true,
-        };
+        }));
       }
 
       const rules = await prisma.rule.findMany({
@@ -580,15 +578,3 @@ export const generateRulesPromptAction = actionClient
 
     return { rulesPrompt: result.join("\n\n") };
   });
-
-export const setRuleEnabledAction = actionClient
-  .metadata({ name: "setRuleEnabled" })
-  .schema(z.object({ ruleId: z.string(), enabled: z.boolean() }))
-  .action(
-    async ({ ctx: { emailAccountId }, parsedInput: { ruleId, enabled } }) => {
-      await prisma.rule.update({
-        where: { id: ruleId, emailAccountId },
-        data: { enabled },
-      });
-    },
-  );
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 a77c45b37d..a8defd4885 100644
--- a/apps/web/utils/ai/choose-rule/ai-choose-rule.ts
+++ b/apps/web/utils/ai/choose-rule/ai-choose-rule.ts
@@ -1,28 +1,78 @@
 import { z } from "zod";
 import type { EmailAccountWithAI } from "@/utils/llms/types";
 import { stringifyEmail } from "@/utils/stringify-email";
-import type { EmailForLLM } from "@/utils/types";
+import { isDefined, type EmailForLLM } from "@/utils/types";
 import { getModel, type ModelType } from "@/utils/llms/model";
 import { createGenerateObject } from "@/utils/llms";
 import { createScopedLogger } from "@/utils/logger";
 import { getUserInfoPrompt, getUserRulesPrompt } from "@/utils/ai/helpers";
-// import { Braintrust } from "@/utils/braintrust";
-// const braintrust = new Braintrust("choose-rule-2");
 
 const logger = createScopedLogger("AI Choose Rule");
 
 type GetAiResponseOptions = {
   email: EmailForLLM;
   emailAccount: EmailAccountWithAI;
-  rules: { name: string; instructions: string }[];
+  rules: { name: string; instructions: string; systemType?: string | null }[];
   modelType?: ModelType;
 };
 
-async function getAiResponse(options: GetAiResponseOptions) {
+async function getAiResponse(options: GetAiResponseOptions): Promise<{
+  result: {
+    matchedRules: {
+      reason: string;
+      ruleName: string;
+    }[];
+    noMatchFound: boolean;
+  };
+  modelOptions: ReturnType<typeof getModel>;
+}> {
   const { email, emailAccount, rules, modelType = "default" } = options;
 
   const emailSection = stringifyEmail(email, 500);
+  const hasCustomRules = rules.some((rule) => !rule.systemType);
+
+  const modelOptions = getModel(emailAccount.user, modelType);
+  const generateObject = createGenerateObject({
+    userEmail: emailAccount.email,
+    label: "Choose rule",
+    modelOptions,
+  });
 
+  // Use different prompts based on whether custom rules exist
+  if (hasCustomRules) {
+    return getAiResponseMultiRule({
+      email,
+      emailSection,
+      emailAccount,
+      rules,
+      modelOptions,
+      generateObject,
+    });
+  } else {
+    return getAiResponseSingleRule({
+      emailSection,
+      emailAccount,
+      rules,
+      modelOptions,
+      generateObject,
+    });
+  }
+}
+
+// Original single-rule logic (proven, for users without custom rules)
+async function getAiResponseSingleRule({
+  emailSection,
+  emailAccount,
+  rules,
+  modelOptions,
+  generateObject,
+}: {
+  emailSection: string;
+  emailAccount: EmailAccountWithAI;
+  rules: GetAiResponseOptions["rules"];
+  modelOptions: ReturnType<typeof getModel>;
+  generateObject: ReturnType<typeof createGenerateObject>;
+}) {
   const system = `You are an AI assistant that helps people manage their emails.
 
 <instructions>
@@ -62,14 +112,6 @@ Example response format:
 ${emailSection}
 </email>`;
 
-  const modelOptions = getModel(emailAccount.user, modelType);
-
-  const generateObject = createGenerateObject({
-    userEmail: emailAccount.email,
-    label: "Choose rule",
-    modelOptions,
-  });
-
   const aiResponse = await generateObject({
     ...modelOptions,
     system,
@@ -87,26 +129,169 @@ ${emailSection}
     }),
   });
 
-  // braintrust.insertToDataset({
-  //   id: email.id,
-  //   input: {
-  //     email: emailSection,
-  //     rules: rules.map((rule) => ({
-  //       name: rule.name,
-  //       instructions: rule.instructions,
-  //     })),
-  //     hasAbout: !!emailAccount.about,
-  //     userAbout: emailAccount.about,
-  //     userEmail: emailAccount.email,
-  //   },
-  //   expected: aiResponse.object.ruleName,
-  // });
-
-  return { result: aiResponse.object, modelOptions };
+  return {
+    result: {
+      matchedRules: aiResponse.object ? [aiResponse.object] : [],
+      noMatchFound: aiResponse.object?.noMatchFound ?? false,
+    },
+    modelOptions,
+  };
+}
+
+// New multi-rule logic (for users with custom rules)
+async function getAiResponseMultiRule({
+  email,
+  emailSection,
+  emailAccount,
+  rules,
+  modelOptions,
+  generateObject,
+}: {
+  email: EmailForLLM;
+  emailSection: string;
+  emailAccount: EmailAccountWithAI;
+  rules: GetAiResponseOptions["rules"];
+  modelOptions: ReturnType<typeof getModel>;
+  generateObject: ReturnType<typeof createGenerateObject>;
+}) {
+  const systemRules = rules.filter((rule) => rule.systemType);
+  const customRules = rules.filter((rule) => !rule.systemType);
+
+  // Build rules list with clear system vs custom distinction
+  let rulesSection = "";
+  if (systemRules.length > 0) {
+    rulesSection += "\n<system_rules>\nSystem preset rules:\n\n";
+    rulesSection += systemRules
+      .map(
+        (rule, idx) =>
+          `${idx + 1}. ${rule.name}${rule.instructions ? `\n   Instructions: ${rule.instructions}` : ""}`,
+      )
+      .join("\n\n");
+    rulesSection += "\n</system_rules>";
+  }
+
+  rulesSection += "\n\n<custom_rules>\nCustom user-defined rules:\n\n";
+  rulesSection += customRules
+    .map(
+      (rule, idx) =>
+        `${idx + 1}. ${rule.name}${rule.instructions ? `\n   Instructions: ${rule.instructions}` : ""}`,
+    )
+    .join("\n\n");
+  rulesSection += "\n</custom_rules>";
+
+  const system = `You are an AI assistant that helps people manage their emails.
+
+<instructions>
+  IMPORTANT: Follow these instructions carefully when selecting rules:
+
+  <priority>
+  1. Review all available rules and select those that genuinely match this email.
+  2. You can select multiple rules if they all apply.
+  3. System preset rules (like To Reply, Newsletter, etc.) typically don't overlap - avoid selecting multiple system rules unless truly necessary.
+  4. Custom user-defined rules can overlap freely - select all that apply.
+  5. Be selective - typically 1-3 rules is appropriate.
+  6. Only set "noMatchFound" to true if no rules can reasonably apply.
+  </priority>
+
+  <guidelines>
+  - If a rule says to exclude certain types of emails, DO NOT select that rule for those excluded emails.
+  - Rules about requiring replies should be prioritized when the email clearly needs a response.
+  - Be concise in your reasoning - avoid repetitive explanations.
+  </guidelines>
+</instructions>
+
+<available_rules>
+${rulesSection}
+</available_rules>
+
+${getUserInfoPrompt({ emailAccount })}
+
+Respond with a valid JSON object:
+
+Example response format (single rule):
+{
+  "matchedRules": [
+    {
+      "ruleName": "Newsletter",
+      "reason": "This is a newsletter subscription"
+    }
+  ],
+  "noMatchFound": false
+}
+
+Example response format (multiple rules):
+{
+  "matchedRules": [
+    {
+      "ruleName": "To Reply",
+      "reason": "This email requires a response"
+    },
+    {
+      "ruleName": "Team Emails",
+      "reason": "From a team member"
+    }
+  ],
+  "noMatchFound": false
+}`;
+
+  const prompt = `Select all rules that apply to this email that was sent to me:
+
+<email>
+${emailSection}
+</email>`;
+
+  const aiResponse = await generateObject({
+    ...modelOptions,
+    system,
+    prompt,
+    schema: z.object({
+      matchedRules: z
+        .array(
+          z.object({
+            ruleName: z.string().describe("The exact name of the rule"),
+            reason: z.string().describe("Why this rule matches"),
+          }),
+        )
+        .describe("Array of all matching rules"),
+      noMatchFound: z
+        .boolean()
+        .describe("True if no match was found, false otherwise"),
+    }),
+  });
+
+  // Log when multiple system rules are selected
+  const selectedSystemRules = aiResponse.object.matchedRules.filter((match) =>
+    systemRules.some(
+      (r) => r.name.toLowerCase() === match.ruleName.toLowerCase(),
+    ),
+  );
+
+  if (selectedSystemRules.length > 1) {
+    logger.warn("Multiple system rules selected", {
+      systemRules: selectedSystemRules.map((r) => r.ruleName),
+      emailId: email.id,
+      model: modelOptions.modelName,
+    });
+  }
+
+  if (aiResponse.object.matchedRules.length > 1) {
+    logger.info("Multiple rules selected", {
+      rules: aiResponse.object.matchedRules.map((r) => r.ruleName),
+      emailId: email.id,
+    });
+  }
+
+  return {
+    result: {
+      matchedRules: aiResponse.object.matchedRules || [],
+      noMatchFound: aiResponse.object?.noMatchFound ?? false,
+    },
+    modelOptions,
+  };
 }
 
 export async function aiChooseRule<
-  T extends { name: string; instructions: string },
+  T extends { name: string; instructions: string; systemType?: string | null },
 >({
   email,
   rules,
@@ -117,47 +302,31 @@ export async function aiChooseRule<
   rules: T[];
   emailAccount: EmailAccountWithAI;
   modelType?: ModelType;
-}) {
-  if (!rules.length) return { reason: "No rules" };
+}): Promise<
+  {
+    rule: T;
+    reason: string;
+  }[]
+> {
+  if (!rules.length) return [];
 
-  const { result: aiResponse, modelOptions } = await getAiResponse({
+  const { result: aiResponse } = await getAiResponse({
     email,
     rules,
     emailAccount,
     modelType,
   });
 
-  if (aiResponse.noMatchFound)
-    return { rule: undefined, reason: "No match found" };
+  if (aiResponse.noMatchFound) return [];
 
-  const selectedRule = aiResponse.ruleName
-    ? rules.find(
-        (rule) =>
-          rule.name.toLowerCase() === aiResponse.ruleName?.toLowerCase(),
-      )
-    : undefined;
-
-  // The AI found a match, but didn't select a rule
-  // We should probably force a retry in this case
-  if (aiResponse.ruleName && !selectedRule) {
-    logger.error("No matching rule found", {
-      noMatchFound: aiResponse.noMatchFound,
-      reason: aiResponse.reason,
-      ruleName: aiResponse.ruleName,
-      rules: rules.map((r) => ({
-        name: r.name,
-        instructions: r.instructions,
-      })),
-      emailId: email.id,
-      model: modelOptions.modelName,
-      provider: modelOptions.provider,
-      providerOptions: modelOptions.providerOptions,
-      modelType,
-    });
-  }
+  const selectedRules = aiResponse.matchedRules
+    .map((match) => {
+      const rule = rules.find(
+        (r) => r.name.toLowerCase() === match.ruleName.toLowerCase(),
+      );
+      return rule ? { rule, reason: match.reason } : undefined;
+    })
+    .filter(isDefined);
 
-  return {
-    rule: selectedRule,
-    reason: aiResponse?.reason,
-  };
+  return selectedRules;
 }
diff --git a/apps/web/utils/ai/choose-rule/match-rules.ts b/apps/web/utils/ai/choose-rule/match-rules.ts
index c6ac767b77..d28d353a22 100644
--- a/apps/web/utils/ai/choose-rule/match-rules.ts
+++ b/apps/web/utils/ai/choose-rule/match-rules.ts
@@ -57,47 +57,10 @@ async function findPotentialMatchingRules({
     instructions: string;
   })[] = [];
 
-  const isCalendarEvent = hasIcsAttachment(message);
-  if (isCalendarEvent) {
-    const calendarRule = rules.find(
-      (r) => r.systemType === SystemType.CALENDAR,
-    );
-    if (calendarRule) {
-      logger.info("Found matching calendar rule", {
-        ruleId: calendarRule.id,
-        messageId: message.id,
-      });
-      return {
-        match: calendarRule,
-        matchReasons: [
-          { type: ConditionType.PRESET, systemType: SystemType.CALENDAR },
-        ],
-      };
-    }
-  }
-
-  // only load once and only when needed
-  let groups: Awaited<ReturnType<typeof getGroupsWithRules>>;
-  async function getGroups({ emailAccountId }: { emailAccountId: string }) {
-    if (!groups) groups = await getGroupsWithRules({ emailAccountId });
-    return groups;
-  }
+  const calendarMatch = checkCalendarMatch({ rules, message });
+  if (calendarMatch) return calendarMatch;
 
-  let sender: { categoryId: string | null } | null | undefined;
-  async function getSender({ emailAccountId }: { emailAccountId: string }) {
-    if (typeof sender === "undefined") {
-      sender = await prisma.newsletter.findUnique({
-        where: {
-          email_emailAccountId: {
-            email: extractEmailAddress(message.headers.from),
-            emailAccountId,
-          },
-        },
-        select: { categoryId: true },
-      });
-    }
-    return sender;
-  }
+  const contextLoader = new ContextLoader(message);
 
   // loop through rules and check if they match
   for (const rule of rules) {
@@ -108,12 +71,14 @@ async function findPotentialMatchingRules({
     const conditionTypes = getConditionTypes(rule);
     const matchReasons: MatchReason[] = [];
 
-    // group - ignores conditional operator
-    // if a match is found, return it
+    // Learned patterns (groups)
+    // If a match is found, return it immediately
+    // Ignores conditional operator
     if (rule.groupId) {
-      const { matchingItem, group, ruleExcluded } = await matchesGroupRule(
+      const groups = await contextLoader.getGroups(rule.emailAccountId);
+      const { matchingItem, group, ruleExcluded } = matchesGroupRule(
         rule,
-        await getGroups({ emailAccountId: rule.emailAccountId }),
+        groups,
         message,
       );
 
@@ -150,10 +115,8 @@ async function findPotentialMatchingRules({
     }
 
     if (conditionTypes.CATEGORY) {
-      const matchedCategory = await matchesCategoryRule(
-        rule,
-        await getSender({ emailAccountId: rule.emailAccountId }),
-      );
+      const sender = await contextLoader.getSender(rule.emailAccountId);
+      const matchedCategory = matchesCategoryRule(rule, sender);
       if (matchedCategory) {
         unmatchedConditions.delete(ConditionType.CATEGORY);
         if (typeof matchedCategory !== "boolean") {
@@ -185,6 +148,64 @@ async function findPotentialMatchingRules({
   return { potentialMatches: filteredPotentialMatches };
 }
 
+function checkCalendarMatch({
+  rules,
+  message,
+}: {
+  rules: RuleWithActionsAndCategories[];
+  message: ParsedMessage;
+}): MatchingRuleResult | undefined {
+  const isCalendarEvent = hasIcsAttachment(message);
+  if (!isCalendarEvent) return;
+
+  const rule = rules.find((r) => r.systemType === SystemType.CALENDAR);
+  if (!rule) return;
+
+  logger.info("Found matching calendar rule", {
+    ruleId: rule.id,
+    messageId: message.id,
+  });
+  return {
+    match: rule,
+    matchReasons: [
+      { type: ConditionType.PRESET, systemType: SystemType.CALENDAR },
+    ],
+  };
+}
+
+// Lazy load context data when needed
+class ContextLoader {
+  private readonly message: ParsedMessage;
+  private groups: Awaited<ReturnType<typeof getGroupsWithRules>>;
+  private sender: { categoryId: string | null } | null | undefined;
+
+  constructor(message: ParsedMessage) {
+    this.message = message;
+    this.groups = [];
+    this.sender = undefined;
+  }
+
+  async getGroups(emailAccountId: string) {
+    if (!this.groups)
+      this.groups = await getGroupsWithRules({ emailAccountId });
+    return this.groups;
+  }
+
+  async getSender(emailAccountId: string) {
+    if (!this.sender) {
+      this.sender = await prisma.newsletter.findUnique({
+        where: {
+          email_emailAccountId: {
+            email: extractEmailAddress(this.message.headers.from),
+            emailAccountId,
+          },
+        },
+      });
+    }
+    return this.sender;
+  }
+}
+
 function getMatchReason(matchReasons?: MatchReason[]): string | undefined {
   if (!matchReasons || matchReasons.length === 0) return;
 
@@ -204,7 +225,7 @@ function getMatchReason(matchReasons?: MatchReason[]): string | undefined {
     .join(", ");
 }
 
-export async function findMatchingRule({
+export async function findMatchingRules({
   rules,
   message,
   emailAccount,
@@ -216,11 +237,13 @@ export async function findMatchingRule({
   emailAccount: EmailAccountWithAI;
   provider: EmailProvider;
   modelType: ModelType;
-}): Promise<{
-  rule?: RuleWithActionsAndCategories;
-  matchReasons?: MatchReason[];
-  reason?: string;
-}> {
+}): Promise<
+  {
+    rule: RuleWithActionsAndCategories;
+    matchReasons?: MatchReason[];
+    reason?: string;
+  }[]
+> {
   const coldEmailRule = await getColdEmailRule(emailAccount.id);
 
   if (coldEmailRule && isColdEmailRuleEnabled(coldEmailRule)) {
@@ -238,24 +261,27 @@ export async function findMatchingRule({
         include: { actions: true, categoryFilters: true },
       });
 
-      return {
-        rule: coldEmailRuleWithCategories,
-        reason: coldEmailResult.reason,
-      };
+      return [
+        {
+          rule: coldEmailRuleWithCategories,
+          matchReasons: [],
+          reason: coldEmailResult.reason,
+        },
+      ];
     }
   }
 
-  const result = await findMatchingRuleWithReasons(
+  const results = await findMatchingRuleWithReasons(
     rules,
     message,
     emailAccount,
     provider,
     modelType,
   );
-  return {
+  return results.map((result) => ({
     ...result,
     reason: result.reason || getMatchReason(result.matchReasons || []),
-  };
+  }));
 }
 
 async function findMatchingRuleWithReasons(
@@ -264,11 +290,13 @@ async function findMatchingRuleWithReasons(
   emailAccount: EmailAccountWithAI,
   provider: EmailProvider,
   modelType: ModelType,
-): Promise<{
-  rule?: RuleWithActionsAndCategories;
-  matchReasons?: MatchReason[];
-  reason?: string;
-}> {
+): Promise<
+  {
+    rule: RuleWithActionsAndCategories;
+    matchReasons?: MatchReason[];
+    reason?: string;
+  }[]
+> {
   const isThread = provider.isReplyInThread(message);
 
   const { match, matchReasons, potentialMatches } =
@@ -279,7 +307,7 @@ async function findMatchingRuleWithReasons(
       provider,
     });
 
-  if (match) return { rule: match, matchReasons };
+  if (match) return [{ rule: match, matchReasons }];
 
   if (potentialMatches?.length) {
     const result = await aiChooseRule({
@@ -292,7 +320,7 @@ async function findMatchingRuleWithReasons(
     return result;
   }
 
-  return {};
+  return [];
 }
 
 export function matchesStaticRule(
@@ -362,7 +390,7 @@ export function splitEmailPatterns(pattern: string): string[] {
     .filter(Boolean);
 }
 
-async function matchesGroupRule(
+function matchesGroupRule(
   rule: RuleWithActionsAndCategories,
   groups: Awaited<ReturnType<typeof getGroupsWithRules>>,
   message: ParsedMessage,
@@ -385,7 +413,7 @@ async function matchesGroupRule(
   return { group: null, matchingItem: null, ruleExcluded: false };
 }
 
-async function matchesCategoryRule(
+function matchesCategoryRule(
   rule: RuleWithActionsAndCategories,
   sender: { categoryId: string | null } | null,
 ) {
diff --git a/apps/web/utils/ai/choose-rule/run-rules.ts b/apps/web/utils/ai/choose-rule/run-rules.ts
index 2be3c3f8ae..55c3e7ba3c 100644
--- a/apps/web/utils/ai/choose-rule/run-rules.ts
+++ b/apps/web/utils/ai/choose-rule/run-rules.ts
@@ -4,18 +4,12 @@ import type {
   RuleWithActionsAndCategories,
 } from "@/utils/types";
 import type { EmailAccountWithAI } from "@/utils/llms/types";
-import {
-  ExecutedRuleStatus,
-  SystemType,
-  type Prisma,
-  type Rule,
-} from "@prisma/client";
+import { ExecutedRuleStatus, SystemType, type Rule } from "@prisma/client";
 import type { ActionItem } from "@/utils/ai/types";
-import { findMatchingRule } from "@/utils/ai/choose-rule/match-rules";
+import { findMatchingRules } from "@/utils/ai/choose-rule/match-rules";
 import { getActionItemsWithAiArgs } from "@/utils/ai/choose-rule/choose-args";
 import { executeAct } from "@/utils/ai/choose-rule/execute";
 import prisma from "@/utils/prisma";
-import { isDuplicateError } from "@/utils/prisma-helpers";
 import { createScopedLogger } from "@/utils/logger";
 import type { MatchReason } from "@/utils/ai/choose-rule/types";
 import { sanitizeActionFields } from "@/utils/action-item";
@@ -63,10 +57,10 @@ export async function runRules({
   emailAccount: EmailAccountWithAI;
   isTest: boolean;
   modelType: ModelType;
-}): Promise<RunRulesResult> {
+}): Promise<RunRulesResult[]> {
   const { regularRules, conversationRules } = prepareRulesWithMetaRule(rules);
 
-  const result = await findMatchingRule({
+  const results = await findMatchingRules({
     rules: regularRules,
     message,
     emailAccount,
@@ -75,14 +69,31 @@ export async function runRules({
   });
 
   logger.trace("Matching rule", () => ({
-    result: filterNullProperties(result),
+    results: results.map(filterNullProperties),
   }));
 
-  if (result.rule) {
+  if (!results.length) {
+    const reason = "No rules matched"; // TODO: get the reason from the prompt?
+    await prisma.executedRule.create({
+      data: {
+        threadId: message.threadId,
+        messageId: message.id,
+        automated: true,
+        reason,
+        status: ExecutedRuleStatus.SKIPPED,
+        emailAccount: { connect: { id: emailAccount.id } },
+      },
+    });
+
+    return [{ rule: null, reason }];
+  }
+
+  const executedRules: RunRulesResult[] = [];
+
+  for (const result of results) {
     let ruleToExecute = result.rule;
     let reasonToUse = result.reason;
 
-    // Check if this is the conversation tracking meta-rule
     if (result.rule.id === CONVERSATION_TRACKING_META_RULE_ID) {
       // Determine which specific sub-rule applies
       const { specificRule, reason: statusReason } =
@@ -95,10 +106,13 @@ export async function runRules({
         });
 
       if (!specificRule) {
-        return {
+        const executedRule: RunRulesResult = {
           rule: null,
           reason: statusReason || "No enabled conversation status rule found",
         };
+
+        executedRules.push(executedRule);
+        continue;
       }
 
       ruleToExecute = specificRule;
@@ -112,7 +126,7 @@ export async function runRules({
       });
     }
 
-    return await executeMatchedRule(
+    const executedRule = await executeMatchedRule(
       ruleToExecute,
       message,
       emailAccount,
@@ -122,15 +136,11 @@ export async function runRules({
       isTest,
       modelType,
     );
-  } else {
-    await saveSkippedExecutedRule({
-      emailAccountId: emailAccount.id,
-      threadId: message.threadId,
-      messageId: message.id,
-      reason: result.reason,
-    });
+
+    executedRules.push(executedRule);
   }
-  return result;
+
+  return executedRules;
 }
 
 function prepareRulesWithMetaRule(rules: RuleWithActionsAndCategories[]): {
@@ -153,7 +163,7 @@ function prepareRulesWithMetaRule(rules: RuleWithActionsAndCategories[]): {
       id: CONVERSATION_TRACKING_META_RULE_ID,
       name: "Conversation Tracking",
       instructions:
-        "Personal conversations with real people. Excludes automated notifications, newsletters, marketing, receipts, and calendar invites. Apply when the email is part of an actual conversation.",
+        "Personal conversations and communication with real people (emails requiring response, FYI updates, discussions, etc). This is the PRIMARY rule for human-to-human email communication.",
       enabled: true,
       runOnThreads: true,
       systemType: null,
@@ -177,7 +187,6 @@ async function executeMatchedRule(
   isTest: boolean,
   modelType: ModelType,
 ) {
-  // get action items with args
   const actionItems = await getActionItemsWithAiArgs({
     message,
     emailAccount,
@@ -192,87 +201,103 @@ async function executeMatchedRule(
       : "immediateActions",
   );
 
-  // handle action
+  if (isTest) {
+    return {
+      rule,
+      actionItems,
+      executedRule: null,
+      reason,
+      matchReasons,
+    };
+  }
 
-  let executedRule: Awaited<ReturnType<typeof saveExecutedRule>> | null = null;
+  const executedRule = await prisma.executedRule.create({
+    data: {
+      actionItems: {
+        createMany: {
+          data:
+            // Only save immediate actions as ExecutedActions
+            immediateActions?.map((item) => {
+              const {
+                delayInMinutes: _delayInMinutes,
+                ...executedActionFields
+              } = sanitizeActionFields(item);
+              return executedActionFields;
+            }) || [],
+        },
+      },
+      messageId: message.id,
+      threadId: message.threadId,
+      automated: true,
+      status: ExecutedRuleStatus.APPLYING, // Changed from PENDING - rules are now always automated
+      reason,
+      rule: rule?.id ? { connect: { id: rule.id } } : undefined,
+      emailAccount: { connect: { id: emailAccount.id } },
+    },
+    include: { actionItems: true },
+  });
 
-  if (!isTest) {
-    executedRule = await saveExecutedRule(
-      {
-        emailAccountId: emailAccount.id,
+  if (rule.systemType === SystemType.COLD_EMAIL) {
+    await saveColdEmail({
+      email: {
+        id: message.id,
         threadId: message.threadId,
-        messageId: message.id,
-      },
-      {
-        rule,
-        actionItems: immediateActions, // Only save immediate actions as ExecutedActions
-        reason,
+        from: message.headers.from,
       },
-    );
+      emailAccount,
+      aiReason: reason ?? null,
+    });
+  }
 
-    if (rule.systemType === SystemType.COLD_EMAIL) {
-      await saveColdEmail({
-        email: {
-          id: message.id,
-          threadId: message.threadId,
-          from: message.headers.from,
-        },
-        emailAccount,
-        aiReason: reason ?? null,
-      });
-    }
+  if (isConversationStatusType(rule.systemType)) {
+    await updateThreadTrackers({
+      emailAccountId: emailAccount.id,
+      threadId: message.threadId,
+      messageId: message.id,
+      sentAt: internalDateToDate(message.internalDate),
+      status: rule.systemType,
+    });
+  }
 
-    if (isConversationStatusType(rule.systemType)) {
-      await updateThreadTrackers({
+  if (executedRule) {
+    if (delayedActions?.length > 0) {
+      // Attempts to cancel any existing scheduled actions to avoid duplicates
+      await cancelScheduledActions({
         emailAccountId: emailAccount.id,
+        messageId: message.id,
         threadId: message.threadId,
+        reason: "Superseded by new rule execution",
+      });
+      await scheduleDelayedActions({
+        executedRuleId: executedRule.id,
+        actionItems: delayedActions,
         messageId: message.id,
-        sentAt: internalDateToDate(message.internalDate),
-        status: rule.systemType,
+        threadId: message.threadId,
+        emailAccountId: emailAccount.id,
       });
     }
 
-    if (executedRule) {
-      if (delayedActions?.length > 0) {
-        // Attempts to cancel any existing scheduled actions to avoid duplicates
-        await cancelScheduledActions({
-          emailAccountId: emailAccount.id,
-          messageId: message.id,
-          threadId: message.threadId,
-          reason: "Superseded by new rule execution",
-        });
-        await scheduleDelayedActions({
-          executedRuleId: executedRule.id,
-          actionItems: delayedActions,
-          messageId: message.id,
-          threadId: message.threadId,
-          emailAccountId: emailAccount.id,
-        });
-      }
-
-      // Execute immediate actions if any
-      if (immediateActions?.length > 0) {
-        await executeAct({
-          client,
-          userEmail: emailAccount.email,
-          userId: emailAccount.userId,
-          emailAccountId: emailAccount.id,
-          executedRule,
-          message,
-        });
-      } else if (!delayedActions?.length) {
-        // No actions at all (neither immediate nor delayed), mark as applied
-        await prisma.executedRule.update({
-          where: { id: executedRule.id },
-          data: { status: ExecutedRuleStatus.APPLIED },
-        });
-      }
+    // Execute immediate actions if any
+    if (immediateActions?.length > 0) {
+      await executeAct({
+        client,
+        userEmail: emailAccount.email,
+        userId: emailAccount.userId,
+        emailAccountId: emailAccount.id,
+        executedRule,
+        message,
+      });
+    } else if (!delayedActions?.length) {
+      // No actions at all (neither immediate nor delayed), mark as applied
+      await prisma.executedRule.update({
+        where: { id: executedRule.id },
+        data: { status: ExecutedRuleStatus.APPLIED },
+      });
     }
   }
 
   // Note: If there are ONLY delayed actions (no immediate), status stays APPLYING
   // and will be updated to APPLIED by checkAndCompleteExecutedRule() when scheduled actions finish
-
   return {
     rule,
     actionItems,
@@ -282,136 +307,6 @@ async function executeMatchedRule(
   };
 }
 
-async function saveSkippedExecutedRule({
-  emailAccountId,
-  threadId,
-  messageId,
-  reason,
-}: {
-  emailAccountId: string;
-  threadId: string;
-  messageId: string;
-  reason?: string;
-}) {
-  const data: Prisma.ExecutedRuleCreateInput = {
-    threadId,
-    messageId,
-    automated: true,
-    reason,
-    status: ExecutedRuleStatus.SKIPPED,
-    emailAccount: { connect: { id: emailAccountId } },
-  };
-
-  await upsertExecutedRule({
-    emailAccountId,
-    threadId,
-    messageId,
-    data,
-  });
-}
-
-async function saveExecutedRule(
-  {
-    emailAccountId,
-    threadId,
-    messageId,
-  }: {
-    emailAccountId: string;
-    threadId: string;
-    messageId: string;
-  },
-  {
-    rule,
-    actionItems,
-    reason,
-  }: {
-    rule: RuleWithActionsAndCategories;
-    actionItems: ActionItem[];
-    reason?: string;
-  },
-) {
-  const data: Prisma.ExecutedRuleCreateInput = {
-    actionItems: {
-      createMany: {
-        data:
-          actionItems?.map((item) => {
-            const { delayInMinutes: _delayInMinutes, ...executedActionFields } =
-              sanitizeActionFields(item);
-            return executedActionFields;
-          }) || [],
-      },
-    },
-    messageId,
-    threadId,
-    automated: true,
-    status: ExecutedRuleStatus.APPLYING, // Changed from PENDING - rules are now always automated
-    reason,
-    rule: rule?.id ? { connect: { id: rule.id } } : undefined,
-    emailAccount: { connect: { id: emailAccountId } },
-  };
-
-  return await upsertExecutedRule({
-    emailAccountId,
-    threadId,
-    messageId,
-    data,
-  });
-}
-
-async function upsertExecutedRule({
-  emailAccountId,
-  threadId,
-  messageId,
-  data,
-}: {
-  emailAccountId: string;
-  threadId: string;
-  messageId: string;
-  data: Prisma.ExecutedRuleCreateInput;
-}) {
-  try {
-    return await prisma.executedRule.upsert({
-      where: {
-        unique_emailAccount_thread_message: {
-          emailAccountId,
-          threadId,
-          messageId,
-        },
-      },
-      create: data,
-      update: data.rule
-        ? data
-        : {
-            ...data,
-            rule: { disconnect: true },
-          },
-      include: { actionItems: true },
-    });
-  } catch (error) {
-    if (isDuplicateError(error)) {
-      // Unique constraint violation, ignore the error
-      // May be due to a race condition?
-      logger.info("Ignored duplicate entry for ExecutedRule", {
-        emailAccountId,
-        threadId,
-        messageId,
-      });
-      return await prisma.executedRule.findUnique({
-        where: {
-          unique_emailAccount_thread_message: {
-            emailAccountId,
-            threadId,
-            messageId,
-          },
-        },
-        include: { actionItems: true },
-      });
-    }
-    // Re-throw any other errors
-    throw error;
-  }
-}
-
 async function analyzeSenderPatternIfAiMatch({
   isTest,
   result,
@@ -445,7 +340,7 @@ function shouldAnalyzeSenderPattern({
 }) {
   if (isTest) return false;
   if (!result.rule) return false;
-  if (result.rule.systemType === SystemType.TO_REPLY) return false;
+  if (isConversationStatusType(result.rule.systemType)) return false;
 
   // skip if we already matched for static reasons
   // learnings only needed for rules that would run through an ai
@@ -456,7 +351,9 @@ function shouldAnalyzeSenderPattern({
         reason.type === "GROUP" ||
         reason.type === "CATEGORY",
     )
-  )
+  ) {
     return false;
+  }
+
   return true;
 }
diff --git a/apps/web/utils/assistant/process-assistant-email.ts b/apps/web/utils/assistant/process-assistant-email.ts
index f6ae8ccf37..b1c5c280ce 100644
--- a/apps/web/utils/assistant/process-assistant-email.ts
+++ b/apps/web/utils/assistant/process-assistant-email.ts
@@ -96,7 +96,7 @@ async function processAssistantEmailInternal({
   const originalMessageId = firstMessageToAssistant.headers["in-reply-to"];
   const originalMessage = await provider.getOriginalMessage(originalMessageId);
 
-  const [emailAccount, executedRule, senderCategory] = await Promise.all([
+  const [emailAccount, executedRules, senderCategory] = await Promise.all([
     prisma.emailAccount.findUnique({
       where: { email: userEmail },
       select: {
@@ -135,13 +135,11 @@ async function processAssistantEmailInternal({
       },
     }),
     originalMessage
-      ? prisma.executedRule.findUnique({
+      ? prisma.executedRule.findMany({
           where: {
-            unique_emailAccount_thread_message: {
-              emailAccountId,
-              threadId: originalMessage.threadId,
-              messageId: originalMessage.id,
-            },
+            emailAccountId,
+            threadId: originalMessage.threadId,
+            messageId: originalMessage.id,
           },
           select: {
             rule: {
@@ -217,7 +215,7 @@ async function processAssistantEmailInternal({
     rules: emailAccount.rules,
     originalEmail: originalMessage,
     messages,
-    matchedRule: executedRule?.rule || null,
+    matchedRule: executedRules?.length ? executedRules[0].rule : null, // TODO: support multiple rule matching
     categories: emailAccount.categories.length ? emailAccount.categories : null,
     senderCategory: senderCategory?.category?.name ?? null,
   });
diff --git a/apps/web/utils/webhook/process-history-item.ts b/apps/web/utils/webhook/process-history-item.ts
index a3640230e2..3758836e67 100644
--- a/apps/web/utils/webhook/process-history-item.ts
+++ b/apps/web/utils/webhook/process-history-item.ts
@@ -58,13 +58,11 @@ export async function processHistoryItem(
     const [parsedMessage, hasExistingRule] = await Promise.all([
       provider.getMessage(messageId),
       threadId
-        ? prisma.executedRule.findUnique({
+        ? prisma.executedRule.findFirst({
             where: {
-              unique_emailAccount_thread_message: {
-                emailAccountId,
-                threadId,
-                messageId,
-              },
+              emailAccountId,
+              threadId,
+              messageId,
             },
             select: { id: true },
           })
@@ -79,13 +77,11 @@ export async function processHistoryItem(
       hasExistingRule !== null
         ? hasExistingRule
         : actualThreadId
-          ? await prisma.executedRule.findUnique({
+          ? await prisma.executedRule.findFirst({
               where: {
-                unique_emailAccount_thread_message: {
-                  emailAccountId,
-                  threadId: actualThreadId,
-                  messageId,
-                },
+                emailAccountId,
+                threadId: actualThreadId,
+                messageId,
               },
               select: { id: true },
             })

From bb46440353cc4320fedf33f1c5afbe5692ea74ea Mon Sep 17 00:00:00 2001
From: Eliezer Steinbock <3090527+elie222@users.noreply.github.com>
Date: Sun, 19 Oct 2025 18:03:25 +0300
Subject: [PATCH 02/40] fix build

---
 .../[emailAccountId]/assistant/ExecutedRulesTable.tsx |  2 +-
 apps/web/utils/ai/choose-rule/ai-choose-rule.ts       | 11 ++++-------
 2 files changed, 5 insertions(+), 8 deletions(-)

diff --git a/apps/web/app/(app)/[emailAccountId]/assistant/ExecutedRulesTable.tsx b/apps/web/app/(app)/[emailAccountId]/assistant/ExecutedRulesTable.tsx
index 946d66465a..cc6b401b42 100644
--- a/apps/web/app/(app)/[emailAccountId]/assistant/ExecutedRulesTable.tsx
+++ b/apps/web/app/(app)/[emailAccountId]/assistant/ExecutedRulesTable.tsx
@@ -136,7 +136,7 @@ export function RuleCell({
       <FixWithChat
         setInput={setInput}
         message={message}
-        result={{ rule, reason }}
+        results={[{ rule, reason }]}
       />
       <RuleDialogComponent />
     </div>
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 a8defd4885..c6cd37e296 100644
--- a/apps/web/utils/ai/choose-rule/ai-choose-rule.ts
+++ b/apps/web/utils/ai/choose-rule/ai-choose-rule.ts
@@ -185,17 +185,14 @@ async function getAiResponseMultiRule({
   IMPORTANT: Follow these instructions carefully when selecting rules:
 
   <priority>
-  1. Review all available rules and select those that genuinely match this email.
-  2. You can select multiple rules if they all apply.
-  3. System preset rules (like To Reply, Newsletter, etc.) typically don't overlap - avoid selecting multiple system rules unless truly necessary.
-  4. Custom user-defined rules can overlap freely - select all that apply.
-  5. Be selective - typically 1-3 rules is appropriate.
-  6. Only set "noMatchFound" to true if no rules can reasonably apply.
+  - Review all available rules and select those that genuinely match this email.
+  - You can select multiple rules, but BE SELECTIVE - it's rare that you need to select more than 1-2 rules.
+  - Only set "noMatchFound" to true if no rules can reasonably apply. There is usually a rule that matches.
   </priority>
 
   <guidelines>
   - If a rule says to exclude certain types of emails, DO NOT select that rule for those excluded emails.
-  - Rules about requiring replies should be prioritized when the email clearly needs a response.
+  - Do not be greedy - only select rules that add meaningful context.
   - Be concise in your reasoning - avoid repetitive explanations.
   </guidelines>
 </instructions>

From feeffffd3f850ce490232bb9b32df4088435a79a Mon Sep 17 00:00:00 2001
From: Eliezer Steinbock <3090527+elie222@users.noreply.github.com>
Date: Sun, 19 Oct 2025 19:35:58 +0300
Subject: [PATCH 03/40] fix multi select prompt

---
 .../utils/ai/choose-rule/ai-choose-rule.ts    | 209 +++++++-----------
 apps/web/utils/ai/choose-rule/match-rules.ts  |   5 +-
 2 files changed, 80 insertions(+), 134 deletions(-)

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 c6cd37e296..ca34dcd7c3 100644
--- a/apps/web/utils/ai/choose-rule/ai-choose-rule.ts
+++ b/apps/web/utils/ai/choose-rule/ai-choose-rule.ts
@@ -4,11 +4,8 @@ import { stringifyEmail } from "@/utils/stringify-email";
 import { isDefined, type EmailForLLM } from "@/utils/types";
 import { getModel, type ModelType } from "@/utils/llms/model";
 import { createGenerateObject } from "@/utils/llms";
-import { createScopedLogger } from "@/utils/logger";
 import { getUserInfoPrompt, getUserRulesPrompt } from "@/utils/ai/helpers";
 
-const logger = createScopedLogger("AI Choose Rule");
-
 type GetAiResponseOptions = {
   email: EmailForLLM;
   emailAccount: EmailAccountWithAI;
@@ -16,41 +13,81 @@ type GetAiResponseOptions = {
   modelType?: ModelType;
 };
 
+export async function aiChooseRule<
+  T extends { name: string; instructions: string; systemType?: string | null },
+>({
+  email,
+  rules,
+  emailAccount,
+  modelType,
+}: {
+  email: EmailForLLM;
+  rules: T[];
+  emailAccount: EmailAccountWithAI;
+  modelType?: ModelType;
+}): Promise<{
+  rules: T[];
+  reason: string;
+}> {
+  if (!rules.length) return { rules: [], reason: "" };
+
+  const { result: aiResponse } = await getAiResponse({
+    email,
+    rules,
+    emailAccount,
+    modelType,
+  });
+
+  if (aiResponse.noMatchFound) return { rules: [], reason: "" };
+
+  const selectedRules = aiResponse.matchedRules
+    .map((match) => {
+      const rule = rules.find(
+        (r) => r.name.toLowerCase() === match.ruleName.toLowerCase(),
+      );
+      return rule;
+    })
+    .filter(isDefined);
+
+  return {
+    rules: selectedRules,
+    reason: aiResponse.reasoning,
+  };
+}
+
 async function getAiResponse(options: GetAiResponseOptions): Promise<{
   result: {
-    matchedRules: {
-      reason: string;
-      ruleName: string;
-    }[];
+    matchedRules: { ruleName: string }[];
+    reasoning: string;
     noMatchFound: boolean;
   };
   modelOptions: ReturnType<typeof getModel>;
 }> {
   const { email, emailAccount, rules, modelType = "default" } = options;
 
-  const emailSection = stringifyEmail(email, 500);
-  const hasCustomRules = rules.some((rule) => !rule.systemType);
-
   const modelOptions = getModel(emailAccount.user, modelType);
+
   const generateObject = createGenerateObject({
     userEmail: emailAccount.email,
     label: "Choose rule",
     modelOptions,
   });
 
-  // Use different prompts based on whether custom rules exist
+  const hasCustomRules = rules.some((rule) => !rule.systemType);
+
   if (hasCustomRules) {
-    return getAiResponseMultiRule({
+    const result = await getAiResponseMultiRule({
       email,
-      emailSection,
       emailAccount,
       rules,
       modelOptions,
       generateObject,
     });
+
+    return { result, modelOptions };
   } else {
     return getAiResponseSingleRule({
-      emailSection,
+      email,
       emailAccount,
       rules,
       modelOptions,
@@ -59,15 +96,14 @@ async function getAiResponse(options: GetAiResponseOptions): Promise<{
   }
 }
 
-// Original single-rule logic (proven, for users without custom rules)
 async function getAiResponseSingleRule({
-  emailSection,
+  email,
   emailAccount,
   rules,
   modelOptions,
   generateObject,
 }: {
-  emailSection: string;
+  email: EmailForLLM;
   emailAccount: EmailAccountWithAI;
   rules: GetAiResponseOptions["rules"];
   modelOptions: ReturnType<typeof getModel>;
@@ -101,7 +137,7 @@ Respond with a valid JSON object:
 
 Example response format:
 {
-  "reason": "This email is a newsletter subscription",
+  "reasoning": "This email is a newsletter subscription",
   "ruleName": "Newsletter",
   "noMatchFound": false
 }`;
@@ -109,7 +145,7 @@ Example response format:
   const prompt = `Select a rule to apply to this email that was sent to me:
 
 <email>
-${emailSection}
+${stringifyEmail(email, 500)}
 </email>`;
 
   const aiResponse = await generateObject({
@@ -117,7 +153,7 @@ ${emailSection}
     system,
     prompt,
     schema: z.object({
-      reason: z
+      reasoning: z
         .string()
         .describe("The reason you chose the rule. Keep it concise"),
       ruleName: z
@@ -133,51 +169,31 @@ ${emailSection}
     result: {
       matchedRules: aiResponse.object ? [aiResponse.object] : [],
       noMatchFound: aiResponse.object?.noMatchFound ?? false,
+      reasoning: aiResponse.object?.reasoning,
     },
     modelOptions,
   };
 }
 
-// New multi-rule logic (for users with custom rules)
 async function getAiResponseMultiRule({
   email,
-  emailSection,
   emailAccount,
   rules,
   modelOptions,
   generateObject,
 }: {
   email: EmailForLLM;
-  emailSection: string;
   emailAccount: EmailAccountWithAI;
   rules: GetAiResponseOptions["rules"];
   modelOptions: ReturnType<typeof getModel>;
   generateObject: ReturnType<typeof createGenerateObject>;
 }) {
-  const systemRules = rules.filter((rule) => rule.systemType);
-  const customRules = rules.filter((rule) => !rule.systemType);
-
-  // Build rules list with clear system vs custom distinction
-  let rulesSection = "";
-  if (systemRules.length > 0) {
-    rulesSection += "\n<system_rules>\nSystem preset rules:\n\n";
-    rulesSection += systemRules
-      .map(
-        (rule, idx) =>
-          `${idx + 1}. ${rule.name}${rule.instructions ? `\n   Instructions: ${rule.instructions}` : ""}`,
-      )
-      .join("\n\n");
-    rulesSection += "\n</system_rules>";
-  }
-
-  rulesSection += "\n\n<custom_rules>\nCustom user-defined rules:\n\n";
-  rulesSection += customRules
+  const rulesSection = rules
     .map(
-      (rule, idx) =>
-        `${idx + 1}. ${rule.name}${rule.instructions ? `\n   Instructions: ${rule.instructions}` : ""}`,
+      (rule) =>
+        `<rule>\n<name>${rule.name}</name>\n<instructions>${rule.instructions}</instructions>\n</rule>`,
     )
-    .join("\n\n");
-  rulesSection += "\n</custom_rules>";
+    .join("\n");
 
   const system = `You are an AI assistant that helps people manage their emails.
 
@@ -207,34 +223,22 @@ Respond with a valid JSON object:
 
 Example response format (single rule):
 {
-  "matchedRules": [
-    {
-      "ruleName": "Newsletter",
-      "reason": "This is a newsletter subscription"
-    }
-  ],
-  "noMatchFound": false
+  "matchedRules": [{ "ruleName": "Newsletter" }],
+  "noMatchFound": false,
+  "reasoning": "This is a newsletter subscription"
 }
 
 Example response format (multiple rules):
 {
-  "matchedRules": [
-    {
-      "ruleName": "To Reply",
-      "reason": "This email requires a response"
-    },
-    {
-      "ruleName": "Team Emails",
-      "reason": "From a team member"
-    }
-  ],
-  "noMatchFound": false
+  "matchedRules": [{ "ruleName": "To Reply" }, { "ruleName": "Team Emails" }],
+  "noMatchFound": false,
+  "reasoning": "This email requires a response and is from a team member"
 }`;
 
   const prompt = `Select all rules that apply to this email that was sent to me:
 
 <email>
-${emailSection}
+${stringifyEmail(email, 500)}
 </email>`;
 
   const aiResponse = await generateObject({
@@ -246,84 +250,23 @@ ${emailSection}
         .array(
           z.object({
             ruleName: z.string().describe("The exact name of the rule"),
-            reason: z.string().describe("Why this rule matches"),
           }),
         )
         .describe("Array of all matching rules"),
+      reasoning: z
+        .string()
+        .describe(
+          "The reasoning you used to choose the rules. Keep it concise",
+        ),
       noMatchFound: z
         .boolean()
         .describe("True if no match was found, false otherwise"),
     }),
   });
 
-  // Log when multiple system rules are selected
-  const selectedSystemRules = aiResponse.object.matchedRules.filter((match) =>
-    systemRules.some(
-      (r) => r.name.toLowerCase() === match.ruleName.toLowerCase(),
-    ),
-  );
-
-  if (selectedSystemRules.length > 1) {
-    logger.warn("Multiple system rules selected", {
-      systemRules: selectedSystemRules.map((r) => r.ruleName),
-      emailId: email.id,
-      model: modelOptions.modelName,
-    });
-  }
-
-  if (aiResponse.object.matchedRules.length > 1) {
-    logger.info("Multiple rules selected", {
-      rules: aiResponse.object.matchedRules.map((r) => r.ruleName),
-      emailId: email.id,
-    });
-  }
-
   return {
-    result: {
-      matchedRules: aiResponse.object.matchedRules || [],
-      noMatchFound: aiResponse.object?.noMatchFound ?? false,
-    },
-    modelOptions,
+    matchedRules: aiResponse.object.matchedRules || [],
+    noMatchFound: aiResponse.object?.noMatchFound ?? false,
+    reasoning: aiResponse.object?.reasoning ?? "",
   };
 }
-
-export async function aiChooseRule<
-  T extends { name: string; instructions: string; systemType?: string | null },
->({
-  email,
-  rules,
-  emailAccount,
-  modelType,
-}: {
-  email: EmailForLLM;
-  rules: T[];
-  emailAccount: EmailAccountWithAI;
-  modelType?: ModelType;
-}): Promise<
-  {
-    rule: T;
-    reason: string;
-  }[]
-> {
-  if (!rules.length) return [];
-
-  const { result: aiResponse } = await getAiResponse({
-    email,
-    rules,
-    emailAccount,
-    modelType,
-  });
-
-  if (aiResponse.noMatchFound) return [];
-
-  const selectedRules = aiResponse.matchedRules
-    .map((match) => {
-      const rule = rules.find(
-        (r) => r.name.toLowerCase() === match.ruleName.toLowerCase(),
-      );
-      return rule ? { rule, reason: match.reason } : undefined;
-    })
-    .filter(isDefined);
-
-  return selectedRules;
-}
diff --git a/apps/web/utils/ai/choose-rule/match-rules.ts b/apps/web/utils/ai/choose-rule/match-rules.ts
index d28d353a22..7c1cbe839a 100644
--- a/apps/web/utils/ai/choose-rule/match-rules.ts
+++ b/apps/web/utils/ai/choose-rule/match-rules.ts
@@ -317,7 +317,10 @@ async function findMatchingRuleWithReasons(
       modelType,
     });
 
-    return result;
+    return result.rules.map((rule) => ({
+      rule,
+      reason: result.reason,
+    }));
   }
 
   return [];

From 1f1dc72627a6cd99bdea8b9dc2421e4dffccf08d Mon Sep 17 00:00:00 2001
From: Eliezer Steinbock <3090527+elie222@users.noreply.github.com>
Date: Mon, 20 Oct 2025 01:02:12 +0300
Subject: [PATCH 04/40] improve filter

---
 apps/web/utils/ai/choose-rule/match-rules.ts | 15 +++++++++------
 1 file changed, 9 insertions(+), 6 deletions(-)

diff --git a/apps/web/utils/ai/choose-rule/match-rules.ts b/apps/web/utils/ai/choose-rule/match-rules.ts
index c26e97c56d..0214095d01 100644
--- a/apps/web/utils/ai/choose-rule/match-rules.ts
+++ b/apps/web/utils/ai/choose-rule/match-rules.ts
@@ -33,6 +33,7 @@ import {
   isColdEmailRuleEnabled,
 } from "@/utils/cold-email/cold-email-rule";
 import { isColdEmail } from "@/utils/cold-email/is-cold-email";
+import { isConversationStatusType } from "@/utils/reply-tracker/conversation-status-config";
 
 const logger = createScopedLogger("match-rules");
 
@@ -139,7 +140,7 @@ async function findPotentialMatchingRules({
     }
   }
 
-  const filteredPotentialMatches = await filterToReplyPreset(
+  const filteredPotentialMatches = await filterConversationStatusRules(
     potentialMatches,
     message,
     provider,
@@ -445,7 +446,7 @@ function matchesCategoryRule(
   return matchedFilter;
 }
 
-export async function filterToReplyPreset<
+export async function filterConversationStatusRules<
   T extends { id: string; systemType: SystemType | null },
 >(
   potentialMatches: T[],
@@ -474,14 +475,16 @@ export async function filterToReplyPreset<
     "account@",
   ];
 
-  function filteredOutToReplyRule() {
-    return potentialMatches.filter((r) => r.systemType !== SystemType.TO_REPLY);
+  function filteredOutConversationStatusRules() {
+    return potentialMatches.filter(
+      (r) => !isConversationStatusType(r.systemType),
+    );
   }
 
   if (
     noReplyPrefixes.some((prefix) => extractedSenderEmail.startsWith(prefix))
   ) {
-    return filteredOutToReplyRule();
+    return filteredOutConversationStatusRules();
   }
 
   try {
@@ -500,7 +503,7 @@ export async function filterToReplyPreset<
           receivedCount,
         },
       );
-      return filteredOutToReplyRule();
+      return filteredOutConversationStatusRules();
     }
   } catch (error) {
     logger.error("Error checking reply history for TO_REPLY filter", {

From 4441c91850bbca9bd4fe8505b1ba314610900cbf Mon Sep 17 00:00:00 2001
From: Eliezer Steinbock <3090527+elie222@users.noreply.github.com>
Date: Mon, 20 Oct 2025 01:03:39 +0300
Subject: [PATCH 05/40] warn

---
 apps/web/app/api/user/complete-registration/route.ts | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/apps/web/app/api/user/complete-registration/route.ts b/apps/web/app/api/user/complete-registration/route.ts
index 4963243824..60a017685e 100644
--- a/apps/web/app/api/user/complete-registration/route.ts
+++ b/apps/web/app/api/user/complete-registration/route.ts
@@ -86,10 +86,9 @@ async function storePosthogSignupEvent(userId: string, email: string) {
   const ONE_HOUR_AGO = new Date(Date.now() - ONE_HOUR_MS);
 
   if (userCreatedAt.createdAt < ONE_HOUR_AGO) {
-    logger.error(
-      "storePosthogSignupEvent: User created more than an hour ago",
-      { userId },
-    );
+    logger.warn("storePosthogSignupEvent: User created more than an hour ago", {
+      userId,
+    });
     return;
   }
 

From c284968e0b09f7c6ca3763660ea4c635f3140ad7 Mon Sep 17 00:00:00 2001
From: Eliezer Steinbock <3090527+elie222@users.noreply.github.com>
Date: Mon, 20 Oct 2025 02:00:51 +0300
Subject: [PATCH 06/40] get no match reasoning

---
 .../utils/ai/choose-rule/ai-choose-rule.ts    | 39 +++++++++-
 apps/web/utils/ai/choose-rule/match-rules.ts  | 74 +++++++++----------
 apps/web/utils/ai/choose-rule/run-rules.ts    | 10 +--
 3 files changed, 77 insertions(+), 46 deletions(-)

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 ca34dcd7c3..7161bf214a 100644
--- a/apps/web/utils/ai/choose-rule/ai-choose-rule.ts
+++ b/apps/web/utils/ai/choose-rule/ai-choose-rule.ts
@@ -206,6 +206,11 @@ async function getAiResponseMultiRule({
   - Only set "noMatchFound" to true if no rules can reasonably apply. There is usually a rule that matches.
   </priority>
 
+  <isPrimary_field>
+  - When returning multiple rules, mark ONLY ONE rule as the primary match (isPrimary: true).
+  - The primary rule should be the MOST SPECIFIC rule that best matches the email's content and purpose.
+  </isPrimary_field>
+
   <guidelines>
   - If a rule says to exclude certain types of emails, DO NOT select that rule for those excluded emails.
   - Do not be greedy - only select rules that add meaningful context.
@@ -223,14 +228,17 @@ Respond with a valid JSON object:
 
 Example response format (single rule):
 {
-  "matchedRules": [{ "ruleName": "Newsletter" }],
+  "matchedRules": [{ "ruleName": "Newsletter", "isPrimary": true }],
   "noMatchFound": false,
   "reasoning": "This is a newsletter subscription"
 }
 
 Example response format (multiple rules):
 {
-  "matchedRules": [{ "ruleName": "To Reply" }, { "ruleName": "Team Emails" }],
+  "matchedRules": [
+    { "ruleName": "To Reply", "isPrimary": true },
+    { "ruleName": "Team Emails", "isPrimary": false }
+  ],
   "noMatchFound": false,
   "reasoning": "This email requires a response and is from a team member"
 }`;
@@ -250,6 +258,11 @@ ${stringifyEmail(email, 500)}
         .array(
           z.object({
             ruleName: z.string().describe("The exact name of the rule"),
+            isPrimary: z
+              .boolean()
+              .describe(
+                "True if the rule is the primary match, false otherwise",
+              ),
           }),
         )
         .describe("Array of all matching rules"),
@@ -270,3 +283,25 @@ ${stringifyEmail(email, 500)}
     reasoning: aiResponse.object?.reasoning ?? "",
   };
 }
+
+/**
+ * Filter system rules: if multiple system rules were matched, only keep the primary one.
+ * Always keep all conversation rules (non-system rules).
+ */
+function filterMultipleSystemRules<
+  T extends { name: string; instructions: string; systemType?: string | null },
+>(selectedRules: { rule: T; isPrimary?: boolean }[]): T[] {
+  const systemRules = selectedRules.filter((r) => r.rule.systemType);
+  const conversationRules = selectedRules.filter((r) => !r.rule.systemType);
+
+  let filteredSystemRules = systemRules;
+  if (systemRules.length > 1) {
+    // Only keep the primary system rule
+    const primarySystemRule = systemRules.find((r) => r.isPrimary);
+    filteredSystemRules = primarySystemRule
+      ? [primarySystemRule]
+      : [systemRules[0]];
+  }
+
+  return [...filteredSystemRules, ...conversationRules].map((r) => r.rule);
+}
diff --git a/apps/web/utils/ai/choose-rule/match-rules.ts b/apps/web/utils/ai/choose-rule/match-rules.ts
index 0214095d01..96a76a462a 100644
--- a/apps/web/utils/ai/choose-rule/match-rules.ts
+++ b/apps/web/utils/ai/choose-rule/match-rules.ts
@@ -39,6 +39,14 @@ const logger = createScopedLogger("match-rules");
 
 const TO_REPLY_RECEIVED_THRESHOLD = 10;
 
+type MatchingRulesResult = {
+  matches: {
+    rule: RuleWithActionsAndCategories;
+    matchReasons?: MatchReason[];
+  }[];
+  reasoning: string;
+};
+
 // if we find a match, return it
 // if we don't find a match, return the potential matches
 // ai rules need further processing to determine if they match
@@ -77,6 +85,7 @@ async function findPotentialMatchingRules({
     // Ignores conditional operator
     if (rule.groupId) {
       const groups = await contextLoader.getGroups(rule.emailAccountId);
+      if (!groups?.length) continue;
       const { matchingItem, group, ruleExcluded } = matchesGroupRule(
         rule,
         groups,
@@ -102,6 +111,7 @@ async function findPotentialMatchingRules({
       Object.keys(conditionTypes) as ConditionType[],
     );
 
+    // TODO: allow multiple matches
     if (conditionTypes.STATIC) {
       const match = matchesStaticRule(rule, message);
       if (match) {
@@ -115,6 +125,7 @@ async function findPotentialMatchingRules({
       }
     }
 
+    // TODO: allow multiple matches?
     if (conditionTypes.CATEGORY) {
       const sender = await contextLoader.getSender(rule.emailAccountId);
       const matchedCategory = matchesCategoryRule(rule, sender);
@@ -177,23 +188,21 @@ function checkCalendarMatch({
 // Lazy load context data when needed
 class ContextLoader {
   private readonly message: ParsedMessage;
-  private groups: Awaited<ReturnType<typeof getGroupsWithRules>>;
-  private sender: { categoryId: string | null } | null | undefined;
+  private groups?: Awaited<ReturnType<typeof getGroupsWithRules>> | null = null;
+  private sender?: { categoryId: string | null } | null = null;
 
   constructor(message: ParsedMessage) {
     this.message = message;
-    this.groups = [];
-    this.sender = undefined;
   }
 
   async getGroups(emailAccountId: string) {
-    if (!this.groups)
+    if (typeof this.groups === "undefined")
       this.groups = await getGroupsWithRules({ emailAccountId });
     return this.groups;
   }
 
   async getSender(emailAccountId: string) {
-    if (!this.sender) {
+    if (typeof this.sender === "undefined") {
       this.sender = await prisma.newsletter.findUnique({
         where: {
           email_emailAccountId: {
@@ -207,6 +216,7 @@ class ContextLoader {
   }
 }
 
+// TODO: how was this used? use it again
 function getMatchReason(matchReasons?: MatchReason[]): string | undefined {
   if (!matchReasons || matchReasons.length === 0) return;
 
@@ -238,13 +248,7 @@ export async function findMatchingRules({
   emailAccount: EmailAccountWithAI;
   provider: EmailProvider;
   modelType: ModelType;
-}): Promise<
-  {
-    rule: RuleWithActionsAndCategories;
-    matchReasons?: MatchReason[];
-    reason?: string;
-  }[]
-> {
+}): Promise<MatchingRulesResult> {
   const coldEmailRule = await getColdEmailRule(emailAccount.id);
 
   if (coldEmailRule && isColdEmailRuleEnabled(coldEmailRule)) {
@@ -262,13 +266,10 @@ export async function findMatchingRules({
         include: { actions: true, categoryFilters: true },
       });
 
-      return [
-        {
-          rule: coldEmailRuleWithCategories,
-          matchReasons: [],
-          reason: coldEmailResult.reason,
-        },
-      ];
+      return {
+        matches: [{ rule: coldEmailRuleWithCategories, matchReasons: [] }],
+        reasoning: coldEmailResult.reason,
+      };
     }
   }
 
@@ -277,32 +278,24 @@ export async function findMatchingRules({
     (rule) => rule.systemType !== SystemType.COLD_EMAIL,
   );
 
-  const results = await findMatchingRuleWithReasons(
+  const results = await findMatchingRulesWithReasons(
     rulesWithoutColdEmail,
     message,
     emailAccount,
     provider,
     modelType,
   );
-  return results.map((result) => ({
-    ...result,
-    reason: result.reason || getMatchReason(result.matchReasons || []),
-  }));
+
+  return results;
 }
 
-async function findMatchingRuleWithReasons(
+async function findMatchingRulesWithReasons(
   rules: RuleWithActionsAndCategories[],
   message: ParsedMessage,
   emailAccount: EmailAccountWithAI,
   provider: EmailProvider,
   modelType: ModelType,
-): Promise<
-  {
-    rule: RuleWithActionsAndCategories;
-    matchReasons?: MatchReason[];
-    reason?: string;
-  }[]
-> {
+): Promise<MatchingRulesResult> {
   const isThread = provider.isReplyInThread(message);
 
   const { match, matchReasons, potentialMatches } =
@@ -313,7 +306,7 @@ async function findMatchingRuleWithReasons(
       provider,
     });
 
-  if (match) return [{ rule: match, matchReasons }];
+  if (match) return { matches: [{ rule: match, matchReasons }], reasoning: "" };
 
   if (potentialMatches?.length) {
     const result = await aiChooseRule({
@@ -323,13 +316,16 @@ async function findMatchingRuleWithReasons(
       modelType,
     });
 
-    return result.rules.map((rule) => ({
-      rule,
-      reason: result.reason,
-    }));
+    return {
+      matches: result.rules.map((rule) => ({
+        rule,
+        matchReasons: [],
+      })),
+      reasoning: result.reason,
+    };
   }
 
-  return [];
+  return { matches: [], reasoning: "" };
 }
 
 export function matchesStaticRule(
diff --git a/apps/web/utils/ai/choose-rule/run-rules.ts b/apps/web/utils/ai/choose-rule/run-rules.ts
index 55c3e7ba3c..0bd43be7ec 100644
--- a/apps/web/utils/ai/choose-rule/run-rules.ts
+++ b/apps/web/utils/ai/choose-rule/run-rules.ts
@@ -69,11 +69,11 @@ export async function runRules({
   });
 
   logger.trace("Matching rule", () => ({
-    results: results.map(filterNullProperties),
+    results: results.matches.map(filterNullProperties),
   }));
 
-  if (!results.length) {
-    const reason = "No rules matched"; // TODO: get the reason from the prompt?
+  if (!results.matches.length) {
+    const reason = results.reasoning || "No rules matched";
     await prisma.executedRule.create({
       data: {
         threadId: message.threadId,
@@ -90,9 +90,9 @@ export async function runRules({
 
   const executedRules: RunRulesResult[] = [];
 
-  for (const result of results) {
+  for (const result of results.matches) {
     let ruleToExecute = result.rule;
-    let reasonToUse = result.reason;
+    let reasonToUse = results.reasoning;
 
     if (result.rule.id === CONVERSATION_TRACKING_META_RULE_ID) {
       // Determine which specific sub-rule applies

From bd619a355c778844e8189707028d5e7564b0dda5 Mon Sep 17 00:00:00 2001
From: Eliezer Steinbock <3090527+elie222@users.noreply.github.com>
Date: Mon, 20 Oct 2025 02:02:53 +0300
Subject: [PATCH 07/40] normalize cold email from

---
 apps/web/utils/cold-email/is-cold-email.ts | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/apps/web/utils/cold-email/is-cold-email.ts b/apps/web/utils/cold-email/is-cold-email.ts
index 45f35df6cd..89aa72e9d2 100644
--- a/apps/web/utils/cold-email/is-cold-email.ts
+++ b/apps/web/utils/cold-email/is-cold-email.ts
@@ -10,6 +10,7 @@ import type { EmailForLLM } from "@/utils/types";
 import type { EmailProvider } from "@/utils/email/types";
 import { getModel, type ModelType } from "@/utils/llms/model";
 import { createGenerateObject } from "@/utils/llms";
+import { extractEmailAddress } from "@/utils/email";
 
 export const COLD_EMAIL_FOLDER_NAME = "Cold Emails";
 
@@ -167,17 +168,19 @@ export async function saveColdEmail({
   emailAccount: EmailAccountWithAI;
   aiReason: string | null;
 }): Promise<ColdEmail> {
+  const from = extractEmailAddress(email.from) || email.from;
+
   return await prisma.coldEmail.upsert({
     where: {
       emailAccountId_fromEmail: {
         emailAccountId: emailAccount.id,
-        fromEmail: email.from,
+        fromEmail: from,
       },
     },
     update: { status: ColdEmailStatus.AI_LABELED_COLD },
     create: {
       status: ColdEmailStatus.AI_LABELED_COLD,
-      fromEmail: email.from,
+      fromEmail: from,
       emailAccountId: emailAccount.id,
       reason: aiReason,
       messageId: email.id,

From e4cc18797a59972b0ab9183e1cece6e67637763c Mon Sep 17 00:00:00 2001
From: Eliezer Steinbock <3090527+elie222@users.noreply.github.com>
Date: Mon, 20 Oct 2025 02:24:33 +0300
Subject: [PATCH 08/40] fix cancel scheduled action

---
 apps/web/utils/ai/choose-rule/run-rules.ts     |  3 ++-
 .../utils/scheduled-actions/scheduler.test.ts  | 18 ++++++++++++++++--
 apps/web/utils/scheduled-actions/scheduler.ts  |  7 +++++++
 3 files changed, 25 insertions(+), 3 deletions(-)

diff --git a/apps/web/utils/ai/choose-rule/run-rules.ts b/apps/web/utils/ai/choose-rule/run-rules.ts
index 0bd43be7ec..ab21f34867 100644
--- a/apps/web/utils/ai/choose-rule/run-rules.ts
+++ b/apps/web/utils/ai/choose-rule/run-rules.ts
@@ -261,11 +261,12 @@ async function executeMatchedRule(
 
   if (executedRule) {
     if (delayedActions?.length > 0) {
-      // Attempts to cancel any existing scheduled actions to avoid duplicates
+      // Cancels existing scheduled actions to avoid duplicates
       await cancelScheduledActions({
         emailAccountId: emailAccount.id,
         messageId: message.id,
         threadId: message.threadId,
+        ruleId: rule.id,
         reason: "Superseded by new rule execution",
       });
       await scheduleDelayedActions({
diff --git a/apps/web/utils/scheduled-actions/scheduler.test.ts b/apps/web/utils/scheduled-actions/scheduler.test.ts
index 4631f372f6..a5a625fa1f 100644
--- a/apps/web/utils/scheduled-actions/scheduler.test.ts
+++ b/apps/web/utils/scheduled-actions/scheduler.test.ts
@@ -33,13 +33,12 @@ describe("scheduler", () => {
       expect(canActionBeDelayed(ActionType.CALL_WEBHOOK)).toBe(false);
       expect(canActionBeDelayed(ActionType.DRAFT_EMAIL)).toBe(false);
       expect(canActionBeDelayed(ActionType.MARK_SPAM)).toBe(false);
-      expect(canActionBeDelayed(ActionType.TRACK_THREAD)).toBe(false);
       expect(canActionBeDelayed(ActionType.DIGEST)).toBe(false);
     });
   });
 
   describe("cancelScheduledActions", () => {
-    it("should cancel scheduled actions for a message", async () => {
+    it("should cancel scheduled actions for a specific rule", async () => {
       // Mock finding actions to cancel
       prisma.scheduledAction.findMany.mockResolvedValue([
         { id: "action-1", scheduledId: "qstash-msg-1" },
@@ -52,6 +51,7 @@ describe("scheduler", () => {
       const result = await cancelScheduledActions({
         messageId: "msg-123",
         emailAccountId: "account-123",
+        ruleId: "rule-123",
       });
 
       expect(prisma.scheduledAction.findMany).toHaveBeenCalledWith({
@@ -59,6 +59,9 @@ describe("scheduler", () => {
           emailAccountId: "account-123",
           messageId: "msg-123",
           status: ScheduledActionStatus.PENDING,
+          executedRule: {
+            ruleId: "rule-123",
+          },
         },
         select: {
           id: true,
@@ -71,6 +74,9 @@ describe("scheduler", () => {
           emailAccountId: "account-123",
           messageId: "msg-123",
           status: ScheduledActionStatus.PENDING,
+          executedRule: {
+            ruleId: "rule-123",
+          },
         },
         data: {
           status: ScheduledActionStatus.CANCELLED,
@@ -87,6 +93,7 @@ describe("scheduler", () => {
       const result = await cancelScheduledActions({
         messageId: "msg-456",
         emailAccountId: "account-123",
+        ruleId: "rule-456",
       });
 
       expect(result).toBe(0);
@@ -102,6 +109,7 @@ describe("scheduler", () => {
         messageId: "msg-123",
         emailAccountId: "account-123",
         threadId: "thread-123",
+        ruleId: "rule-123",
         reason: "Custom reason",
       });
 
@@ -111,6 +119,9 @@ describe("scheduler", () => {
           messageId: "msg-123",
           threadId: "thread-123",
           status: ScheduledActionStatus.PENDING,
+          executedRule: {
+            ruleId: "rule-123",
+          },
         },
         select: {
           id: true,
@@ -124,6 +135,9 @@ describe("scheduler", () => {
           messageId: "msg-123",
           threadId: "thread-123",
           status: ScheduledActionStatus.PENDING,
+          executedRule: {
+            ruleId: "rule-123",
+          },
         },
         data: {
           status: ScheduledActionStatus.CANCELLED,
diff --git a/apps/web/utils/scheduled-actions/scheduler.ts b/apps/web/utils/scheduled-actions/scheduler.ts
index 75acfe9446..fa55985554 100644
--- a/apps/web/utils/scheduled-actions/scheduler.ts
+++ b/apps/web/utils/scheduled-actions/scheduler.ts
@@ -168,11 +168,13 @@ export async function cancelScheduledActions({
   emailAccountId,
   messageId,
   threadId,
+  ruleId,
   reason = "Superseded by new rule",
 }: {
   emailAccountId: string;
   messageId: string;
   threadId?: string;
+  ruleId: string;
   reason?: string;
 }) {
   try {
@@ -183,6 +185,9 @@ export async function cancelScheduledActions({
         messageId,
         ...(threadId && { threadId }),
         status: ScheduledActionStatus.PENDING,
+        executedRule: {
+          ruleId,
+        },
       },
       select: { id: true, scheduledId: true },
     });
@@ -220,6 +225,7 @@ export async function cancelScheduledActions({
         messageId,
         ...(threadId && { threadId }),
         status: ScheduledActionStatus.PENDING,
+        executedRule: { ruleId },
       },
       data: {
         status: ScheduledActionStatus.CANCELLED,
@@ -231,6 +237,7 @@ export async function cancelScheduledActions({
       emailAccountId,
       messageId,
       threadId,
+      ruleId,
       reason,
     });
 

From f0bd0092de0769bb17f98289452ad741573b3ac2 Mon Sep 17 00:00:00 2001
From: Eliezer Steinbock <3090527+elie222@users.noreply.github.com>
Date: Mon, 20 Oct 2025 02:26:59 +0300
Subject: [PATCH 09/40] fix context loader bug

---
 apps/web/utils/ai/choose-rule/match-rules.ts | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/apps/web/utils/ai/choose-rule/match-rules.ts b/apps/web/utils/ai/choose-rule/match-rules.ts
index 96a76a462a..1aac83f3b4 100644
--- a/apps/web/utils/ai/choose-rule/match-rules.ts
+++ b/apps/web/utils/ai/choose-rule/match-rules.ts
@@ -188,21 +188,21 @@ function checkCalendarMatch({
 // Lazy load context data when needed
 class ContextLoader {
   private readonly message: ParsedMessage;
-  private groups?: Awaited<ReturnType<typeof getGroupsWithRules>> | null = null;
-  private sender?: { categoryId: string | null } | null = null;
+  private groups?: Awaited<ReturnType<typeof getGroupsWithRules>> | null;
+  private sender?: { categoryId: string | null } | null;
 
   constructor(message: ParsedMessage) {
     this.message = message;
   }
 
   async getGroups(emailAccountId: string) {
-    if (typeof this.groups === "undefined")
+    if (this.groups === undefined)
       this.groups = await getGroupsWithRules({ emailAccountId });
     return this.groups;
   }
 
   async getSender(emailAccountId: string) {
-    if (typeof this.sender === "undefined") {
+    if (this.sender === undefined) {
       this.sender = await prisma.newsletter.findUnique({
         where: {
           email_emailAccountId: {

From c1808fec93adbcd86b972f262bd259e59e655614 Mon Sep 17 00:00:00 2001
From: Eliezer Steinbock <3090527+elie222@users.noreply.github.com>
Date: Mon, 20 Oct 2025 05:44:54 +0300
Subject: [PATCH 10/40] Remove categories from rules

---
 apps/web/__tests__/helpers.ts                 |   1 -
 .../assistant/ConditionSummaryCard.tsx        | 102 --------
 .../assistant/ProcessRules.tsx                |  13 +-
 .../[emailAccountId]/assistant/RuleForm.tsx   | 179 +------------
 .../[emailAccountId]/assistant/Rules.tsx      |   1 -
 .../[emailAccountId]/assistant/constants.ts   |   1 -
 .../BulkUnsubscribeSection.tsx                |   1 -
 .../debug/rule-history/[ruleId]/page.tsx      |  15 --
 apps/web/app/api/google/webhook/types.ts      |   4 +-
 .../outlook/webhook/process-history-item.ts   |   4 +-
 .../api/user/planned/get-executed-rules.ts    |   1 -
 .../api/user/rules/[id]/example/controller.ts |  12 +-
 apps/web/app/api/user/rules/[id]/route.ts     |   2 -
 apps/web/app/api/user/rules/route.ts          |   1 -
 apps/web/components/GroupedTable.tsx          |  38 ---
 apps/web/prisma/schema.prisma                 |  14 +-
 apps/web/utils/actions/ai-rule.ts             |  21 +-
 apps/web/utils/actions/rule.ts                |  22 +-
 apps/web/utils/actions/rule.validation.ts     |  21 +-
 .../ai/assistant/process-user-request.ts      | 240 +-----------------
 apps/web/utils/ai/choose-rule/run-rules.ts    |  22 +-
 apps/web/utils/ai/choose-rule/types.ts        |  31 ++-
 apps/web/utils/ai/rule/create-rule-schema.ts  |  48 +---
 apps/web/utils/ai/rule/prompt-to-rules-old.ts |  41 +--
 apps/web/utils/ai/rule/prompt-to-rules.ts     |  42 +--
 .../assistant/process-assistant-email.ts      |   2 -
 apps/web/utils/category.server.ts             |  26 --
 apps/web/utils/condition.ts                   |  73 +-----
 apps/web/utils/config.ts                      |   5 +-
 .../handle-conversation-status.ts             |   9 +-
 apps/web/utils/rule/rule-history.ts           |   9 -
 apps/web/utils/rule/rule-to-text.ts           |  20 +-
 apps/web/utils/rule/rule.ts                   | 107 +-------
 apps/web/utils/rule/types.ts                  |   3 +-
 apps/web/utils/types.ts                       |   8 -
 .../web/utils/webhook/process-history-item.ts |   4 +-
 .../utils/webhook/validate-webhook-account.ts |   2 +-
 37 files changed, 108 insertions(+), 1037 deletions(-)
 delete mode 100644 apps/web/app/(app)/[emailAccountId]/assistant/ConditionSummaryCard.tsx

diff --git a/apps/web/__tests__/helpers.ts b/apps/web/__tests__/helpers.ts
index 439f56ad34..3207be1440 100644
--- a/apps/web/__tests__/helpers.ts
+++ b/apps/web/__tests__/helpers.ts
@@ -57,7 +57,6 @@ export function getRule(instructions: string, actions: Action[] = []) {
     body: null,
     to: null,
     enabled: true,
-    categoryFilterType: null,
     conditionalOperator: LogicalOperator.AND,
   };
 }
diff --git a/apps/web/app/(app)/[emailAccountId]/assistant/ConditionSummaryCard.tsx b/apps/web/app/(app)/[emailAccountId]/assistant/ConditionSummaryCard.tsx
deleted file mode 100644
index a3a62a1417..0000000000
--- a/apps/web/app/(app)/[emailAccountId]/assistant/ConditionSummaryCard.tsx
+++ /dev/null
@@ -1,102 +0,0 @@
-import { BotIcon, FilterIcon } from "lucide-react";
-import { capitalCase } from "capital-case";
-import type { CreateRuleBody } from "@/utils/actions/rule.validation";
-import { ConditionType } from "@/utils/config";
-import { CardBasic } from "@/components/ui/card";
-import { CategoryFilterType } from "@prisma/client";
-
-export function ConditionSummaryCard({
-  condition,
-  categories,
-}: {
-  condition: CreateRuleBody["conditions"][number];
-  categories?: Array<{ id: string; name: string }>;
-}) {
-  let summaryContent: React.ReactNode = condition.type;
-  let Icon = FilterIcon;
-  let textColorClass = "text-gray-500";
-
-  switch (condition.type) {
-    case ConditionType.AI: {
-      Icon = BotIcon;
-      textColorClass = "text-purple-500";
-      summaryContent = condition.instructions || "No instructions set";
-      break;
-    }
-
-    case ConditionType.STATIC: {
-      textColorClass = "text-blue-500";
-      const parts: string[] = [];
-
-      if (condition.from) {
-        parts.push(`From: ${condition.from}`);
-      }
-      if (condition.to) {
-        parts.push(`To: ${condition.to}`);
-      }
-      if (condition.subject) {
-        parts.push(`Subject: ${condition.subject}`);
-      }
-
-      if (parts.length > 0) {
-        summaryContent = (
-          <>
-            <span>Static Condition</span>
-            <div className="mt-2 space-y-1">
-              {parts.map((part, index) => (
-                <div key={index} className="text-muted-foreground">
-                  {part}
-                </div>
-              ))}
-            </div>
-          </>
-        );
-      } else {
-        summaryContent = "Static Condition (no filters set)";
-      }
-      break;
-    }
-
-    case ConditionType.CATEGORY: {
-      textColorClass = "text-green-500";
-      const filterType =
-        condition.categoryFilterType || CategoryFilterType.INCLUDE;
-      const categoryFilters = condition.categoryFilters || [];
-
-      if (categoryFilters.length > 0 && categories && categories.length > 0) {
-        const categoryNames = categoryFilters
-          .map((id) => {
-            const category = categories.find((cat) => cat.id === id);
-            return category ? capitalCase(category.name) : null;
-          })
-          .filter(Boolean)
-          .join(", ");
-
-        summaryContent = (
-          <>
-            <span>Category Condition</span>
-            <span className="mt-2 block text-muted-foreground">
-              {filterType === CategoryFilterType.INCLUDE ? "Match" : "Skip"}{" "}
-              categories: {categoryNames || "Unknown"}
-            </span>
-          </>
-        );
-      } else {
-        summaryContent = "Category Condition (no categories selected)";
-      }
-      break;
-    }
-
-    default:
-      summaryContent = `${condition.type} Condition`;
-  }
-
-  return (
-    <CardBasic className="flex items-center justify-between p-4">
-      <div className="flex items-center gap-3">
-        <Icon className={`size-5 ${textColorClass} flex-shrink-0`} />
-        <div className="whitespace-pre-wrap">{summaryContent}</div>
-      </div>
-    </CardBasic>
-  );
-}
diff --git a/apps/web/app/(app)/[emailAccountId]/assistant/ProcessRules.tsx b/apps/web/app/(app)/[emailAccountId]/assistant/ProcessRules.tsx
index 8f5e51a0cd..d167fb3e55 100644
--- a/apps/web/app/(app)/[emailAccountId]/assistant/ProcessRules.tsx
+++ b/apps/web/app/(app)/[emailAccountId]/assistant/ProcessRules.tsx
@@ -25,12 +25,7 @@ import { Card } from "@/components/ui/card";
 import type { RunRulesResult } from "@/utils/ai/choose-rule/run-rules";
 import { SearchForm } from "@/components/SearchForm";
 import type { BatchExecutedRulesResponse } from "@/app/api/user/executed-rules/batch/route";
-import {
-  isAIRule,
-  isCategoryRule,
-  isGroupRule,
-  isStaticRule,
-} from "@/utils/condition";
+import { isAIRule, isGroupRule, isStaticRule } from "@/utils/condition";
 import { BulkRunRules } from "@/app/(app)/[emailAccountId]/assistant/BulkRunRules";
 import { cn } from "@/utils";
 import { TestCustomEmailForm } from "@/app/(app)/[emailAccountId]/assistant/TestCustomEmailForm";
@@ -114,11 +109,7 @@ export function ProcessRulesContent({ testMode }: { testMode: boolean }) {
 
   // only show test rules form if we have an AI rule. this form won't match group/static rules which will confuse users
   const hasAiRules = rules?.some(
-    (rule) =>
-      isAIRule(rule) &&
-      !isGroupRule(rule) &&
-      !isStaticRule(rule) &&
-      !isCategoryRule(rule),
+    (rule) => isAIRule(rule) && !isGroupRule(rule) && !isStaticRule(rule),
   );
 
   const isRunningAllRef = useRef(false);
diff --git a/apps/web/app/(app)/[emailAccountId]/assistant/RuleForm.tsx b/apps/web/app/(app)/[emailAccountId]/assistant/RuleForm.tsx
index 32c0431a72..bbfa2ffd19 100644
--- a/apps/web/app/(app)/[emailAccountId]/assistant/RuleForm.tsx
+++ b/apps/web/app/(app)/[emailAccountId]/assistant/RuleForm.tsx
@@ -2,7 +2,6 @@
 
 import { useCallback, useEffect, useMemo, useState } from "react";
 import { useRouter } from "next/navigation";
-import Link from "next/link";
 import {
   type FieldError,
   type FieldErrors,
@@ -12,10 +11,8 @@ import {
 } from "react-hook-form";
 import { zodResolver } from "@hookform/resolvers/zod";
 import TextareaAutosize from "react-textarea-autosize";
-import { capitalCase } from "capital-case";
 import { usePostHog } from "posthog-js/react";
 import {
-  ExternalLinkIcon,
   PlusIcon,
   FilterIcon,
   ChevronDownIcon,
@@ -27,13 +24,8 @@ import { CardBasic } from "@/components/ui/card";
 import { Button } from "@/components/ui/button";
 import { ErrorMessage, Input, Label } from "@/components/Input";
 import { toastError, toastSuccess } from "@/components/Toast";
-import { SectionDescription, TypographyH3 } from "@/components/Typography";
-import {
-  ActionType,
-  CategoryFilterType,
-  LogicalOperator,
-  SystemType,
-} from "@prisma/client";
+import { TypographyH3 } from "@/components/Typography";
+import { ActionType, LogicalOperator, SystemType } from "@prisma/client";
 import { ConditionType, type CoreConditionType } from "@/utils/config";
 import {
   createRuleAction,
@@ -49,12 +41,9 @@ import { Toggle } from "@/components/Toggle";
 import { LoadingContent } from "@/components/LoadingContent";
 import { TooltipExplanation } from "@/components/TooltipExplanation";
 import { useLabels } from "@/hooks/useLabels";
-import { MultiSelectFilter } from "@/components/MultiSelectFilter";
-import { useCategories } from "@/hooks/useCategories";
 import { hasVariables, TEMPLATE_VARIABLE_PATTERN } from "@/utils/template";
 import { getEmptyCondition } from "@/utils/condition";
 import { AlertError } from "@/components/Alert";
-import { RadioGroup, RadioGroupItem } from "@/components/ui/radio-group";
 import {
   DropdownMenu,
   DropdownMenuContent,
@@ -76,7 +65,6 @@ import {
   DialogTrigger,
 } from "@/components/ui/dialog";
 import { ActionSummaryCard } from "@/app/(app)/[emailAccountId]/assistant/ActionSummaryCard";
-import { ConditionSummaryCard } from "@/app/(app)/[emailAccountId]/assistant/ConditionSummaryCard";
 import {
   Select,
   SelectContent,
@@ -85,7 +73,6 @@ import {
   SelectTrigger,
 } from "@/components/ui/select";
 import { Form, FormControl, FormField, FormItem } from "@/components/ui/form";
-import { isDefined } from "@/utils/types";
 import { canActionBeDelayed } from "@/utils/delayed-actions";
 import type { EmailLabel } from "@/providers/EmailProvider";
 import { FolderSelector } from "@/components/FolderSelector";
@@ -185,11 +172,6 @@ export function RuleForm({
   const { append, remove } = useFieldArray({ control, name: "actions" });
 
   const { userLabels, isLoading, mutate: mutateLabels } = useLabels();
-  const {
-    categories,
-    isLoading: categoriesLoading,
-    error: categoriesError,
-  } = useCategories();
   const { folders, isLoading: foldersLoading } = useFolders();
   const router = useRouter();
 
@@ -561,23 +543,14 @@ export function RuleForm({
                                     label: "Static",
                                     value: ConditionType.STATIC,
                                   },
-                                  // Deprecated: only show if this is the selected condition type
-                                  condition.type === ConditionType.CATEGORY
-                                    ? {
-                                        label: "Sender Category",
-                                        value: ConditionType.CATEGORY,
-                                      }
-                                    : null,
-                                ]
-                                  .filter(isDefined)
-                                  .map((option) => (
-                                    <SelectItem
-                                      key={option.value}
-                                      value={option.value}
-                                    >
-                                      {option.label}
-                                    </SelectItem>
-                                  ))}
+                                ].map((option) => (
+                                  <SelectItem
+                                    key={option.value}
+                                    value={option.value}
+                                  >
+                                    {option.label}
+                                  </SelectItem>
+                                ))}
                               </SelectContent>
                             </Select>
                           </FormItem>
@@ -672,140 +645,10 @@ export function RuleForm({
                           />
                         </>
                       )}
-
-                      {watch(`conditions.${index}.type`) ===
-                        ConditionType.CATEGORY && (
-                        <>
-                          <div className="flex items-center gap-4">
-                            <RadioGroup
-                              defaultValue={CategoryFilterType.INCLUDE}
-                              value={
-                                watch(
-                                  `conditions.${index}.categoryFilterType`,
-                                ) || undefined
-                              }
-                              onValueChange={(value) =>
-                                setValue(
-                                  `conditions.${index}.categoryFilterType`,
-                                  value as CategoryFilterType,
-                                )
-                              }
-                              className="flex gap-6"
-                            >
-                              <div className="flex items-center space-x-2">
-                                <RadioGroupItem
-                                  value={CategoryFilterType.INCLUDE}
-                                  id="include"
-                                />
-                                <Label name="include" label="Match" />
-                              </div>
-                              <div className="flex items-center space-x-2">
-                                <RadioGroupItem
-                                  value={CategoryFilterType.EXCLUDE}
-                                  id="exclude"
-                                />
-                                <Label name="exclude" label="Skip" />
-                              </div>
-                            </RadioGroup>
-
-                            <TooltipExplanation text="This stops the AI from applying this rule to emails that don't match your criteria." />
-                          </div>
-
-                          <LoadingContent
-                            loading={categoriesLoading}
-                            error={categoriesError}
-                          >
-                            {categories.length ? (
-                              <>
-                                <MultiSelectFilter
-                                  title="Categories"
-                                  maxDisplayedValues={8}
-                                  options={categories.map((category) => ({
-                                    label: capitalCase(category.name),
-                                    value: category.id,
-                                  }))}
-                                  selectedValues={
-                                    new Set(
-                                      watch(
-                                        `conditions.${index}.categoryFilters`,
-                                      ),
-                                    )
-                                  }
-                                  setSelectedValues={(selectedValues) => {
-                                    setValue(
-                                      `conditions.${index}.categoryFilters`,
-                                      Array.from(selectedValues),
-                                    );
-                                  }}
-                                />
-                                {(
-                                  errors.conditions?.[index] as {
-                                    categoryFilters?: { message?: string };
-                                  }
-                                )?.categoryFilters?.message && (
-                                  <ErrorMessage
-                                    message={
-                                      (
-                                        errors.conditions?.[index] as {
-                                          categoryFilters?: {
-                                            message?: string;
-                                          };
-                                        }
-                                      )?.categoryFilters?.message || ""
-                                    }
-                                  />
-                                )}
-
-                                <Button
-                                  asChild
-                                  variant="ghost"
-                                  size="sm"
-                                  className="ml-2"
-                                >
-                                  <Link
-                                    href={prefixPath(
-                                      emailAccountId,
-                                      "/smart-categories/setup",
-                                    )}
-                                    target="_blank"
-                                  >
-                                    Create category
-                                    <ExternalLinkIcon className="ml-1.5 size-4" />
-                                  </Link>
-                                </Button>
-                              </>
-                            ) : (
-                              <div>
-                                <SectionDescription>
-                                  No sender categories found.
-                                </SectionDescription>
-
-                                <Button asChild className="mt-1">
-                                  <Link
-                                    href={prefixPath(
-                                      emailAccountId,
-                                      "/smart-categories",
-                                    )}
-                                    target="_blank"
-                                  >
-                                    Set up Sender Categories
-                                    <ExternalLinkIcon className="ml-1.5 size-4" />
-                                  </Link>
-                                </Button>
-                              </div>
-                            )}
-                          </LoadingContent>
-                        </>
-                      )}
                     </CardLayoutRight>
                   </CardLayout>
                 </CardBasic>
-              ) : (
-                <ConditionSummaryCard
-                  condition={watch(`conditions.${index}`)}
-                  categories={categories}
-                />
-              )}
+              ) : null}
             </div>
           ))}
         </div>
diff --git a/apps/web/app/(app)/[emailAccountId]/assistant/Rules.tsx b/apps/web/app/(app)/[emailAccountId]/assistant/Rules.tsx
index b5e39ecf0f..31d1d88c31 100644
--- a/apps/web/app/(app)/[emailAccountId]/assistant/Rules.tsx
+++ b/apps/web/app/(app)/[emailAccountId]/assistant/Rules.tsx
@@ -110,7 +110,6 @@ export function Rules({
         runOnThreads: false,
         automate: true,
         actions: getDefaultActions(systemType, provider),
-        categoryFilters: [],
         group: null,
         emailAccountId: emailAccountId,
         createdAt: new Date(),
diff --git a/apps/web/app/(app)/[emailAccountId]/assistant/constants.ts b/apps/web/app/(app)/[emailAccountId]/assistant/constants.ts
index 8b7936c573..703c494690 100644
--- a/apps/web/app/(app)/[emailAccountId]/assistant/constants.ts
+++ b/apps/web/app/(app)/[emailAccountId]/assistant/constants.ts
@@ -8,7 +8,6 @@ import {
   MailOpenIcon,
   ShieldCheckIcon,
   WebhookIcon,
-  EyeIcon,
   FileTextIcon,
   FolderInputIcon,
 } from "lucide-react";
diff --git a/apps/web/app/(app)/[emailAccountId]/bulk-unsubscribe/BulkUnsubscribeSection.tsx b/apps/web/app/(app)/[emailAccountId]/bulk-unsubscribe/BulkUnsubscribeSection.tsx
index e5f4dd6e95..d98745fb50 100644
--- a/apps/web/app/(app)/[emailAccountId]/bulk-unsubscribe/BulkUnsubscribeSection.tsx
+++ b/apps/web/app/(app)/[emailAccountId]/bulk-unsubscribe/BulkUnsubscribeSection.tsx
@@ -35,7 +35,6 @@ import {
   BulkUnsubscribeRowDesktop,
 } from "@/app/(app)/[emailAccountId]/bulk-unsubscribe/BulkUnsubscribeDesktop";
 import { Card } from "@/components/ui/card";
-import { ShortcutTooltip } from "@/app/(app)/[emailAccountId]/bulk-unsubscribe/ShortcutTooltip";
 import { SearchBar } from "@/app/(app)/[emailAccountId]/bulk-unsubscribe/SearchBar";
 import { useToggleSelect } from "@/hooks/useToggleSelect";
 import { BulkActions } from "@/app/(app)/[emailAccountId]/bulk-unsubscribe/BulkActions";
diff --git a/apps/web/app/(app)/[emailAccountId]/debug/rule-history/[ruleId]/page.tsx b/apps/web/app/(app)/[emailAccountId]/debug/rule-history/[ruleId]/page.tsx
index 3757fb9394..e0505937ba 100644
--- a/apps/web/app/(app)/[emailAccountId]/debug/rule-history/[ruleId]/page.tsx
+++ b/apps/web/app/(app)/[emailAccountId]/debug/rule-history/[ruleId]/page.tsx
@@ -160,21 +160,6 @@ export default async function RuleHistoryPage(props: {
                     </div>
                   )}
 
-                  {history.categoryFilterType && (
-                    <div>
-                      <h4 className="mb-1 font-semibold">Category Filters</h4>
-                      <p className="text-sm">
-                        Type: {history.categoryFilterType}
-                        {history.categoryFilters && (
-                          <span className="ml-2">
-                            ({(history.categoryFilters as any[]).length}{" "}
-                            categories)
-                          </span>
-                        )}
-                      </p>
-                    </div>
-                  )}
-
                   {history.systemType && (
                     <div>
                       <h4 className="mb-1 font-semibold">System Type</h4>
diff --git a/apps/web/app/api/google/webhook/types.ts b/apps/web/app/api/google/webhook/types.ts
index 6fd1903d71..4ff63b9f61 100644
--- a/apps/web/app/api/google/webhook/types.ts
+++ b/apps/web/app/api/google/webhook/types.ts
@@ -1,5 +1,5 @@
 import type { gmail_v1 } from "@googleapis/gmail";
-import type { RuleWithActionsAndCategories } from "@/utils/types";
+import type { RuleWithActions } from "@/utils/types";
 import type { EmailAccountWithAI } from "@/utils/llms/types";
 import type { EmailAccount } from "@prisma/client";
 
@@ -16,7 +16,7 @@ export type ProcessHistoryOptions = {
   history: gmail_v1.Schema$History[];
   gmail: gmail_v1.Gmail;
   accessToken: string;
-  rules: RuleWithActionsAndCategories[];
+  rules: RuleWithActions[];
   hasAutomationRules: boolean;
   hasAiAccess: boolean;
   emailAccount: Pick<EmailAccount, "autoCategorizeSenders"> &
diff --git a/apps/web/app/api/outlook/webhook/process-history-item.ts b/apps/web/app/api/outlook/webhook/process-history-item.ts
index bedb5fc0da..d851d56844 100644
--- a/apps/web/app/api/outlook/webhook/process-history-item.ts
+++ b/apps/web/app/api/outlook/webhook/process-history-item.ts
@@ -1,14 +1,14 @@
 import type { OutlookResourceData } from "@/app/api/outlook/webhook/types";
 import { logger as globalLogger } from "@/app/api/outlook/webhook/logger";
 import { processHistoryItem as processHistoryItemShared } from "@/utils/webhook/process-history-item";
-import type { RuleWithActionsAndCategories } from "@/utils/types";
+import type { RuleWithActions } from "@/utils/types";
 import type { EmailAccountWithAI } from "@/utils/llms/types";
 import type { EmailAccount } from "@prisma/client";
 import type { EmailProvider } from "@/utils/email/types";
 
 type ProcessHistoryOptions = {
   provider: EmailProvider;
-  rules: RuleWithActionsAndCategories[];
+  rules: RuleWithActions[];
   hasAutomationRules: boolean;
   hasAiAccess: boolean;
   emailAccount: Pick<EmailAccount, "autoCategorizeSenders"> &
diff --git a/apps/web/app/api/user/planned/get-executed-rules.ts b/apps/web/app/api/user/planned/get-executed-rules.ts
index e4d5bbd75c..4aacb34f31 100644
--- a/apps/web/app/api/user/planned/get-executed-rules.ts
+++ b/apps/web/app/api/user/planned/get-executed-rules.ts
@@ -42,7 +42,6 @@ export async function getExecutedRules({
         rule: {
           include: {
             group: { select: { name: true } },
-            categoryFilters: true,
           },
         },
         actionItems: true,
diff --git a/apps/web/app/api/user/rules/[id]/example/controller.ts b/apps/web/app/api/user/rules/[id]/example/controller.ts
index d387fadb7c..5cb529d9f3 100644
--- a/apps/web/app/api/user/rules/[id]/example/controller.ts
+++ b/apps/web/app/api/user/rules/[id]/example/controller.ts
@@ -7,12 +7,7 @@ import {
   splitEmailPatterns,
 } from "@/utils/ai/choose-rule/match-rules";
 import { fetchPaginatedMessages } from "@/app/api/user/group/[groupId]/messages/controller";
-import {
-  isGroupRule,
-  isAIRule,
-  isStaticRule,
-  isCategoryRule,
-} from "@/utils/condition";
+import { isGroupRule, isAIRule, isStaticRule } from "@/utils/condition";
 import { LogicalOperator } from "@prisma/client";
 import type { EmailProvider } from "@/utils/email/types";
 
@@ -23,13 +18,12 @@ export async function fetchExampleMessages(
   const isStatic = isStaticRule(rule);
   const isGroup = isGroupRule(rule);
   const isAI = isAIRule(rule);
-  const isCategory = isCategoryRule(rule);
 
-  if (isAI || isCategory) return [];
+  if (isAI) return [];
 
   // if AND and more than 1 condition, return []
   // TODO: handle multiple conditions properly and return real examples
-  const conditions = [isStatic, isGroup, isAI, isCategory];
+  const conditions = [isStatic, isGroup, isAI];
   const trueConditionsCount = conditions.filter(Boolean).length;
 
   if (
diff --git a/apps/web/app/api/user/rules/[id]/route.ts b/apps/web/app/api/user/rules/[id]/route.ts
index 3952dcd2b9..4b336ba1a6 100644
--- a/apps/web/app/api/user/rules/[id]/route.ts
+++ b/apps/web/app/api/user/rules/[id]/route.ts
@@ -18,7 +18,6 @@ async function getRule({
     where: { id: ruleId, emailAccount: { id: emailAccountId } },
     include: {
       actions: true,
-      categoryFilters: true,
     },
   });
 
@@ -42,7 +41,6 @@ async function getRule({
       folderName: { value: action.folderName },
       folderId: { value: action.folderId },
     })),
-    categoryFilters: rule.categoryFilters.map((category) => category.id),
     conditions: getConditions(rule),
   };
 
diff --git a/apps/web/app/api/user/rules/route.ts b/apps/web/app/api/user/rules/route.ts
index 7d2bae0e9a..49c18fb37c 100644
--- a/apps/web/app/api/user/rules/route.ts
+++ b/apps/web/app/api/user/rules/route.ts
@@ -10,7 +10,6 @@ async function getRules({ emailAccountId }: { emailAccountId: string }) {
     include: {
       actions: true,
       group: { select: { name: true } },
-      categoryFilters: { select: { id: true, name: true } },
     },
     orderBy: { createdAt: "asc" },
   });
diff --git a/apps/web/components/GroupedTable.tsx b/apps/web/components/GroupedTable.tsx
index 169ffd8811..2d0274eca3 100644
--- a/apps/web/components/GroupedTable.tsx
+++ b/apps/web/components/GroupedTable.tsx
@@ -16,12 +16,9 @@ import {
   ChevronRight,
   MoreVerticalIcon,
   PencilIcon,
-  FileCogIcon,
-  PlusIcon,
   BookmarkXIcon,
 } from "lucide-react";
 import { Table, TableBody, TableCell, TableRow } from "@/components/ui/table";
-import { ConditionType } from "@/utils/config";
 import { EmailCell } from "@/components/EmailCell";
 import { useThreads } from "@/hooks/useThreads";
 import { Skeleton } from "@/components/ui/skeleton";
@@ -58,7 +55,6 @@ import type { CategoryWithRules } from "@/utils/category.server";
 import { ViewEmailButton } from "@/components/ViewEmailButton";
 import { CategorySelect } from "@/components/CategorySelect";
 import { useAccount } from "@/providers/EmailAccountProvider";
-import { prefixPath } from "@/utils/path";
 
 const COLUMNS = 4;
 
@@ -247,7 +243,6 @@ export function GroupedTable({
             return (
               <Fragment key={categoryName}>
                 <GroupRow
-                  emailAccountId={emailAccountId}
                   category={category}
                   count={senders.length}
                   isExpanded={!!isCategoryExpanded}
@@ -371,7 +366,6 @@ export function SendersTable({
 }
 
 function GroupRow({
-  emailAccountId,
   category,
   count,
   isExpanded,
@@ -380,7 +374,6 @@ function GroupRow({
   onEditCategory,
   onRemoveAllFromCategory,
 }: {
-  emailAccountId: string;
   category: CategoryWithRules;
   count: number;
   isExpanded: boolean;
@@ -427,37 +420,6 @@ function GroupRow({
           </DropdownMenuContent>
         </DropdownMenu>
 
-        {category.rules.length ? (
-          <div className="flex items-center gap-1">
-            {category.rules.map((rule) => (
-              <Button variant="outline" size="xs" asChild key={rule.id}>
-                <Link
-                  href={prefixPath(
-                    emailAccountId,
-                    `/assistant/rule/${rule.id}`,
-                  )}
-                  target="_blank"
-                >
-                  <FileCogIcon className="mr-1 size-4" />
-                  <span>{rule.name || `Rule ${rule.id}`}</span>
-                </Link>
-              </Button>
-            ))}
-          </div>
-        ) : (
-          <Button variant="outline" size="xs" asChild>
-            <Link
-              href={prefixPath(
-                emailAccountId,
-                `/assistant/rule/create?type=${ConditionType.CATEGORY}&categoryId=${category.id}&label=${category.name}`,
-              )}
-              target="_blank"
-            >
-              <PlusIcon className="mr-2 size-4" />
-              Attach rule
-            </Link>
-          </Button>
-        )}
         <Button variant="outline" size="xs" onClick={onArchiveAll}>
           <ArchiveIcon className="mr-2 size-4" />
           Archive all
diff --git a/apps/web/prisma/schema.prisma b/apps/web/prisma/schema.prisma
index 5c61117420..99a5564c72 100644
--- a/apps/web/prisma/schema.prisma
+++ b/apps/web/prisma/schema.prisma
@@ -119,9 +119,9 @@ model EmailAccount {
   personaAnalysis           Json? // ai analysis of the user's persona
   role                      String? // the role confirmed by the user - previously `User.surveyRole`
 
-  statsEmailFrequency        Frequency         @default(WEEKLY)
-  summaryEmailFrequency      Frequency         @default(WEEKLY)
-  lastSummaryEmailAt         DateTime?
+  statsEmailFrequency   Frequency         @default(WEEKLY)
+  summaryEmailFrequency Frequency         @default(WEEKLY)
+  lastSummaryEmailAt    DateTime?
   coldEmailBlocker      ColdEmailSetting? // @deprecated
   coldEmailDigest       Boolean           @default(false) // @deprecated
   coldEmailPrompt       String? // @deprecated
@@ -401,8 +401,8 @@ model Rule {
 
   // category condition
   // only apply to (or do not apply to) senders in these categories
-  categoryFilterType CategoryFilterType?
-  categoryFilters    Category[]
+  categoryFilterType CategoryFilterType? // deprecated
+  categoryFilters Category[] // deprecated
 
   systemType SystemType?
 
@@ -454,11 +454,11 @@ model RuleHistory {
   to                  String?
   subject             String?
   body                String?
-  categoryFilterType  String?
+  categoryFilterType  String? // deprecated
   systemType          String?
 
   actions         Json
-  categoryFilters Json?
+  categoryFilters Json? // deprecated
 
   @@unique([ruleId, version])
   @@index([ruleId, createdAt])
diff --git a/apps/web/utils/actions/ai-rule.ts b/apps/web/utils/actions/ai-rule.ts
index 5d6a692821..8ebcb2c1a8 100644
--- a/apps/web/utils/actions/ai-rule.ts
+++ b/apps/web/utils/actions/ai-rule.ts
@@ -23,9 +23,8 @@ import { aiDiffRules } from "@/utils/ai/rule/diff-rules";
 import { aiFindExistingRules } from "@/utils/ai/rule/find-existing-rules";
 import { aiGenerateRulesPrompt } from "@/utils/ai/rule/generate-rules-prompt";
 import { aiFindSnippets } from "@/utils/ai/snippets/find-snippets";
-import type { CreateOrUpdateRuleSchemaWithCategories } from "@/utils/ai/rule/create-rule-schema";
+import type { CreateOrUpdateRuleSchema } from "@/utils/ai/rule/create-rule-schema";
 import { deleteRule, safeCreateRule, safeUpdateRule } from "@/utils/rule/rule";
-import { getUserCategoriesForNames } from "@/utils/category.server";
 import { actionClient } from "@/utils/actions/safe-action";
 import { getEmailAccountWithAi } from "@/utils/user/get";
 import { SafeError } from "@/utils/error";
@@ -88,7 +87,7 @@ export const runRulesAction = actionClient
           emailAccountId,
           enabled: true,
         },
-        include: { actions: true, categoryFilters: true },
+        include: { actions: true },
       });
 
       const result = await runRules({
@@ -124,7 +123,7 @@ export const testAiCustomContentAction = actionClient
           enabled: true,
           instructions: { not: null },
         },
-        include: { actions: true, categoryFilters: true },
+        include: { actions: true },
       });
 
       const result = await runRules({
@@ -164,7 +163,7 @@ export const createAutomationAction = actionClient
 
     if (!emailAccount) throw new Error("Email account not found");
 
-    let result: CreateOrUpdateRuleSchemaWithCategories;
+    let result: CreateOrUpdateRuleSchema;
 
     try {
       result = await aiCreateRule(prompt, emailAccount);
@@ -297,7 +296,6 @@ export const saveRulesPromptAction = actionClient
             emailAccount,
             promptFile: diff.addedRules.join("\n\n"),
             isEditing: false,
-            availableCategories: emailAccount.categories.map((c) => c.name),
           });
           logger.info("Added rules", {
             addedRules: addedRules?.length || 0,
@@ -376,7 +374,6 @@ export const saveRulesPromptAction = actionClient
               )
               .join("\n\n"),
             isEditing: true,
-            availableCategories: emailAccount.categories.map((c) => c.name),
           });
 
           for (const rule of editedRules) {
@@ -392,18 +389,12 @@ export const saveRulesPromptAction = actionClient
               ruleId: rule.ruleId,
             });
 
-            const categoryIds = await getUserCategoriesForNames({
-              emailAccountId,
-              names: rule.condition.categories?.categoryFilters || [],
-            });
-
             editRulesCount++;
 
             await safeUpdateRule({
               ruleId: rule.ruleId,
               result: rule,
               emailAccountId,
-              categoryIds,
               provider: emailAccount.account.provider,
             });
           }
@@ -414,7 +405,6 @@ export const saveRulesPromptAction = actionClient
           emailAccount,
           promptFile: rulesPrompt,
           isEditing: false,
-          availableCategories: emailAccount.categories.map((c) => c.name),
         });
         logger.info("Rules to be added", { count: addedRules?.length || 0 });
       }
@@ -426,7 +416,6 @@ export const saveRulesPromptAction = actionClient
         await safeCreateRule({
           result: rule,
           emailAccountId,
-          categoryNames: rule.condition.categories?.categoryFilters || [],
           shouldCreateIfDuplicate: false,
           provider: emailAccount.account.provider,
           runOnThreads: true,
@@ -490,7 +479,6 @@ export const createRulesAction = actionClient
       const addedRules = await aiPromptToRules({
         emailAccount,
         promptFile: prompt,
-        availableCategories: emailAccount.categories.map((c) => c.name),
       });
 
       logger.info("Rules to be added", { count: addedRules?.length || 0 });
@@ -503,7 +491,6 @@ export const createRulesAction = actionClient
         const createdRule = await safeCreateRule({
           result: rule,
           emailAccountId,
-          categoryNames: rule.condition.categories?.categoryFilters || [],
           shouldCreateIfDuplicate: false,
           provider: emailAccount.account.provider,
           runOnThreads: true,
diff --git a/apps/web/utils/actions/rule.ts b/apps/web/utils/actions/rule.ts
index b34fcfd35b..9377be64e7 100644
--- a/apps/web/utils/actions/rule.ts
+++ b/apps/web/utils/actions/rule.ts
@@ -83,15 +83,8 @@ export const createRuleAction = actionClient
             to: conditions.to || null,
             subject: conditions.subject || null,
             // body: conditions.body || null,
-            categoryFilterType: conditions.categoryFilterType || null,
-            categoryFilters:
-              conditions.categoryFilterType && conditions.categoryFilters
-                ? {
-                    connect: conditions.categoryFilters.map((id) => ({ id })),
-                  }
-                : {},
           },
-          include: { actions: true, categoryFilters: true, group: true },
+          include: { actions: true, group: true },
         });
 
         // Track rule creation in history
@@ -133,7 +126,7 @@ export const updateRuleAction = actionClient
       try {
         const currentRule = await prisma.rule.findUnique({
           where: { id, emailAccountId },
-          include: { actions: true, categoryFilters: true, group: true },
+          include: { actions: true, group: true },
         });
         if (!currentRule) throw new SafeError("Rule not found");
 
@@ -161,15 +154,8 @@ export const updateRuleAction = actionClient
               to: conditions.to || null,
               subject: conditions.subject || null,
               // body: conditions.body || null,
-              categoryFilterType: conditions.categoryFilterType || null,
-              categoryFilters:
-                conditions.categoryFilterType && conditions.categoryFilters
-                  ? {
-                      set: conditions.categoryFilters.map((id) => ({ id })),
-                    }
-                  : { set: [] },
             },
-            include: { actions: true, categoryFilters: true, group: true },
+            include: { actions: true, group: true },
           }),
           // delete removed actions
           ...(actionsToDelete.length
@@ -298,7 +284,7 @@ export const deleteRuleAction = actionClient
   .action(async ({ ctx: { emailAccountId }, parsedInput: { id } }) => {
     const rule = await prisma.rule.findUnique({
       where: { id, emailAccountId },
-      include: { actions: true, categoryFilters: true, group: true },
+      include: { actions: true, group: true },
     });
     if (!rule) return; // already deleted
     if (rule.emailAccountId !== emailAccountId)
diff --git a/apps/web/utils/actions/rule.validation.ts b/apps/web/utils/actions/rule.validation.ts
index 660d2473d1..5bc126d62d 100644
--- a/apps/web/utils/actions/rule.validation.ts
+++ b/apps/web/utils/actions/rule.validation.ts
@@ -1,10 +1,5 @@
 import { z } from "zod";
-import {
-  ActionType,
-  CategoryFilterType,
-  LogicalOperator,
-  SystemType,
-} from "@prisma/client";
+import { ActionType, LogicalOperator, SystemType } from "@prisma/client";
 import { ConditionType } from "@/utils/config";
 import { NINETY_DAYS_MINUTES } from "@/utils/date";
 
@@ -28,11 +23,7 @@ const zodActionType = z.enum([
   ActionType.MOVE_FOLDER,
 ]);
 
-const zodConditionType = z.enum([
-  ConditionType.AI,
-  ConditionType.STATIC,
-  ConditionType.CATEGORY,
-]);
+const zodConditionType = z.enum([ConditionType.AI, ConditionType.STATIC]);
 
 const zodSystemRule = z.enum([
   SystemType.TO_REPLY,
@@ -58,18 +49,10 @@ const zodStaticCondition = z.object({
   body: z.string().nullish(),
 });
 
-const zodCategoryCondition = z.object({
-  categoryFilterType: z
-    .enum([CategoryFilterType.INCLUDE, CategoryFilterType.EXCLUDE])
-    .nullish(),
-  categoryFilters: z.array(z.string()).nullish(),
-});
-
 const zodCondition = z.object({
   type: zodConditionType,
   ...zodAiCondition.shape,
   ...zodStaticCondition.shape,
-  ...zodCategoryCondition.shape,
 });
 export type ZodCondition = z.infer<typeof zodCondition>;
 
diff --git a/apps/web/utils/ai/assistant/process-user-request.ts b/apps/web/utils/ai/assistant/process-user-request.ts
index 5e5fd81414..7b2907b17c 100644
--- a/apps/web/utils/ai/assistant/process-user-request.ts
+++ b/apps/web/utils/ai/assistant/process-user-request.ts
@@ -1,7 +1,7 @@
 import { stepCountIs, tool } from "ai";
 import { z } from "zod";
 import { createGenerateText } from "@/utils/llms";
-import { createScopedLogger, type Logger } from "@/utils/logger";
+import { createScopedLogger } from "@/utils/logger";
 import {
   type Category,
   GroupItemType,
@@ -10,26 +10,14 @@ import {
 } from "@prisma/client";
 import type { EmailAccountWithAI } from "@/utils/llms/types";
 import type { RuleWithRelations } from "@/utils/rule/types";
-import { isDefined, type ParsedMessage } from "@/utils/types";
-import {
-  createRuleSchema,
-  type CreateRuleSchemaWithCategories,
-  getCreateRuleSchemaWithCategories,
-} from "@/utils/ai/rule/create-rule-schema";
+import type { ParsedMessage } from "@/utils/types";
+import { createRuleSchema } from "@/utils/ai/rule/create-rule-schema";
 import { deleteGroupItem } from "@/utils/group/group-item";
-import {
-  addRuleCategories,
-  createRule,
-  partialUpdateRule,
-  removeRuleCategories,
-} from "@/utils/rule/rule";
-import { updateCategoryForSender } from "@/utils/categorize/senders/categorize";
-import { findSenderByEmail } from "@/utils/sender";
+import { createRule, partialUpdateRule } from "@/utils/rule/rule";
 import { getEmailForLLM } from "@/utils/get-email-from-message";
 import { stringifyEmailSimple } from "@/utils/stringify-email";
 import { env } from "@/env";
 import { posthogCaptureEvent } from "@/utils/posthog";
-import { getUserCategoriesForNames } from "@/utils/category.server";
 import { getModel } from "@/utils/llms/model";
 import { getUserInfoPrompt } from "@/utils/ai/helpers";
 
@@ -382,142 +370,9 @@ ${senderCategory || "No category"}
             }),
           }
         : {}),
-      ...(categories
-        ? {
-            update_sender_category: getUpdateCategoryTool({
-              emailAccountId: emailAccount.id,
-              userEmail: emailAccount.email,
-              categories,
-              logger,
-            }),
-            add_categories: tool({
-              description: "Add categories to a rule",
-              inputSchema: 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);
-                  trackToolCall({
-                    tool: "add_categories",
-                    email: emailAccount.email,
-                  });
-
-                  const { ruleName } = options;
-
-                  const rule = rules.find((r) => r.name === ruleName);
-
-                  if (!rule) {
-                    logger.error("Rule not found", {
-                      ...options,
-                      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) {
-                  const message =
-                    error instanceof Error ? error.message : String(error);
-
-                  logger.error("Error while adding categories to rule", {
-                    ...options,
-                    error: message,
-                  });
-
-                  return {
-                    error: "Failed to add categories to rule",
-                    message,
-                  };
-                }
-              },
-            }),
-            remove_categories: tool({
-              description: "Remove categories from a rule",
-              inputSchema: 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);
-                  trackToolCall({
-                    tool: "remove_categories",
-                    email: emailAccount.email,
-                  });
-
-                  const { ruleName } = options;
-
-                  const rule = rules.find((r) => r.name === ruleName);
-
-                  if (!rule) {
-                    logger.error("Rule not found", {
-                      ...options,
-                      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) {
-                  const message =
-                    error instanceof Error ? error.message : String(error);
-
-                  logger.error("Error while removing categories from rule", {
-                    ...options,
-                    error: message,
-                  });
-
-                  return {
-                    error: "Failed to remove categories from rule",
-                    message,
-                  };
-                }
-              },
-            }),
-          }
-        : {}),
       create_rule: tool({
         description: "Create a new rule",
-        inputSchema: categories
-          ? getCreateRuleSchemaWithCategories(
-              categories.map((c) => c.name) as [string, ...string[]],
-              emailAccount.account.provider,
-            )
-          : createRuleSchema(emailAccount.account.provider),
+        inputSchema: createRuleSchema(emailAccount.account.provider),
         execute: async ({ name, condition, actions }) => {
           logger.info("Create Rule", { name, condition, actions });
           trackToolCall({
@@ -525,15 +380,7 @@ ${senderCategory || "No category"}
             email: emailAccount.email,
           });
 
-          const conditions =
-            condition as CreateRuleSchemaWithCategories["condition"];
-
           try {
-            const categoryIds = await getUserCategoriesForNames({
-              emailAccountId: emailAccount.id,
-              names: conditions.categories?.categoryFilters || [],
-            });
-
             const rule = await createRule({
               result: {
                 name,
@@ -556,7 +403,6 @@ ${senderCategory || "No category"}
                 })),
               },
               emailAccountId: emailAccount.id,
-              categoryIds,
               provider: emailAccount.account.provider,
               runOnThreads: true,
             });
@@ -618,70 +464,6 @@ ${senderCategory || "No category"}
   return result;
 }
 
-const getUpdateCategoryTool = ({
-  emailAccountId,
-  categories,
-  userEmail,
-  logger,
-}: {
-  emailAccountId: string;
-  categories: Pick<Category, "id" | "name">[];
-  userEmail: string;
-  logger: Logger;
-}) =>
-  tool({
-    description: "Update the category of a sender",
-    inputSchema: 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 });
-      trackToolCall({
-        tool: "update_sender_category",
-        email: userEmail,
-      });
-
-      const existingSender = await findSenderByEmail({
-        emailAccountId,
-        email: sender,
-      });
-
-      const cat = categories.find((c) => c.name === category);
-
-      if (!cat) {
-        logger.error("Category not found", { category });
-        return { error: "Category not found" };
-      }
-
-      try {
-        await updateCategoryForSender({
-          emailAccountId,
-          sender: existingSender?.email || sender,
-          categoryId: cat.id,
-        });
-        return { success: true };
-      } catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-
-        logger.error("Error while updating category for sender", {
-          sender,
-          category,
-          error: message,
-        });
-        return {
-          error: "Failed to update category for sender",
-          message,
-        };
-      }
-    },
-  });
-
 function ruleToXML(rule: RuleWithRelations) {
   return `<rule>
   <rule_name>${rule.name}</rule_name>
@@ -698,14 +480,6 @@ function ruleToXML(rule: RuleWithRelations) {
     </static_conditions>`
         : ""
     }
-    ${
-      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>
 
   ${
@@ -736,10 +510,6 @@ function hasStaticConditions(rule: RuleWithRelations) {
   return Boolean(rule.from || rule.to || rule.subject || rule.body);
 }
 
-function hasCategoryConditions(rule: RuleWithRelations) {
-  return Boolean(rule.categoryFilters && rule.categoryFilters.length > 0);
-}
-
 function getPatternType(type: string) {
   if (type === "from") return GroupItemType.FROM;
   if (type === "subject") return GroupItemType.SUBJECT;
diff --git a/apps/web/utils/ai/choose-rule/run-rules.ts b/apps/web/utils/ai/choose-rule/run-rules.ts
index ab21f34867..94ad64d4a1 100644
--- a/apps/web/utils/ai/choose-rule/run-rules.ts
+++ b/apps/web/utils/ai/choose-rule/run-rules.ts
@@ -1,8 +1,5 @@
 import { after } from "next/server";
-import type {
-  ParsedMessage,
-  RuleWithActionsAndCategories,
-} from "@/utils/types";
+import type { ParsedMessage, RuleWithActions } from "@/utils/types";
 import type { EmailAccountWithAI } from "@/utils/llms/types";
 import { ExecutedRuleStatus, SystemType, type Rule } from "@prisma/client";
 import type { ActionItem } from "@/utils/ai/types";
@@ -30,6 +27,7 @@ import {
 } from "@/utils/reply-tracker/handle-conversation-status";
 import { saveColdEmail } from "@/utils/cold-email/is-cold-email";
 import { internalDateToDate } from "@/utils/date";
+import { ConditionType } from "@/utils/config";
 
 const logger = createScopedLogger("ai-run-rules");
 
@@ -53,7 +51,7 @@ export async function runRules({
 }: {
   provider: EmailProvider;
   message: ParsedMessage;
-  rules: RuleWithActionsAndCategories[];
+  rules: RuleWithActions[];
   emailAccount: EmailAccountWithAI;
   isTest: boolean;
   modelType: ModelType;
@@ -143,9 +141,9 @@ export async function runRules({
   return executedRules;
 }
 
-function prepareRulesWithMetaRule(rules: RuleWithActionsAndCategories[]): {
-  regularRules: RuleWithActionsAndCategories[];
-  conversationRules: RuleWithActionsAndCategories[];
+function prepareRulesWithMetaRule(rules: RuleWithActions[]): {
+  regularRules: RuleWithActions[];
+  conversationRules: RuleWithActions[];
 } {
   // Separate conversation status rules from regular rules
   const conversationRules = rules.filter((r) =>
@@ -168,7 +166,6 @@ function prepareRulesWithMetaRule(rules: RuleWithActionsAndCategories[]): {
       runOnThreads: true,
       systemType: null,
       actions: [],
-      categoryFilters: [],
     };
 
     regularRules.push(metaRule);
@@ -178,7 +175,7 @@ function prepareRulesWithMetaRule(rules: RuleWithActionsAndCategories[]): {
 }
 
 async function executeMatchedRule(
-  rule: RuleWithActionsAndCategories,
+  rule: RuleWithActions,
   message: ParsedMessage,
   emailAccount: EmailAccountWithAI,
   client: EmailProvider,
@@ -348,9 +345,8 @@ function shouldAnalyzeSenderPattern({
   if (
     result.matchReasons?.some(
       (reason) =>
-        reason.type === "STATIC" ||
-        reason.type === "GROUP" ||
-        reason.type === "CATEGORY",
+        reason.type === ConditionType.STATIC ||
+        reason.type === ConditionType.LEARNED_PATTERN,
     )
   ) {
     return false;
diff --git a/apps/web/utils/ai/choose-rule/types.ts b/apps/web/utils/ai/choose-rule/types.ts
index 571d2796e2..952de1e909 100644
--- a/apps/web/utils/ai/choose-rule/types.ts
+++ b/apps/web/utils/ai/choose-rule/types.ts
@@ -1,22 +1,17 @@
-import type { Category, Group, GroupItem, SystemType } from "@prisma/client";
+import type { Group, GroupItem, SystemType } from "@prisma/client";
 import type { ConditionType } from "@/utils/config";
-import type { RuleWithActionsAndCategories } from "@/utils/types";
+import type { RuleWithActions } from "@/utils/types";
 
 export type StaticMatch = {
   type: Extract<ConditionType, "STATIC">;
 };
 
-export type GroupMatch = {
-  type: Extract<ConditionType, "GROUP">;
+export type LearnedPatternMatch = {
+  type: Extract<ConditionType, "LEARNED_PATTERN">;
   group: Pick<Group, "id" | "name">;
   groupItem: Pick<GroupItem, "id" | "type" | "value" | "exclude">;
 };
 
-export type CategoryMatch = {
-  type: Extract<ConditionType, "CATEGORY">;
-  category: Pick<Category, "id" | "name">;
-};
-
 export type AiMatch = {
   type: Extract<ConditionType, "AI">;
 };
@@ -28,15 +23,23 @@ export type PresetMatch = {
 
 export type MatchReason =
   | StaticMatch
-  | GroupMatch
-  | CategoryMatch
+  | LearnedPatternMatch
   | AiMatch
   | PresetMatch;
 
 export type MatchingRuleResult = {
-  match?: RuleWithActionsAndCategories;
-  matchReasons?: MatchReason[];
-  potentialMatches?: (RuleWithActionsAndCategories & {
+  // If there's an exact match that should bypass any further processing
+  // match: RuleWithActionsAndCategories | null;
+  // matchReasons: MatchReason[];
+
+  // Potential AI match rules
+  potentialAiMatches: (RuleWithActions & {
     instructions: string;
   })[];
+  // Now that we support matching multiple rules, it's possible to match a static rule and an ai rule
+  // So we need to return the static matches we've already found
+  matches: {
+    rule: RuleWithActions;
+    matchReasons: MatchReason[];
+  }[];
 };
diff --git a/apps/web/utils/ai/rule/create-rule-schema.ts b/apps/web/utils/ai/rule/create-rule-schema.ts
index 1d1b1f2490..ab3bba5889 100644
--- a/apps/web/utils/ai/rule/create-rule-schema.ts
+++ b/apps/web/utils/ai/rule/create-rule-schema.ts
@@ -1,9 +1,5 @@
 import { z } from "zod";
-import {
-  ActionType,
-  CategoryFilterType,
-  LogicalOperator,
-} from "@prisma/client";
+import { ActionType, LogicalOperator } from "@prisma/client";
 import { delayInMinutesSchema } from "@/utils/actions/rule.validation";
 import { isMicrosoftProvider } from "@/utils/email/provider-types";
 import { isDefined } from "@/utils/types";
@@ -122,45 +118,7 @@ export const createRuleSchema = (provider: string) =>
     actions: z.array(actionSchema(provider)).describe("The actions to take"),
   });
 
-export const getCreateRuleSchemaWithCategories = (
-  availableCategories: [string, ...string[]],
-  provider: string,
-) => {
-  return createRuleSchema(provider).extend({
-    condition: conditionSchema.extend({
-      categories: z
-        .object({
-          categoryFilterType: z
-            .enum([CategoryFilterType.INCLUDE, CategoryFilterType.EXCLUDE])
-            .nullish()
-            .describe(
-              "Whether senders in `categoryFilters` should be included or excluded",
-            ),
-          categoryFilters: z
-            .array(z.string())
-            .nullish()
-            .describe(
-              `The categories to match. If multiple categories are specified, the rule will match if ANY of the categories match (OR operation). Available categories: ${availableCategories
-                .map((c) => `"${c}"`)
-                .join(", ")}`,
-            ),
-        })
-        .nullish()
-        .describe("The categories to match or skip"),
-    }),
-  });
-};
-
 export type CreateRuleSchema = z.infer<ReturnType<typeof createRuleSchema>>;
-export type CreateRuleSchemaWithCategories = CreateRuleSchema & {
-  condition: CreateRuleSchema["condition"] & {
-    categories?: {
-      categoryFilterType: CategoryFilterType;
-      categoryFilters: string[];
-    };
-  };
+export type CreateOrUpdateRuleSchema = CreateRuleSchema & {
+  ruleId?: string;
 };
-export type CreateOrUpdateRuleSchemaWithCategories =
-  CreateRuleSchemaWithCategories & {
-    ruleId?: string;
-  };
diff --git a/apps/web/utils/ai/rule/prompt-to-rules-old.ts b/apps/web/utils/ai/rule/prompt-to-rules-old.ts
index 5420ff95fc..80b8acf1bf 100644
--- a/apps/web/utils/ai/rule/prompt-to-rules-old.ts
+++ b/apps/web/utils/ai/rule/prompt-to-rules-old.ts
@@ -2,9 +2,8 @@ import { z } from "zod";
 import { createGenerateObject } from "@/utils/llms";
 import type { EmailAccountWithAI } from "@/utils/llms/types";
 import {
-  type CreateOrUpdateRuleSchemaWithCategories,
+  type CreateOrUpdateRuleSchema,
   createRuleSchema,
-  getCreateRuleSchemaWithCategories,
 } from "@/utils/ai/rule/create-rule-schema";
 import { createScopedLogger } from "@/utils/logger";
 import { convertMentionsToLabels } from "@/utils/mention";
@@ -21,36 +20,18 @@ export async function aiPromptToRulesOld({
   emailAccount,
   promptFile,
   isEditing,
-  availableCategories,
 }: {
   emailAccount: EmailAccountWithAI;
   promptFile: string;
   isEditing: boolean;
-  availableCategories?: string[];
-}): Promise<CreateOrUpdateRuleSchemaWithCategories[]> {
+}): Promise<CreateOrUpdateRuleSchema[]> {
   function getSchema() {
-    if (availableCategories?.length) {
-      const createRuleSchemaWithCategories = getCreateRuleSchemaWithCategories(
-        availableCategories as [string, ...string[]],
-        emailAccount.account.provider,
-      );
-      const updateRuleSchemaWithCategories =
-        createRuleSchemaWithCategories.extend({
-          ruleId: z.string().optional(),
-        });
-
-      return isEditing
-        ? updateRuleSchemaWithCategories
-        : createRuleSchemaWithCategories;
-    }
     return isEditing
       ? updateRuleSchema(emailAccount.account.provider)
       : createRuleSchema(emailAccount.account.provider);
   }
 
-  const system = getSystemPrompt({
-    hasSmartCategories: !!availableCategories?.length,
-  });
+  const system = getSystemPrompt();
 
   const cleanedPromptFile = convertMentionsToLabels(promptFile);
 
@@ -85,11 +66,7 @@ ${cleanedPromptFile}
   return rules;
 }
 
-function getSystemPrompt({
-  hasSmartCategories,
-}: {
-  hasSmartCategories: boolean;
-}) {
+function getSystemPrompt() {
   return `You are an AI assistant that converts email management rules into a structured format. Parse the given prompt file and conver them into rules.
 
 IMPORTANT: If a user provides a snippet, use that full snippet in the rule. Don't include placeholders unless it's clear one is needed.
@@ -108,16 +85,6 @@ If a rule can be handled fully with static conditions, do so, but this is rarely
         "name": "Label Newsletters",
         "condition": {
           "aiInstructions": "Apply this rule to newsletters"
-          ${
-            hasSmartCategories
-              ? `,
-            "categories": {
-              "categoryFilterType": "INCLUDE",
-              "categoryFilters": ["Newsletters"]
-            },
-            "conditionalOperator": "OR"`
-              : ""
-          }
         },
         "actions": [
           {
diff --git a/apps/web/utils/ai/rule/prompt-to-rules.ts b/apps/web/utils/ai/rule/prompt-to-rules.ts
index d438fa8711..c29d3ccdd1 100644
--- a/apps/web/utils/ai/rule/prompt-to-rules.ts
+++ b/apps/web/utils/ai/rule/prompt-to-rules.ts
@@ -2,9 +2,8 @@ import { z } from "zod";
 import { createGenerateObject } from "@/utils/llms";
 import type { EmailAccountWithAI } from "@/utils/llms/types";
 import {
+  type CreateRuleSchema,
   createRuleSchema,
-  type CreateRuleSchemaWithCategories,
-  getCreateRuleSchemaWithCategories,
 } from "@/utils/ai/rule/create-rule-schema";
 import { createScopedLogger } from "@/utils/logger";
 import { convertMentionsToLabels } from "@/utils/mention";
@@ -15,26 +14,11 @@ const logger = createScopedLogger("ai-prompt-to-rules");
 export async function aiPromptToRules({
   emailAccount,
   promptFile,
-  availableCategories,
 }: {
   emailAccount: EmailAccountWithAI;
   promptFile: string;
-  availableCategories?: string[];
-}): Promise<CreateRuleSchemaWithCategories[]> {
-  function getSchema() {
-    if (availableCategories?.length) {
-      return getCreateRuleSchemaWithCategories(
-        availableCategories as [string, ...string[]],
-        emailAccount.account.provider,
-      );
-    }
-
-    return createRuleSchema(emailAccount.account.provider);
-  }
-
-  const system = getSystemPrompt({
-    hasSmartCategories: !!availableCategories?.length,
-  });
+}): Promise<CreateRuleSchema[]> {
+  const system = getSystemPrompt();
 
   const cleanedPromptFile = convertMentionsToLabels(promptFile);
 
@@ -56,7 +40,9 @@ ${cleanedPromptFile}
     ...modelOptions,
     prompt,
     system,
-    schema: z.object({ rules: z.array(getSchema()) }),
+    schema: z.object({
+      rules: z.array(createRuleSchema(emailAccount.account.provider)),
+    }),
   });
 
   if (!aiResponse.object) {
@@ -69,11 +55,7 @@ ${cleanedPromptFile}
   return rules;
 }
 
-function getSystemPrompt({
-  hasSmartCategories,
-}: {
-  hasSmartCategories: boolean;
-}) {
+function getSystemPrompt() {
   return `You are an AI assistant that converts email management rules into a structured format. Parse the given prompt and convert it into rules.
 
 IMPORTANT: If a user provides a snippet, use that full snippet in the rule. Don't include placeholders unless it's clear one is needed.
@@ -95,16 +77,6 @@ IMPORTANT: You must return a JSON object.
           "name": "Label Newsletters",
           "condition": {
             "aiInstructions": "Apply this rule to newsletters"
-            ${
-              hasSmartCategories
-                ? `,
-              "categories": {
-                "categoryFilterType": "INCLUDE",
-                "categoryFilters": ["Newsletters"]
-              },
-              "conditionalOperator": "OR"`
-                : ""
-            }
           },
           "actions": [
             {
diff --git a/apps/web/utils/assistant/process-assistant-email.ts b/apps/web/utils/assistant/process-assistant-email.ts
index b1c5c280ce..017dda466c 100644
--- a/apps/web/utils/assistant/process-assistant-email.ts
+++ b/apps/web/utils/assistant/process-assistant-email.ts
@@ -114,7 +114,6 @@ async function processAssistantEmailInternal({
         rules: {
           include: {
             actions: true,
-            categoryFilters: true,
             group: {
               select: {
                 id: true,
@@ -145,7 +144,6 @@ async function processAssistantEmailInternal({
             rule: {
               include: {
                 actions: true,
-                categoryFilters: true,
                 group: true,
               },
             },
diff --git a/apps/web/utils/category.server.ts b/apps/web/utils/category.server.ts
index 19359bd8bd..c77e45d0cf 100644
--- a/apps/web/utils/category.server.ts
+++ b/apps/web/utils/category.server.ts
@@ -1,8 +1,5 @@
 import prisma from "@/utils/prisma";
 import type { Prisma } from "@prisma/client";
-import { createScopedLogger } from "@/utils/logger";
-
-const logger = createScopedLogger("category");
 
 export type CategoryWithRules = Prisma.CategoryGetPayload<{
   select: {
@@ -40,26 +37,3 @@ export const getUserCategoriesWithRules = async ({
   });
   return categories;
 };
-
-export const getUserCategoriesForNames = async ({
-  emailAccountId,
-  names,
-}: {
-  emailAccountId: string;
-  names: string[];
-}) => {
-  if (!names.length) return [];
-
-  const categories = await prisma.category.findMany({
-    where: { emailAccountId, 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);
-};
diff --git a/apps/web/utils/condition.ts b/apps/web/utils/condition.ts
index 85eb88125a..b226aa7546 100644
--- a/apps/web/utils/condition.ts
+++ b/apps/web/utils/condition.ts
@@ -1,9 +1,4 @@
-import {
-  CategoryFilterType,
-  LogicalOperator,
-  type Category,
-  type Rule,
-} from "@prisma/client";
+import { LogicalOperator, type Category, type Rule } from "@prisma/client";
 import { ConditionType, type CoreConditionType } from "@/utils/config";
 import type {
   CreateRuleBody,
@@ -22,11 +17,9 @@ export type RuleConditions = Partial<
     | "to"
     | "subject"
     | "body"
-    | "categoryFilterType"
     | "conditionalOperator"
   > & {
     group?: { name: string } | null;
-    categoryFilters?: Pick<Category, "id" | "name">[];
   }
 >;
 
@@ -46,10 +39,6 @@ export function isStaticRule(rule: RuleConditions) {
   return !!rule.from || !!rule.to || !!rule.subject || !!rule.body;
 }
 
-export function isCategoryRule(rule: RuleConditions) {
-  return !!(rule.categoryFilters?.length && rule.categoryFilterType);
-}
-
 export function getConditions(rule: RuleConditions) {
   const conditions: CreateRuleBody["conditions"] = [];
 
@@ -70,14 +59,6 @@ export function getConditions(rule: RuleConditions) {
     });
   }
 
-  if (isCategoryRule(rule)) {
-    conditions.push({
-      type: ConditionType.CATEGORY,
-      categoryFilterType: rule.categoryFilterType,
-      categoryFilters: rule.categoryFilters?.map((category) => category.id),
-    });
-  }
-
   return conditions;
 }
 
@@ -93,10 +74,7 @@ export function getConditionTypes(
   );
 }
 
-export function getEmptyCondition(
-  type: CoreConditionType,
-  category?: string,
-): ZodCondition {
+export function getEmptyCondition(type: CoreConditionType): ZodCondition {
   switch (type) {
     case ConditionType.AI:
       return {
@@ -111,12 +89,6 @@ export function getEmptyCondition(
         subject: null,
         body: null,
       };
-    case ConditionType.CATEGORY:
-      return {
-        type: ConditionType.CATEGORY,
-        categoryFilterType: CategoryFilterType.INCLUDE,
-        categoryFilters: category ? [category] : null,
-      };
     default:
       // biome-ignore lint/correctness/noSwitchDeclarations: intentional exhaustive check
       const exhaustiveCheck: never = type;
@@ -130,8 +102,6 @@ type FlattenedConditions = {
   to?: string | null;
   subject?: string | null;
   body?: string | null;
-  categoryFilterType?: CategoryFilterType | null;
-  categoryFilters?: string[] | null;
 };
 
 export const flattenConditions = (
@@ -148,10 +118,6 @@ export const flattenConditions = (
         acc.subject = condition.subject;
         acc.body = condition.body;
         break;
-      case ConditionType.CATEGORY:
-        acc.categoryFilterType = condition.categoryFilterType;
-        acc.categoryFilters = condition.categoryFilters;
-        break;
       default:
         logger.warn("Unknown condition type", { condition });
         // biome-ignore lint/correctness/noSwitchDeclarations: intentional exhaustive check
@@ -178,10 +144,8 @@ function conditionTypeToString(conditionType: ConditionType): string {
       return "AI";
     case ConditionType.STATIC:
       return "Static";
-    case ConditionType.GROUP:
+    case ConditionType.LEARNED_PATTERN:
       return "Group";
-    case ConditionType.CATEGORY:
-      return "Category";
     case ConditionType.PRESET:
       return "Preset";
     default:
@@ -207,36 +171,5 @@ export function conditionsToString(rule: RuleConditions) {
   // AI condition
   if (rule.instructions) conditions.push(rule.instructions);
 
-  // Category condition
-  const categoryFilters = rule.categoryFilters;
-  if (rule.categoryFilterType && categoryFilters?.length) {
-    const max = 3;
-    const categories =
-      categoryFilters
-        .slice(0, max)
-        .map((category) => category.name)
-        .join(", ") + (categoryFilters.length > max ? ", ..." : "");
-    conditions.push(
-      `${rule.categoryFilterType === CategoryFilterType.EXCLUDE ? "Exclude " : ""}${
-        categoryFilters.length === 1 ? "Category" : "Categories"
-      }: ${categories}`,
-    );
-  }
-
   return conditions.join(connector);
 }
-
-export function categoryFilterTypeToString(
-  categoryFilterType: CategoryFilterType,
-): string {
-  switch (categoryFilterType) {
-    case CategoryFilterType.INCLUDE:
-      return "Include";
-    case CategoryFilterType.EXCLUDE:
-      return "Exclude";
-    default:
-      // biome-ignore lint/correctness/noSwitchDeclarations: intentional exhaustive check
-      const exhaustiveCheck: never = categoryFilterType;
-      return exhaustiveCheck;
-  }
-}
diff --git a/apps/web/utils/config.ts b/apps/web/utils/config.ts
index 20e16a567f..3afc7a1236 100644
--- a/apps/web/utils/config.ts
+++ b/apps/web/utils/config.ts
@@ -12,13 +12,12 @@ export const KNOWLEDGE_BASIC_MAX_CHARS = 2000;
 export const ConditionType = {
   AI: "AI",
   STATIC: "STATIC",
-  GROUP: "GROUP",
-  CATEGORY: "CATEGORY",
+  LEARNED_PATTERN: "LEARNED_PATTERN",
   PRESET: "PRESET",
 } as const;
 
 export type ConditionType = (typeof ConditionType)[keyof typeof ConditionType];
-export type CoreConditionType = Exclude<ConditionType, "GROUP" | "PRESET">;
+export type CoreConditionType = Extract<ConditionType, "AI" | "STATIC">;
 
 export const WELCOME_PATH = "/welcome-redirect";
 
diff --git a/apps/web/utils/reply-tracker/handle-conversation-status.ts b/apps/web/utils/reply-tracker/handle-conversation-status.ts
index 2644a75476..36ca905e3d 100644
--- a/apps/web/utils/reply-tracker/handle-conversation-status.ts
+++ b/apps/web/utils/reply-tracker/handle-conversation-status.ts
@@ -1,9 +1,6 @@
 import type { EmailAccountWithAI } from "@/utils/llms/types";
 import type { ModelType } from "@/utils/llms/model";
-import type {
-  ParsedMessage,
-  RuleWithActionsAndCategories,
-} from "@/utils/types";
+import type { ParsedMessage, RuleWithActions } from "@/utils/types";
 import type { EmailProvider } from "@/utils/email/types";
 import { aiDetermineThreadStatus } from "@/utils/ai/reply/determine-thread-status";
 import { getEmailForLLM } from "@/utils/get-email-from-message";
@@ -26,13 +23,13 @@ export async function determineConversationStatus({
   provider,
   modelType,
 }: {
-  conversationRules: RuleWithActionsAndCategories[];
+  conversationRules: RuleWithActions[];
   message: ParsedMessage;
   emailAccount: EmailAccountWithAI;
   provider: EmailProvider;
   modelType: ModelType;
 }): Promise<{
-  specificRule: RuleWithActionsAndCategories | null;
+  specificRule: RuleWithActions | null;
   reason: string;
 }> {
   logger.info("Determining conversation status", {
diff --git a/apps/web/utils/rule/rule-history.ts b/apps/web/utils/rule/rule-history.ts
index b6f38aa52a..772caeac5e 100644
--- a/apps/web/utils/rule/rule-history.ts
+++ b/apps/web/utils/rule/rule-history.ts
@@ -41,13 +41,6 @@ export async function createRuleHistory({
     url: action.url,
   }));
 
-  // Serialize category filters to JSON
-  const categoryFiltersSnapshot = rule.categoryFilters?.map((category) => ({
-    id: category.id,
-    name: category.name,
-    description: category.description,
-  }));
-
   return prisma.ruleHistory.create({
     data: {
       ruleId: rule.id,
@@ -61,11 +54,9 @@ export async function createRuleHistory({
       to: rule.to,
       subject: rule.subject,
       body: rule.body,
-      categoryFilterType: rule.categoryFilterType,
       systemType: rule.systemType,
       promptText: rule.promptText,
       actions: actionsSnapshot,
-      categoryFilters: categoryFiltersSnapshot,
       triggerType,
       // Note: this is unique and can fail in race conditions. Not a big deal for now.
       version: nextVersion,
diff --git a/apps/web/utils/rule/rule-to-text.ts b/apps/web/utils/rule/rule-to-text.ts
index 407fd20b47..eca86a0e01 100644
--- a/apps/web/utils/rule/rule-to-text.ts
+++ b/apps/web/utils/rule/rule-to-text.ts
@@ -1,13 +1,8 @@
 import type { Rule, Action } from "@prisma/client";
-import {
-  ActionType,
-  CategoryFilterType,
-  LogicalOperator,
-} from "@prisma/client";
+import { ActionType, LogicalOperator } from "@prisma/client";
 
 export interface RuleWithActions extends Rule {
   actions: Action[];
-  categoryFilters?: { name: string }[];
   group?: { name: string } | null;
 }
 
@@ -36,19 +31,6 @@ export function ruleToText(rule: RuleWithActions): string {
     conditions.push(`'Body' contains "${rule.body}"`);
   }
 
-  // if (rule.group) {
-  //   conditions.push(`Sender is in group "${rule.group.name}"`);
-  // }
-
-  if (rule.categoryFilterType && rule.categoryFilters?.length) {
-    const categoryNames = rule.categoryFilters.map((c) => c.name).join(", ");
-    if (rule.categoryFilterType === CategoryFilterType.INCLUDE) {
-      conditions.push(`Sender is in categories: ${categoryNames}`);
-    } else {
-      conditions.push(`Sender is NOT in categories: ${categoryNames}`);
-    }
-  }
-
   // Build actions
   rule.actions.forEach((action) => {
     switch (action.type) {
diff --git a/apps/web/utils/rule/rule.ts b/apps/web/utils/rule/rule.ts
index 1f27d1959a..2a715f7577 100644
--- a/apps/web/utils/rule/rule.ts
+++ b/apps/web/utils/rule/rule.ts
@@ -1,13 +1,11 @@
-import type { CreateOrUpdateRuleSchemaWithCategories } from "@/utils/ai/rule/create-rule-schema";
+import type { CreateOrUpdateRuleSchema } from "@/utils/ai/rule/create-rule-schema";
 import prisma from "@/utils/prisma";
 import { isDuplicateError } from "@/utils/prisma-helpers";
 import { createScopedLogger } from "@/utils/logger";
 import { ActionType } from "@prisma/client";
 import type { Prisma, Rule, SystemType } from "@prisma/client";
-import { getUserCategoriesForNames } from "@/utils/category.server";
 import { getActionRiskLevel, type RiskAction } from "@/utils/risk";
 import { hasExampleParams } from "@/app/(app)/[emailAccountId]/assistant/examples";
-import { SafeError } from "@/utils/error";
 import { createRuleHistory } from "@/utils/rule/rule-history";
 import { isMicrosoftProvider } from "@/utils/email/provider-types";
 import { createEmailProvider } from "@/utils/email/provider";
@@ -25,16 +23,13 @@ export function partialUpdateRule({
   return prisma.rule.update({
     where: { id: ruleId },
     data,
-    include: { actions: true, categoryFilters: true, group: true },
+    include: { actions: true, group: true },
   });
 }
 
 // Extended type for system rules that can include labelId and folderId
-type CreateRuleWithLabelId = Omit<
-  CreateOrUpdateRuleSchemaWithCategories,
-  "actions"
-> & {
-  actions: (CreateOrUpdateRuleSchemaWithCategories["actions"][number] & {
+type CreateRuleWithLabelId = Omit<CreateOrUpdateRuleSchema, "actions"> & {
+  actions: (CreateOrUpdateRuleSchema["actions"][number] & {
     labelId?: string | null;
     folderId?: string | null;
   })[];
@@ -44,7 +39,6 @@ export async function safeCreateRule({
   result,
   emailAccountId,
   provider,
-  categoryNames,
   systemType,
   triggerType = "ai_creation",
   shouldCreateIfDuplicate,
@@ -53,22 +47,15 @@ export async function safeCreateRule({
   result: CreateRuleWithLabelId;
   emailAccountId: string;
   provider: string;
-  categoryNames?: string[] | null;
   systemType?: SystemType | null;
   triggerType?: "ai_creation" | "manual_creation" | "system_creation";
   shouldCreateIfDuplicate: boolean; // maybe this should just always be false?
   runOnThreads: boolean;
 }) {
-  const categoryIds = await getUserCategoriesForNames({
-    emailAccountId,
-    names: categoryNames || [],
-  });
-
   try {
     const rule = await createRule({
       result,
       emailAccountId,
-      categoryIds,
       systemType,
       triggerType,
       provider,
@@ -82,7 +69,6 @@ export async function safeCreateRule({
         const rule = await createRule({
           result: { ...result, name: `${result.name} - ${Date.now()}` },
           emailAccountId,
-          categoryIds,
           triggerType,
           provider,
           runOnThreads,
@@ -97,7 +83,7 @@ export async function safeCreateRule({
               name: result.name,
             },
           },
-          include: { actions: true, categoryFilters: true, group: true },
+          include: { actions: true, group: true },
         });
 
         // If we're creating a system rule and the existing rule doesn't have
@@ -112,7 +98,6 @@ export async function safeCreateRule({
           const rule = await createRule({
             result: { ...result, name: `${result.name} - ${Date.now()}` },
             emailAccountId,
-            categoryIds,
             systemType,
             triggerType,
             provider,
@@ -140,14 +125,12 @@ export async function safeUpdateRule({
   ruleId,
   result,
   emailAccountId,
-  categoryIds,
   triggerType = "ai_update",
   provider,
 }: {
   ruleId: string;
-  result: CreateOrUpdateRuleSchemaWithCategories;
+  result: CreateOrUpdateRuleSchema;
   emailAccountId: string;
-  categoryIds?: string[] | null;
   triggerType?: "ai_update" | "manual_update" | "system_update";
   provider: string;
 }) {
@@ -156,7 +139,6 @@ export async function safeUpdateRule({
       ruleId,
       result,
       emailAccountId,
-      categoryIds,
       triggerType,
       provider,
     });
@@ -167,7 +149,6 @@ export async function safeUpdateRule({
       const rule = await createRule({
         result: { ...result, name: `${result.name} - ${Date.now()}` },
         emailAccountId,
-        categoryIds,
         triggerType: "ai_creation", // Default for safeUpdateRule fallback
         provider,
         runOnThreads: true,
@@ -190,15 +171,13 @@ export async function safeUpdateRule({
 export async function createRule({
   result,
   emailAccountId,
-  categoryIds,
   systemType,
   triggerType = "ai_creation",
   provider,
   runOnThreads,
 }: {
-  result: CreateOrUpdateRuleSchemaWithCategories;
+  result: CreateOrUpdateRuleSchema;
   emailAccountId: string;
-  categoryIds?: string[] | null;
   systemType?: SystemType | null;
   triggerType?: "ai_creation" | "manual_creation" | "system_creation";
   provider: string;
@@ -233,16 +212,8 @@ export async function createRule({
       from: result.condition.static?.from,
       to: result.condition.static?.to,
       subject: result.condition.static?.subject,
-      categoryFilterType: result.condition.categories?.categoryFilterType,
-      categoryFilters: categoryIds
-        ? {
-            connect: categoryIds.map((id) => ({
-              id,
-            })),
-          }
-        : undefined,
     },
-    include: { actions: true, categoryFilters: true, group: true },
+    include: { actions: true, group: true },
   });
 
   // Track rule creation in history
@@ -255,14 +226,12 @@ async function updateRule({
   ruleId,
   result,
   emailAccountId,
-  categoryIds,
   triggerType = "ai_update",
   provider,
 }: {
   ruleId: string;
-  result: CreateOrUpdateRuleSchemaWithCategories;
+  result: CreateOrUpdateRuleSchema;
   emailAccountId: string;
-  categoryIds?: string[] | null;
   triggerType?: "ai_update" | "manual_update" | "system_update";
   provider: string;
 }) {
@@ -284,16 +253,8 @@ async function updateRule({
       from: result.condition.static?.from,
       to: result.condition.static?.to,
       subject: result.condition.static?.subject,
-      categoryFilterType: result.condition.categories?.categoryFilterType,
-      categoryFilters: categoryIds
-        ? {
-            set: categoryIds.map((id) => ({
-              id,
-            })),
-          }
-        : undefined,
     },
-    include: { actions: true, categoryFilters: true, group: true },
+    include: { actions: true, group: true },
   });
 
   // Track rule update in history
@@ -309,7 +270,7 @@ export async function updateRuleActions({
   emailAccountId,
 }: {
   ruleId: string;
-  actions: CreateOrUpdateRuleSchemaWithCategories["actions"];
+  actions: CreateOrUpdateRuleSchema["actions"];
   provider: string;
   emailAccountId: string;
 }) {
@@ -344,10 +305,7 @@ export async function deleteRule({
   ]);
 }
 
-function shouldEnable(
-  rule: CreateOrUpdateRuleSchemaWithCategories,
-  actions: RiskAction[],
-) {
+function shouldEnable(rule: CreateOrUpdateRuleSchema, actions: RiskAction[]) {
   // Don't automate if it's an example rule that should have been edited by the user
   if (
     hasExampleParams({
@@ -372,47 +330,8 @@ function shouldEnable(
   return riskLevels.every((level) => level === "low");
 }
 
-export async function addRuleCategories(ruleId: string, categoryIds: string[]) {
-  const rule = await prisma.rule.findUnique({
-    where: { id: ruleId },
-    include: { categoryFilters: true },
-  });
-
-  if (!rule) throw new SafeError("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 SafeError("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 },
-  });
-}
-
 async function mapActionFields(
-  actions: (CreateOrUpdateRuleSchemaWithCategories["actions"][number] & {
+  actions: (CreateOrUpdateRuleSchema["actions"][number] & {
     labelId?: string | null;
     folderId?: string | null;
   })[],
diff --git a/apps/web/utils/rule/types.ts b/apps/web/utils/rule/types.ts
index 79881bbad8..53be21e760 100644
--- a/apps/web/utils/rule/types.ts
+++ b/apps/web/utils/rule/types.ts
@@ -1,5 +1,5 @@
 import type { safeCreateRule } from "@/utils/rule/rule";
-import type { Action, Rule, Category, Prisma } from "@prisma/client";
+import type { Action, Rule, Prisma } from "@prisma/client";
 
 export type CreateRuleResult = NonNullable<
   Awaited<ReturnType<typeof safeCreateRule>>
@@ -7,7 +7,6 @@ export type CreateRuleResult = NonNullable<
 
 export type RuleWithRelations = Rule & {
   actions: Action[];
-  categoryFilters?: Category[];
   group?:
     | (Prisma.GroupGetPayload<{
         select: { id: true; name: true };
diff --git a/apps/web/utils/types.ts b/apps/web/utils/types.ts
index ee3663ef69..a0a44caec5 100644
--- a/apps/web/utils/types.ts
+++ b/apps/web/utils/types.ts
@@ -13,14 +13,6 @@ export type RuleWithActions = Prisma.RuleGetPayload<{
   include: { actions: true };
 }>;
 
-export type RuleWithActionsAndCategories = Prisma.RuleGetPayload<{
-  include: { actions: true; categoryFilters: true };
-}>;
-
-export type AIRuleWithActionsAndCategories = RuleWithActionsAndCategories & {
-  instructions: string;
-};
-
 export type BatchError = {
   error: {
     code: number;
diff --git a/apps/web/utils/webhook/process-history-item.ts b/apps/web/utils/webhook/process-history-item.ts
index 3758836e67..94b8ab2920 100644
--- a/apps/web/utils/webhook/process-history-item.ts
+++ b/apps/web/utils/webhook/process-history-item.ts
@@ -9,13 +9,13 @@ import { type EmailAccount, NewsletterStatus } from "@prisma/client";
 import { extractEmailAddress } from "@/utils/email";
 import { isIgnoredSender } from "@/utils/filter-ignored-senders";
 import type { EmailProvider } from "@/utils/email/types";
-import type { RuleWithActionsAndCategories } from "@/utils/types";
+import type { RuleWithActions } from "@/utils/types";
 import type { EmailAccountWithAI } from "@/utils/llms/types";
 import type { Logger } from "@/utils/logger";
 
 export type SharedProcessHistoryOptions = {
   provider: EmailProvider;
-  rules: RuleWithActionsAndCategories[];
+  rules: RuleWithActions[];
   hasAutomationRules: boolean;
   hasAiAccess: boolean;
   emailAccount: EmailAccountWithAI &
diff --git a/apps/web/utils/webhook/validate-webhook-account.ts b/apps/web/utils/webhook/validate-webhook-account.ts
index 4d7cd65373..6c839a15e7 100644
--- a/apps/web/utils/webhook/validate-webhook-account.ts
+++ b/apps/web/utils/webhook/validate-webhook-account.ts
@@ -28,7 +28,7 @@ export async function getWebhookEmailAccount(
       },
       rules: {
         where: { enabled: true },
-        include: { actions: true, categoryFilters: true },
+        include: { actions: true },
       },
       user: {
         select: {

From 8cfd43cac508088e54b78c5593795532d0079607 Mon Sep 17 00:00:00 2001
From: Eliezer Steinbock <3090527+elie222@users.noreply.github.com>
Date: Mon, 20 Oct 2025 06:21:45 +0300
Subject: [PATCH 11/40] fix up match rules to work with multiple rules

---
 apps/web/utils/ai/choose-rule/match-rules.ts | 298 +++++++++----------
 apps/web/utils/ai/choose-rule/types.ts       |  13 +-
 apps/web/utils/condition.ts                  |   4 +-
 3 files changed, 140 insertions(+), 175 deletions(-)

diff --git a/apps/web/utils/ai/choose-rule/match-rules.ts b/apps/web/utils/ai/choose-rule/match-rules.ts
index 1aac83f3b4..7348b97224 100644
--- a/apps/web/utils/ai/choose-rule/match-rules.ts
+++ b/apps/web/utils/ai/choose-rule/match-rules.ts
@@ -3,16 +3,8 @@ import {
   findMatchingGroup,
   getGroupsWithRules,
 } from "@/utils/group/find-matching-group";
-import type {
-  ParsedMessage,
-  RuleWithActions,
-  RuleWithActionsAndCategories,
-} from "@/utils/types";
-import {
-  CategoryFilterType,
-  LogicalOperator,
-  SystemType,
-} from "@prisma/client";
+import type { ParsedMessage, RuleWithActions } from "@/utils/types";
+import { LogicalOperator, SystemType } from "@prisma/client";
 import { ConditionType } from "@/utils/config";
 import prisma from "@/utils/prisma";
 import { aiChooseRule } from "@/utils/ai/choose-rule/ai-choose-rule";
@@ -41,7 +33,7 @@ const TO_REPLY_RECEIVED_THRESHOLD = 10;
 
 type MatchingRulesResult = {
   matches: {
-    rule: RuleWithActionsAndCategories;
+    rule: RuleWithActions;
     matchReasons?: MatchReason[];
   }[];
   reasoning: string;
@@ -57,34 +49,42 @@ async function findPotentialMatchingRules({
   isThread,
   provider,
 }: {
-  rules: RuleWithActionsAndCategories[];
+  rules: RuleWithActions[];
   message: ParsedMessage;
   isThread: boolean;
   provider: EmailProvider;
 }): Promise<MatchingRuleResult> {
-  const potentialMatches: (RuleWithActionsAndCategories & {
-    instructions: string;
-  })[] = [];
+  const matches: {
+    rule: RuleWithActions;
+    matchReasons: MatchReason[]; // why do we need match reasons?
+  }[] = [];
+  const potentialAiMatches: (RuleWithActions & { instructions: string })[] = [];
 
-  const calendarMatch = checkCalendarMatch({ rules, message });
-  if (calendarMatch) return calendarMatch;
+  const learnedPatternsLoader = new LearnedPatternsLoader();
 
-  const contextLoader = new ContextLoader(message);
-
-  // loop through rules and check if they match
+  // Go through all rules
+  // Collect matches and potential AI matches
   for (const rule of rules) {
-    const { runOnThreads, conditionalOperator: operator } = rule;
+    // Special case for calendar rules
+    const calendarMatch =
+      rule.systemType === SystemType.CALENDAR && hasIcsAttachment(message);
 
-    if (isThread && !runOnThreads) continue;
+    if (calendarMatch) {
+      matches.push({
+        rule,
+        matchReasons: [
+          { type: ConditionType.PRESET, systemType: SystemType.CALENDAR },
+        ],
+      });
+    }
 
-    const conditionTypes = getConditionTypes(rule);
-    const matchReasons: MatchReason[] = [];
+    // TODO: still run this, if a previous email in the thread matched the rule
+    if (isThread && !rule.runOnThreads) continue;
 
     // Learned patterns (groups)
-    // If a match is found, return it immediately
     // Ignores conditional operator
     if (rule.groupId) {
-      const groups = await contextLoader.getGroups(rule.emailAccountId);
+      const groups = await learnedPatternsLoader.getGroups(rule.emailAccountId);
       if (!groups?.length) continue;
       const { matchingItem, group, ruleExcluded } = matchesGroupRule(
         rule,
@@ -96,127 +96,123 @@ async function findPotentialMatchingRules({
       if (ruleExcluded) continue;
 
       if (matchingItem) {
-        matchReasons.push({
-          type: ConditionType.GROUP,
-          groupItem: matchingItem,
-          group,
+        matches.push({
+          rule,
+          matchReasons: [
+            {
+              type: ConditionType.LEARNED_PATTERN,
+              groupItem: matchingItem,
+              group,
+            },
+          ],
         });
-
-        return { match: rule, matchReasons };
       }
     }
 
-    // Regular conditions:
-    const unmatchedConditions = new Set<ConditionType>(
-      Object.keys(conditionTypes) as ConditionType[],
-    );
-
-    // TODO: allow multiple matches
-    if (conditionTypes.STATIC) {
-      const match = matchesStaticRule(rule, message);
-      if (match) {
-        unmatchedConditions.delete(ConditionType.STATIC);
-        matchReasons.push({ type: ConditionType.STATIC });
-        if (operator === LogicalOperator.OR || !unmatchedConditions.size)
-          return { match: rule, matchReasons };
-      } else {
-        // no match, so can't be a match with AND
-        if (operator === LogicalOperator.AND) continue;
-      }
-    }
+    // AI + Static conditions
+    const { matched, potentialAiMatch, matchReasons } = evaluateRuleConditions({
+      rule,
+      message,
+    });
 
-    // TODO: allow multiple matches?
-    if (conditionTypes.CATEGORY) {
-      const sender = await contextLoader.getSender(rule.emailAccountId);
-      const matchedCategory = matchesCategoryRule(rule, sender);
-      if (matchedCategory) {
-        unmatchedConditions.delete(ConditionType.CATEGORY);
-        if (typeof matchedCategory !== "boolean") {
-          matchReasons.push({
-            type: ConditionType.CATEGORY,
-            category: matchedCategory,
-          });
-        }
-        if (operator === LogicalOperator.OR || !unmatchedConditions.size)
-          return { match: rule, matchReasons };
-      } else {
-        // no match, so can't be a match with AND
-        if (operator === LogicalOperator.AND) continue;
-      }
+    if (matched) {
+      matches.push({ rule, matchReasons });
     }
 
-    if (conditionTypes.AI && isAIRule(rule)) {
-      // we'll need to run the LLM later to determine if it matches
-      potentialMatches.push(rule);
+    if (potentialAiMatch) {
+      potentialAiMatches.push({
+        ...rule,
+        instructions: rule.instructions ?? "",
+      });
     }
   }
 
-  const filteredPotentialMatches = await filterConversationStatusRules(
-    potentialMatches,
+  // TODO: move into loop for consistency?
+  const filteredPotentialAiMatches = await filterConversationStatusRules(
+    potentialAiMatches,
     message,
     provider,
   );
 
-  return { potentialMatches: filteredPotentialMatches };
+  const hasLearnedPatternMatch = matches.some((m) =>
+    m.matchReasons.some((r) => r.type === ConditionType.LEARNED_PATTERN),
+  );
+
+  // If we have a learned pattern match, then return all matches and no potential AI matches
+  // Learned patterns are used for efficiency to avoid running AI for every rule
+  return {
+    matches,
+    potentialAiMatches: hasLearnedPatternMatch
+      ? []
+      : filteredPotentialAiMatches,
+  };
 }
 
-function checkCalendarMatch({
-  rules,
+function evaluateRuleConditions({
+  rule,
   message,
 }: {
-  rules: RuleWithActionsAndCategories[];
+  rule: RuleWithActions;
   message: ParsedMessage;
-}): MatchingRuleResult | undefined {
-  const isCalendarEvent = hasIcsAttachment(message);
-  if (!isCalendarEvent) return;
-
-  const rule = rules.find((r) => r.systemType === SystemType.CALENDAR);
-  if (!rule) return;
+}): {
+  matched: boolean;
+  potentialAiMatch: boolean;
+  matchReasons: MatchReason[];
+} {
+  const { conditionalOperator: operator } = rule;
+  const conditionTypes = getConditionTypes(rule);
+  const hasAiCondition = conditionTypes.AI && isAIRule(rule);
+  const hasStaticCondition = conditionTypes.STATIC;
+
+  const matchReasons: MatchReason[] = [];
+
+  // Check STATIC condition
+  const staticMatch = hasStaticCondition
+    ? matchesStaticRule(rule, message)
+    : false;
+  if (staticMatch) {
+    matchReasons.push({ type: ConditionType.STATIC });
+  }
 
-  logger.info("Found matching calendar rule", {
-    ruleId: rule.id,
-    messageId: message.id,
-  });
-  return {
-    match: rule,
-    matchReasons: [
-      { type: ConditionType.PRESET, systemType: SystemType.CALENDAR },
-    ],
-  };
+  // Determine result based on what we have
+  if (operator === LogicalOperator.OR) {
+    // OR logic
+    if (staticMatch) {
+      // Found a match, no need for AI
+      return { matched: true, potentialAiMatch: false, matchReasons };
+    }
+    if (hasAiCondition) {
+      // No static match, but have AI - need to check AI
+      return { matched: false, potentialAiMatch: true, matchReasons };
+    }
+    // No matches at all
+    return { matched: false, potentialAiMatch: false, matchReasons };
+  } else {
+    // AND logic
+    if (hasStaticCondition && !staticMatch) {
+      // Static failed, so AND fails
+      return { matched: false, potentialAiMatch: false, matchReasons: [] };
+    }
+    if (hasAiCondition) {
+      // Static passed (or doesn't exist), but need AI to complete AND
+      return { matched: false, potentialAiMatch: true, matchReasons };
+    }
+    // Only static, and it passed
+    return { matched: staticMatch, potentialAiMatch: false, matchReasons };
+  }
 }
 
-// Lazy load context data when needed
-class ContextLoader {
-  private readonly message: ParsedMessage;
+// Lazy load learned patterns when needed
+class LearnedPatternsLoader {
   private groups?: Awaited<ReturnType<typeof getGroupsWithRules>> | null;
-  private sender?: { categoryId: string | null } | null;
-
-  constructor(message: ParsedMessage) {
-    this.message = message;
-  }
 
   async getGroups(emailAccountId: string) {
     if (this.groups === undefined)
       this.groups = await getGroupsWithRules({ emailAccountId });
     return this.groups;
   }
-
-  async getSender(emailAccountId: string) {
-    if (this.sender === undefined) {
-      this.sender = await prisma.newsletter.findUnique({
-        where: {
-          email_emailAccountId: {
-            email: extractEmailAddress(this.message.headers.from),
-            emailAccountId,
-          },
-        },
-      });
-    }
-    return this.sender;
-  }
 }
 
-// TODO: how was this used? use it again
 function getMatchReason(matchReasons?: MatchReason[]): string | undefined {
   if (!matchReasons || matchReasons.length === 0) return;
 
@@ -225,10 +221,8 @@ function getMatchReason(matchReasons?: MatchReason[]): string | undefined {
       switch (reason.type) {
         case ConditionType.STATIC:
           return "Matched static conditions";
-        case ConditionType.GROUP:
+        case ConditionType.LEARNED_PATTERN:
           return `Matched learned pattern: "${reason.groupItem.type}: ${reason.groupItem.value}"`;
-        case ConditionType.CATEGORY:
-          return `Matched category: "${reason.category.name}"`;
         case ConditionType.PRESET:
           return "Matched a system preset";
       }
@@ -243,7 +237,7 @@ export async function findMatchingRules({
   provider,
   modelType,
 }: {
-  rules: RuleWithActionsAndCategories[];
+  rules: RuleWithActions[];
   message: ParsedMessage;
   emailAccount: EmailAccountWithAI;
   provider: EmailProvider;
@@ -261,13 +255,13 @@ export async function findMatchingRules({
     });
 
     if (coldEmailResult.isColdEmail) {
-      const coldEmailRuleWithCategories = await prisma.rule.findUniqueOrThrow({
+      const coldRule = await prisma.rule.findUniqueOrThrow({
         where: { id: coldEmailRule.id },
-        include: { actions: true, categoryFilters: true },
+        include: { actions: true },
       });
 
       return {
-        matches: [{ rule: coldEmailRuleWithCategories, matchReasons: [] }],
+        matches: [{ rule: coldRule, matchReasons: [] }],
         reasoning: coldEmailResult.reason,
       };
     }
@@ -290,7 +284,7 @@ export async function findMatchingRules({
 }
 
 async function findMatchingRulesWithReasons(
-  rules: RuleWithActionsAndCategories[],
+  rules: RuleWithActions[],
   message: ParsedMessage,
   emailAccount: EmailAccountWithAI,
   provider: EmailProvider,
@@ -298,20 +292,17 @@ async function findMatchingRulesWithReasons(
 ): Promise<MatchingRulesResult> {
   const isThread = provider.isReplyInThread(message);
 
-  const { match, matchReasons, potentialMatches } =
-    await findPotentialMatchingRules({
-      rules,
-      message,
-      isThread,
-      provider,
-    });
-
-  if (match) return { matches: [{ rule: match, matchReasons }], reasoning: "" };
+  const { matches, potentialAiMatches } = await findPotentialMatchingRules({
+    rules,
+    message,
+    isThread,
+    provider,
+  });
 
-  if (potentialMatches?.length) {
+  if (potentialAiMatches.length) {
     const result = await aiChooseRule({
       email: getEmailForLLM(message),
-      rules: potentialMatches,
+      rules: potentialAiMatches,
       emailAccount,
       modelType,
     });
@@ -319,13 +310,18 @@ async function findMatchingRulesWithReasons(
     return {
       matches: result.rules.map((rule) => ({
         rule,
-        matchReasons: [],
+        matchReasons: [{ type: ConditionType.AI }],
       })),
       reasoning: result.reason,
     };
+  } else {
+    return {
+      matches,
+      reasoning: matches
+        .flatMap((m) => getMatchReason(m.matchReasons))
+        .join(", "),
+    };
   }
-
-  return { matches: [], reasoning: "" };
 }
 
 export function matchesStaticRule(
@@ -396,7 +392,7 @@ export function splitEmailPatterns(pattern: string): string[] {
 }
 
 function matchesGroupRule(
-  rule: RuleWithActionsAndCategories,
+  rule: RuleWithActions,
   groups: Awaited<ReturnType<typeof getGroupsWithRules>>,
   message: ParsedMessage,
 ) {
@@ -418,30 +414,6 @@ function matchesGroupRule(
   return { group: null, matchingItem: null, ruleExcluded: false };
 }
 
-function matchesCategoryRule(
-  rule: RuleWithActionsAndCategories,
-  sender: { categoryId: string | null } | null,
-) {
-  if (!rule.categoryFilterType || rule.categoryFilters.length === 0)
-    return true;
-
-  if (!sender) return false;
-
-  const matchedFilter = rule.categoryFilters.find(
-    (c) => c.id === sender.categoryId,
-  );
-
-  if (
-    (rule.categoryFilterType === CategoryFilterType.INCLUDE &&
-      !matchedFilter) ||
-    (rule.categoryFilterType === CategoryFilterType.EXCLUDE && matchedFilter)
-  ) {
-    return false;
-  }
-
-  return matchedFilter;
-}
-
 export async function filterConversationStatusRules<
   T extends { id: string; systemType: SystemType | null },
 >(
diff --git a/apps/web/utils/ai/choose-rule/types.ts b/apps/web/utils/ai/choose-rule/types.ts
index 952de1e909..4335abfc25 100644
--- a/apps/web/utils/ai/choose-rule/types.ts
+++ b/apps/web/utils/ai/choose-rule/types.ts
@@ -28,18 +28,11 @@ export type MatchReason =
   | PresetMatch;
 
 export type MatchingRuleResult = {
-  // If there's an exact match that should bypass any further processing
-  // match: RuleWithActionsAndCategories | null;
-  // matchReasons: MatchReason[];
-
-  // Potential AI match rules
-  potentialAiMatches: (RuleWithActions & {
-    instructions: string;
-  })[];
-  // Now that we support matching multiple rules, it's possible to match a static rule and an ai rule
-  // So we need to return the static matches we've already found
   matches: {
     rule: RuleWithActions;
     matchReasons: MatchReason[];
   }[];
+  potentialAiMatches: (RuleWithActions & {
+    instructions: string;
+  })[];
 };
diff --git a/apps/web/utils/condition.ts b/apps/web/utils/condition.ts
index b226aa7546..e5daa1c08b 100644
--- a/apps/web/utils/condition.ts
+++ b/apps/web/utils/condition.ts
@@ -64,13 +64,13 @@ export function getConditions(rule: RuleConditions) {
 
 export function getConditionTypes(
   rule: RuleConditions,
-): Record<ConditionType, boolean> {
+): Record<CoreConditionType, boolean> {
   return getConditions(rule).reduce(
     (acc, condition) => {
       acc[condition.type] = true;
       return acc;
     },
-    {} as Record<ConditionType, boolean>,
+    {} as Record<CoreConditionType, boolean>,
   );
 }
 

From 9dcca895e7e7af3e9a07f0893daecab782d572bf Mon Sep 17 00:00:00 2001
From: Eliezer Steinbock <3090527+elie222@users.noreply.github.com>
Date: Mon, 20 Oct 2025 06:23:05 +0300
Subject: [PATCH 12/40] reorder file

---
 apps/web/utils/ai/choose-rule/match-rules.ts | 108 +++++++++----------
 1 file changed, 52 insertions(+), 56 deletions(-)

diff --git a/apps/web/utils/ai/choose-rule/match-rules.ts b/apps/web/utils/ai/choose-rule/match-rules.ts
index 7348b97224..7e4a5f26ba 100644
--- a/apps/web/utils/ai/choose-rule/match-rules.ts
+++ b/apps/web/utils/ai/choose-rule/match-rules.ts
@@ -39,9 +39,58 @@ type MatchingRulesResult = {
   reasoning: string;
 };
 
-// if we find a match, return it
-// if we don't find a match, return the potential matches
-// ai rules need further processing to determine if they match
+export async function findMatchingRules({
+  rules,
+  message,
+  emailAccount,
+  provider,
+  modelType,
+}: {
+  rules: RuleWithActions[];
+  message: ParsedMessage;
+  emailAccount: EmailAccountWithAI;
+  provider: EmailProvider;
+  modelType: ModelType;
+}): Promise<MatchingRulesResult> {
+  const coldEmailRule = await getColdEmailRule(emailAccount.id);
+
+  if (coldEmailRule && isColdEmailRuleEnabled(coldEmailRule)) {
+    const coldEmailResult = await isColdEmail({
+      email: getEmailForLLM(message),
+      emailAccount,
+      provider,
+      modelType,
+      coldEmailRule,
+    });
+
+    if (coldEmailResult.isColdEmail) {
+      const coldRule = await prisma.rule.findUniqueOrThrow({
+        where: { id: coldEmailRule.id },
+        include: { actions: true },
+      });
+
+      return {
+        matches: [{ rule: coldRule, matchReasons: [] }],
+        reasoning: coldEmailResult.reason,
+      };
+    }
+  }
+
+  // Filter out cold email rule which was already checked above
+  const rulesWithoutColdEmail = rules.filter(
+    (rule) => rule.systemType !== SystemType.COLD_EMAIL,
+  );
+
+  const results = await findMatchingRulesWithReasons(
+    rulesWithoutColdEmail,
+    message,
+    emailAccount,
+    provider,
+    modelType,
+  );
+
+  return results;
+}
 
 async function findPotentialMatchingRules({
   rules,
@@ -230,59 +279,6 @@ function getMatchReason(matchReasons?: MatchReason[]): string | undefined {
     .join(", ");
 }
 
-export async function findMatchingRules({
-  rules,
-  message,
-  emailAccount,
-  provider,
-  modelType,
-}: {
-  rules: RuleWithActions[];
-  message: ParsedMessage;
-  emailAccount: EmailAccountWithAI;
-  provider: EmailProvider;
-  modelType: ModelType;
-}): Promise<MatchingRulesResult> {
-  const coldEmailRule = await getColdEmailRule(emailAccount.id);
-
-  if (coldEmailRule && isColdEmailRuleEnabled(coldEmailRule)) {
-    const coldEmailResult = await isColdEmail({
-      email: getEmailForLLM(message),
-      emailAccount,
-      provider,
-      modelType,
-      coldEmailRule,
-    });
-
-    if (coldEmailResult.isColdEmail) {
-      const coldRule = await prisma.rule.findUniqueOrThrow({
-        where: { id: coldEmailRule.id },
-        include: { actions: true },
-      });
-
-      return {
-        matches: [{ rule: coldRule, matchReasons: [] }],
-        reasoning: coldEmailResult.reason,
-      };
-    }
-  }
-
-  // Filter out cold email rule which was already checked above
-  const rulesWithoutColdEmail = rules.filter(
-    (rule) => rule.systemType !== SystemType.COLD_EMAIL,
-  );
-
-  const results = await findMatchingRulesWithReasons(
-    rulesWithoutColdEmail,
-    message,
-    emailAccount,
-    provider,
-    modelType,
-  );
-
-  return results;
-}
-
 async function findMatchingRulesWithReasons(
   rules: RuleWithActions[],
   message: ParsedMessage,

From b046492d391883f330e61d69d30b70121d2ac013 Mon Sep 17 00:00:00 2001
From: Eliezer Steinbock <3090527+elie222@users.noreply.github.com>
Date: Mon, 20 Oct 2025 06:43:52 +0300
Subject: [PATCH 13/40] Fix tests

---
 .../utils/ai/choose-rule/match-rules.test.ts  | 613 +++++++++---------
 apps/web/utils/ai/choose-rule/match-rules.ts  |  85 ++-
 2 files changed, 369 insertions(+), 329 deletions(-)

diff --git a/apps/web/utils/ai/choose-rule/match-rules.test.ts b/apps/web/utils/ai/choose-rule/match-rules.test.ts
index 05762d3404..3171b9e1e9 100644
--- a/apps/web/utils/ai/choose-rule/match-rules.test.ts
+++ b/apps/web/utils/ai/choose-rule/match-rules.test.ts
@@ -1,21 +1,19 @@
 import { describe, it, expect, vi, beforeEach } from "vitest";
 import {
-  findMatchingRule,
+  findMatchingRules,
   matchesStaticRule,
-  filterToReplyPreset,
+  filterConversationStatusRules,
+  evaluateRuleConditions,
 } from "./match-rules";
 import {
-  type Category,
-  CategoryFilterType,
   type GroupItem,
   GroupItemType,
   LogicalOperator,
-  type Newsletter,
   type Prisma,
   SystemType,
 } from "@prisma/client";
 import type {
-  RuleWithActionsAndCategories,
+  RuleWithActions,
   ParsedMessage,
   ParsedMessageHeaders,
 } from "@/utils/types";
@@ -23,6 +21,7 @@ import type { EmailProvider } from "@/utils/email/types";
 import prisma from "@/utils/__mocks__/prisma";
 import { aiChooseRule } from "@/utils/ai/choose-rule/ai-choose-rule";
 import { getEmailAccount } from "@/__tests__/helpers";
+import { ConditionType } from "@/utils/config";
 
 // Run with:
 // pnpm test match-rules.test.ts
@@ -763,7 +762,7 @@ describe("findMatchingRule", () => {
       headers: getHeaders({ from: "test@example.com" }),
     });
     const emailAccount = getEmailAccount();
-    const result = await findMatchingRule({
+    const result = await findMatchingRules({
       rules,
       message,
       emailAccount,
@@ -771,8 +770,10 @@ describe("findMatchingRule", () => {
       modelType: "default",
     });
 
-    expect(result.rule?.id).toBe(rule.id);
-    expect(result.reason).toBe("Matched static conditions");
+    expect(result.matches[0].rule.id).toBe(rule.id);
+    expect(result.matches[0].matchReasons).toEqual([
+      { type: ConditionType.STATIC },
+    ]);
   });
 
   it("matches a static domain", async () => {
@@ -783,7 +784,7 @@ describe("findMatchingRule", () => {
     });
     const emailAccount = getEmailAccount();
 
-    const result = await findMatchingRule({
+    const result = await findMatchingRules({
       rules,
       message,
       emailAccount,
@@ -791,8 +792,10 @@ describe("findMatchingRule", () => {
       modelType: "default",
     });
 
-    expect(result.rule?.id).toBe(rule.id);
-    expect(result.reason).toBe("Matched static conditions");
+    expect(result.matches[0].rule.id).toBe(rule.id);
+    expect(result.matches[0].matchReasons).toEqual([
+      { type: ConditionType.STATIC },
+    ]);
   });
 
   it("doens't match wrong static domain", async () => {
@@ -803,7 +806,7 @@ describe("findMatchingRule", () => {
     });
     const emailAccount = getEmailAccount();
 
-    const result = await findMatchingRule({
+    const result = await findMatchingRules({
       rules,
       message,
       emailAccount,
@@ -811,8 +814,8 @@ describe("findMatchingRule", () => {
       modelType: "default",
     });
 
-    expect(result.rule?.id).toBeUndefined();
-    expect(result.reason).toBeUndefined();
+    expect(result.matches).toHaveLength(0);
+    expect(result.reasoning).toBe("");
   });
 
   it("matches a group rule", async () => {
@@ -834,101 +837,7 @@ describe("findMatchingRule", () => {
     });
     const emailAccount = getEmailAccount();
 
-    const result = await findMatchingRule({
-      rules,
-      message,
-      emailAccount,
-      provider,
-      modelType: "default",
-    });
-
-    expect(result.rule?.id).toBe(rule.id);
-    expect(result.reason).toBe(
-      `Matched learned pattern: "FROM: test@example.com"`,
-    );
-  });
-
-  it("matches a smart category rule", async () => {
-    prisma.newsletter.findUnique.mockResolvedValue(
-      getNewsletter({ categoryId: "test-category" }),
-    );
-
-    const rule = getRule({
-      categoryFilters: [getCategory({ id: "test-category" })],
-      categoryFilterType: CategoryFilterType.INCLUDE,
-    });
-    const rules = [rule];
-    const message = getMessage();
-    const emailAccount = getEmailAccount();
-
-    const result = await findMatchingRule({
-      rules,
-      message,
-      emailAccount,
-      provider,
-      modelType: "default",
-    });
-
-    expect(result.rule?.id).toBe(rule.id);
-    expect(result.reason).toBe('Matched category: "category"');
-  });
-
-  it("matches a smart category rule with exclude", async () => {
-    prisma.newsletter.findUnique.mockResolvedValue(
-      getNewsletter({ categoryId: "test-category" }),
-    );
-
-    const rule = getRule({
-      categoryFilters: [getCategory({ id: "test-category" })],
-      categoryFilterType: CategoryFilterType.EXCLUDE,
-    });
-    const rules = [rule];
-    const message = getMessage();
-    const emailAccount = getEmailAccount();
-
-    const result = await findMatchingRule({
-      rules,
-      message,
-      emailAccount,
-      provider,
-      modelType: "default",
-    });
-
-    expect(result.rule?.id).toBeUndefined();
-    expect(result.reason).toBeUndefined();
-  });
-
-  it("matches a rule with multiple conditions AND (category and group)", async () => {
-    const rule = getRule({
-      conditionalOperator: LogicalOperator.AND,
-      categoryFilters: [getCategory({ id: "category1" })],
-      groupId: "group1",
-    });
-
-    prisma.group.findMany.mockResolvedValue([
-      getGroup({
-        id: "group1",
-        items: [
-          getGroupItem({
-            groupId: "group1",
-            type: GroupItemType.FROM,
-            value: "test@example.com",
-          }),
-        ],
-        rule,
-      }),
-    ]);
-    prisma.newsletter.findUnique.mockResolvedValue(
-      getNewsletter({ categoryId: "category1" }),
-    );
-
-    const rules = [rule];
-    const message = getMessage({
-      headers: getHeaders({ from: "test@example.com" }),
-    });
-    const emailAccount = getEmailAccount();
-
-    const result = await findMatchingRule({
+    const result = await findMatchingRules({
       rules,
       message,
       emailAccount,
@@ -936,146 +845,18 @@ describe("findMatchingRule", () => {
       modelType: "default",
     });
 
-    expect(result.rule?.id).toBe(rule.id);
-    expect(result.reason).toBe(
+    expect(result.matches[0]?.rule.id).toBe(rule.id);
+    expect(result.reasoning).toBe(
       `Matched learned pattern: "FROM: test@example.com"`,
     );
   });
 
-  it("matches a rule with multiple conditions AND (category and AI)", async () => {
-    prisma.newsletter.findUnique.mockResolvedValue(
-      getNewsletter({ categoryId: "newsletterCategory" }),
-    );
-
-    const rule = getRule({
-      conditionalOperator: LogicalOperator.AND,
-      instructions: "Match if the email is an AI newsletter",
-      categoryFilters: [getCategory({ id: "newsletterCategory" })],
-    });
-
-    (aiChooseRule as ReturnType<typeof vi.fn>).mockImplementationOnce(() => {
-      return {
-        reason: "reason",
-        rule: { id: "r123" },
-      };
-    });
-
-    const rules = [rule];
-    const message = getMessage({
-      headers: getHeaders({ from: "ai@newsletter.com" }),
-    });
-    const emailAccount = getEmailAccount();
-
-    const result = await findMatchingRule({
-      rules,
-      message,
-      emailAccount,
-      provider,
-      modelType: "default",
-    });
-
-    expect(result.rule?.id).toBe(rule.id);
-    expect(result.reason).toBeDefined();
-    expect(aiChooseRule).toHaveBeenCalledOnce();
-  });
-
-  it("doesn't match when AI condition fails (category matches but AI doesn't)", async () => {
-    prisma.newsletter.findUnique.mockResolvedValue(
-      getNewsletter({ categoryId: "newsletterCategory" }),
-    );
-
-    const rule = getRule({
-      conditionalOperator: LogicalOperator.AND,
-      instructions: "Match if the email is an AI newsletter",
-      categoryFilters: [getCategory({ id: "newsletterCategory" })],
-    });
-
-    (aiChooseRule as ReturnType<typeof vi.fn>).mockImplementationOnce(() => {
-      return {
-        reason: "Not an AI newsletter",
-        rule: undefined,
-      };
-    });
-
-    const rules = [rule];
-    const message = getMessage({
-      headers: getHeaders({ from: "marketing@newsletter.com" }),
-    });
-    const emailAccount = getEmailAccount();
-
-    const result = await findMatchingRule({
-      rules,
-      message,
-      emailAccount,
-      provider,
-      modelType: "default",
-    });
-
-    expect(result.rule).toBeUndefined();
-    expect(result.reason).toBeDefined();
-    expect(aiChooseRule).toHaveBeenCalledOnce();
-  });
-
-  it("should match with only one of category or group", async () => {
-    prisma.newsletter.findUnique.mockResolvedValue(
-      getNewsletter({ categoryId: "category1" }),
-    );
-    prisma.group.findMany.mockResolvedValue([]);
-
-    const rule = getRule({
-      conditionalOperator: LogicalOperator.AND,
-      categoryFilters: [getCategory({ id: "category1" })],
-      groupId: "group1",
-    });
-    const rules = [rule];
-    const message = getMessage();
-    const emailAccount = getEmailAccount();
-
-    const result = await findMatchingRule({
-      rules,
-      message,
-      emailAccount,
-      provider,
-      modelType: "default",
-    });
-
-    expect(result.rule?.id).toBe(rule.id);
-    expect(result.reason).toBe('Matched category: "category"');
-  });
-
-  it("matches with OR and one of category or group", async () => {
-    prisma.newsletter.findUnique.mockResolvedValue(
-      getNewsletter({ categoryId: "category1" }),
-    );
-    prisma.group.findMany.mockResolvedValue([]);
-
-    const rule = getRule({
-      conditionalOperator: LogicalOperator.OR,
-      categoryFilters: [getCategory({ id: "category1" })],
-      groupId: "group1",
-    });
-    const rules = [rule];
-    const message = getMessage();
-    const emailAccount = getEmailAccount();
-
-    const result = await findMatchingRule({
-      rules,
-      message,
-      emailAccount,
-      provider,
-      modelType: "default",
-    });
-
-    expect(result.rule?.id).toBe(rule.id);
-    expect(result.reason).toBe('Matched category: "category"');
-  });
-
-  it("should not match when item matches but is in wrong group", async () => {
+  it("should match via default when group doesn't match and no other conditions", async () => {
     const rule = getRule({
       groupId: "correctGroup", // Rule specifically looks for correctGroup
     });
 
-    // Set up two groups - one referenced by the rule, one not
+    // Set up groups - message doesn't match the rule's group
     prisma.group.findMany.mockResolvedValue([
       getGroup({
         id: "wrongGroup",
@@ -1102,11 +883,11 @@ describe("findMatchingRule", () => {
 
     const rules = [rule];
     const message = getMessage({
-      headers: getHeaders({ from: "test@example.com" }), // This matches item in wrongGroup
+      headers: getHeaders({ from: "test@example.com" }), // Doesn't match correctGroup
     });
     const emailAccount = getEmailAccount();
 
-    const result = await findMatchingRule({
+    const result = await findMatchingRules({
       rules,
       message,
       emailAccount,
@@ -1114,8 +895,9 @@ describe("findMatchingRule", () => {
       modelType: "default",
     });
 
-    expect(result.rule).toBeUndefined();
-    expect(result.reason).toBeUndefined();
+    // Group didn't match, but no other conditions means match everything
+    expect(result.matches).toHaveLength(1);
+    expect(result.matches[0]?.matchReasons).toEqual([]);
   });
 
   it("should match only when item is in the correct group", async () => {
@@ -1152,7 +934,7 @@ describe("findMatchingRule", () => {
     });
     const emailAccount = getEmailAccount();
 
-    const result = await findMatchingRule({
+    const result = await findMatchingRules({
       rules,
       message,
       emailAccount,
@@ -1160,8 +942,8 @@ describe("findMatchingRule", () => {
       modelType: "default",
     });
 
-    expect(result.rule?.id).toBe(rule.id);
-    expect(result.reason).toContain("test@example.com");
+    expect(result.matches[0]?.rule.id).toBe(rule.id);
+    expect(result.reasoning).toContain("test@example.com");
   });
 
   it("should handle multiple rules with different group conditions correctly", async () => {
@@ -1199,7 +981,7 @@ describe("findMatchingRule", () => {
     });
     const emailAccount = getEmailAccount();
 
-    const result = await findMatchingRule({
+    const result = await findMatchingRules({
       rules,
       message,
       emailAccount,
@@ -1208,8 +990,8 @@ describe("findMatchingRule", () => {
     });
 
     // Should match the first rule only
-    expect(result.rule?.id).toBe("rule1");
-    expect(result.reason).toContain("test@example.com");
+    expect(result.matches[0]?.rule.id).toBe("rule1");
+    expect(result.reasoning).toContain("test@example.com");
   });
 
   it("should exclude a rule when an exclusion pattern matches", async () => {
@@ -1240,7 +1022,7 @@ describe("findMatchingRule", () => {
     });
     const emailAccount = getEmailAccount();
 
-    const result = await findMatchingRule({
+    const result = await findMatchingRules({
       rules,
       message,
       emailAccount,
@@ -1249,8 +1031,142 @@ describe("findMatchingRule", () => {
     });
 
     // The rule should be excluded (not matched)
-    expect(result.rule).toBeUndefined();
-    expect(result.reason).toBeUndefined();
+    expect(result.matches).toHaveLength(0);
+    expect(result.reasoning).toBe("");
+  });
+
+  it("should match via static condition when group rule doesn't match pattern (OR operator)", async () => {
+    const rule = getRule({
+      id: "group-with-fallback",
+      groupId: "test-group",
+      from: "fallback@example.com", // Static condition
+      conditionalOperator: LogicalOperator.OR,
+    });
+
+    // Group has different pattern
+    prisma.group.findMany.mockResolvedValue([
+      getGroup({
+        id: "test-group",
+        items: [
+          getGroupItem({
+            type: GroupItemType.FROM,
+            value: "group@example.com",
+          }),
+        ],
+        rule,
+      }),
+    ]);
+
+    const rules = [rule];
+    const message = getMessage({
+      headers: getHeaders({ from: "fallback@example.com" }), // Matches static, not group
+    });
+    const emailAccount = getEmailAccount();
+
+    const result = await findMatchingRules({
+      rules,
+      message,
+      emailAccount,
+      provider,
+      modelType: "default",
+    });
+
+    expect(result.matches[0]?.rule.id).toBe(rule.id);
+    expect(result.matches[0]?.matchReasons).toEqual([
+      { type: ConditionType.STATIC },
+    ]);
+  });
+
+  it("should match via static when group rule has group miss and static hit (AND operator)", async () => {
+    const rule = getRule({
+      id: "group-with-and",
+      groupId: "test-group",
+      from: "test@example.com", // Static condition
+      conditionalOperator: LogicalOperator.AND, // Only applies to AI/Static, not groups
+    });
+
+    // Group has different pattern
+    prisma.group.findMany.mockResolvedValue([
+      getGroup({
+        id: "test-group",
+        items: [
+          getGroupItem({
+            type: GroupItemType.FROM,
+            value: "group@example.com",
+          }),
+        ],
+        rule,
+      }),
+    ]);
+
+    const rules = [rule];
+    const message = getMessage({
+      headers: getHeaders({ from: "test@example.com" }), // Matches static, not group
+    });
+    const emailAccount = getEmailAccount();
+
+    const result = await findMatchingRules({
+      rules,
+      message,
+      emailAccount,
+      provider,
+      modelType: "default",
+    });
+
+    // Groups are independent of AND/OR operator - static match should work
+    expect(result.matches[0]?.rule.id).toBe(rule.id);
+    expect(result.matches[0]?.matchReasons).toEqual([
+      { type: ConditionType.STATIC },
+    ]);
+  });
+
+  it("should match when group rule with AND operator has both group and static match", async () => {
+    const rule = getRule({
+      id: "group-with-and-both",
+      groupId: "test-group",
+      subject: "Important", // Additional static condition
+      conditionalOperator: LogicalOperator.AND,
+    });
+
+    prisma.group.findMany.mockResolvedValue([
+      getGroup({
+        id: "test-group",
+        items: [
+          getGroupItem({ type: GroupItemType.FROM, value: "test@example.com" }),
+        ],
+        rule,
+      }),
+    ]);
+
+    const rules = [rule];
+    const message = getMessage({
+      headers: getHeaders({
+        from: "test@example.com", // Matches group
+        subject: "Important update", // Matches static
+      }),
+    });
+    const emailAccount = getEmailAccount();
+
+    const result = await findMatchingRules({
+      rules,
+      message,
+      emailAccount,
+      provider,
+      modelType: "default",
+    });
+
+    // Should match via learned pattern and short-circuit (not check static)
+    expect(result.matches[0]?.rule.id).toBe(rule.id);
+    expect(result.matches[0]?.matchReasons).toEqual([
+      {
+        type: ConditionType.LEARNED_PATTERN,
+        groupItem: expect.objectContaining({
+          type: GroupItemType.FROM,
+          value: "test@example.com",
+        }),
+        group: expect.objectContaining({ id: "test-group" }),
+      },
+    ]);
   });
 
   it("should match learned pattern when email has display name format", async () => {
@@ -1287,7 +1203,7 @@ describe("findMatchingRule", () => {
     });
     const emailAccount = getEmailAccount();
 
-    const result = await findMatchingRule({
+    const result = await findMatchingRules({
       rules,
       message,
       emailAccount,
@@ -1296,8 +1212,8 @@ describe("findMatchingRule", () => {
     });
 
     // Should match despite the display name format, due to the group rule
-    expect(result.rule?.id).toBe(rule.id);
-    expect(result.reason).toBe(
+    expect(result.matches[0]?.rule.id).toBe(rule.id);
+    expect(result.reasoning).toBe(
       `Matched learned pattern: "FROM: central@example.com"`,
     );
     expect(aiChooseRule).not.toHaveBeenCalled();
@@ -1325,7 +1241,7 @@ describe("filterToReplyPreset", () => {
       headers: getHeaders({ from: "noreply@company.com" }),
     });
 
-    const result = await filterToReplyPreset(
+    const result = await filterConversationStatusRules(
       potentialMatches,
       message,
       provider,
@@ -1355,7 +1271,7 @@ describe("filterToReplyPreset", () => {
       headers: getHeaders({ from: "user@example.com" }),
     });
 
-    const result = await filterToReplyPreset(
+    const result = await filterConversationStatusRules(
       potentialMatches,
       message,
       provider,
@@ -1399,7 +1315,7 @@ describe("filterToReplyPreset", () => {
       headers: getHeaders({ from: "sender@example.com" }),
     });
 
-    const result = await filterToReplyPreset(
+    const result = await filterConversationStatusRules(
       potentialMatches,
       message,
       provider,
@@ -1447,7 +1363,7 @@ describe("filterToReplyPreset", () => {
       headers: getHeaders({ from: "friend@example.com" }),
     });
 
-    const result = await filterToReplyPreset(
+    const result = await filterConversationStatusRules(
       potentialMatches,
       message,
       provider,
@@ -1484,7 +1400,7 @@ describe("filterToReplyPreset", () => {
       headers: getHeaders({ from: "newcontact@example.com" }),
     });
 
-    const result = await filterToReplyPreset(
+    const result = await filterConversationStatusRules(
       potentialMatches,
       message,
       provider,
@@ -1517,7 +1433,7 @@ describe("filterToReplyPreset", () => {
         headers: getHeaders({ from: email }),
       });
 
-      const result = await filterToReplyPreset(
+      const result = await filterConversationStatusRules(
         [toReplyRule],
         message,
         provider,
@@ -1550,7 +1466,7 @@ describe("filterToReplyPreset", () => {
       headers: getHeaders({ from: "user@example.com" }),
     });
 
-    const result = await filterToReplyPreset(
+    const result = await filterConversationStatusRules(
       potentialMatches,
       message,
       provider,
@@ -1575,7 +1491,7 @@ describe("filterToReplyPreset", () => {
       headers: getHeaders({ from: "" }),
     });
 
-    const result = await filterToReplyPreset(
+    const result = await filterConversationStatusRules(
       potentialMatches,
       message,
       provider,
@@ -1587,19 +1503,15 @@ describe("filterToReplyPreset", () => {
   });
 });
 
-function getRule(
-  overrides: Partial<RuleWithActionsAndCategories> = {},
-): RuleWithActionsAndCategories {
+function getRule(overrides: Partial<RuleWithActions> = {}): RuleWithActions {
   return {
     id: "r123",
     userId: "userId",
     runOnThreads: true,
     conditionalOperator: LogicalOperator.AND,
-    categoryFilters: [],
-    categoryFilterType: CategoryFilterType.INCLUDE,
     type: null,
     ...overrides,
-  } as RuleWithActionsAndCategories;
+  } as RuleWithActions;
 }
 
 function getHeaders(
@@ -1621,18 +1533,6 @@ function getMessage(overrides: Partial<ParsedMessage> = {}): ParsedMessage {
   return message as ParsedMessage;
 }
 
-function getCategory(overrides: Partial<Category> = {}): Category {
-  return {
-    id: "category1",
-    name: "category",
-    createdAt: new Date(),
-    updatedAt: new Date(),
-    emailAccountId: "emailAccountId",
-    description: null,
-    ...overrides,
-  };
-}
-
 function getGroup(
   overrides: Partial<
     Prisma.GroupGetPayload<{ include: { items: true; rule: true } }>
@@ -1664,23 +1564,138 @@ function getGroupItem(overrides: Partial<GroupItem> = {}): GroupItem {
   };
 }
 
-function getNewsletter(overrides: Partial<Newsletter> = {}): Newsletter {
-  return {
-    id: "newsletter1",
-    createdAt: new Date(),
-    updatedAt: new Date(),
-    userId: "userId",
-    email: "test@example.com",
-    status: null,
-    categoryId: "category1",
-    ...overrides,
-  } as Newsletter;
-}
+describe("evaluateRuleConditions", () => {
+  it("should match STATIC condition", () => {
+    const rule = getRule({ from: "test@example.com" });
+    const message = getMessage({
+      headers: getHeaders({ from: "test@example.com" }),
+    });
+
+    const result = evaluateRuleConditions({ rule, message });
+
+    expect(result.matched).toBe(true);
+    expect(result.potentialAiMatch).toBe(false);
+    expect(result.matchReasons).toEqual([{ type: ConditionType.STATIC }]);
+  });
+
+  it("should not match when STATIC condition fails", () => {
+    const rule = getRule({ from: "test@example.com" });
+    const message = getMessage({
+      headers: getHeaders({ from: "other@example.com" }),
+    });
+
+    const result = evaluateRuleConditions({ rule, message });
+
+    expect(result.matched).toBe(false);
+    expect(result.potentialAiMatch).toBe(false);
+    expect(result.matchReasons).toEqual([]);
+  });
+
+  it("should return potentialAiMatch for AI-only rule", () => {
+    const rule = getRule({
+      instructions: "Some AI instructions",
+      from: null,
+      to: null,
+      subject: null,
+      body: null,
+    });
+    const message = getMessage();
+
+    const result = evaluateRuleConditions({ rule, message });
+
+    expect(result.matched).toBe(false);
+    expect(result.potentialAiMatch).toBe(true);
+    expect(result.matchReasons).toEqual([]);
+  });
+
+  it("OR: should match immediately with STATIC, ignoring AI", () => {
+    const rule = getRule({
+      conditionalOperator: LogicalOperator.OR,
+      from: "test@example.com",
+      instructions: "Some AI instructions",
+    });
+    const message = getMessage({
+      headers: getHeaders({ from: "test@example.com" }),
+    });
+
+    const result = evaluateRuleConditions({ rule, message });
+
+    expect(result.matched).toBe(true);
+    expect(result.potentialAiMatch).toBe(false);
+    expect(result.matchReasons).toEqual([{ type: ConditionType.STATIC }]);
+  });
+
+  it("OR: should return potentialAiMatch when STATIC fails but has AI", () => {
+    const rule = getRule({
+      conditionalOperator: LogicalOperator.OR,
+      from: "test@example.com",
+      instructions: "Some AI instructions",
+    });
+    const message = getMessage({
+      headers: getHeaders({ from: "other@example.com" }),
+    });
+
+    const result = evaluateRuleConditions({ rule, message });
+
+    expect(result.matched).toBe(false);
+    expect(result.potentialAiMatch).toBe(true);
+    expect(result.matchReasons).toEqual([]);
+  });
+
+  it("AND: should return potentialAiMatch when STATIC passes and has AI", () => {
+    const rule = getRule({
+      conditionalOperator: LogicalOperator.AND,
+      from: "test@example.com",
+      instructions: "Some AI instructions",
+    });
+    const message = getMessage({
+      headers: getHeaders({ from: "test@example.com" }),
+    });
+
+    const result = evaluateRuleConditions({ rule, message });
+
+    expect(result.matched).toBe(false);
+    expect(result.potentialAiMatch).toBe(true);
+    expect(result.matchReasons).toEqual([{ type: ConditionType.STATIC }]);
+  });
+
+  it("AND: should not match when STATIC fails even with AI", () => {
+    const rule = getRule({
+      conditionalOperator: LogicalOperator.AND,
+      from: "test@example.com",
+      instructions: "Some AI instructions",
+    });
+    const message = getMessage({
+      headers: getHeaders({ from: "other@example.com" }),
+    });
+
+    const result = evaluateRuleConditions({ rule, message });
+
+    expect(result.matched).toBe(false);
+    expect(result.potentialAiMatch).toBe(false);
+    expect(result.matchReasons).toEqual([]);
+  });
+
+  it("should match when no conditions are present", () => {
+    const rule = getRule({
+      from: null,
+      to: null,
+      subject: null,
+      body: null,
+      instructions: null,
+    });
+    const message = getMessage();
+
+    const result = evaluateRuleConditions({ rule, message });
+
+    expect(result.matched).toBe(true);
+    expect(result.potentialAiMatch).toBe(false);
+    expect(result.matchReasons).toEqual([]);
+  });
+});
 
 function getStaticRule(
-  rule: Partial<
-    Pick<RuleWithActionsAndCategories, "from" | "to" | "subject" | "body">
-  >,
+  rule: Partial<Pick<RuleWithActions, "from" | "to" | "subject" | "body">>,
 ) {
   return {
     from: null,
diff --git a/apps/web/utils/ai/choose-rule/match-rules.ts b/apps/web/utils/ai/choose-rule/match-rules.ts
index 7e4a5f26ba..e8191e0ffa 100644
--- a/apps/web/utils/ai/choose-rule/match-rules.ts
+++ b/apps/web/utils/ai/choose-rule/match-rules.ts
@@ -92,6 +92,26 @@ export async function findMatchingRules({
   return results;
 }
 
+/**
+ * Finds all rules that potentially match a message.
+ *
+ * Matching Logic:
+ * 1. For rules with learned patterns (groups):
+ *    - If pattern matches → add to matches and short-circuit (skip other checks for this rule)
+ *    - If pattern doesn't match → continue to check static/AI conditions below
+ *    - Note: Groups are independent of the AND/OR operator (which only applies to AI/Static conditions)
+ *
+ * 2. For all other rules (or group rules that didn't match via pattern):
+ *    - Check static conditions (from, to, subject, body)
+ *    - Check if AI instructions are present
+ *    - Respect the conditional operator (AND/OR) between static and AI conditions
+ *    - Add to matches if conditions match, or to potentialAiMatches if AI check is needed
+ *
+ * 3. Prioritization (at the end):
+ *    - If ANY learned pattern matches were found → ignore all potentialAiMatches
+ *    - This is an optimization: learned patterns are trusted and avoid expensive AI calls
+ *    - Multiple learned pattern matches can be returned
+ */
 async function findPotentialMatchingRules({
   rules,
   message,
@@ -105,14 +125,13 @@ async function findPotentialMatchingRules({
 }): Promise<MatchingRuleResult> {
   const matches: {
     rule: RuleWithActions;
-    matchReasons: MatchReason[]; // why do we need match reasons?
+    matchReasons: MatchReason[];
   }[] = [];
   const potentialAiMatches: (RuleWithActions & { instructions: string })[] = [];
 
   const learnedPatternsLoader = new LearnedPatternsLoader();
 
-  // Go through all rules
-  // Collect matches and potential AI matches
+  // Go through all rules and collect matches and potential AI matches
   for (const rule of rules) {
     // Special case for calendar rules
     const calendarMatch =
@@ -131,30 +150,33 @@ async function findPotentialMatchingRules({
     if (isThread && !rule.runOnThreads) continue;
 
     // Learned patterns (groups)
-    // Ignores conditional operator
+    // Note: Groups are independent of the AND/OR operator (which only applies to AI/Static conditions)
     if (rule.groupId) {
       const groups = await learnedPatternsLoader.getGroups(rule.emailAccountId);
-      if (!groups?.length) continue;
-      const { matchingItem, group, ruleExcluded } = matchesGroupRule(
-        rule,
-        groups,
-        message,
-      );
-
-      // If this rule is excluded by an exclusion pattern, skip it entirely
-      if (ruleExcluded) continue;
-
-      if (matchingItem) {
-        matches.push({
+      if (groups?.length) {
+        const { matchingItem, group, ruleExcluded } = matchesGroupRule(
           rule,
-          matchReasons: [
-            {
-              type: ConditionType.LEARNED_PATTERN,
-              groupItem: matchingItem,
-              group,
-            },
-          ],
-        });
+          groups,
+          message,
+        );
+
+        // If this rule is excluded by an exclusion pattern, skip it entirely
+        if (ruleExcluded) continue;
+
+        if (matchingItem) {
+          // Group matched - add to matches and skip other condition checks
+          matches.push({
+            rule,
+            matchReasons: [
+              {
+                type: ConditionType.LEARNED_PATTERN,
+                groupItem: matchingItem,
+                group,
+              },
+            ],
+          });
+          continue;
+        }
       }
     }
 
@@ -197,7 +219,7 @@ async function findPotentialMatchingRules({
   };
 }
 
-function evaluateRuleConditions({
+export function evaluateRuleConditions({
   rule,
   message,
 }: {
@@ -234,8 +256,9 @@ function evaluateRuleConditions({
       // No static match, but have AI - need to check AI
       return { matched: false, potentialAiMatch: true, matchReasons };
     }
-    // No matches at all
-    return { matched: false, potentialAiMatch: false, matchReasons };
+    // No conditions at all (match everything) or no matches
+    const matched = !hasStaticCondition && !hasAiCondition;
+    return { matched, potentialAiMatch: false, matchReasons };
   } else {
     // AND logic
     if (hasStaticCondition && !staticMatch) {
@@ -246,8 +269,9 @@ function evaluateRuleConditions({
       // Static passed (or doesn't exist), but need AI to complete AND
       return { matched: false, potentialAiMatch: true, matchReasons };
     }
-    // Only static, and it passed
-    return { matched: staticMatch, potentialAiMatch: false, matchReasons };
+    // Only static (and it passed), or no conditions at all (match everything)
+    const matched = hasStaticCondition ? staticMatch : true;
+    return { matched, potentialAiMatch: false, matchReasons };
   }
 }
 
@@ -314,7 +338,8 @@ async function findMatchingRulesWithReasons(
     return {
       matches,
       reasoning: matches
-        .flatMap((m) => getMatchReason(m.matchReasons))
+        .map((m) => getMatchReason(m.matchReasons))
+        .filter((r): r is string => !!r)
         .join(", "),
     };
   }

From cd3713d488458bfdb9b894899a94acbb8174fa3e Mon Sep 17 00:00:00 2001
From: Eliezer Steinbock <3090527+elie222@users.noreply.github.com>
Date: Mon, 20 Oct 2025 06:51:30 +0300
Subject: [PATCH 14/40] increase test coverage for match rules

---
 apps/web/package.json                         |   1 +
 .../utils/ai/choose-rule/match-rules.test.ts  | 232 ++++++++++++++++++
 pnpm-lock.yaml                                | 129 ++++++++++
 3 files changed, 362 insertions(+)

diff --git a/apps/web/package.json b/apps/web/package.json
index 44e9751ca8..d0d3903638 100644
--- a/apps/web/package.json
+++ b/apps/web/package.json
@@ -182,6 +182,7 @@
     "@types/react-dom": "19.1.9",
     "@types/react-syntax-highlighter": "15.5.13",
     "@types/string-similarity": "4.0.2",
+    "@vitest/coverage-v8": "3.2.4",
     "@vitest/ui": "3.2.4",
     "autoprefixer": "10.4.21",
     "cross-env": "7.0.3",
diff --git a/apps/web/utils/ai/choose-rule/match-rules.test.ts b/apps/web/utils/ai/choose-rule/match-rules.test.ts
index 3171b9e1e9..a318bacc56 100644
--- a/apps/web/utils/ai/choose-rule/match-rules.test.ts
+++ b/apps/web/utils/ai/choose-rule/match-rules.test.ts
@@ -1564,6 +1564,221 @@ function getGroupItem(overrides: Partial<GroupItem> = {}): GroupItem {
   };
 }
 
+describe("findMatchingRules - Integration Tests", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("should match calendar rule when message has .ics attachment", async () => {
+    const calendarRule = getRule({
+      id: "calendar-rule",
+      systemType: SystemType.CALENDAR,
+    });
+
+    const rules = [calendarRule];
+    const message = getMessage({
+      headers: getHeaders(),
+      attachments: [
+        {
+          filename: "meeting.ics",
+          mimeType: "text/calendar",
+          size: 1024,
+          attachmentId: "attachment-1",
+          headers: {
+            "content-type": "text/calendar",
+            "content-description": "",
+            "content-transfer-encoding": "",
+            "content-id": "",
+          },
+        },
+      ],
+    });
+    const emailAccount = getEmailAccount();
+
+    const result = await findMatchingRules({
+      rules,
+      message,
+      emailAccount,
+      provider,
+      modelType: "default",
+    });
+
+    expect(result.matches[0]?.rule.id).toBe("calendar-rule");
+    expect(result.matches[0]?.matchReasons).toEqual([
+      { type: ConditionType.PRESET, systemType: SystemType.CALENDAR },
+    ]);
+  });
+
+  it("should execute AI rules when potentialAiMatches exist", async () => {
+    const aiRule = getRule({
+      id: "ai-rule",
+      instructions: "Archive promotional emails",
+      from: null,
+      to: null,
+      subject: null,
+      body: null,
+    });
+
+    vi.mocked(aiChooseRule).mockResolvedValue({
+      rules: [aiRule as any],
+      reason: "This is a promotional email",
+    });
+
+    const rules = [aiRule];
+    const message = getMessage();
+    const emailAccount = getEmailAccount();
+
+    const result = await findMatchingRules({
+      rules,
+      message,
+      emailAccount,
+      provider,
+      modelType: "default",
+    });
+
+    expect(aiChooseRule).toHaveBeenCalledWith(
+      expect.objectContaining({
+        email: expect.any(Object),
+        emailAccount,
+        modelType: "default",
+        rules: expect.arrayContaining([
+          expect.objectContaining({
+            id: "ai-rule",
+            instructions: "Archive promotional emails",
+          }),
+        ]),
+      }),
+    );
+
+    expect(result.matches[0]?.rule.id).toBe("ai-rule");
+    expect(result.matches[0]?.matchReasons).toEqual([
+      { type: ConditionType.AI },
+    ]);
+    expect(result.reasoning).toBe("This is a promotional email");
+  });
+
+  it("should prioritize learned patterns over AI rules", async () => {
+    const learnedPatternRule = getRule({
+      id: "learned-rule",
+      groupId: "group1",
+    });
+
+    const aiRule = getRule({
+      id: "ai-rule",
+      instructions: "Some AI instructions",
+    });
+
+    prisma.group.findMany.mockResolvedValue([
+      getGroup({
+        id: "group1",
+        items: [
+          getGroupItem({ type: GroupItemType.FROM, value: "test@example.com" }),
+        ],
+        rule: learnedPatternRule,
+      }),
+    ]);
+
+    const rules = [learnedPatternRule, aiRule];
+    const message = getMessage({
+      headers: getHeaders({ from: "test@example.com" }),
+    });
+    const emailAccount = getEmailAccount();
+
+    const result = await findMatchingRules({
+      rules,
+      message,
+      emailAccount,
+      provider,
+      modelType: "default",
+    });
+
+    // Should match via learned pattern
+    expect(result.matches[0]?.rule.id).toBe("learned-rule");
+    expect(result.matches[0]?.matchReasons?.[0]?.type).toBe(
+      ConditionType.LEARNED_PATTERN,
+    );
+
+    // AI should NOT be called because learned pattern matched
+    expect(aiChooseRule).not.toHaveBeenCalled();
+  });
+
+  it("should skip rules with runOnThreads=false when message is a thread", async () => {
+    const threadRule = getRule({
+      id: "thread-rule",
+      from: "test@example.com",
+      runOnThreads: false,
+    });
+
+    // Mock provider to return true for isReplyInThread
+    const threadProvider = {
+      isReplyInThread: vi.fn().mockReturnValue(true),
+    } as unknown as EmailProvider;
+
+    const rules = [threadRule];
+    const message = getMessage({
+      headers: getHeaders({ from: "test@example.com" }),
+    });
+    const emailAccount = getEmailAccount();
+
+    const result = await findMatchingRules({
+      rules,
+      message,
+      emailAccount,
+      provider: threadProvider,
+      modelType: "default",
+    });
+
+    // Rule should not match because it's a thread and runOnThreads=false
+    expect(result.matches).toHaveLength(0);
+  });
+
+  it("should handle invalid regex patterns gracefully", () => {
+    const rule = getRule({
+      from: "[invalid(regex",
+    });
+
+    const message = getMessage({
+      headers: getHeaders({ from: "test@example.com" }),
+    });
+
+    // Should not throw, just return false
+    const result = matchesStaticRule(rule, message);
+    expect(result).toBe(false);
+  });
+
+  it("should combine static match with AI potentialMatch correctly", async () => {
+    const mixedRule = getRule({
+      id: "mixed-rule",
+      from: "test@example.com",
+      instructions: "Archive if promotional",
+      conditionalOperator: LogicalOperator.AND,
+    });
+
+    vi.mocked(aiChooseRule).mockResolvedValue({
+      rules: [mixedRule as any],
+      reason: "Email is promotional",
+    });
+
+    const rules = [mixedRule];
+    const message = getMessage({
+      headers: getHeaders({ from: "test@example.com" }),
+    });
+    const emailAccount = getEmailAccount();
+
+    const result = await findMatchingRules({
+      rules,
+      message,
+      emailAccount,
+      provider,
+      modelType: "default",
+    });
+
+    // Static matched, so should be sent to AI for AND check
+    expect(aiChooseRule).toHaveBeenCalled();
+    expect(result.matches[0]?.rule.id).toBe("mixed-rule");
+  });
+});
+
 describe("evaluateRuleConditions", () => {
   it("should match STATIC condition", () => {
     const rule = getRule({ from: "test@example.com" });
@@ -1692,6 +1907,23 @@ describe("evaluateRuleConditions", () => {
     expect(result.potentialAiMatch).toBe(false);
     expect(result.matchReasons).toEqual([]);
   });
+
+  it("OR: should not match when STATIC fails and no AI condition", () => {
+    const rule = getRule({
+      conditionalOperator: LogicalOperator.OR,
+      from: "test@example.com",
+      instructions: null,
+    });
+    const message = getMessage({
+      headers: getHeaders({ from: "other@example.com" }),
+    });
+
+    const result = evaluateRuleConditions({ rule, message });
+
+    expect(result.matched).toBe(false);
+    expect(result.potentialAiMatch).toBe(false);
+    expect(result.matchReasons).toEqual([]);
+  });
 });
 
 function getStaticRule(
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index a34a333ad7..90f562d87b 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -592,6 +592,9 @@ importers:
       '@types/string-similarity':
         specifier: 4.0.2
         version: 4.0.2
+      '@vitest/coverage-v8':
+        specifier: 3.2.4
+        version: 3.2.4(vitest@3.2.4)
       '@vitest/ui':
         specifier: 3.2.4
         version: 3.2.4(vitest@3.2.4)
@@ -1517,6 +1520,10 @@ packages:
     resolution: {integrity: sha512-ruv7Ae4J5dUYULmeXw1gmb7rYRz57OWCPM57pHojnLq/3Z1CK2lNSLTCVjxVk1F/TZHwOZZrOWi0ur95BbLxNQ==}
     engines: {node: '>=6.9.0'}
 
+  '@bcoe/v8-coverage@1.0.2':
+    resolution: {integrity: sha512-6zABk/ECA/QYSCQ1NGiVwwbQerUCZ+TQbp64Q3AgmfNvurHH0j8TtXa1qbShXA6qqkpAj4V5W8pP6mLe1mcMqA==}
+    engines: {node: '>=18'}
+
   '@better-auth/sso@1.3.7':
     resolution: {integrity: sha512-MTwBiNash7HN0nLtQiL1tvYgWBn6GjYj6EYvtrQeb0/+UW0tjBDgsl39ojiFFSWGuT0gxPv+ij8tQNaFmQ1+2g==}
     peerDependencies:
@@ -2253,6 +2260,10 @@ packages:
     resolution: {integrity: sha512-wgm9Ehl2jpeqP3zw/7mo3kRHFp5MEDhqAdwy1fTGkHAwnkGOVsgpvQhL8B5n1qlb01jV3n/bI0ZfZp5lWA1k4w==}
     engines: {node: '>=18.0.0'}
 
+  '@istanbuljs/schema@0.1.3':
+    resolution: {integrity: sha512-ZXRY4jNvVgSVQ8DL3LTcakaAtXwTVUxE81hslsyD2AtoXW/wVob10HkOJ1X/pAlcI7D+2YoZKg5do8G/w6RYgA==}
+    engines: {node: '>=8'}
+
   '@jridgewell/gen-mapping@0.3.13':
     resolution: {integrity: sha512-2kkt/7niJ6MgEPxF0bYdQ6etZaA+fQvDcLKckhy1yIQOzaoKjBBjSj63/aLVjYE3qhRt5dvM+uUyfCg6UKCBbA==}
 
@@ -2272,6 +2283,9 @@ packages:
   '@jridgewell/trace-mapping@0.3.30':
     resolution: {integrity: sha512-GQ7Nw5G2lTu/BtHTKfXhKHok2WGetd4XYcVKGx00SjAk8GMwgJM3zr6zORiPGuOE+/vkc90KtTosSSvaCjKb2Q==}
 
+  '@jridgewell/trace-mapping@0.3.31':
+    resolution: {integrity: sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw==}
+
   '@jridgewell/trace-mapping@0.3.9':
     resolution: {integrity: sha512-3Belt6tdc8bPgAtbcmdtNJlirVoTmEb5e2gC94PnkwEW9jI6CAHUeoG85tjWP5WquqfavoMtMwiG4P926ZKKuQ==}
 
@@ -4954,6 +4968,15 @@ packages:
     peerDependencies:
       vite: ^4.2.0 || ^5.0.0 || ^6.0.0 || ^7.0.0
 
+  '@vitest/coverage-v8@3.2.4':
+    resolution: {integrity: sha512-EyF9SXU6kS5Ku/U82E259WSnvg6c8KTjppUncuNdm5QHpe17mwREHnjDzozC8x9MZ0xfBUFSaLkRv4TMA75ALQ==}
+    peerDependencies:
+      '@vitest/browser': 3.2.4
+      vitest: 3.2.4
+    peerDependenciesMeta:
+      '@vitest/browser':
+        optional: true
+
   '@vitest/expect@3.2.4':
     resolution: {integrity: sha512-Io0yyORnB6sikFlt8QW5K7slY4OjqNX9jmJQ02QDda8lyM6B5oNgVWoSoKPac8/kgnCUzuHQKrSLtu/uOqqrig==}
 
@@ -5298,6 +5321,9 @@ packages:
     resolution: {integrity: sha512-x1FCFnFifvYDDzTaLII71vG5uvDwgtmDTEVWAxrgeiR8VjMONcCXJx7E+USjDtHlwFmt9MysbqgF9b9Vjr6w+w==}
     engines: {node: '>=4'}
 
+  ast-v8-to-istanbul@0.3.7:
+    resolution: {integrity: sha512-kr1Hy6YRZBkGQSb6puP+D6FQ59Cx4m0siYhAxygMCAgadiWQ6oxAxQXHOMvJx67SJ63jRoVIIg5eXzUbbct1ww==}
+
   astring@1.9.0:
     resolution: {integrity: sha512-LElXdjswlqjWrPpJFg1Fx4wpkOCxj1TDHlSV4PlaRxHGWko024xICaa97ZkMfs6DRKlCguiAI+rbXv5GWwXIkg==}
     hasBin: true
@@ -7214,6 +7240,9 @@ packages:
     resolution: {integrity: sha512-Y22oTqIU4uuPgEemfz7NDJz6OeKf12Lsu+QC+s3BVpda64lTiMYCyGwg5ki4vFxkMwQdeZDl2adZoqUgdFuTgQ==}
     engines: {node: '>=18'}
 
+  html-escaper@2.0.2:
+    resolution: {integrity: sha512-H2iMtd0I4Mt5eYiapRdIDjp+XzelXQ0tFE4JS7YFwFevXXMmOp9myNrUvCg0D6ws8iqkRPBfKHgbwig1SmlLfg==}
+
   html-parse-stringify@3.0.1:
     resolution: {integrity: sha512-KknJ50kTInJ7qIScF3jeaFRpMpE8/lfiTdzf/twXyPBLAGrLRTmkz3AdTnKeh40X8k9L2fdYwEp/42WGXIRGcg==}
 
@@ -7569,6 +7598,22 @@ packages:
     resolution: {integrity: sha512-nZmoK4wKdzPs5USq4JHBiimjdKSVAOm2T1KyDoadtMPNXYHxiENd19ou4iU/V4juFM6LVgYQnpxCYmxqNP4Obw==}
     engines: {node: '>=18'}
 
+  istanbul-lib-coverage@3.2.2:
+    resolution: {integrity: sha512-O8dpsF+r0WV/8MNRKfnmrtCWhuKjxrq2w+jpzBL5UZKTi2LeVWnWOmWRxFlesJONmc+wLAGvKQZEOanko0LFTg==}
+    engines: {node: '>=8'}
+
+  istanbul-lib-report@3.0.1:
+    resolution: {integrity: sha512-GCfE1mtsHGOELCU8e/Z7YWzpmybrx/+dSTfLrvY8qRmaY6zXTKWn6WQIjaAFw069icm6GVMNkgu0NzI4iPZUNw==}
+    engines: {node: '>=10'}
+
+  istanbul-lib-source-maps@5.0.6:
+    resolution: {integrity: sha512-yg2d+Em4KizZC5niWhQaIomgf5WlL4vOOjZ5xGCmF8SnPE/mDWWXgvRExdcpCgh9lLRRa1/fSYp2ymmbJ1pI+A==}
+    engines: {node: '>=10'}
+
+  istanbul-reports@3.2.0:
+    resolution: {integrity: sha512-HGYWWS/ehqTV3xN10i23tkPkpH46MLCIMFNCaaKNavAXTF1RkqxawEPtnjnGZ6XKSInBKkiOA5BKS+aZiY3AvA==}
+    engines: {node: '>=8'}
+
   jackspeak@3.4.3:
     resolution: {integrity: sha512-OGlZQpz2yfahA/Rd1Y8Cd9SIEsqvXkLVoSw/cgwhnhFMDbsQFeZYoJJ7bIZBS9BcamUW96asq/npPWugM+RQBw==}
 
@@ -7954,6 +7999,9 @@ packages:
     resolution: {integrity: sha512-ISQTe55T2ao7XtlAStud6qwYPZjE4GK1S/BeVPus4jrq6JuOnQ00YKQC581RWhR122W7msZV263KzVeLoqidyQ==}
     engines: {node: '>=12'}
 
+  magicast@0.3.5:
+    resolution: {integrity: sha512-L0WhttDl+2BOsybvEOLK7fW3UA0OQ0IQ2d6Zl2x/a6vVRs3bAY0ECOSHHeL5jD+SbOpOCUEi0y1DgHEn9Qn1AQ==}
+
   make-dir@1.3.0:
     resolution: {integrity: sha512-2w31R7SJtieJJnQtGc7RVL2StM2vGYVfqUOvUDxH6bC6aJTxPxTF0GnIgCyu7tjockiUWAYQRbxa7vKn34s5sQ==}
     engines: {node: '>=4'}
@@ -7966,6 +8014,10 @@ packages:
     resolution: {integrity: sha512-g3FeP20LNwhALb/6Cz6Dd4F2ngze0jz7tbzrD2wAV+o9FeNHe4rL+yK2md0J/fiSf1sa1ADhXqi5+oVwOM/eGw==}
     engines: {node: '>=8'}
 
+  make-dir@4.0.0:
+    resolution: {integrity: sha512-hXdUTZYIVOt1Ex//jAQi+wTZZpUpwBj/0QsOzqegb3rGMMeJiSEu5xLHnYfBrRV4RH2+OCSOO95Is/7x1WJ4bw==}
+    engines: {node: '>=10'}
+
   make-error@1.3.6:
     resolution: {integrity: sha512-s8UhlNe7vPKomQhC1qFelMokr/Sc3AgNbso3n74mVPA5LTZwkB9NlXf4XPamLxJE8h0gh73rM94xvwRT2CVInw==}
 
@@ -10372,6 +10424,10 @@ packages:
     engines: {node: '>=10'}
     hasBin: true
 
+  test-exclude@7.0.1:
+    resolution: {integrity: sha512-pFYqmTw68LXVjeWJMST4+borgQP2AyMNbg1BpZh9LbyhUeNkeaPF9gzfPGUAnSMV3qPYdWUwDIjjCLiSDOl7vg==}
+    engines: {node: '>=18'}
+
   text-decoder@1.2.3:
     resolution: {integrity: sha512-3/o9z3X0X0fTupwsYvR03pJ/DjWuqqrfwBgTQzdWDiQSm9KitAyz/9WqsT2JQW7KV2m+bC2ol/zqpW37NHxLaA==}
 
@@ -12360,6 +12416,8 @@ snapshots:
       '@babel/helper-string-parser': 7.27.1
       '@babel/helper-validator-identifier': 7.27.1
 
+  '@bcoe/v8-coverage@1.0.2': {}
+
   '@better-auth/sso@1.3.7(react-dom@19.1.1(react@19.1.1))(react@19.1.1)(zod@3.25.46)':
     dependencies:
       '@better-fetch/fetch': 1.1.18
@@ -13045,6 +13103,8 @@ snapshots:
     dependencies:
       minipass: 7.1.2
 
+  '@istanbuljs/schema@0.1.3': {}
+
   '@jridgewell/gen-mapping@0.3.13':
     dependencies:
       '@jridgewell/sourcemap-codec': 1.5.5
@@ -13070,6 +13130,11 @@ snapshots:
       '@jridgewell/resolve-uri': 3.1.2
       '@jridgewell/sourcemap-codec': 1.5.5
 
+  '@jridgewell/trace-mapping@0.3.31':
+    dependencies:
+      '@jridgewell/resolve-uri': 3.1.2
+      '@jridgewell/sourcemap-codec': 1.5.5
+
   '@jridgewell/trace-mapping@0.3.9':
     dependencies:
       '@jridgewell/resolve-uri': 3.1.2
@@ -16273,6 +16338,25 @@ snapshots:
     transitivePeerDependencies:
       - supports-color
 
+  '@vitest/coverage-v8@3.2.4(vitest@3.2.4)':
+    dependencies:
+      '@ampproject/remapping': 2.3.0
+      '@bcoe/v8-coverage': 1.0.2
+      ast-v8-to-istanbul: 0.3.7
+      debug: 4.4.1(supports-color@8.1.1)
+      istanbul-lib-coverage: 3.2.2
+      istanbul-lib-report: 3.0.1
+      istanbul-lib-source-maps: 5.0.6
+      istanbul-reports: 3.2.0
+      magic-string: 0.30.18
+      magicast: 0.3.5
+      std-env: 3.9.0
+      test-exclude: 7.0.1
+      tinyrainbow: 2.0.0
+      vitest: 3.2.4(@types/debug@4.1.12)(@types/node@24.3.0)(@vitest/ui@3.2.4)(jiti@2.5.1)(jsdom@26.1.0)(terser@5.43.1)(tsx@4.20.5)(yaml@2.8.1)
+    transitivePeerDependencies:
+      - supports-color
+
   '@vitest/expect@3.2.4':
     dependencies:
       '@types/chai': 5.2.2
@@ -16685,6 +16769,12 @@ snapshots:
     dependencies:
       tslib: 2.8.1
 
+  ast-v8-to-istanbul@0.3.7:
+    dependencies:
+      '@jridgewell/trace-mapping': 0.3.31
+      estree-walker: 3.0.3
+      js-tokens: 9.0.1
+
   astring@1.9.0: {}
 
   async-mutex@0.5.0:
@@ -18925,6 +19015,8 @@ snapshots:
     dependencies:
       whatwg-encoding: 3.1.1
 
+  html-escaper@2.0.2: {}
+
   html-parse-stringify@3.0.1:
     dependencies:
       void-elements: 3.1.0
@@ -19269,6 +19361,27 @@ snapshots:
       - supports-color
       - utf-8-validate
 
+  istanbul-lib-coverage@3.2.2: {}
+
+  istanbul-lib-report@3.0.1:
+    dependencies:
+      istanbul-lib-coverage: 3.2.2
+      make-dir: 4.0.0
+      supports-color: 7.2.0
+
+  istanbul-lib-source-maps@5.0.6:
+    dependencies:
+      '@jridgewell/trace-mapping': 0.3.30
+      debug: 4.4.1(supports-color@8.1.1)
+      istanbul-lib-coverage: 3.2.2
+    transitivePeerDependencies:
+      - supports-color
+
+  istanbul-reports@3.2.0:
+    dependencies:
+      html-escaper: 2.0.2
+      istanbul-lib-report: 3.0.1
+
   jackspeak@3.4.3:
     dependencies:
       '@isaacs/cliui': 8.0.2
@@ -19663,6 +19776,12 @@ snapshots:
     dependencies:
       '@jridgewell/sourcemap-codec': 1.5.5
 
+  magicast@0.3.5:
+    dependencies:
+      '@babel/parser': 7.28.3
+      '@babel/types': 7.28.2
+      source-map-js: 1.2.1
+
   make-dir@1.3.0:
     dependencies:
       pify: 3.0.0
@@ -19676,6 +19795,10 @@ snapshots:
     dependencies:
       semver: 6.3.1
 
+  make-dir@4.0.0:
+    dependencies:
+      semver: 7.7.2
+
   make-error@1.3.6: {}
 
   map-obj@1.0.1: {}
@@ -22855,6 +22978,12 @@ snapshots:
       commander: 2.20.3
       source-map-support: 0.5.21
 
+  test-exclude@7.0.1:
+    dependencies:
+      '@istanbuljs/schema': 0.1.3
+      glob: 10.4.5
+      minimatch: 9.0.5
+
   text-decoder@1.2.3:
     dependencies:
       b4a: 1.6.7

From d11cc9638b630bd81df739de8d09c404606866f5 Mon Sep 17 00:00:00 2001
From: Eliezer Steinbock <3090527+elie222@users.noreply.github.com>
Date: Mon, 20 Oct 2025 07:02:47 +0300
Subject: [PATCH 15/40] more match rule tests

---
 .../assistant/rule/create/page.tsx            |   3 +-
 .../utils/ai/choose-rule/match-rules.test.ts  | 129 ++++++++++++++++++
 2 files changed, 130 insertions(+), 2 deletions(-)

diff --git a/apps/web/app/(app)/[emailAccountId]/assistant/rule/create/page.tsx b/apps/web/app/(app)/[emailAccountId]/assistant/rule/create/page.tsx
index fa36475bf4..60072bedaf 100644
--- a/apps/web/app/(app)/[emailAccountId]/assistant/rule/create/page.tsx
+++ b/apps/web/app/(app)/[emailAccountId]/assistant/rule/create/page.tsx
@@ -9,7 +9,6 @@ export default async function CreateRulePage(props: {
     example?: string;
     groupId?: string;
     type?: CoreConditionType;
-    categoryId?: string;
     label?: string;
   }>;
 }) {
@@ -33,7 +32,7 @@ export default async function CreateRulePage(props: {
                 ]
               : [],
             conditions: searchParams.type
-              ? [getEmptyCondition(searchParams.type, searchParams.categoryId)]
+              ? [getEmptyCondition(searchParams.type)]
               : [],
             runOnThreads: true,
           }
diff --git a/apps/web/utils/ai/choose-rule/match-rules.test.ts b/apps/web/utils/ai/choose-rule/match-rules.test.ts
index a318bacc56..7fffcc4441 100644
--- a/apps/web/utils/ai/choose-rule/match-rules.test.ts
+++ b/apps/web/utils/ai/choose-rule/match-rules.test.ts
@@ -22,6 +22,11 @@ import prisma from "@/utils/__mocks__/prisma";
 import { aiChooseRule } from "@/utils/ai/choose-rule/ai-choose-rule";
 import { getEmailAccount } from "@/__tests__/helpers";
 import { ConditionType } from "@/utils/config";
+import {
+  getColdEmailRule,
+  isColdEmailRuleEnabled,
+} from "@/utils/cold-email/cold-email-rule";
+import { isColdEmail } from "@/utils/cold-email/is-cold-email";
 
 // Run with:
 // pnpm test match-rules.test.ts
@@ -38,6 +43,13 @@ vi.mock("@/utils/ai/choose-rule/ai-choose-rule", () => ({
 vi.mock("@/utils/reply-tracker/check-sender-reply-history", () => ({
   checkSenderReplyHistory: vi.fn(),
 }));
+vi.mock("@/utils/cold-email/cold-email-rule", () => ({
+  getColdEmailRule: vi.fn(),
+  isColdEmailRuleEnabled: vi.fn(),
+}));
+vi.mock("@/utils/cold-email/is-cold-email", () => ({
+  isColdEmail: vi.fn(),
+}));
 
 describe("matchesStaticRule", () => {
   it("should match wildcard pattern at start of email", () => {
@@ -1569,6 +1581,122 @@ describe("findMatchingRules - Integration Tests", () => {
     vi.clearAllMocks();
   });
 
+  it("should detect and return cold email when enabled", async () => {
+    const coldEmailRule = getRule({
+      id: "cold-email-rule",
+      systemType: SystemType.COLD_EMAIL,
+    });
+
+    vi.mocked(getColdEmailRule).mockResolvedValue(coldEmailRule);
+    vi.mocked(isColdEmailRuleEnabled).mockReturnValue(true);
+    vi.mocked(isColdEmail).mockResolvedValue({
+      isColdEmail: true,
+      reason: "ai",
+    });
+    vi.mocked(prisma.rule.findUniqueOrThrow).mockResolvedValue(coldEmailRule);
+
+    const rules = [coldEmailRule];
+    const message = getMessage({
+      headers: getHeaders({ from: "coldemailer@example.com" }),
+    });
+    const emailAccount = getEmailAccount();
+
+    const result = await findMatchingRules({
+      rules,
+      message,
+      emailAccount,
+      provider,
+      modelType: "default",
+    });
+
+    expect(getColdEmailRule).toHaveBeenCalledWith(emailAccount.id);
+    expect(isColdEmailRuleEnabled).toHaveBeenCalledWith(coldEmailRule);
+    expect(isColdEmail).toHaveBeenCalledWith({
+      email: expect.any(Object),
+      emailAccount,
+      provider,
+      modelType: "default",
+      coldEmailRule,
+    });
+
+    expect(result.matches[0]?.rule.id).toBe("cold-email-rule");
+    expect(result.reasoning).toBe("ai");
+  });
+
+  it("should skip cold email detection when rule is not enabled", async () => {
+    const coldEmailRule = getRule({
+      id: "cold-email-rule",
+      systemType: SystemType.COLD_EMAIL,
+    });
+
+    const normalRule = getRule({
+      id: "normal-rule",
+      from: "test@example.com",
+    });
+
+    vi.mocked(getColdEmailRule).mockResolvedValue(coldEmailRule);
+    vi.mocked(isColdEmailRuleEnabled).mockReturnValue(false);
+
+    const rules = [coldEmailRule, normalRule];
+    const message = getMessage({
+      headers: getHeaders({ from: "test@example.com" }),
+    });
+    const emailAccount = getEmailAccount();
+
+    const result = await findMatchingRules({
+      rules,
+      message,
+      emailAccount,
+      provider,
+      modelType: "default",
+    });
+
+    expect(getColdEmailRule).toHaveBeenCalledWith(emailAccount.id);
+    expect(isColdEmailRuleEnabled).toHaveBeenCalledWith(coldEmailRule);
+    expect(isColdEmail).not.toHaveBeenCalled();
+
+    // Should match the normal rule instead
+    expect(result.matches[0]?.rule.id).toBe("normal-rule");
+  });
+
+  it("should continue to other rules when email is not cold", async () => {
+    const coldEmailRule = getRule({
+      id: "cold-email-rule",
+      systemType: SystemType.COLD_EMAIL,
+    });
+
+    const normalRule = getRule({
+      id: "normal-rule",
+      from: "test@example.com",
+    });
+
+    vi.mocked(getColdEmailRule).mockResolvedValue(coldEmailRule);
+    vi.mocked(isColdEmailRuleEnabled).mockReturnValue(true);
+    vi.mocked(isColdEmail).mockResolvedValue({
+      isColdEmail: false,
+      reason: "hasPreviousEmail",
+    });
+
+    const rules = [coldEmailRule, normalRule];
+    const message = getMessage({
+      headers: getHeaders({ from: "test@example.com" }),
+    });
+    const emailAccount = getEmailAccount();
+
+    const result = await findMatchingRules({
+      rules,
+      message,
+      emailAccount,
+      provider,
+      modelType: "default",
+    });
+
+    expect(isColdEmail).toHaveBeenCalled();
+
+    // Should continue and match the normal rule
+    expect(result.matches[0]?.rule.id).toBe("normal-rule");
+  });
+
   it("should match calendar rule when message has .ics attachment", async () => {
     const calendarRule = getRule({
       id: "calendar-rule",
@@ -1742,6 +1870,7 @@ describe("findMatchingRules - Integration Tests", () => {
     });
 
     // Should not throw, just return false
+    expect(() => matchesStaticRule(rule, message)).not.toThrow();
     const result = matchesStaticRule(rule, message);
     expect(result).toBe(false);
   });

From f4d6b617d2f93f70075da846b9c37ce4fcc15c31 Mon Sep 17 00:00:00 2001
From: Eliezer Steinbock <3090527+elie222@users.noreply.github.com>
Date: Mon, 20 Oct 2025 07:11:22 +0300
Subject: [PATCH 16/40] delete more old category code

---
 apps/web/app/api/threads/route.ts             |  3 --
 apps/web/components/CategoryBadge.tsx         | 32 -------------------
 apps/web/components/email-list/EmailList.tsx  | 23 ++-----------
 .../components/email-list/EmailListItem.tsx   |  6 +---
 apps/web/components/email-list/types.ts       |  1 -
 .../ai/assistant/process-user-request.ts      | 22 ++-----------
 .../assistant/process-assistant-email.ts      | 18 +----------
 apps/web/utils/condition.ts                   |  2 +-
 8 files changed, 8 insertions(+), 99 deletions(-)
 delete mode 100644 apps/web/components/CategoryBadge.tsx

diff --git a/apps/web/app/api/threads/route.ts b/apps/web/app/api/threads/route.ts
index e3a6a15c7a..1a56016c2b 100644
--- a/apps/web/app/api/threads/route.ts
+++ b/apps/web/app/api/threads/route.ts
@@ -3,8 +3,6 @@ import { withEmailProvider } from "@/utils/middleware";
 import { type ThreadsQuery, threadsQuery } from "@/app/api/threads/validation";
 import { isDefined } from "@/utils/types";
 import prisma from "@/utils/prisma";
-import { getCategory } from "@/utils/redis/category";
-import { ExecutedRuleStatus } from "@prisma/client";
 import { createScopedLogger } from "@/utils/logger";
 import { isIgnoredSender } from "@/utils/filter-ignored-senders";
 import type { EmailProvider } from "@/utils/email/types";
@@ -109,7 +107,6 @@ async function getThreads({
         messages: filteredMessages,
         snippet: thread.snippet,
         plan,
-        category: await getCategory({ emailAccountId, threadId: thread.id }),
       };
     }),
   );
diff --git a/apps/web/components/CategoryBadge.tsx b/apps/web/components/CategoryBadge.tsx
deleted file mode 100644
index 2a50299467..0000000000
--- a/apps/web/components/CategoryBadge.tsx
+++ /dev/null
@@ -1,32 +0,0 @@
-import { Badge, type Color } from "@/components/Badge";
-import { capitalCase } from "capital-case";
-
-const categoryColors: Record<string, Color> = {
-  NEWSLETTER: "blue",
-  PROMOTIONAL: "yellow",
-  RECEIPT: "yellow",
-  ALERT: "yellow",
-  NOTIFICATION: "yellow",
-  FORUM: "yellow",
-  EVENT: "green",
-  TRAVEL: "green",
-  QUESTION: "red",
-  SUPPORT: "red",
-  COLD_EMAIL: "yellow",
-  SOCIAL_MEDIA: "yellow",
-  LEGAL_UPDATE: "yellow",
-  OTHER: "yellow",
-};
-
-export function CategoryBadge(props: { category?: string }) {
-  const { category } = props;
-
-  return (
-    <Badge
-      color={category ? categoryColors[category] || "gray" : "gray"}
-      className="max-w-[100px] overflow-hidden"
-    >
-      {capitalCase(category || "Uncategorized")}
-    </Badge>
-  );
-}
diff --git a/apps/web/components/email-list/EmailList.tsx b/apps/web/components/email-list/EmailList.tsx
index 6142d0bc9d..bd6fb549a8 100644
--- a/apps/web/components/email-list/EmailList.tsx
+++ b/apps/web/components/email-list/EmailList.tsx
@@ -2,8 +2,6 @@
 
 import { useCallback, useRef, useState, useMemo } from "react";
 import { useQueryState } from "nuqs";
-import countBy from "lodash/countBy";
-import { capitalCase } from "capital-case";
 import Link from "next/link";
 import { toast } from "sonner";
 import { ChevronsDownIcon } from "lucide-react";
@@ -52,13 +50,6 @@ export function List({
   const { emailAccountId } = useAccount();
   const [selectedTab] = useQueryState("tab", { defaultValue: "all" });
 
-  const categories = useMemo(() => {
-    return countBy(
-      emails,
-      (email) => email.category?.category || "Uncategorized",
-    );
-  }, [emails]);
-
   const planned = useMemo(() => {
     return emails.filter((email) => email.plan?.rule);
   }, [emails]);
@@ -75,27 +66,19 @@ export function List({
         value: "planned",
         href: "/mail?tab=planned",
       },
-      ...Object.entries(categories).map(([category, count]) => ({
-        label: `${capitalCase(category)} (${count})`,
-        value: category,
-        href: `/mail?tab=${category}`,
-      })),
     ],
-    [categories, planned],
+    [planned],
   );
 
   // only show tabs if there are planned emails or categorized emails
-  const showTabs = !!(planned.length || emails.find((email) => email.category));
+  const showTabs = !!planned.length;
 
   const filteredEmails = useMemo(() => {
     if (selectedTab === "planned") return planned;
 
     if (selectedTab === "all") return emails;
 
-    if (selectedTab === "Uncategorized")
-      return emails.filter((email) => !email.category?.category);
-
-    return emails.filter((email) => email.category?.category === selectedTab);
+    return emails;
   }, [emails, selectedTab, planned]);
 
   return (
diff --git a/apps/web/components/email-list/EmailListItem.tsx b/apps/web/components/email-list/EmailListItem.tsx
index f55d3fe441..020d42392c 100644
--- a/apps/web/components/email-list/EmailListItem.tsx
+++ b/apps/web/components/email-list/EmailListItem.tsx
@@ -11,7 +11,6 @@ import { ActionButtons } from "@/components/ActionButtons";
 import { PlanBadge } from "@/components/PlanBadge";
 import type { Thread } from "@/components/email-list/types";
 import { extractNameFromEmail, participant } from "@/utils/email";
-import { CategoryBadge } from "@/components/CategoryBadge";
 import { Checkbox } from "@/components/Checkbox";
 import { EmailDate } from "@/components/email-list/EmailDate";
 import { decodeSnippet } from "@/utils/gmail/decode";
@@ -167,11 +166,8 @@ export const EmailListItem = forwardRef(
                   />
                 </div>
 
-                {!!(thread.category?.category || thread.plan) && (
+                {!!thread.plan && (
                   <div className="ml-3 flex items-center space-x-2 whitespace-nowrap">
-                    {thread.category?.category ? (
-                      <CategoryBadge category={thread.category.category} />
-                    ) : null}
                     <PlanBadge plan={thread.plan} provider={provider} />
                   </div>
                 )}
diff --git a/apps/web/components/email-list/types.ts b/apps/web/components/email-list/types.ts
index 20b4a254f3..e34af05c3b 100644
--- a/apps/web/components/email-list/types.ts
+++ b/apps/web/components/email-list/types.ts
@@ -7,7 +7,6 @@ export type Thread = {
   messages: FullThread["messages"];
   snippet: FullThread["snippet"];
   plan: FullThread["plan"];
-  category: FullThread["category"];
 };
 
 export type Executing = Record<string, boolean>;
diff --git a/apps/web/utils/ai/assistant/process-user-request.ts b/apps/web/utils/ai/assistant/process-user-request.ts
index 7b2907b17c..9c594c8823 100644
--- a/apps/web/utils/ai/assistant/process-user-request.ts
+++ b/apps/web/utils/ai/assistant/process-user-request.ts
@@ -2,12 +2,7 @@ import { stepCountIs, tool } from "ai";
 import { z } from "zod";
 import { createGenerateText } from "@/utils/llms";
 import { createScopedLogger } from "@/utils/logger";
-import {
-  type Category,
-  GroupItemType,
-  LogicalOperator,
-  type Rule,
-} from "@prisma/client";
+import { GroupItemType, LogicalOperator, type Rule } from "@prisma/client";
 import type { EmailAccountWithAI } from "@/utils/llms/types";
 import type { RuleWithRelations } from "@/utils/rule/types";
 import type { ParsedMessage } from "@/utils/types";
@@ -27,16 +22,12 @@ export async function processUserRequest({
   originalEmail,
   messages,
   matchedRule,
-  categories,
-  senderCategory,
 }: {
   emailAccount: EmailAccountWithAI;
   rules: RuleWithRelations[];
   originalEmail: ParsedMessage | null;
   messages: { role: "assistant" | "user"; content: string }[];
   matchedRule: RuleWithRelations | null;
-  categories: Pick<Category, "id" | "name">[] | null;
-  senderCategory: string | null;
 }) {
   const logger = createScopedLogger("ai-fix-rules").with({
     emailAccountId: emailAccount.id,
@@ -63,7 +54,6 @@ You can fix rules using these specific operations:
 - Change conditional operator (AND/OR logic)
 - Modify AI instructions
 - Update static conditions (from, to, subject, body)
-- Add or remove categories
 
 2. Create New Rules:
 - Create new rules when asked or when existing ones cannot be modified to fit the need
@@ -85,7 +75,7 @@ When fixing rules:
 
 Rule matching logic:
 - All static conditions (from, to, subject, body) use AND logic - meaning all static conditions must match
-- Top level conditions (AI instructions, static, category) can use either AND or OR logic, controlled by the conditionalOperator setting
+- Top level conditions (AI instructions, static) 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
@@ -117,14 +107,6 @@ ${
 ${stringifyEmailSimple(getEmailForLLM(originalEmail))}
 </original_email>`
     : ""
-}
-
-${
-  originalEmail && categories?.length
-    ? `<sender_category>
-${senderCategory || "No category"}
-</sender_category>`
-    : ""
 }`;
 
   const allMessages = [
diff --git a/apps/web/utils/assistant/process-assistant-email.ts b/apps/web/utils/assistant/process-assistant-email.ts
index 017dda466c..fae0c6280c 100644
--- a/apps/web/utils/assistant/process-assistant-email.ts
+++ b/apps/web/utils/assistant/process-assistant-email.ts
@@ -96,7 +96,7 @@ async function processAssistantEmailInternal({
   const originalMessageId = firstMessageToAssistant.headers["in-reply-to"];
   const originalMessage = await provider.getOriginalMessage(originalMessageId);
 
-  const [emailAccount, executedRules, senderCategory] = await Promise.all([
+  const [emailAccount, executedRules] = await Promise.all([
     prisma.emailAccount.findUnique({
       where: { email: userEmail },
       select: {
@@ -129,7 +129,6 @@ async function processAssistantEmailInternal({
             },
           },
         },
-        categories: true,
         account: { select: { provider: true } },
       },
     }),
@@ -150,19 +149,6 @@ async function processAssistantEmailInternal({
           },
         })
       : null,
-    originalMessage
-      ? prisma.newsletter.findUnique({
-          where: {
-            email_emailAccountId: {
-              email: extractEmailAddress(originalMessage.headers.from),
-              emailAccountId,
-            },
-          },
-          select: {
-            category: { select: { name: true } },
-          },
-        })
-      : null,
   ]);
 
   if (!emailAccount) {
@@ -214,8 +200,6 @@ async function processAssistantEmailInternal({
     originalEmail: originalMessage,
     messages,
     matchedRule: executedRules?.length ? executedRules[0].rule : null, // TODO: support multiple rule matching
-    categories: emailAccount.categories.length ? emailAccount.categories : null,
-    senderCategory: senderCategory?.category?.name ?? null,
   });
 
   const toolCalls = result.steps.flatMap((step) => step.toolCalls);
diff --git a/apps/web/utils/condition.ts b/apps/web/utils/condition.ts
index e5daa1c08b..b8b9401e57 100644
--- a/apps/web/utils/condition.ts
+++ b/apps/web/utils/condition.ts
@@ -1,4 +1,4 @@
-import { LogicalOperator, type Category, type Rule } from "@prisma/client";
+import { LogicalOperator, type Rule } from "@prisma/client";
 import { ConditionType, type CoreConditionType } from "@/utils/config";
 import type {
   CreateRuleBody,

From a9b335c2caadcee272ed9b227a219da08743e89d Mon Sep 17 00:00:00 2001
From: Eliezer Steinbock <3090527+elie222@users.noreply.github.com>
Date: Mon, 20 Oct 2025 07:20:19 +0300
Subject: [PATCH 17/40] fixes

---
 apps/web/utils/ai/choose-rule/match-rules.ts | 39 +++++++++++++++++---
 1 file changed, 34 insertions(+), 5 deletions(-)

diff --git a/apps/web/utils/ai/choose-rule/match-rules.ts b/apps/web/utils/ai/choose-rule/match-rules.ts
index e8191e0ffa..27ae639138 100644
--- a/apps/web/utils/ai/choose-rule/match-rules.ts
+++ b/apps/web/utils/ai/choose-rule/match-rules.ts
@@ -144,6 +144,7 @@ async function findPotentialMatchingRules({
           { type: ConditionType.PRESET, systemType: SystemType.CALENDAR },
         ],
       });
+      continue;
     }
 
     // TODO: still run this, if a previous email in the thread matched the rule
@@ -327,12 +328,40 @@ async function findMatchingRulesWithReasons(
       modelType,
     });
 
-    return {
-      matches: result.rules.map((rule) => ({
-        rule,
-        matchReasons: [{ type: ConditionType.AI }],
+    // Build combined matches: start with existing static/learned matches, then append AI-selected matches
+    const combinedMatches = [
+      // Map existing matches to the same output shape
+      ...matches.map((match) => ({
+        rule: match.rule,
+        matchReasons: match.matchReasons || [],
       })),
-      reasoning: result.reason,
+      // Append AI-selected matches, deduplicating by rule id
+      ...result.rules
+        .filter(
+          (aiRule) =>
+            !matches.some(
+              (existingMatch) => existingMatch.rule.id === aiRule.id,
+            ),
+        )
+        .map((rule) => ({
+          rule,
+          matchReasons: [{ type: ConditionType.AI }],
+        })),
+    ];
+
+    // Combine reasoning: existing reasoning plus AI reasoning
+    const existingReasoning = matches
+      .map((m) => getMatchReason(m.matchReasons))
+      .filter((r): r is string => !!r)
+      .join(", ");
+
+    const combinedReasoning = existingReasoning
+      ? `${existingReasoning}; ${result.reason}`
+      : result.reason;
+
+    return {
+      matches: combinedMatches,
+      reasoning: combinedReasoning,
     };
   } else {
     return {

From 28b82f0770e3f056c7334f13a98763ea1c3256d3 Mon Sep 17 00:00:00 2001
From: Eliezer Steinbock <3090527+elie222@users.noreply.github.com>
Date: Mon, 20 Oct 2025 08:18:03 +0300
Subject: [PATCH 18/40] use isprimary to only choose one system rule

---
 apps/web/__tests__/ai-choose-rule.test.ts     | 101 ++++++++----------
 .../utils/ai/choose-rule/ai-choose-rule.ts    |  32 +-----
 apps/web/utils/ai/choose-rule/match-rules.ts  |  27 ++++-
 3 files changed, 75 insertions(+), 85 deletions(-)

diff --git a/apps/web/__tests__/ai-choose-rule.test.ts b/apps/web/__tests__/ai-choose-rule.test.ts
index 3a7dc4a1d5..02c82b7e95 100644
--- a/apps/web/__tests__/ai-choose-rule.test.ts
+++ b/apps/web/__tests__/ai-choose-rule.test.ts
@@ -17,7 +17,7 @@ describe.runIf(isAiTest)("aiChooseRule", () => {
       emailAccount: getEmailAccount(),
     });
 
-    expect(result).toEqual({ reason: "No rules" });
+    expect(result).toEqual({ rules: [], reason: "" });
   });
 
   test("Should return correct rule when only one rule passed", async () => {
@@ -31,10 +31,10 @@ describe.runIf(isAiTest)("aiChooseRule", () => {
       emailAccount: getEmailAccount(),
     });
 
-    expect(result).toEqual({
-      rule,
-      reason: expect.any(String),
-    });
+    expect(result.rules).toHaveLength(1);
+    expect(result.rules[0].rule).toEqual(rule);
+    expect(result.rules[0].isPrimary).toBe(true);
+    expect(result.reason).toBeTruthy();
   });
 
   test("Should return correct rule when multiple rules passed", async () => {
@@ -51,10 +51,9 @@ describe.runIf(isAiTest)("aiChooseRule", () => {
       emailAccount: getEmailAccount(),
     });
 
-    expect(result).toEqual({
-      rule: rule2,
-      reason: expect.any(String),
-    });
+    expect(result.rules).toHaveLength(1);
+    expect(result.rules[0].rule).toEqual(rule2);
+    expect(result.reason).toBeTruthy();
   });
 
   test("Should generate action arguments", async () => {
@@ -91,10 +90,9 @@ describe.runIf(isAiTest)("aiChooseRule", () => {
       emailAccount: getEmailAccount(),
     });
 
-    expect(result).toEqual({
-      rule: rule2,
-      reason: expect.any(String),
-    });
+    expect(result.rules).toHaveLength(1);
+    expect(result.rules[0].rule).toEqual(rule2);
+    expect(result.reason).toBeTruthy();
   });
 
   describe("Complex real-world rule scenarios", () => {
@@ -159,10 +157,9 @@ describe.runIf(isAiTest)("aiChooseRule", () => {
         emailAccount: getEmailAccount(),
       });
 
-      expect(result).toEqual({
-        rule: requiresResponse,
-        reason: expect.any(String),
-      });
+      expect(result.rules).toHaveLength(1);
+      expect(result.rules[0].rule).toEqual(requiresResponse);
+      expect(result.reason).toBeTruthy();
     });
 
     test("Should match technical issues", async () => {
@@ -176,10 +173,9 @@ describe.runIf(isAiTest)("aiChooseRule", () => {
         emailAccount: getEmailAccount(),
       });
 
-      expect(result).toEqual({
-        rule: technicalIssues,
-        reason: expect.any(String),
-      });
+      expect(result.rules).toHaveLength(1);
+      expect(result.rules[0].rule).toEqual(technicalIssues);
+      expect(result.reason).toBeTruthy();
     });
 
     test("Should match financial emails", async () => {
@@ -192,10 +188,9 @@ describe.runIf(isAiTest)("aiChooseRule", () => {
         emailAccount: getEmailAccount(),
       });
 
-      expect(result).toEqual({
-        rule: financial,
-        reason: expect.any(String),
-      });
+      expect(result.rules).toHaveLength(1);
+      expect(result.rules[0].rule).toEqual(financial);
+      expect(result.reason).toBeTruthy();
     });
 
     test("Should match recruiter emails", async () => {
@@ -209,10 +204,9 @@ describe.runIf(isAiTest)("aiChooseRule", () => {
         emailAccount: getEmailAccount(),
       });
 
-      expect(result).toEqual({
-        rule: recruiters,
-        reason: expect.any(String),
-      });
+      expect(result.rules).toHaveLength(1);
+      expect(result.rules[0].rule).toEqual(recruiters);
+      expect(result.reason).toBeTruthy();
     });
 
     test("Should match legal documents", async () => {
@@ -225,10 +219,9 @@ describe.runIf(isAiTest)("aiChooseRule", () => {
         emailAccount: getEmailAccount(),
       });
 
-      expect(result).toEqual({
-        rule: legal,
-        reason: expect.any(String),
-      });
+      expect(result.rules).toHaveLength(1);
+      expect(result.rules[0].rule).toEqual(legal);
+      expect(result.reason).toBeTruthy();
     });
 
     test("Should match emails requiring response", async () => {
@@ -241,10 +234,9 @@ describe.runIf(isAiTest)("aiChooseRule", () => {
         emailAccount: getEmailAccount(),
       });
 
-      expect(result).toEqual({
-        rule: requiresResponse,
-        reason: expect.any(String),
-      });
+      expect(result.rules).toHaveLength(1);
+      expect(result.rules[0].rule).toEqual(requiresResponse);
+      expect(result.reason).toBeTruthy();
     });
 
     test("Should match product updates", async () => {
@@ -257,10 +249,9 @@ describe.runIf(isAiTest)("aiChooseRule", () => {
         emailAccount: getEmailAccount(),
       });
 
-      expect(result).toEqual({
-        rule: productUpdates,
-        reason: expect.any(String),
-      });
+      expect(result.rules).toHaveLength(1);
+      expect(result.rules[0].rule).toEqual(productUpdates);
+      expect(result.reason).toBeTruthy();
     });
 
     test("Should match marketing emails", async () => {
@@ -273,10 +264,9 @@ describe.runIf(isAiTest)("aiChooseRule", () => {
         emailAccount: getEmailAccount(),
       });
 
-      expect(result).toEqual({
-        rule: marketing,
-        reason: expect.any(String),
-      });
+      expect(result.rules).toHaveLength(1);
+      expect(result.rules[0].rule).toEqual(marketing);
+      expect(result.reason).toBeTruthy();
     });
 
     test("Should match team updates", async () => {
@@ -289,10 +279,9 @@ describe.runIf(isAiTest)("aiChooseRule", () => {
         emailAccount: getEmailAccount(),
       });
 
-      expect(result).toEqual({
-        rule: teamUpdates,
-        reason: expect.any(String),
-      });
+      expect(result.rules).toHaveLength(1);
+      expect(result.rules[0].rule).toEqual(teamUpdates);
+      expect(result.reason).toBeTruthy();
     });
 
     test("Should match customer feedback", async () => {
@@ -305,10 +294,9 @@ describe.runIf(isAiTest)("aiChooseRule", () => {
         emailAccount: getEmailAccount(),
       });
 
-      expect(result).toEqual({
-        rule: customerFeedback,
-        reason: expect.any(String),
-      });
+      expect(result.rules).toHaveLength(1);
+      expect(result.rules[0].rule).toEqual(customerFeedback);
+      expect(result.reason).toBeTruthy();
     });
 
     test("Should match event invitations", async () => {
@@ -321,10 +309,9 @@ describe.runIf(isAiTest)("aiChooseRule", () => {
         emailAccount: getEmailAccount(),
       });
 
-      expect(result).toEqual({
-        rule: events,
-        reason: expect.any(String),
-      });
+      expect(result.rules).toHaveLength(1);
+      expect(result.rules[0].rule).toEqual(events);
+      expect(result.reason).toBeTruthy();
     });
   });
 });
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 7161bf214a..cab3aa8353 100644
--- a/apps/web/utils/ai/choose-rule/ai-choose-rule.ts
+++ b/apps/web/utils/ai/choose-rule/ai-choose-rule.ts
@@ -26,7 +26,7 @@ export async function aiChooseRule<
   emailAccount: EmailAccountWithAI;
   modelType?: ModelType;
 }): Promise<{
-  rules: T[];
+  rules: { rule: T; isPrimary?: boolean }[];
   reason: string;
 }> {
   if (!rules.length) return { rules: [], reason: "" };
@@ -40,24 +40,24 @@ export async function aiChooseRule<
 
   if (aiResponse.noMatchFound) return { rules: [], reason: "" };
 
-  const selectedRules = aiResponse.matchedRules
+  const rulesWithMetadata = aiResponse.matchedRules
     .map((match) => {
       const rule = rules.find(
         (r) => r.name.toLowerCase() === match.ruleName.toLowerCase(),
       );
-      return rule;
+      return rule ? { rule, isPrimary: match.isPrimary } : undefined;
     })
     .filter(isDefined);
 
   return {
-    rules: selectedRules,
+    rules: rulesWithMetadata,
     reason: aiResponse.reasoning,
   };
 }
 
 async function getAiResponse(options: GetAiResponseOptions): Promise<{
   result: {
-    matchedRules: { ruleName: string }[];
+    matchedRules: { ruleName: string; isPrimary?: boolean }[];
     reasoning: string;
     noMatchFound: boolean;
   };
@@ -283,25 +283,3 @@ ${stringifyEmail(email, 500)}
     reasoning: aiResponse.object?.reasoning ?? "",
   };
 }
-
-/**
- * Filter system rules: if multiple system rules were matched, only keep the primary one.
- * Always keep all conversation rules (non-system rules).
- */
-function filterMultipleSystemRules<
-  T extends { name: string; instructions: string; systemType?: string | null },
->(selectedRules: { rule: T; isPrimary?: boolean }[]): T[] {
-  const systemRules = selectedRules.filter((r) => r.rule.systemType);
-  const conversationRules = selectedRules.filter((r) => !r.rule.systemType);
-
-  let filteredSystemRules = systemRules;
-  if (systemRules.length > 1) {
-    // Only keep the primary system rule
-    const primarySystemRule = systemRules.find((r) => r.isPrimary);
-    filteredSystemRules = primarySystemRule
-      ? [primarySystemRule]
-      : [systemRules[0]];
-  }
-
-  return [...filteredSystemRules, ...conversationRules].map((r) => r.rule);
-}
diff --git a/apps/web/utils/ai/choose-rule/match-rules.ts b/apps/web/utils/ai/choose-rule/match-rules.ts
index 27ae639138..05615d42a0 100644
--- a/apps/web/utils/ai/choose-rule/match-rules.ts
+++ b/apps/web/utils/ai/choose-rule/match-rules.ts
@@ -321,13 +321,18 @@ async function findMatchingRulesWithReasons(
   });
 
   if (potentialAiMatches.length) {
-    const result = await aiChooseRule({
+    const fullResult = await aiChooseRule({
       email: getEmailForLLM(message),
       rules: potentialAiMatches,
       emailAccount,
       modelType,
     });
 
+    const result = {
+      rules: filterMultipleSystemRules(fullResult.rules),
+      reason: fullResult.reason,
+    };
+
     // Build combined matches: start with existing static/learned matches, then append AI-selected matches
     const combinedMatches = [
       // Map existing matches to the same output shape
@@ -532,3 +537,23 @@ export async function filterConversationStatusRules<
 
   return potentialMatches;
 }
+
+/**
+ * Filter system rules: if multiple system rules were matched, only keep the primary one.
+ * Always keep all conversation rules (non-system rules).
+ */
+export function filterMultipleSystemRules<
+  T extends { name: string; instructions: string; systemType?: string | null },
+>(selectedRules: { rule: T; isPrimary?: boolean }[]): T[] {
+  const systemRules = selectedRules.filter((r) => r.rule.systemType);
+  const conversationRules = selectedRules.filter((r) => !r.rule.systemType);
+
+  let filteredSystemRules = systemRules;
+  if (systemRules.length > 1) {
+    // Only keep the primary system rule
+    const primarySystemRule = systemRules.find((r) => r.isPrimary);
+    filteredSystemRules = primarySystemRule ? [primarySystemRule] : systemRules;
+  }
+
+  return [...filteredSystemRules, ...conversationRules].map((r) => r.rule);
+}

From 98b009dcacaaa3e6456141a4abaf2f8cb5a96be7 Mon Sep 17 00:00:00 2001
From: Eliezer Steinbock <3090527+elie222@users.noreply.github.com>
Date: Mon, 20 Oct 2025 08:26:16 +0300
Subject: [PATCH 19/40] ensure conversation tracking continues

---
 apps/web/utils/ai/choose-rule/run-rules.ts | 126 ++++++++++++++++++++-
 1 file changed, 121 insertions(+), 5 deletions(-)

diff --git a/apps/web/utils/ai/choose-rule/run-rules.ts b/apps/web/utils/ai/choose-rule/run-rules.ts
index 94ad64d4a1..b98a974f0a 100644
--- a/apps/web/utils/ai/choose-rule/run-rules.ts
+++ b/apps/web/utils/ai/choose-rule/run-rules.ts
@@ -20,7 +20,10 @@ import {
 import groupBy from "lodash/groupBy";
 import type { EmailProvider } from "@/utils/email/types";
 import type { ModelType } from "@/utils/llms/model";
-import { isConversationStatusType } from "@/utils/reply-tracker/conversation-status-config";
+import {
+  CONVERSATION_STATUS_TYPES,
+  isConversationStatusType,
+} from "@/utils/reply-tracker/conversation-status-config";
 import {
   determineConversationStatus,
   updateThreadTrackers,
@@ -66,11 +69,21 @@ export async function runRules({
     modelType,
   });
 
+  // Auto-reapply conversation tracking for thread continuity
+  const finalMatches = await ensureConversationRuleContinuity({
+    emailAccountId: emailAccount.id,
+    threadId: message.threadId,
+    messageId: message.id,
+    conversationRules,
+    regularRules,
+    matches: results.matches,
+  });
+
   logger.trace("Matching rule", () => ({
-    results: results.matches.map(filterNullProperties),
+    results: finalMatches.map(filterNullProperties),
   }));
 
-  if (!results.matches.length) {
+  if (!finalMatches.length) {
     const reason = results.reasoning || "No rules matched";
     await prisma.executedRule.create({
       data: {
@@ -88,11 +101,11 @@ export async function runRules({
 
   const executedRules: RunRulesResult[] = [];
 
-  for (const result of results.matches) {
+  for (const result of finalMatches) {
     let ruleToExecute = result.rule;
     let reasonToUse = results.reasoning;
 
-    if (result.rule.id === CONVERSATION_TRACKING_META_RULE_ID) {
+    if (isConversationRule(result.rule.id)) {
       // Determine which specific sub-rule applies
       const { specificRule, reason: statusReason } =
         await determineConversationStatus({
@@ -354,3 +367,106 @@ function shouldAnalyzeSenderPattern({
 
   return true;
 }
+
+/**
+ * Checks if a conversation status rule was previously applied to any email in this thread.
+ */
+async function checkPreviousConversationRuleInThread({
+  emailAccountId,
+  threadId,
+  messageId,
+}: {
+  emailAccountId: string;
+  threadId: string;
+  messageId: string;
+}): Promise<boolean> {
+  const previousConversationRule = await prisma.executedRule.findFirst({
+    where: {
+      emailAccountId,
+      threadId,
+      messageId: { not: messageId },
+      status: ExecutedRuleStatus.APPLIED,
+      rule: { systemType: { in: CONVERSATION_STATUS_TYPES } },
+    },
+    select: { id: true },
+  });
+
+  return !!previousConversationRule;
+}
+
+/**
+ * Ensures conversation tracking continues throughout a thread.
+ * If a conversation meta rule was previously applied to any email in this thread,
+ * we automatically add it to matches even if the AI didn't select it.
+ * This ensures conversation tracking continues consistently throughout the thread.
+ *
+ * Note: The meta rule is still passed to the AI (in regularRules), which may
+ * influence it to select the rule naturally, but we enforce it regardless.
+ *
+ * Returns a new array of matches (does not mutate the input).
+ */
+async function ensureConversationRuleContinuity({
+  emailAccountId,
+  threadId,
+  messageId,
+  conversationRules,
+  regularRules,
+  matches,
+}: {
+  emailAccountId: string;
+  threadId: string;
+  messageId: string;
+  conversationRules: RuleWithActions[];
+  regularRules: RuleWithActions[];
+  matches: { rule: RuleWithActions; matchReasons?: MatchReason[] }[];
+}): Promise<{ rule: RuleWithActions; matchReasons?: MatchReason[] }[]> {
+  if (conversationRules.length === 0) {
+    return matches;
+  }
+
+  const hadConversationRuleInThread =
+    await checkPreviousConversationRuleInThread({
+      emailAccountId,
+      threadId,
+      messageId,
+    });
+
+  if (!hadConversationRuleInThread) {
+    return matches;
+  }
+
+  const hasConversationMetaRuleInMatches = matches.some((match) =>
+    isConversationRule(match.rule.id),
+  );
+
+  if (hasConversationMetaRuleInMatches) {
+    return matches;
+  }
+
+  logger.info(
+    "Automatically adding conversation meta rule due to previous application in thread",
+  );
+
+  // Find the meta rule in regularRules
+  const metaRule = regularRules.find((r) => isConversationRule(r.id));
+
+  if (!metaRule) {
+    return matches;
+  }
+
+  return [
+    ...matches,
+    {
+      rule: metaRule,
+      matchReasons: [
+        {
+          type: ConditionType.STATIC,
+        },
+      ],
+    },
+  ];
+}
+
+function isConversationRule(ruleId: string): boolean {
+  return ruleId === CONVERSATION_TRACKING_META_RULE_ID;
+}

From db35d0045168f01c86d0a472c2c0ad48b1f5572f Mon Sep 17 00:00:00 2001
From: Eliezer Steinbock <3090527+elie222@users.noreply.github.com>
Date: Mon, 20 Oct 2025 08:38:59 +0300
Subject: [PATCH 20/40] tests

---
 .../utils/ai/choose-rule/match-rules.test.ts  |   5 +-
 apps/web/utils/ai/choose-rule/match-rules.ts  |   6 +-
 .../utils/ai/choose-rule/run-rules.test.ts    | 215 ++++++++++++++++++
 apps/web/utils/ai/choose-rule/run-rules.ts    |   8 +-
 4 files changed, 227 insertions(+), 7 deletions(-)
 create mode 100644 apps/web/utils/ai/choose-rule/run-rules.test.ts

diff --git a/apps/web/utils/ai/choose-rule/match-rules.test.ts b/apps/web/utils/ai/choose-rule/match-rules.test.ts
index 7fffcc4441..f6fedc4d6c 100644
--- a/apps/web/utils/ai/choose-rule/match-rules.test.ts
+++ b/apps/web/utils/ai/choose-rule/match-rules.test.ts
@@ -1522,6 +1522,7 @@ function getRule(overrides: Partial<RuleWithActions> = {}): RuleWithActions {
     runOnThreads: true,
     conditionalOperator: LogicalOperator.AND,
     type: null,
+    systemType: null,
     ...overrides,
   } as RuleWithActions;
 }
@@ -1748,7 +1749,7 @@ describe("findMatchingRules - Integration Tests", () => {
     });
 
     vi.mocked(aiChooseRule).mockResolvedValue({
-      rules: [aiRule as any],
+      rules: [{ rule: aiRule as any }],
       reason: "This is a promotional email",
     });
 
@@ -1884,7 +1885,7 @@ describe("findMatchingRules - Integration Tests", () => {
     });
 
     vi.mocked(aiChooseRule).mockResolvedValue({
-      rules: [mixedRule as any],
+      rules: [{ rule: mixedRule as any }],
       reason: "Email is promotional",
     });
 
diff --git a/apps/web/utils/ai/choose-rule/match-rules.ts b/apps/web/utils/ai/choose-rule/match-rules.ts
index 05615d42a0..cb4fa172b3 100644
--- a/apps/web/utils/ai/choose-rule/match-rules.ts
+++ b/apps/web/utils/ai/choose-rule/match-rules.ts
@@ -545,8 +545,10 @@ export async function filterConversationStatusRules<
 export function filterMultipleSystemRules<
   T extends { name: string; instructions: string; systemType?: string | null },
 >(selectedRules: { rule: T; isPrimary?: boolean }[]): T[] {
-  const systemRules = selectedRules.filter((r) => r.rule.systemType);
-  const conversationRules = selectedRules.filter((r) => !r.rule.systemType);
+  const systemRules = selectedRules.filter((r) => r.rule?.systemType);
+  const conversationRules = selectedRules.filter(
+    (r) => r.rule && !r.rule?.systemType,
+  );
 
   let filteredSystemRules = systemRules;
   if (systemRules.length > 1) {
diff --git a/apps/web/utils/ai/choose-rule/run-rules.test.ts b/apps/web/utils/ai/choose-rule/run-rules.test.ts
new file mode 100644
index 0000000000..032db580e7
--- /dev/null
+++ b/apps/web/utils/ai/choose-rule/run-rules.test.ts
@@ -0,0 +1,215 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import {
+  ensureConversationRuleContinuity,
+  CONVERSATION_TRACKING_META_RULE_ID,
+} from "./run-rules";
+import { ExecutedRuleStatus, SystemType } from "@prisma/client";
+import { ConditionType } from "@/utils/config";
+import prisma from "@/utils/__mocks__/prisma";
+import type { RuleWithActions } from "@/utils/types";
+
+vi.mock("@/utils/prisma");
+vi.mock("server-only", () => ({}));
+
+describe("ensureConversationRuleContinuity", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  const emailAccountId = "account-1";
+  const threadId = "thread-1";
+  const messageId = "msg-1";
+
+  const createRule = (
+    id: string,
+    systemType: SystemType | null = null,
+  ): RuleWithActions => ({
+    id,
+    name: `Rule ${id}`,
+    instructions: `Instructions for ${id}`,
+    enabled: true,
+    emailAccountId,
+    createdAt: new Date(),
+    updatedAt: new Date(),
+    actions: [],
+    runOnThreads: false,
+    from: null,
+    to: null,
+    subject: null,
+    body: null,
+    groupId: null,
+    conditionalOperator: "AND" as const,
+    systemType,
+    automate: true,
+    promptText: null,
+  });
+
+  const conversationMetaRule = createRule(CONVERSATION_TRACKING_META_RULE_ID);
+  const toReplyRule = createRule("to-reply-rule", SystemType.TO_REPLY);
+  const regularRule = createRule("regular-rule");
+
+  it("returns matches unchanged when there are no conversation rules", async () => {
+    const matches = [{ rule: regularRule }];
+
+    const result = await ensureConversationRuleContinuity({
+      emailAccountId,
+      threadId,
+      messageId,
+      conversationRules: [],
+      regularRules: [regularRule],
+      matches,
+    });
+
+    expect(result).toEqual(matches);
+    expect(prisma.executedRule.findFirst).not.toHaveBeenCalled();
+  });
+
+  it("returns matches unchanged when no previous conversation rule was applied in thread", async () => {
+    prisma.executedRule.findFirst.mockResolvedValue(null);
+
+    const matches = [{ rule: regularRule }];
+
+    const result = await ensureConversationRuleContinuity({
+      emailAccountId,
+      threadId,
+      messageId,
+      conversationRules: [toReplyRule],
+      regularRules: [regularRule, conversationMetaRule],
+      matches,
+    });
+
+    expect(result).toEqual(matches);
+    expect(prisma.executedRule.findFirst).toHaveBeenCalledWith({
+      where: {
+        emailAccountId,
+        threadId,
+        messageId: { not: messageId },
+        status: ExecutedRuleStatus.APPLIED,
+        rule: {
+          systemType: {
+            in: expect.arrayContaining([
+              SystemType.TO_REPLY,
+              SystemType.AWAITING_REPLY,
+              SystemType.FYI,
+              SystemType.ACTIONED,
+            ]),
+          },
+        },
+      },
+      select: { id: true },
+    });
+  });
+
+  it("returns matches unchanged when conversation meta rule is already in matches", async () => {
+    prisma.executedRule.findFirst.mockResolvedValue({
+      id: "executed-rule-1",
+    } as any);
+
+    const matches = [{ rule: conversationMetaRule }, { rule: regularRule }];
+
+    const result = await ensureConversationRuleContinuity({
+      emailAccountId,
+      threadId,
+      messageId,
+      conversationRules: [toReplyRule],
+      regularRules: [regularRule, conversationMetaRule],
+      matches,
+    });
+
+    expect(result).toEqual(matches);
+  });
+
+  it("adds conversation meta rule when previous conversation rule was applied and meta rule not in matches", async () => {
+    prisma.executedRule.findFirst.mockResolvedValue({
+      id: "executed-rule-1",
+    } as any);
+
+    const matches = [{ rule: regularRule }];
+
+    const result = await ensureConversationRuleContinuity({
+      emailAccountId,
+      threadId,
+      messageId,
+      conversationRules: [toReplyRule],
+      regularRules: [regularRule, conversationMetaRule],
+      matches,
+    });
+
+    expect(result).toHaveLength(2);
+    expect(result[0]).toEqual({ rule: regularRule });
+    expect(result[1]).toEqual({
+      rule: conversationMetaRule,
+      matchReasons: [{ type: ConditionType.STATIC }],
+    });
+  });
+
+  it("returns original matches when conversation meta rule cannot be found in regularRules", async () => {
+    prisma.executedRule.findFirst.mockResolvedValue({
+      id: "executed-rule-1",
+    } as any);
+
+    const matches = [{ rule: regularRule }];
+
+    const result = await ensureConversationRuleContinuity({
+      emailAccountId,
+      threadId,
+      messageId,
+      conversationRules: [toReplyRule],
+      regularRules: [regularRule], // No meta rule
+      matches,
+    });
+
+    expect(result).toEqual(matches);
+  });
+
+  it("does not mutate the original matches array", async () => {
+    prisma.executedRule.findFirst.mockResolvedValue({
+      id: "executed-rule-1",
+    } as any);
+
+    const matches = [{ rule: regularRule }];
+    const originalMatches = [...matches];
+
+    const result = await ensureConversationRuleContinuity({
+      emailAccountId,
+      threadId,
+      messageId,
+      conversationRules: [toReplyRule],
+      regularRules: [regularRule, conversationMetaRule],
+      matches,
+    });
+
+    expect(matches).toEqual(originalMatches);
+    expect(result).not.toBe(matches);
+  });
+
+  it("queries database with correct parameters", async () => {
+    prisma.executedRule.findFirst.mockResolvedValue(null);
+
+    const matches = [{ rule: regularRule }];
+
+    await ensureConversationRuleContinuity({
+      emailAccountId,
+      threadId,
+      messageId,
+      conversationRules: [toReplyRule],
+      regularRules: [regularRule, conversationMetaRule],
+      matches,
+    });
+
+    expect(prisma.executedRule.findFirst).toHaveBeenCalledWith({
+      where: {
+        emailAccountId,
+        threadId,
+        messageId: { not: messageId },
+        status: ExecutedRuleStatus.APPLIED,
+        rule: {
+          systemType: {
+            in: expect.any(Array),
+          },
+        },
+      },
+      select: { id: true },
+    });
+  });
+});
diff --git a/apps/web/utils/ai/choose-rule/run-rules.ts b/apps/web/utils/ai/choose-rule/run-rules.ts
index b98a974f0a..e34bbb5f02 100644
--- a/apps/web/utils/ai/choose-rule/run-rules.ts
+++ b/apps/web/utils/ai/choose-rule/run-rules.ts
@@ -42,7 +42,7 @@ export type RunRulesResult = {
   existing?: boolean;
 };
 
-const CONVERSATION_TRACKING_META_RULE_ID = "conversation-tracking-meta";
+export const CONVERSATION_TRACKING_META_RULE_ID = "conversation-tracking-meta";
 
 export async function runRules({
   provider,
@@ -105,7 +105,7 @@ export async function runRules({
     let ruleToExecute = result.rule;
     let reasonToUse = results.reasoning;
 
-    if (isConversationRule(result.rule.id)) {
+    if (result.rule && isConversationRule(result.rule.id)) {
       // Determine which specific sub-rule applies
       const { specificRule, reason: statusReason } =
         await determineConversationStatus({
@@ -404,8 +404,10 @@ async function checkPreviousConversationRuleInThread({
  * influence it to select the rule naturally, but we enforce it regardless.
  *
  * Returns a new array of matches (does not mutate the input).
+ *
+ * @internal Exported for testing
  */
-async function ensureConversationRuleContinuity({
+export async function ensureConversationRuleContinuity({
   emailAccountId,
   threadId,
   messageId,

From 7a332dc82d5d638e471a39673d4f4ea1f06074d7 Mon Sep 17 00:00:00 2001
From: Eliezer Steinbock <3090527+elie222@users.noreply.github.com>
Date: Mon, 20 Oct 2025 13:33:34 +0300
Subject: [PATCH 21/40] allow applying previously applied rules on threads

---
 .../utils/ai/choose-rule/match-rules.test.ts  |  3 +
 apps/web/utils/ai/choose-rule/match-rules.ts  | 83 ++++++++++++++++++-
 .../utils/ai/choose-rule/run-rules.test.ts    | 10 +--
 apps/web/utils/ai/choose-rule/run-rules.ts    |  7 --
 4 files changed, 83 insertions(+), 20 deletions(-)

diff --git a/apps/web/utils/ai/choose-rule/match-rules.test.ts b/apps/web/utils/ai/choose-rule/match-rules.test.ts
index f6fedc4d6c..21b0c4aad9 100644
--- a/apps/web/utils/ai/choose-rule/match-rules.test.ts
+++ b/apps/web/utils/ai/choose-rule/match-rules.test.ts
@@ -1843,6 +1843,9 @@ describe("findMatchingRules - Integration Tests", () => {
       isReplyInThread: vi.fn().mockReturnValue(true),
     } as unknown as EmailProvider;
 
+    // Mock no previously executed rules in thread
+    prisma.executedRule.findMany.mockResolvedValue([]);
+
     const rules = [threadRule];
     const message = getMessage({
       headers: getHeaders({ from: "test@example.com" }),
diff --git a/apps/web/utils/ai/choose-rule/match-rules.ts b/apps/web/utils/ai/choose-rule/match-rules.ts
index cb4fa172b3..131a717d5a 100644
--- a/apps/web/utils/ai/choose-rule/match-rules.ts
+++ b/apps/web/utils/ai/choose-rule/match-rules.ts
@@ -4,7 +4,11 @@ import {
   getGroupsWithRules,
 } from "@/utils/group/find-matching-group";
 import type { ParsedMessage, RuleWithActions } from "@/utils/types";
-import { LogicalOperator, SystemType } from "@prisma/client";
+import {
+  ExecutedRuleStatus,
+  LogicalOperator,
+  SystemType,
+} from "@prisma/client";
 import { ConditionType } from "@/utils/config";
 import prisma from "@/utils/prisma";
 import { aiChooseRule } from "@/utils/ai/choose-rule/ai-choose-rule";
@@ -117,11 +121,13 @@ async function findPotentialMatchingRules({
   message,
   isThread,
   provider,
+  emailAccountId,
 }: {
   rules: RuleWithActions[];
   message: ParsedMessage;
   isThread: boolean;
   provider: EmailProvider;
+  emailAccountId: string;
 }): Promise<MatchingRuleResult> {
   const matches: {
     rule: RuleWithActions;
@@ -130,6 +136,10 @@ async function findPotentialMatchingRules({
   const potentialAiMatches: (RuleWithActions & { instructions: string })[] = [];
 
   const learnedPatternsLoader = new LearnedPatternsLoader();
+  const previousRulesLoader = new PreviousThreadRulesLoader({
+    emailAccountId,
+    threadId: message.threadId,
+  });
 
   // Go through all rules and collect matches and potential AI matches
   for (const rule of rules) {
@@ -147,9 +157,6 @@ async function findPotentialMatchingRules({
       continue;
     }
 
-    // TODO: still run this, if a previous email in the thread matched the rule
-    if (isThread && !rule.runOnThreads) continue;
-
     // Learned patterns (groups)
     // Note: Groups are independent of the AND/OR operator (which only applies to AI/Static conditions)
     if (rule.groupId) {
@@ -181,6 +188,17 @@ async function findPotentialMatchingRules({
       }
     }
 
+    // Skip rules with runOnThreads=false, unless this rule was previously applied in the thread
+    // This ensures thread continuity (e.g., notifications continue to be labeled as notifications)
+    if (isThread && !rule.runOnThreads) {
+      const previousRuleIds = await previousRulesLoader.getRuleIds();
+      const wasPreviouslyApplied = previousRuleIds.has(rule.id);
+
+      if (!wasPreviouslyApplied) {
+        continue;
+      }
+    }
+
     // AI + Static conditions
     const { matched, potentialAiMatch, matchReasons } = evaluateRuleConditions({
       rule,
@@ -287,6 +305,34 @@ class LearnedPatternsLoader {
   }
 }
 
+// Lazy load previously executed rules in thread when needed
+class PreviousThreadRulesLoader {
+  private ruleIds?: Set<string>;
+  private readonly emailAccountId: string;
+  private readonly threadId: string;
+
+  constructor({
+    emailAccountId,
+    threadId,
+  }: {
+    emailAccountId: string;
+    threadId: string;
+  }) {
+    this.emailAccountId = emailAccountId;
+    this.threadId = threadId;
+  }
+
+  async getRuleIds(): Promise<Set<string>> {
+    if (this.ruleIds === undefined) {
+      this.ruleIds = await getPreviouslyExecutedRuleIds({
+        emailAccountId: this.emailAccountId,
+        threadId: this.threadId,
+      });
+    }
+    return this.ruleIds;
+  }
+}
+
 function getMatchReason(matchReasons?: MatchReason[]): string | undefined {
   if (!matchReasons || matchReasons.length === 0) return;
 
@@ -318,6 +364,7 @@ async function findMatchingRulesWithReasons(
     message,
     isThread,
     provider,
+    emailAccountId: emailAccount.id,
   });
 
   if (potentialAiMatches.length) {
@@ -559,3 +606,31 @@ export function filterMultipleSystemRules<
 
   return [...filteredSystemRules, ...conversationRules].map((r) => r.rule);
 }
+
+/**
+ * Gets the IDs of rules that were previously executed in this thread.
+ * This allows us to continue applying the same rules to a thread for consistency,
+ * even if `runOnThreads` is false.
+ */
+async function getPreviouslyExecutedRuleIds({
+  emailAccountId,
+  threadId,
+}: {
+  emailAccountId: string;
+  threadId: string;
+}): Promise<Set<string>> {
+  const previousRules = await prisma.executedRule.findMany({
+    where: {
+      emailAccountId,
+      threadId,
+      status: ExecutedRuleStatus.APPLIED,
+      ruleId: { not: null },
+    },
+    select: { ruleId: true },
+    distinct: ["ruleId"],
+  });
+
+  return new Set(
+    previousRules.map((r) => r.ruleId).filter((id): id is string => !!id),
+  );
+}
diff --git a/apps/web/utils/ai/choose-rule/run-rules.test.ts b/apps/web/utils/ai/choose-rule/run-rules.test.ts
index 032db580e7..1b9534cf4c 100644
--- a/apps/web/utils/ai/choose-rule/run-rules.test.ts
+++ b/apps/web/utils/ai/choose-rule/run-rules.test.ts
@@ -42,6 +42,7 @@ describe("ensureConversationRuleContinuity", () => {
     systemType,
     automate: true,
     promptText: null,
+    categoryFilterType: null,
   });
 
   const conversationMetaRule = createRule(CONVERSATION_TRACKING_META_RULE_ID);
@@ -54,7 +55,6 @@ describe("ensureConversationRuleContinuity", () => {
     const result = await ensureConversationRuleContinuity({
       emailAccountId,
       threadId,
-      messageId,
       conversationRules: [],
       regularRules: [regularRule],
       matches,
@@ -72,7 +72,6 @@ describe("ensureConversationRuleContinuity", () => {
     const result = await ensureConversationRuleContinuity({
       emailAccountId,
       threadId,
-      messageId,
       conversationRules: [toReplyRule],
       regularRules: [regularRule, conversationMetaRule],
       matches,
@@ -83,7 +82,6 @@ describe("ensureConversationRuleContinuity", () => {
       where: {
         emailAccountId,
         threadId,
-        messageId: { not: messageId },
         status: ExecutedRuleStatus.APPLIED,
         rule: {
           systemType: {
@@ -110,7 +108,6 @@ describe("ensureConversationRuleContinuity", () => {
     const result = await ensureConversationRuleContinuity({
       emailAccountId,
       threadId,
-      messageId,
       conversationRules: [toReplyRule],
       regularRules: [regularRule, conversationMetaRule],
       matches,
@@ -129,7 +126,6 @@ describe("ensureConversationRuleContinuity", () => {
     const result = await ensureConversationRuleContinuity({
       emailAccountId,
       threadId,
-      messageId,
       conversationRules: [toReplyRule],
       regularRules: [regularRule, conversationMetaRule],
       matches,
@@ -153,7 +149,6 @@ describe("ensureConversationRuleContinuity", () => {
     const result = await ensureConversationRuleContinuity({
       emailAccountId,
       threadId,
-      messageId,
       conversationRules: [toReplyRule],
       regularRules: [regularRule], // No meta rule
       matches,
@@ -173,7 +168,6 @@ describe("ensureConversationRuleContinuity", () => {
     const result = await ensureConversationRuleContinuity({
       emailAccountId,
       threadId,
-      messageId,
       conversationRules: [toReplyRule],
       regularRules: [regularRule, conversationMetaRule],
       matches,
@@ -191,7 +185,6 @@ describe("ensureConversationRuleContinuity", () => {
     await ensureConversationRuleContinuity({
       emailAccountId,
       threadId,
-      messageId,
       conversationRules: [toReplyRule],
       regularRules: [regularRule, conversationMetaRule],
       matches,
@@ -201,7 +194,6 @@ describe("ensureConversationRuleContinuity", () => {
       where: {
         emailAccountId,
         threadId,
-        messageId: { not: messageId },
         status: ExecutedRuleStatus.APPLIED,
         rule: {
           systemType: {
diff --git a/apps/web/utils/ai/choose-rule/run-rules.ts b/apps/web/utils/ai/choose-rule/run-rules.ts
index e34bbb5f02..d6dd10dd2d 100644
--- a/apps/web/utils/ai/choose-rule/run-rules.ts
+++ b/apps/web/utils/ai/choose-rule/run-rules.ts
@@ -73,7 +73,6 @@ export async function runRules({
   const finalMatches = await ensureConversationRuleContinuity({
     emailAccountId: emailAccount.id,
     threadId: message.threadId,
-    messageId: message.id,
     conversationRules,
     regularRules,
     matches: results.matches,
@@ -374,17 +373,14 @@ function shouldAnalyzeSenderPattern({
 async function checkPreviousConversationRuleInThread({
   emailAccountId,
   threadId,
-  messageId,
 }: {
   emailAccountId: string;
   threadId: string;
-  messageId: string;
 }): Promise<boolean> {
   const previousConversationRule = await prisma.executedRule.findFirst({
     where: {
       emailAccountId,
       threadId,
-      messageId: { not: messageId },
       status: ExecutedRuleStatus.APPLIED,
       rule: { systemType: { in: CONVERSATION_STATUS_TYPES } },
     },
@@ -410,14 +406,12 @@ async function checkPreviousConversationRuleInThread({
 export async function ensureConversationRuleContinuity({
   emailAccountId,
   threadId,
-  messageId,
   conversationRules,
   regularRules,
   matches,
 }: {
   emailAccountId: string;
   threadId: string;
-  messageId: string;
   conversationRules: RuleWithActions[];
   regularRules: RuleWithActions[];
   matches: { rule: RuleWithActions; matchReasons?: MatchReason[] }[];
@@ -430,7 +424,6 @@ export async function ensureConversationRuleContinuity({
     await checkPreviousConversationRuleInThread({
       emailAccountId,
       threadId,
-      messageId,
     });
 
   if (!hadConversationRuleInThread) {

From fdfe9e6884b58b5f246f346c9bff27e8fec22c57 Mon Sep 17 00:00:00 2001
From: Eliezer Steinbock <3090527+elie222@users.noreply.github.com>
Date: Mon, 20 Oct 2025 14:13:17 +0300
Subject: [PATCH 22/40] add more tests for match rules

---
 .../utils/ai/choose-rule/match-rules.test.ts  | 385 ++++++++++++++++++
 .../utils/ai/choose-rule/run-rules.test.ts    |   1 -
 2 files changed, 385 insertions(+), 1 deletion(-)

diff --git a/apps/web/utils/ai/choose-rule/match-rules.test.ts b/apps/web/utils/ai/choose-rule/match-rules.test.ts
index 21b0c4aad9..ad17baf76c 100644
--- a/apps/web/utils/ai/choose-rule/match-rules.test.ts
+++ b/apps/web/utils/ai/choose-rule/match-rules.test.ts
@@ -1,4 +1,5 @@
 import { describe, it, expect, vi, beforeEach } from "vitest";
+import { filterMultipleSystemRules } from "./match-rules";
 import {
   findMatchingRules,
   matchesStaticRule,
@@ -1864,6 +1865,261 @@ describe("findMatchingRules - Integration Tests", () => {
     expect(result.matches).toHaveLength(0);
   });
 
+  describe("filterMultipleSystemRules branches", () => {
+    it("returns all system rules when none marked primary (plus conversation rules)", () => {
+      const sysA: {
+        name: string;
+        instructions: string;
+        systemType: string | null;
+      } = {
+        name: "Sys A",
+        instructions: "",
+        systemType: "TO_REPLY",
+      };
+      const sysB: {
+        name: string;
+        instructions: string;
+        systemType: string | null;
+      } = {
+        name: "Sys B",
+        instructions: "",
+        systemType: "AWAITING_REPLY",
+      };
+      const conv: {
+        name: string;
+        instructions: string;
+        systemType: string | null;
+      } = {
+        name: "Conv",
+        instructions: "",
+        systemType: null,
+      };
+
+      const result = filterMultipleSystemRules([
+        { rule: sysA, isPrimary: false },
+        { rule: sysB },
+        { rule: conv },
+      ]);
+
+      expect(result).toEqual([sysA, sysB, conv]);
+    });
+
+    it("keeps only the primary system rule when multiple system rules present", () => {
+      const sysA: {
+        name: string;
+        instructions: string;
+        systemType: string | null;
+      } = {
+        name: "Sys A",
+        instructions: "",
+        systemType: "TO_REPLY",
+      };
+      const sysB: {
+        name: string;
+        instructions: string;
+        systemType: string | null;
+      } = {
+        name: "Sys B",
+        instructions: "",
+        systemType: "AWAITING_REPLY",
+      };
+      const conv: {
+        name: string;
+        instructions: string;
+        systemType: string | null;
+      } = {
+        name: "Conv",
+        instructions: "",
+        systemType: null,
+      };
+
+      const result = filterMultipleSystemRules([
+        { rule: sysA, isPrimary: false },
+        { rule: sysB, isPrimary: true },
+        { rule: conv },
+      ]);
+
+      expect(result).toEqual([sysB, conv]);
+    });
+  });
+
+  describe("Group rules fallthrough when no groups exist", () => {
+    it("falls through to static/AI evaluation when getGroupsWithRules returns empty", async () => {
+      const groupRule = getRule({
+        id: "group-rule-1",
+        from: "group@example.com",
+        groupId: "g1",
+      });
+
+      // Ensure provider treats this as non-thread
+      const providerNoThread = {
+        isReplyInThread: vi.fn().mockReturnValue(false),
+      } as unknown as EmailProvider;
+
+      // Mock groups to be empty so the code path skips learned pattern branch
+      const groupModule = await import("@/utils/group/find-matching-group");
+      vi.spyOn(groupModule, "getGroupsWithRules").mockResolvedValue([] as any);
+
+      const rules = [groupRule];
+      const message = getMessage({
+        headers: getHeaders({ from: "group@example.com" }),
+      });
+      const emailAccount = getEmailAccount();
+
+      const result = await findMatchingRules({
+        rules,
+        message,
+        emailAccount,
+        provider: providerNoThread,
+        modelType: "default",
+      });
+
+      // Should match via static evaluation since groups are empty
+      expect(result.matches).toHaveLength(1);
+      expect(result.matches[0]?.rule.id).toBe("group-rule-1");
+    });
+  });
+  describe("Thread continuity - runOnThreads=false rules", () => {
+    it("should continue applying rule in a thread when it was previously applied", async () => {
+      const notifRule = getRule({
+        id: "notif-rule",
+        from: "notif@example.com",
+        runOnThreads: false,
+      });
+
+      // Mock provider to indicate this is a thread
+      const threadProvider = {
+        isReplyInThread: vi.fn().mockReturnValue(true),
+      } as unknown as EmailProvider;
+
+      // Mock DB to return previously executed rule id
+      prisma.executedRule.findMany.mockResolvedValue([
+        { ruleId: "notif-rule" },
+      ] as any);
+
+      const rules = [notifRule];
+      const message = getMessage({
+        headers: getHeaders({ from: "notif@example.com" }),
+      });
+      const emailAccount = getEmailAccount();
+
+      const result = await findMatchingRules({
+        rules,
+        message,
+        emailAccount,
+        provider: threadProvider,
+        modelType: "default",
+      });
+
+      expect(prisma.executedRule.findMany).toHaveBeenCalledTimes(1);
+      expect(result.matches).toHaveLength(1);
+      expect(result.matches[0]?.rule.id).toBe("notif-rule");
+    });
+
+    it("should lazy-load previous rules only once for multiple runOnThreads=false rules", async () => {
+      const ruleA = getRule({
+        id: "rule-a",
+        from: "multi@example.com",
+        runOnThreads: false,
+      });
+      const ruleB = getRule({
+        id: "rule-b",
+        from: "multi@example.com",
+        runOnThreads: false,
+      });
+
+      const threadProvider = {
+        isReplyInThread: vi.fn().mockReturnValue(true),
+      } as unknown as EmailProvider;
+
+      prisma.executedRule.findMany.mockResolvedValue([
+        { ruleId: "rule-a" },
+        { ruleId: "rule-b" },
+      ] as any);
+
+      const rules = [ruleA, ruleB];
+      const message = getMessage({
+        headers: getHeaders({ from: "multi@example.com" }),
+      });
+      const emailAccount = getEmailAccount();
+
+      const result = await findMatchingRules({
+        rules,
+        message,
+        emailAccount,
+        provider: threadProvider,
+        modelType: "default",
+      });
+
+      expect(prisma.executedRule.findMany).toHaveBeenCalledTimes(1);
+      expect(result.matches.map((m) => m.rule.id).sort()).toEqual([
+        "rule-a",
+        "rule-b",
+      ]);
+    });
+
+    it("should not query DB when message is not a thread", async () => {
+      const notifRule = getRule({
+        id: "not-thread",
+        from: "no-thread@example.com",
+        runOnThreads: false,
+      });
+
+      const providerNotThread = {
+        isReplyInThread: vi.fn().mockReturnValue(false),
+      } as unknown as EmailProvider;
+
+      const rules = [notifRule];
+      const message = getMessage({
+        headers: getHeaders({ from: "no-thread@example.com" }),
+      });
+      const emailAccount = getEmailAccount();
+
+      const result = await findMatchingRules({
+        rules,
+        message,
+        emailAccount,
+        provider: providerNotThread,
+        modelType: "default",
+      });
+
+      expect(prisma.executedRule.findMany).not.toHaveBeenCalled();
+      // Not a thread, so normal matching applies (matches by static from)
+      expect(result.matches).toHaveLength(1);
+      expect(result.matches[0]?.rule.id).toBe("not-thread");
+    });
+
+    it("should not query DB when rule has runOnThreads=true (even in a thread)", async () => {
+      const threadRule = getRule({
+        id: "thread-ok",
+        from: "yes-thread@example.com",
+        runOnThreads: true,
+      });
+
+      const threadProvider = {
+        isReplyInThread: vi.fn().mockReturnValue(true),
+      } as unknown as EmailProvider;
+
+      const rules = [threadRule];
+      const message = getMessage({
+        headers: getHeaders({ from: "yes-thread@example.com" }),
+      });
+      const emailAccount = getEmailAccount();
+
+      const result = await findMatchingRules({
+        rules,
+        message,
+        emailAccount,
+        provider: threadProvider,
+        modelType: "default",
+      });
+
+      expect(prisma.executedRule.findMany).not.toHaveBeenCalled();
+      expect(result.matches).toHaveLength(1);
+      expect(result.matches[0]?.rule.id).toBe("thread-ok");
+    });
+  });
+
   it("should handle invalid regex patterns gracefully", () => {
     const rule = getRule({
       from: "[invalid(regex",
@@ -1910,6 +2166,135 @@ describe("findMatchingRules - Integration Tests", () => {
     expect(aiChooseRule).toHaveBeenCalled();
     expect(result.matches[0]?.rule.id).toBe("mixed-rule");
   });
+
+  it("merges static match with AI rule and combines reasoning text", async () => {
+    const staticRule = getRule({
+      id: "static-rule-1",
+      from: "reason@example.com",
+    });
+    const aiOnlyRule = getRule({ id: "ai-rule-2", instructions: "Do X" });
+
+    // Ensure potentialAiMatches includes aiOnlyRule
+    vi.mocked(aiChooseRule).mockResolvedValue({
+      rules: [aiOnlyRule as any],
+      reason: "AI reasoning here",
+    });
+
+    const rules = [staticRule, aiOnlyRule];
+    const message = getMessage({
+      headers: getHeaders({ from: "reason@example.com" }),
+    });
+    const emailAccount = getEmailAccount();
+
+    const result = await findMatchingRules({
+      rules,
+      message,
+      emailAccount,
+      provider,
+      modelType: "default",
+    });
+
+    // Reasoning should combine existing matchReasons text + AI reason
+    // existing part comes from getMatchReason => "Matched static conditions"
+    expect(result.reasoning).toBe(
+      "Matched static conditions; AI reasoning here",
+    );
+  });
+
+  it("matchesStaticRule: catches RegExp construction error and returns false", () => {
+    const rule = getRule({ from: "trigger-error" });
+    const message = getMessage({
+      headers: getHeaders({ from: "any@example.com" }),
+    });
+
+    const OriginalRegExp = RegExp;
+    // Monkeypatch RegExp to throw for our specific pattern
+    // Only for this test; restore afterwards
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    (globalThis as any).RegExp = ((pattern: string) => {
+      if (pattern.includes("trigger-error")) {
+        throw new Error("synthetic error");
+      }
+      // Delegate to original
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      return new (OriginalRegExp as any)(pattern);
+    }) as unknown as RegExpConstructor;
+
+    try {
+      const matched = matchesStaticRule(rule as any, message as any);
+      expect(matched).toBe(false);
+    } finally {
+      // restore
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      (globalThis as any).RegExp =
+        OriginalRegExp as unknown as RegExpConstructor;
+    }
+  });
+
+  it("AI path: returns only AI reasoning when no static matches and AI returns no rules", async () => {
+    const aiOnlyRule = getRule({ id: "ai-only-1", instructions: "Do Y" });
+
+    vi.mocked(aiChooseRule).mockResolvedValue({
+      rules: [],
+      reason: "AI had reasoning but selected nothing",
+    });
+
+    const rules = [aiOnlyRule];
+    const message = getMessage({
+      // No static matchers
+      headers: getHeaders({ from: "nobody@example.com" }),
+    });
+    const emailAccount = getEmailAccount();
+
+    const result = await findMatchingRules({
+      rules,
+      message,
+      emailAccount,
+      provider,
+      modelType: "default",
+    });
+
+    expect(result.matches.map((m) => m.rule.id)).toEqual([]);
+    expect(result.reasoning).toBe("AI had reasoning but selected nothing");
+  });
+
+  it("AI path: dedups AI-selected rule when it duplicates a static match", async () => {
+    const dupRule = getRule({
+      id: "dup-rule",
+      from: "dup@example.com",
+      instructions: "Use AI too",
+      runOnThreads: true,
+    });
+
+    vi.mocked(aiChooseRule).mockResolvedValue({
+      rules: [{ rule: dupRule as any }],
+      reason: "AI selects dup-rule",
+    });
+
+    const rules = [dupRule];
+    const message = getMessage({
+      headers: getHeaders({ from: "dup@example.com" }),
+    });
+    const emailAccount = getEmailAccount();
+
+    const spy = vi.spyOn(provider, "isReplyInThread").mockReturnValue(false);
+    try {
+      const result = await findMatchingRules({
+        rules,
+        message,
+        emailAccount,
+        provider,
+        modelType: "default",
+      });
+
+      // Only one occurrence of dup-rule should remain
+      const ids = result.matches.map((m) => m.rule.id);
+      expect(ids).toEqual(["dup-rule"]);
+      expect(result.reasoning).toContain("AI selects dup-rule");
+    } finally {
+      spy.mockRestore();
+    }
+  });
 });
 
 describe("evaluateRuleConditions", () => {
diff --git a/apps/web/utils/ai/choose-rule/run-rules.test.ts b/apps/web/utils/ai/choose-rule/run-rules.test.ts
index 1b9534cf4c..9e7b93ff63 100644
--- a/apps/web/utils/ai/choose-rule/run-rules.test.ts
+++ b/apps/web/utils/ai/choose-rule/run-rules.test.ts
@@ -18,7 +18,6 @@ describe("ensureConversationRuleContinuity", () => {
 
   const emailAccountId = "account-1";
   const threadId = "thread-1";
-  const messageId = "msg-1";
 
   const createRule = (
     id: string,

From 121d762240a5d0a229fe25774409c17688d7ed6e Mon Sep 17 00:00:00 2001
From: Eliezer Steinbock <3090527+elie222@users.noreply.github.com>
Date: Mon, 20 Oct 2025 14:47:20 +0300
Subject: [PATCH 23/40] update ui components

---
 apps/web/components/ExpandableText.tsx        |   2 +-
 apps/web/components/ProgressPanel.tsx         |   2 +-
 apps/web/components/TabSelect.tsx             |   2 +-
 apps/web/components/ai-elements/actions.tsx   |   4 +-
 .../web/components/ai-elements/code-block.tsx |   2 +-
 .../components/ai-elements/conversation.tsx   |  37 +++++-
 apps/web/components/ai-elements/loader.tsx    |   2 +-
 apps/web/components/ai-elements/message.tsx   |   2 +-
 apps/web/components/ai-elements/reasoning.tsx |   9 +-
 apps/web/components/ai-elements/response.tsx  |   2 +-
 apps/web/components/ai-elements/shimmer.tsx   |  64 ++++++++++
 .../web/components/ai-elements/suggestion.tsx |   2 +-
 apps/web/components/ai-elements/tool.tsx      |  25 +++-
 apps/web/components/ui/alert-dialog.tsx       |   2 +-
 apps/web/components/ui/form.tsx               |   2 +-
 apps/web/components/ui/input.tsx              |   2 +-
 apps/web/components/ui/progress.tsx           |   2 +-
 apps/web/components/ui/scroll-area.tsx        |   4 +-
 apps/web/components/ui/select.tsx             |  51 +++++++-
 apps/web/package.json                         |   4 +-
 pnpm-lock.yaml                                | 109 +++++++++++++++++-
 21 files changed, 292 insertions(+), 39 deletions(-)
 create mode 100644 apps/web/components/ai-elements/shimmer.tsx

diff --git a/apps/web/components/ExpandableText.tsx b/apps/web/components/ExpandableText.tsx
index 28c9b34123..b1d98c9db9 100644
--- a/apps/web/components/ExpandableText.tsx
+++ b/apps/web/components/ExpandableText.tsx
@@ -2,7 +2,7 @@
 
 import { useState } from "react";
 import { ChevronDownIcon, ChevronUpIcon } from "lucide-react";
-import { motion } from "framer-motion";
+import { motion } from "motion/react";
 import { cn } from "@/utils";
 
 export function ExpandableText({
diff --git a/apps/web/components/ProgressPanel.tsx b/apps/web/components/ProgressPanel.tsx
index e4485aeb95..75fc327d97 100644
--- a/apps/web/components/ProgressPanel.tsx
+++ b/apps/web/components/ProgressPanel.tsx
@@ -1,6 +1,6 @@
 "use client";
 
-import { AnimatePresence, motion } from "framer-motion";
+import { AnimatePresence, motion } from "motion/react";
 import { ProgressBar } from "@tremor/react";
 import { cn } from "@/utils";
 import { LoadingMiniSpinner } from "@/components/Loading";
diff --git a/apps/web/components/TabSelect.tsx b/apps/web/components/TabSelect.tsx
index f6a315b219..fc0f9d040e 100644
--- a/apps/web/components/TabSelect.tsx
+++ b/apps/web/components/TabSelect.tsx
@@ -10,7 +10,7 @@
  */
 import { cn } from "@/utils";
 import { cva, type VariantProps } from "class-variance-authority";
-import { LayoutGroup, motion } from "framer-motion";
+import { LayoutGroup, motion } from "motion/react";
 import Link from "next/link";
 import { type Dispatch, type SetStateAction, useId } from "react";
 import { ArrowUpRight } from "lucide-react";
diff --git a/apps/web/components/ai-elements/actions.tsx b/apps/web/components/ai-elements/actions.tsx
index 76fbfeeee5..1d189e8a89 100644
--- a/apps/web/components/ai-elements/actions.tsx
+++ b/apps/web/components/ai-elements/actions.tsx
@@ -7,7 +7,7 @@ import {
   TooltipProvider,
   TooltipTrigger,
 } from "@/components/ui/tooltip";
-import { cn } from "@/utils";
+import { cn } from "@/utils/index";
 import type { ComponentProps } from "react";
 
 export type ActionsProps = ComponentProps<"div">;
@@ -35,7 +35,7 @@ export const Action = ({
   const button = (
     <Button
       className={cn(
-        "size-9 p-1.5 text-muted-foreground hover:text-foreground relative",
+        "relative size-9 p-1.5 text-muted-foreground hover:text-foreground",
         className,
       )}
       size={size}
diff --git a/apps/web/components/ai-elements/code-block.tsx b/apps/web/components/ai-elements/code-block.tsx
index bec4946ef4..9b761fc5f7 100644
--- a/apps/web/components/ai-elements/code-block.tsx
+++ b/apps/web/components/ai-elements/code-block.tsx
@@ -1,7 +1,7 @@
 "use client";
 
 import { Button } from "@/components/ui/button";
-import { cn } from "@/utils";
+import { cn } from "@/utils/index";
 import { CheckIcon, CopyIcon } from "lucide-react";
 import type { ComponentProps, HTMLAttributes, ReactNode } from "react";
 import { createContext, useContext, useState } from "react";
diff --git a/apps/web/components/ai-elements/conversation.tsx b/apps/web/components/ai-elements/conversation.tsx
index bd305e366d..0c4e69d4ee 100644
--- a/apps/web/components/ai-elements/conversation.tsx
+++ b/apps/web/components/ai-elements/conversation.tsx
@@ -1,7 +1,7 @@
 "use client";
 
 import { Button } from "@/components/ui/button";
-import { cn } from "@/utils";
+import { cn } from "@/utils/index";
 import { ArrowDownIcon } from "lucide-react";
 import type { ComponentProps } from "react";
 import { useCallback } from "react";
@@ -30,6 +30,41 @@ export const ConversationContent = ({
   <StickToBottom.Content className={cn("p-4", className)} {...props} />
 );
 
+export type ConversationEmptyStateProps = ComponentProps<"div"> & {
+  title?: string;
+  description?: string;
+  icon?: React.ReactNode;
+};
+
+export const ConversationEmptyState = ({
+  className,
+  title = "No messages yet",
+  description = "Start a conversation to see messages here",
+  icon,
+  children,
+  ...props
+}: ConversationEmptyStateProps) => (
+  <div
+    className={cn(
+      "flex size-full flex-col items-center justify-center gap-3 p-8 text-center",
+      className,
+    )}
+    {...props}
+  >
+    {children ?? (
+      <>
+        {icon && <div className="text-muted-foreground">{icon}</div>}
+        <div className="space-y-1">
+          <h3 className="font-medium text-sm">{title}</h3>
+          {description && (
+            <p className="text-muted-foreground text-sm">{description}</p>
+          )}
+        </div>
+      </>
+    )}
+  </div>
+);
+
 export type ConversationScrollButtonProps = ComponentProps<typeof Button>;
 
 export const ConversationScrollButton = ({
diff --git a/apps/web/components/ai-elements/loader.tsx b/apps/web/components/ai-elements/loader.tsx
index 5791d8ddcb..87960fd1e9 100644
--- a/apps/web/components/ai-elements/loader.tsx
+++ b/apps/web/components/ai-elements/loader.tsx
@@ -1,4 +1,4 @@
-import { cn } from "@/utils";
+import { cn } from "@/utils/index";
 import type { HTMLAttributes } from "react";
 
 type LoaderIconProps = {
diff --git a/apps/web/components/ai-elements/message.tsx b/apps/web/components/ai-elements/message.tsx
index 55a27ae111..89f117b21f 100644
--- a/apps/web/components/ai-elements/message.tsx
+++ b/apps/web/components/ai-elements/message.tsx
@@ -1,5 +1,5 @@
 import { Avatar, AvatarFallback, AvatarImage } from "@/components/ui/avatar";
-import { cn } from "@/utils";
+import { cn } from "@/utils/index";
 import type { UIMessage } from "ai";
 import { cva, type VariantProps } from "class-variance-authority";
 import type { ComponentProps, HTMLAttributes } from "react";
diff --git a/apps/web/components/ai-elements/reasoning.tsx b/apps/web/components/ai-elements/reasoning.tsx
index 51df275a9f..2c91891809 100644
--- a/apps/web/components/ai-elements/reasoning.tsx
+++ b/apps/web/components/ai-elements/reasoning.tsx
@@ -6,17 +6,18 @@ import {
   CollapsibleContent,
   CollapsibleTrigger,
 } from "@/components/ui/collapsible";
-import { cn } from "@/utils";
+import { cn } from "@/utils/index";
 import { BrainIcon, ChevronDownIcon } from "lucide-react";
 import type { ComponentProps } from "react";
 import { createContext, memo, useContext, useEffect, useState } from "react";
 import { Response } from "./response";
+import { Shimmer } from "./shimmer";
 
 type ReasoningContextValue = {
   isStreaming: boolean;
   isOpen: boolean;
   setIsOpen: (open: boolean) => void;
-  duration: number | undefined;
+  duration: number;
 };
 
 const ReasoningContext = createContext<ReasoningContextValue | null>(null);
@@ -58,7 +59,7 @@ export const Reasoning = memo(
     });
     const [duration, setDuration] = useControllableState({
       prop: durationProp,
-      defaultProp: undefined,
+      defaultProp: 0,
     });
 
     const [hasAutoClosed, setHasAutoClosed] = useState(false);
@@ -114,7 +115,7 @@ export type ReasoningTriggerProps = ComponentProps<typeof CollapsibleTrigger>;
 
 const getThinkingMessage = (isStreaming: boolean, duration?: number) => {
   if (isStreaming || duration === 0) {
-    return <p>Thinking...</p>;
+    return <Shimmer duration={1}>Thinking...</Shimmer>;
   }
   if (duration === undefined) {
     return <p>Thought for a few seconds</p>;
diff --git a/apps/web/components/ai-elements/response.tsx b/apps/web/components/ai-elements/response.tsx
index 24929dbed1..344b4d510b 100644
--- a/apps/web/components/ai-elements/response.tsx
+++ b/apps/web/components/ai-elements/response.tsx
@@ -1,6 +1,6 @@
 "use client";
 
-import { cn } from "@/utils";
+import { cn } from "@/utils/index";
 import { type ComponentProps, memo } from "react";
 import { Streamdown } from "streamdown";
 
diff --git a/apps/web/components/ai-elements/shimmer.tsx b/apps/web/components/ai-elements/shimmer.tsx
new file mode 100644
index 0000000000..aedcca10c5
--- /dev/null
+++ b/apps/web/components/ai-elements/shimmer.tsx
@@ -0,0 +1,64 @@
+"use client";
+
+import { cn } from "@/utils/index";
+import { motion } from "motion/react";
+import {
+  type CSSProperties,
+  type ElementType,
+  type JSX,
+  memo,
+  useMemo,
+} from "react";
+
+export type TextShimmerProps = {
+  children: string;
+  as?: ElementType;
+  className?: string;
+  duration?: number;
+  spread?: number;
+};
+
+const ShimmerComponent = ({
+  children,
+  as: Component = "p",
+  className,
+  duration = 2,
+  spread = 2,
+}: TextShimmerProps) => {
+  const MotionComponent = motion.create(
+    Component as keyof JSX.IntrinsicElements,
+  );
+
+  const dynamicSpread = useMemo(
+    () => (children?.length ?? 0) * spread,
+    [children, spread],
+  );
+
+  return (
+    <MotionComponent
+      animate={{ backgroundPosition: "0% center" }}
+      className={cn(
+        "relative inline-block bg-[length:250%_100%,auto] bg-clip-text text-transparent",
+        "[--bg:linear-gradient(90deg,#0000_calc(50%-var(--spread)),var(--color-background),#0000_calc(50%+var(--spread)))] [background-repeat:no-repeat,padding-box]",
+        className,
+      )}
+      initial={{ backgroundPosition: "100% center" }}
+      style={
+        {
+          "--spread": `${dynamicSpread}px`,
+          backgroundImage:
+            "var(--bg), linear-gradient(var(--color-muted-foreground), var(--color-muted-foreground))",
+        } as CSSProperties
+      }
+      transition={{
+        repeat: Number.POSITIVE_INFINITY,
+        duration,
+        ease: "linear",
+      }}
+    >
+      {children}
+    </MotionComponent>
+  );
+};
+
+export const Shimmer = memo(ShimmerComponent);
diff --git a/apps/web/components/ai-elements/suggestion.tsx b/apps/web/components/ai-elements/suggestion.tsx
index 8037addb82..3c6522ec19 100644
--- a/apps/web/components/ai-elements/suggestion.tsx
+++ b/apps/web/components/ai-elements/suggestion.tsx
@@ -2,7 +2,7 @@
 
 import { Button } from "@/components/ui/button";
 import { ScrollArea, ScrollBar } from "@/components/ui/scroll-area";
-import { cn } from "@/utils";
+import { cn } from "@/utils/index";
 import type { ComponentProps } from "react";
 
 export type SuggestionsProps = ComponentProps<typeof ScrollArea>;
diff --git a/apps/web/components/ai-elements/tool.tsx b/apps/web/components/ai-elements/tool.tsx
index 3aa963956e..12af7096ca 100644
--- a/apps/web/components/ai-elements/tool.tsx
+++ b/apps/web/components/ai-elements/tool.tsx
@@ -6,7 +6,7 @@ import {
   CollapsibleContent,
   CollapsibleTrigger,
 } from "@/components/ui/collapsible";
-import { cn } from "@/utils";
+import { cn } from "@/utils/index";
 import type { ToolUIPart } from "ai";
 import {
   CheckCircleIcon,
@@ -17,6 +17,7 @@ import {
   XCircleIcon,
 } from "lucide-react";
 import type { ComponentProps, ReactNode } from "react";
+import { isValidElement } from "react";
 import { CodeBlock } from "./code-block";
 
 export type ToolProps = ComponentProps<typeof Collapsible>;
@@ -29,6 +30,7 @@ export const Tool = ({ className, ...props }: ToolProps) => (
 );
 
 export type ToolHeaderProps = {
+  title?: string;
   type: ToolUIPart["type"];
   state: ToolUIPart["state"];
   className?: string;
@@ -50,7 +52,7 @@ const getStatusBadge = (status: ToolUIPart["state"]) => {
   } as const;
 
   return (
-    <Badge className="rounded-full text-xs" variant="secondary">
+    <Badge className="gap-1.5 rounded-full text-xs" variant="secondary">
       {icons[status]}
       {labels[status]}
     </Badge>
@@ -59,6 +61,7 @@ const getStatusBadge = (status: ToolUIPart["state"]) => {
 
 export const ToolHeader = ({
   className,
+  title,
   type,
   state,
   ...props
@@ -72,7 +75,9 @@ export const ToolHeader = ({
   >
     <div className="flex items-center gap-2">
       <WrenchIcon className="size-4 text-muted-foreground" />
-      <span className="font-medium text-sm">{type}</span>
+      <span className="font-medium text-sm">
+        {title ?? type.split("-").slice(1).join("-")}
+      </span>
       {getStatusBadge(state)}
     </div>
     <ChevronDownIcon className="size-4 text-muted-foreground transition-transform group-data-[state=open]:rotate-180" />
@@ -107,7 +112,7 @@ export const ToolInput = ({ className, input, ...props }: ToolInputProps) => (
 );
 
 export type ToolOutputProps = ComponentProps<"div"> & {
-  output: ReactNode;
+  output: ToolUIPart["output"];
   errorText: ToolUIPart["errorText"];
 };
 
@@ -121,6 +126,16 @@ export const ToolOutput = ({
     return null;
   }
 
+  let Output = <div>{output as ReactNode}</div>;
+
+  if (typeof output === "object" && !isValidElement(output)) {
+    Output = (
+      <CodeBlock code={JSON.stringify(output, null, 2)} language="json" />
+    );
+  } else if (typeof output === "string") {
+    Output = <CodeBlock code={output} language="json" />;
+  }
+
   return (
     <div className={cn("space-y-2 p-4", className)} {...props}>
       <h4 className="font-medium text-muted-foreground text-xs uppercase tracking-wide">
@@ -135,7 +150,7 @@ export const ToolOutput = ({
         )}
       >
         {errorText && <div>{errorText}</div>}
-        {output && <div>{output}</div>}
+        {Output}
       </div>
     </div>
   );
diff --git a/apps/web/components/ui/alert-dialog.tsx b/apps/web/components/ui/alert-dialog.tsx
index 254c7fb440..a7cd335b51 100644
--- a/apps/web/components/ui/alert-dialog.tsx
+++ b/apps/web/components/ui/alert-dialog.tsx
@@ -4,7 +4,7 @@ import * as React from "react";
 import * as AlertDialogPrimitive from "@radix-ui/react-alert-dialog";
 
 import { cn } from "@/utils";
-import { buttonVariants } from "@/components/ui//button";
+import { buttonVariants } from "@/components/ui/button";
 
 const AlertDialog = AlertDialogPrimitive.Root;
 
diff --git a/apps/web/components/ui/form.tsx b/apps/web/components/ui/form.tsx
index c7752d6c69..8bc0acac0c 100644
--- a/apps/web/components/ui/form.tsx
+++ b/apps/web/components/ui/form.tsx
@@ -13,7 +13,7 @@ import {
 } from "react-hook-form";
 
 import { cn } from "@/utils";
-import { Label } from "@/components/ui//label";
+import { Label } from "@/components/ui/label";
 
 const Form = FormProvider;
 
diff --git a/apps/web/components/ui/input.tsx b/apps/web/components/ui/input.tsx
index ab94e5e1ba..213900a1f1 100644
--- a/apps/web/components/ui/input.tsx
+++ b/apps/web/components/ui/input.tsx
@@ -1,6 +1,6 @@
 import * as React from "react";
 
-import { cn } from "@/utils";
+import { cn } from "@/utils/index";
 
 // Note we usually use /components/Input.tsx instead of this one
 const Input = React.forwardRef<HTMLInputElement, React.ComponentProps<"input">>(
diff --git a/apps/web/components/ui/progress.tsx b/apps/web/components/ui/progress.tsx
index 42db6e6838..3ebcd4247e 100644
--- a/apps/web/components/ui/progress.tsx
+++ b/apps/web/components/ui/progress.tsx
@@ -3,7 +3,7 @@
 import * as React from "react";
 import * as ProgressPrimitive from "@radix-ui/react-progress";
 
-import { cn } from "@/utils";
+import { cn } from "@/utils/index";
 
 const Progress = React.forwardRef<
   React.ElementRef<typeof ProgressPrimitive.Root>,
diff --git a/apps/web/components/ui/scroll-area.tsx b/apps/web/components/ui/scroll-area.tsx
index 8ba4039996..d8e9b2971e 100644
--- a/apps/web/components/ui/scroll-area.tsx
+++ b/apps/web/components/ui/scroll-area.tsx
@@ -3,7 +3,7 @@
 import * as React from "react";
 import * as ScrollAreaPrimitive from "@radix-ui/react-scroll-area";
 
-import { cn } from "@/utils";
+import { cn } from "@/utils/index";
 
 const ScrollArea = React.forwardRef<
   React.ElementRef<typeof ScrollAreaPrimitive.Root>,
@@ -40,7 +40,7 @@ const ScrollBar = React.forwardRef<
     )}
     {...props}
   >
-    <ScrollAreaPrimitive.ScrollAreaThumb className="relative flex-1 rounded-full bg-slate-200 dark:bg-slate-800" />
+    <ScrollAreaPrimitive.ScrollAreaThumb className="relative flex-1 rounded-full bg-border" />
   </ScrollAreaPrimitive.ScrollAreaScrollbar>
 ));
 ScrollBar.displayName = ScrollAreaPrimitive.ScrollAreaScrollbar.displayName;
diff --git a/apps/web/components/ui/select.tsx b/apps/web/components/ui/select.tsx
index b1e249ad45..c864ad22d8 100644
--- a/apps/web/components/ui/select.tsx
+++ b/apps/web/components/ui/select.tsx
@@ -2,9 +2,9 @@
 
 import * as React from "react";
 import * as SelectPrimitive from "@radix-ui/react-select";
-import { Check, ChevronDown } from "lucide-react";
+import { Check, ChevronDown, ChevronUp } from "lucide-react";
 
-import { cn } from "@/utils";
+import { cn } from "@/utils/index";
 
 const Select = SelectPrimitive.Root;
 
@@ -19,7 +19,7 @@ const SelectTrigger = React.forwardRef<
   <SelectPrimitive.Trigger
     ref={ref}
     className={cn(
-      "flex h-10 w-full items-center justify-between rounded-md border border-input bg-background px-3 py-2 text-sm text-foreground ring-offset-background placeholder:text-muted-foreground focus:outline-none focus:ring-2 focus:ring-ring focus:ring-offset-2 disabled:cursor-not-allowed disabled:opacity-50",
+      "flex h-10 w-full items-center justify-between rounded-md border border-input bg-background px-3 py-2 text-sm ring-offset-background data-[placeholder]:text-muted-foreground focus:outline-none focus:ring-2 focus:ring-ring focus:ring-offset-2 disabled:cursor-not-allowed disabled:opacity-50 [&>span]:line-clamp-1",
       className,
     )}
     {...props}
@@ -32,6 +32,41 @@ const SelectTrigger = React.forwardRef<
 ));
 SelectTrigger.displayName = SelectPrimitive.Trigger.displayName;
 
+const SelectScrollUpButton = React.forwardRef<
+  React.ElementRef<typeof SelectPrimitive.ScrollUpButton>,
+  React.ComponentPropsWithoutRef<typeof SelectPrimitive.ScrollUpButton>
+>(({ className, ...props }, ref) => (
+  <SelectPrimitive.ScrollUpButton
+    ref={ref}
+    className={cn(
+      "flex cursor-default items-center justify-center py-1",
+      className,
+    )}
+    {...props}
+  >
+    <ChevronUp className="h-4 w-4" />
+  </SelectPrimitive.ScrollUpButton>
+));
+SelectScrollUpButton.displayName = SelectPrimitive.ScrollUpButton.displayName;
+
+const SelectScrollDownButton = React.forwardRef<
+  React.ElementRef<typeof SelectPrimitive.ScrollDownButton>,
+  React.ComponentPropsWithoutRef<typeof SelectPrimitive.ScrollDownButton>
+>(({ className, ...props }, ref) => (
+  <SelectPrimitive.ScrollDownButton
+    ref={ref}
+    className={cn(
+      "flex cursor-default items-center justify-center py-1",
+      className,
+    )}
+    {...props}
+  >
+    <ChevronDown className="h-4 w-4" />
+  </SelectPrimitive.ScrollDownButton>
+));
+SelectScrollDownButton.displayName =
+  SelectPrimitive.ScrollDownButton.displayName;
+
 const SelectContent = React.forwardRef<
   React.ElementRef<typeof SelectPrimitive.Content>,
   React.ComponentPropsWithoutRef<typeof SelectPrimitive.Content>
@@ -40,7 +75,7 @@ const SelectContent = React.forwardRef<
     <SelectPrimitive.Content
       ref={ref}
       className={cn(
-        "relative z-50 min-w-[8rem] overflow-hidden rounded-md border border-slate-200 bg-background text-slate-950 shadow-md data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 dark:border-slate-800 dark:text-slate-50",
+        "relative z-50 max-h-[--radix-select-content-available-height] min-w-[8rem] overflow-y-auto overflow-x-hidden rounded-md border bg-popover text-popover-foreground shadow-md data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 origin-[--radix-select-content-transform-origin]",
         position === "popper" &&
           "data-[side=bottom]:translate-y-1 data-[side=left]:-translate-x-1 data-[side=right]:translate-x-1 data-[side=top]:-translate-y-1",
         className,
@@ -48,6 +83,7 @@ const SelectContent = React.forwardRef<
       position={position}
       {...props}
     >
+      <SelectScrollUpButton />
       <SelectPrimitive.Viewport
         className={cn(
           "p-1",
@@ -57,6 +93,7 @@ const SelectContent = React.forwardRef<
       >
         {children}
       </SelectPrimitive.Viewport>
+      <SelectScrollDownButton />
     </SelectPrimitive.Content>
   </SelectPrimitive.Portal>
 ));
@@ -81,7 +118,7 @@ const SelectItem = React.forwardRef<
   <SelectPrimitive.Item
     ref={ref}
     className={cn(
-      "relative flex w-full cursor-default select-none items-center rounded-sm py-1.5 pl-8 pr-2 text-sm outline-none focus:bg-slate-100 focus:text-primary data-[disabled]:pointer-events-none data-[disabled]:opacity-50 dark:focus:bg-slate-800 dark:focus:text-slate-50",
+      "relative flex w-full cursor-default select-none items-center rounded-sm py-1.5 pl-8 pr-2 text-sm outline-none focus:bg-accent focus:text-accent-foreground data-[disabled]:pointer-events-none data-[disabled]:opacity-50",
       className,
     )}
     {...props}
@@ -103,7 +140,7 @@ const SelectSeparator = React.forwardRef<
 >(({ className, ...props }, ref) => (
   <SelectPrimitive.Separator
     ref={ref}
-    className={cn("-mx-1 my-1 h-px bg-slate-100 dark:bg-slate-800", className)}
+    className={cn("-mx-1 my-1 h-px bg-muted", className)}
     {...props}
   />
 ));
@@ -118,4 +155,6 @@ export {
   SelectLabel,
   SelectItem,
   SelectSeparator,
+  SelectScrollUpButton,
+  SelectScrollDownButton,
 };
diff --git a/apps/web/package.json b/apps/web/package.json
index d0d3903638..88a97b66cd 100644
--- a/apps/web/package.json
+++ b/apps/web/package.json
@@ -108,7 +108,6 @@
     "encoding": "0.1.13",
     "fast-deep-equal": "3.1.3",
     "fast-xml-parser": "5.2.5",
-    "framer-motion": "12.23.12",
     "gmail-api-parse-message": "2.1.2",
     "google": "link:@next/third-parties/google",
     "he": "1.2.0",
@@ -122,6 +121,8 @@
     "linkifyjs": "4.3.2",
     "lodash": "4.17.21",
     "lucide-react": "0.542.0",
+    "motion": "12.23.24",
+    "nanoid": "5.1.5",
     "next": "15.5.2",
     "next-axiom": "1.9.2",
     "next-safe-action": "7.10.8",
@@ -160,6 +161,7 @@
     "tailwind-merge": "2.6.0",
     "tailwindcss-animate": "1.0.7",
     "tiptap-markdown": "0.8.10",
+    "tokenlens": "1.3.1",
     "typescript": "5.9.2",
     "use-stick-to-bottom": "1.1.1",
     "usehooks-ts": "3.1.1",
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 90f562d87b..f189de136b 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -375,9 +375,6 @@ importers:
       fast-xml-parser:
         specifier: 5.2.5
         version: 5.2.5
-      framer-motion:
-        specifier: 12.23.12
-        version: 12.23.12(@emotion/is-prop-valid@1.2.2)(react-dom@19.1.1(react@19.1.1))(react@19.1.1)
       gmail-api-parse-message:
         specifier: 2.1.2
         version: 2.1.2
@@ -417,6 +414,12 @@ importers:
       lucide-react:
         specifier: 0.542.0
         version: 0.542.0(react@19.1.1)
+      motion:
+        specifier: 12.23.24
+        version: 12.23.24(@emotion/is-prop-valid@1.2.2)(react-dom@19.1.1(react@19.1.1))(react@19.1.1)
+      nanoid:
+        specifier: 5.1.5
+        version: 5.1.5
       next:
         specifier: 15.5.2
         version: 15.5.2(@babel/core@7.28.3)(@opentelemetry/api@1.9.0)(react-dom@19.1.1(react@19.1.1))(react@19.1.1)
@@ -531,6 +534,9 @@ importers:
       tiptap-markdown:
         specifier: 0.8.10
         version: 0.8.10(@tiptap/core@2.26.1(@tiptap/pm@2.26.1))
+      tokenlens:
+        specifier: 1.3.1
+        version: 1.3.1
       typescript:
         specifier: 5.9.2
         version: 5.9.2
@@ -4498,6 +4504,18 @@ packages:
       '@tiptap/core': ^2.7.0
       '@tiptap/pm': ^2.7.0
 
+  '@tokenlens/core@1.3.0':
+    resolution: {integrity: sha512-d8YNHNC+q10bVpi95fELJwJyPVf1HfvBEI18eFQxRSZTdByXrP+f/ZtlhSzkx0Jl0aEmYVeBA5tPeeYRioLViQ==}
+
+  '@tokenlens/fetch@1.3.0':
+    resolution: {integrity: sha512-RONDRmETYly9xO8XMKblmrZjKSwCva4s5ebJwQNfNlChZoA5kplPoCgnWceHnn1J1iRjLVlrCNB43ichfmGBKQ==}
+
+  '@tokenlens/helpers@1.3.1':
+    resolution: {integrity: sha512-t6yL8N6ES8337E6eVSeH4hCKnPdWkZRFpupy9w5E66Q9IeqQ9IO7XQ6gh12JKjvWiRHuyyJ8MBP5I549Cr41EQ==}
+
+  '@tokenlens/models@1.3.0':
+    resolution: {integrity: sha512-9mx7ZGeewW4ndXAiD7AT1bbCk4OpJeortbjHHyNkgap+pMPPn1chY6R5zqe1ggXIUzZ2l8VOAKfPqOvpcrisJw==}
+
   '@tootallnate/quickjs-emscripten@0.23.0':
     resolution: {integrity: sha512-C5Mc6rdnsaJDjO3UpGW/CQTHtCKaYlScZTly4JIu97Jxo/odCiH0ITnDXSJPTOrEKk/ycSZ0AOgTmkDtkOsvIA==}
 
@@ -6908,6 +6926,20 @@ packages:
       react-dom:
         optional: true
 
+  framer-motion@12.23.24:
+    resolution: {integrity: sha512-HMi5HRoRCTou+3fb3h9oTLyJGBxHfW+HnNE25tAXOvVx/IvwMHK0cx7IR4a2ZU6sh3IX1Z+4ts32PcYBOqka8w==}
+    peerDependencies:
+      '@emotion/is-prop-valid': '*'
+      react: ^18.0.0 || ^19.0.0
+      react-dom: ^18.0.0 || ^19.0.0
+    peerDependenciesMeta:
+      '@emotion/is-prop-valid':
+        optional: true
+      react:
+        optional: true
+      react-dom:
+        optional: true
+
   fresh@0.5.2:
     resolution: {integrity: sha512-zJ2mQYM18rEFOudeV4GShTGIQ7RbzA7ozbU9I/XBpm7kqgMywgmylMwXHxZJmkVoYkna9d2pVXVXPdYTP9ej8Q==}
     engines: {node: '>= 0.6'}
@@ -8392,9 +8424,26 @@ packages:
   motion-dom@12.23.12:
     resolution: {integrity: sha512-RcR4fvMCTESQBD/uKQe49D5RUeDOokkGRmz4ceaJKDBgHYtZtntC/s2vLvY38gqGaytinij/yi3hMcWVcEF5Kw==}
 
+  motion-dom@12.23.23:
+    resolution: {integrity: sha512-n5yolOs0TQQBRUFImrRfs/+6X4p3Q4n1dUEqt/H58Vx7OW6RF+foWEgmTVDhIWJIMXOuNNL0apKH2S16en9eiA==}
+
   motion-utils@12.23.6:
     resolution: {integrity: sha512-eAWoPgr4eFEOFfg2WjIsMoqJTW6Z8MTUCgn/GZ3VRpClWBdnbjryiA3ZSNLyxCTmCQx4RmYX6jX1iWHbenUPNQ==}
 
+  motion@12.23.24:
+    resolution: {integrity: sha512-Rc5E7oe2YZ72N//S3QXGzbnXgqNrTESv8KKxABR20q2FLch9gHLo0JLyYo2hZ238bZ9Gx6cWhj9VO0IgwbMjCw==}
+    peerDependencies:
+      '@emotion/is-prop-valid': '*'
+      react: ^18.0.0 || ^19.0.0
+      react-dom: ^18.0.0 || ^19.0.0
+    peerDependenciesMeta:
+      '@emotion/is-prop-valid':
+        optional: true
+      react:
+        optional: true
+      react-dom:
+        optional: true
+
   mrmime@2.0.1:
     resolution: {integrity: sha512-Y3wQdFg2Va6etvQ5I82yUhGdsKrcYox6p7FfL1LbK2J4V01F9TGlepTIhnK24t7koZibmg82KGglhA1XK5IsLQ==}
     engines: {node: '>=10'}
@@ -10538,6 +10587,9 @@ packages:
     resolution: {integrity: sha512-o5sSPKEkg/DIQNmH43V0/uerLrpzVedkUh8tGNvaeXpfpuwjKenlSox/2O/BTlZUtEe+JG7s5YhEz608PlAHRA==}
     engines: {node: '>=0.6'}
 
+  tokenlens@1.3.1:
+    resolution: {integrity: sha512-7oxmsS5PNCX3z+b+z07hL5vCzlgHKkCGrEQjQmWl5l+v5cUrtL7S1cuST4XThaL1XyjbTX8J5hfP0cjDJRkaLA==}
+
   totalist@3.0.1:
     resolution: {integrity: sha512-sf4i37nQ2LBx4m3wB74y+ubopq6W/dIzXg0FDGjsYnZHVa1Da8FH853wlL2gtUhg+xJXjfk3kUZS3BRoQeoQBQ==}
     engines: {node: '>=6'}
@@ -13113,7 +13165,7 @@ snapshots:
   '@jridgewell/remapping@2.3.5':
     dependencies:
       '@jridgewell/gen-mapping': 0.3.13
-      '@jridgewell/trace-mapping': 0.3.30
+      '@jridgewell/trace-mapping': 0.3.31
     optional: true
 
   '@jridgewell/resolve-uri@3.1.2': {}
@@ -13121,7 +13173,7 @@ snapshots:
   '@jridgewell/source-map@0.3.11':
     dependencies:
       '@jridgewell/gen-mapping': 0.3.13
-      '@jridgewell/trace-mapping': 0.3.30
+      '@jridgewell/trace-mapping': 0.3.31
 
   '@jridgewell/sourcemap-codec@1.5.5': {}
 
@@ -15839,6 +15891,21 @@ snapshots:
       '@tiptap/core': 2.26.1(@tiptap/pm@2.26.1)
       '@tiptap/pm': 2.26.1
 
+  '@tokenlens/core@1.3.0': {}
+
+  '@tokenlens/fetch@1.3.0':
+    dependencies:
+      '@tokenlens/core': 1.3.0
+
+  '@tokenlens/helpers@1.3.1':
+    dependencies:
+      '@tokenlens/core': 1.3.0
+      '@tokenlens/fetch': 1.3.0
+
+  '@tokenlens/models@1.3.0':
+    dependencies:
+      '@tokenlens/core': 1.3.0
+
   '@tootallnate/quickjs-emscripten@0.23.0': {}
 
   '@tremor/react@3.18.7(react-dom@19.1.1(react@19.1.1))(react@19.1.1)':
@@ -18543,6 +18610,16 @@ snapshots:
       react: 19.1.1
       react-dom: 19.1.1(react@19.1.1)
 
+  framer-motion@12.23.24(@emotion/is-prop-valid@1.2.2)(react-dom@19.1.1(react@19.1.1))(react@19.1.1):
+    dependencies:
+      motion-dom: 12.23.23
+      motion-utils: 12.23.6
+      tslib: 2.8.1
+    optionalDependencies:
+      '@emotion/is-prop-valid': 1.2.2
+      react: 19.1.1
+      react-dom: 19.1.1(react@19.1.1)
+
   fresh@0.5.2: {}
 
   fresh@2.0.0: {}
@@ -20458,8 +20535,21 @@ snapshots:
     dependencies:
       motion-utils: 12.23.6
 
+  motion-dom@12.23.23:
+    dependencies:
+      motion-utils: 12.23.6
+
   motion-utils@12.23.6: {}
 
+  motion@12.23.24(@emotion/is-prop-valid@1.2.2)(react-dom@19.1.1(react@19.1.1))(react@19.1.1):
+    dependencies:
+      framer-motion: 12.23.24(@emotion/is-prop-valid@1.2.2)(react-dom@19.1.1(react@19.1.1))(react@19.1.1)
+      tslib: 2.8.1
+    optionalDependencies:
+      '@emotion/is-prop-valid': 1.2.2
+      react: 19.1.1
+      react-dom: 19.1.1(react@19.1.1)
+
   mrmime@2.0.1: {}
 
   ms@2.0.0: {}
@@ -22962,7 +23052,7 @@ snapshots:
 
   terser-webpack-plugin@5.3.14(esbuild@0.25.9)(webpack@5.101.3(esbuild@0.25.9)):
     dependencies:
-      '@jridgewell/trace-mapping': 0.3.30
+      '@jridgewell/trace-mapping': 0.3.31
       jest-worker: 27.5.1
       schema-utils: 4.3.2
       serialize-javascript: 6.0.2
@@ -23091,6 +23181,13 @@ snapshots:
 
   toidentifier@1.0.1: {}
 
+  tokenlens@1.3.1:
+    dependencies:
+      '@tokenlens/core': 1.3.0
+      '@tokenlens/fetch': 1.3.0
+      '@tokenlens/helpers': 1.3.1
+      '@tokenlens/models': 1.3.0
+
   totalist@3.0.1: {}
 
   tough-cookie@4.1.4:

From f124aa158fa5b05b27d738fe21b722591a0500f6 Mon Sep 17 00:00:00 2001
From: Eliezer Steinbock <3090527+elie222@users.noreply.github.com>
Date: Mon, 20 Oct 2025 14:48:57 +0300
Subject: [PATCH 24/40] dont store executed rule on test

---
 apps/web/utils/ai/choose-rule/run-rules.ts | 22 ++++++++++++----------
 1 file changed, 12 insertions(+), 10 deletions(-)

diff --git a/apps/web/utils/ai/choose-rule/run-rules.ts b/apps/web/utils/ai/choose-rule/run-rules.ts
index d6dd10dd2d..bd2c0db361 100644
--- a/apps/web/utils/ai/choose-rule/run-rules.ts
+++ b/apps/web/utils/ai/choose-rule/run-rules.ts
@@ -84,16 +84,18 @@ export async function runRules({
 
   if (!finalMatches.length) {
     const reason = results.reasoning || "No rules matched";
-    await prisma.executedRule.create({
-      data: {
-        threadId: message.threadId,
-        messageId: message.id,
-        automated: true,
-        reason,
-        status: ExecutedRuleStatus.SKIPPED,
-        emailAccount: { connect: { id: emailAccount.id } },
-      },
-    });
+    if (!isTest) {
+      await prisma.executedRule.create({
+        data: {
+          threadId: message.threadId,
+          messageId: message.id,
+          automated: true,
+          reason,
+          status: ExecutedRuleStatus.SKIPPED,
+          emailAccount: { connect: { id: emailAccount.id } },
+        },
+      });
+    }
 
     return [{ rule: null, reason }];
   }

From 20e87eeb47f613ca461aecfe6bcafc63ddf58c85 Mon Sep 17 00:00:00 2001
From: Eliezer Steinbock <3090527+elie222@users.noreply.github.com>
Date: Mon, 20 Oct 2025 14:57:44 +0300
Subject: [PATCH 25/40] fix comment

---
 apps/web/utils/ai/choose-rule/match-rules.ts | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/apps/web/utils/ai/choose-rule/match-rules.ts b/apps/web/utils/ai/choose-rule/match-rules.ts
index 131a717d5a..8afb2d5f00 100644
--- a/apps/web/utils/ai/choose-rule/match-rules.ts
+++ b/apps/web/utils/ai/choose-rule/match-rules.ts
@@ -407,9 +407,10 @@ async function findMatchingRulesWithReasons(
       .filter((r): r is string => !!r)
       .join(", ");
 
-    const combinedReasoning = existingReasoning
-      ? `${existingReasoning}; ${result.reason}`
-      : result.reason;
+    const aiReason = result.reason?.trim();
+    const combinedReasoning = [existingReasoning, aiReason]
+      .filter((r): r is string => !!r)
+      .join("; ");
 
     return {
       matches: combinedMatches,

From 2fcf906bc5d94cde03207d6c36b2d89e5219a655 Mon Sep 17 00:00:00 2001
From: Eliezer Steinbock <3090527+elie222@users.noreply.github.com>
Date: Mon, 20 Oct 2025 15:00:18 +0300
Subject: [PATCH 26/40] fix comment

---
 apps/web/__tests__/ai-choose-rule.test.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/apps/web/__tests__/ai-choose-rule.test.ts b/apps/web/__tests__/ai-choose-rule.test.ts
index 02c82b7e95..bb1a03a934 100644
--- a/apps/web/__tests__/ai-choose-rule.test.ts
+++ b/apps/web/__tests__/ai-choose-rule.test.ts
@@ -56,7 +56,7 @@ describe.runIf(isAiTest)("aiChooseRule", () => {
     expect(result.reason).toBeTruthy();
   });
 
-  test("Should generate action arguments", async () => {
+  test("Should select the correct rule and provide a reason", async () => {
     const rule1 = getRule(
       "Match emails that have the word 'question' in the subject line",
     );

From 49b17ba2b47018169bda33a393ce730ae796e9b7 Mon Sep 17 00:00:00 2001
From: Eliezer Steinbock <3090527+elie222@users.noreply.github.com>
Date: Mon, 20 Oct 2025 15:03:45 +0300
Subject: [PATCH 27/40] fix comment

---
 apps/web/utils/assistant/process-assistant-email.ts | 1 +
 1 file changed, 1 insertion(+)

diff --git a/apps/web/utils/assistant/process-assistant-email.ts b/apps/web/utils/assistant/process-assistant-email.ts
index fae0c6280c..b91613e54e 100644
--- a/apps/web/utils/assistant/process-assistant-email.ts
+++ b/apps/web/utils/assistant/process-assistant-email.ts
@@ -139,6 +139,7 @@ async function processAssistantEmailInternal({
             threadId: originalMessage.threadId,
             messageId: originalMessage.id,
           },
+          orderBy: [{ createdAt: "desc" }, { id: "desc" }],
           select: {
             rule: {
               include: {

From b2239d283bbff6dc68d1d5c9922ae39b5b6de7ee Mon Sep 17 00:00:00 2001
From: Eliezer Steinbock <3090527+elie222@users.noreply.github.com>
Date: Mon, 20 Oct 2025 15:22:50 +0300
Subject: [PATCH 28/40] dont load folders for non microsoft

---
 .../[emailAccountId]/assistant/RuleForm.tsx      |  2 +-
 apps/web/hooks/useFolders.ts                     | 16 ++++++++++++----
 2 files changed, 13 insertions(+), 5 deletions(-)

diff --git a/apps/web/app/(app)/[emailAccountId]/assistant/RuleForm.tsx b/apps/web/app/(app)/[emailAccountId]/assistant/RuleForm.tsx
index bbfa2ffd19..1ed3f80588 100644
--- a/apps/web/app/(app)/[emailAccountId]/assistant/RuleForm.tsx
+++ b/apps/web/app/(app)/[emailAccountId]/assistant/RuleForm.tsx
@@ -172,7 +172,7 @@ export function RuleForm({
   const { append, remove } = useFieldArray({ control, name: "actions" });
 
   const { userLabels, isLoading, mutate: mutateLabels } = useLabels();
-  const { folders, isLoading: foldersLoading } = useFolders();
+  const { folders, isLoading: foldersLoading } = useFolders(provider);
   const router = useRouter();
 
   const posthog = usePostHog();
diff --git a/apps/web/hooks/useFolders.ts b/apps/web/hooks/useFolders.ts
index 6d837375ac..952d3e6024 100644
--- a/apps/web/hooks/useFolders.ts
+++ b/apps/web/hooks/useFolders.ts
@@ -1,8 +1,16 @@
 import useSWR from "swr";
 import type { GetFoldersResponse } from "@/app/api/user/folders/route";
+import { isMicrosoftProvider } from "@/utils/email/provider-types";
 
-export function useFolders() {
-  const { data, error, isLoading, mutate } =
-    useSWR<GetFoldersResponse>("/api/user/folders");
-  return { folders: data || [], isLoading, error, mutate };
+export function useFolders(provider: string) {
+  const enabled = isMicrosoftProvider(provider);
+  const { data, error, isLoading, mutate } = useSWR<GetFoldersResponse>(
+    enabled ? "/api/user/folders" : null,
+  );
+  return {
+    folders: data || [],
+    isLoading: enabled ? !!isLoading : false,
+    error,
+    mutate,
+  };
 }

From 4fab4035b85072aaced64bc851c1b772af39f654 Mon Sep 17 00:00:00 2001
From: Eliezer Steinbock <3090527+elie222@users.noreply.github.com>
Date: Mon, 20 Oct 2025 15:28:50 +0300
Subject: [PATCH 29/40] revert deletion of condition summary card

---
 .../assistant/ConditionSummaryCard.tsx        | 68 +++++++++++++++++++
 .../[emailAccountId]/assistant/RuleForm.tsx   |  5 +-
 2 files changed, 72 insertions(+), 1 deletion(-)
 create mode 100644 apps/web/app/(app)/[emailAccountId]/assistant/ConditionSummaryCard.tsx

diff --git a/apps/web/app/(app)/[emailAccountId]/assistant/ConditionSummaryCard.tsx b/apps/web/app/(app)/[emailAccountId]/assistant/ConditionSummaryCard.tsx
new file mode 100644
index 0000000000..e945c8aae7
--- /dev/null
+++ b/apps/web/app/(app)/[emailAccountId]/assistant/ConditionSummaryCard.tsx
@@ -0,0 +1,68 @@
+import { BotIcon, FilterIcon } from "lucide-react";
+import type { CreateRuleBody } from "@/utils/actions/rule.validation";
+import { ConditionType } from "@/utils/config";
+import { CardBasic } from "@/components/ui/card";
+
+export function ConditionSummaryCard({
+  condition,
+}: {
+  condition: CreateRuleBody["conditions"][number];
+}) {
+  let summaryContent: React.ReactNode = condition.type;
+  let Icon = FilterIcon;
+  let textColorClass = "text-gray-500";
+
+  switch (condition.type) {
+    case ConditionType.AI: {
+      Icon = BotIcon;
+      textColorClass = "text-purple-500";
+      summaryContent = condition.instructions || "No instructions set";
+      break;
+    }
+
+    case ConditionType.STATIC: {
+      textColorClass = "text-blue-500";
+      const parts: string[] = [];
+
+      if (condition.from) {
+        parts.push(`From: ${condition.from}`);
+      }
+      if (condition.to) {
+        parts.push(`To: ${condition.to}`);
+      }
+      if (condition.subject) {
+        parts.push(`Subject: ${condition.subject}`);
+      }
+
+      if (parts.length > 0) {
+        summaryContent = (
+          <>
+            <span>Static Condition</span>
+            <div className="mt-2 space-y-1">
+              {parts.map((part, index) => (
+                <div key={index} className="text-muted-foreground">
+                  {part}
+                </div>
+              ))}
+            </div>
+          </>
+        );
+      } else {
+        summaryContent = "Static Condition (no filters set)";
+      }
+      break;
+    }
+
+    default:
+      summaryContent = `${condition.type} Condition`;
+  }
+
+  return (
+    <CardBasic className="flex items-center justify-between p-4">
+      <div className="flex items-center gap-3">
+        <Icon className={`size-5 ${textColorClass} flex-shrink-0`} />
+        <div className="whitespace-pre-wrap">{summaryContent}</div>
+      </div>
+    </CardBasic>
+  );
+}
diff --git a/apps/web/app/(app)/[emailAccountId]/assistant/RuleForm.tsx b/apps/web/app/(app)/[emailAccountId]/assistant/RuleForm.tsx
index 1ed3f80588..236cc10a82 100644
--- a/apps/web/app/(app)/[emailAccountId]/assistant/RuleForm.tsx
+++ b/apps/web/app/(app)/[emailAccountId]/assistant/RuleForm.tsx
@@ -65,6 +65,7 @@ import {
   DialogTrigger,
 } from "@/components/ui/dialog";
 import { ActionSummaryCard } from "@/app/(app)/[emailAccountId]/assistant/ActionSummaryCard";
+import { ConditionSummaryCard } from "@/app/(app)/[emailAccountId]/assistant/ConditionSummaryCard";
 import {
   Select,
   SelectContent,
@@ -648,7 +649,9 @@ export function RuleForm({
                     </CardLayoutRight>
                   </CardLayout>
                 </CardBasic>
-              ) : null}
+              ) : (
+                <ConditionSummaryCard condition={conditions[index]} />
+              )}
             </div>
           ))}
         </div>

From 3f5c6b1877f6bee71073b8f0e415ebbb9890f2f0 Mon Sep 17 00:00:00 2001
From: Eliezer Steinbock <3090527+elie222@users.noreply.github.com>
Date: Mon, 20 Oct 2025 16:38:38 +0300
Subject: [PATCH 30/40] group batches by date in the ui

---
 .../assistant/ProcessResultDisplay.tsx        | 52 +++++++++++++------
 .../assistant/ProcessRules.tsx                |  1 +
 .../api/user/executed-rules/batch/route.ts    |  1 +
 apps/web/utils/actions/ai-rule.ts             |  2 +
 apps/web/utils/ai/choose-rule/run-rules.ts    | 10 +++-
 5 files changed, 49 insertions(+), 17 deletions(-)

diff --git a/apps/web/app/(app)/[emailAccountId]/assistant/ProcessResultDisplay.tsx b/apps/web/app/(app)/[emailAccountId]/assistant/ProcessResultDisplay.tsx
index c51b1fbbd9..2aff598852 100644
--- a/apps/web/app/(app)/[emailAccountId]/assistant/ProcessResultDisplay.tsx
+++ b/apps/web/app/(app)/[emailAccountId]/assistant/ProcessResultDisplay.tsx
@@ -1,5 +1,7 @@
 "use client";
 
+import groupBy from "lodash/groupBy";
+import sortBy from "lodash/sortBy";
 import { capitalCase } from "capital-case";
 import { CheckCircle2Icon, EyeIcon, ExternalLinkIcon } from "lucide-react";
 import type { RunRulesResult } from "@/utils/ai/choose-rule/run-rules";
@@ -52,23 +54,41 @@ export function ProcessResultDisplay({
     ruleDialog.onOpen({ ruleId });
   };
 
-  return results.map((result) => (
-    <>
-      <HoverCard
-        className="w-auto max-w-5xl"
-        content={
-          <ActionSummaryCard result={result} onViewRule={handleViewRule} />
-        }
-      >
-        <Badge color="green">
-          {prefix ? prefix : ""}
-          {result.rule?.name}
-          <EyeIcon className="ml-1.5 size-3.5 opacity-70" />
-        </Badge>
-      </HoverCard>
+  const groupedResults = groupBy(results, (result) => {
+    return result.createdAt.toString();
+  });
+
+  const sortedBatches = sortBy(Object.entries(groupedResults), ([date]) => {
+    return -new Date(date).getTime(); // Negative for descending order
+  });
+
+  return (
+    <div className="flex flex-col gap-2">
+      {sortedBatches.map(([date, batchResults]) => (
+        <div key={date} className="flex gap-1">
+          {batchResults.map((result, resultIndex) => (
+            <HoverCard
+              key={`${date}-${resultIndex}`}
+              className="w-auto max-w-5xl"
+              content={
+                <ActionSummaryCard
+                  result={result}
+                  onViewRule={handleViewRule}
+                />
+              }
+            >
+              <Badge color="green">
+                {prefix ? prefix : ""}
+                {result.rule?.name}
+                <EyeIcon className="ml-1.5 size-3.5 opacity-70" />
+              </Badge>
+            </HoverCard>
+          ))}
+        </div>
+      ))}
       <RuleDialogComponent />
-    </>
-  ));
+    </div>
+  );
 }
 
 function ActionSummaryCard({
diff --git a/apps/web/app/(app)/[emailAccountId]/assistant/ProcessRules.tsx b/apps/web/app/(app)/[emailAccountId]/assistant/ProcessRules.tsx
index d167fb3e55..0ae2446d7a 100644
--- a/apps/web/app/(app)/[emailAccountId]/assistant/ProcessRules.tsx
+++ b/apps/web/app/(app)/[emailAccountId]/assistant/ProcessRules.tsx
@@ -132,6 +132,7 @@ export function ProcessRulesContent({ testMode }: { testMode: boolean }) {
             actionItems: r.actionItems,
             reason: r.reason,
             existing: true,
+            createdAt: r.createdAt,
           }));
         }
       }
diff --git a/apps/web/app/api/user/executed-rules/batch/route.ts b/apps/web/app/api/user/executed-rules/batch/route.ts
index c0d8bcc6b7..b5ef82bb18 100644
--- a/apps/web/app/api/user/executed-rules/batch/route.ts
+++ b/apps/web/app/api/user/executed-rules/batch/route.ts
@@ -27,6 +27,7 @@ async function getData({
       actionItems: true,
       rule: true,
       status: true,
+      createdAt: true,
     },
     orderBy: { id: "asc" },
   });
diff --git a/apps/web/utils/actions/ai-rule.ts b/apps/web/utils/actions/ai-rule.ts
index 8ebcb2c1a8..ae0a63f89d 100644
--- a/apps/web/utils/actions/ai-rule.ts
+++ b/apps/web/utils/actions/ai-rule.ts
@@ -67,6 +67,7 @@ export const runRulesAction = actionClient
               reason: true,
               actionItems: true,
               rule: true,
+              createdAt: true,
             },
           })
         : [];
@@ -79,6 +80,7 @@ export const runRulesAction = actionClient
           actionItems: executedRule.actionItems,
           reason: executedRule.reason,
           existing: true,
+          createdAt: executedRule.createdAt,
         }));
       }
 
diff --git a/apps/web/utils/ai/choose-rule/run-rules.ts b/apps/web/utils/ai/choose-rule/run-rules.ts
index bd2c0db361..bc06c54a35 100644
--- a/apps/web/utils/ai/choose-rule/run-rules.ts
+++ b/apps/web/utils/ai/choose-rule/run-rules.ts
@@ -40,6 +40,7 @@ export type RunRulesResult = {
   reason?: string | null;
   matchReasons?: MatchReason[];
   existing?: boolean;
+  createdAt: Date;
 };
 
 export const CONVERSATION_TRACKING_META_RULE_ID = "conversation-tracking-meta";
@@ -59,6 +60,7 @@ export async function runRules({
   isTest: boolean;
   modelType: ModelType;
 }): Promise<RunRulesResult[]> {
+  const batchTimestamp = new Date(); // Single timestamp for this batch execution
   const { regularRules, conversationRules } = prepareRulesWithMetaRule(rules);
 
   const results = await findMatchingRules({
@@ -97,7 +99,7 @@ export async function runRules({
       });
     }
 
-    return [{ rule: null, reason }];
+    return [{ rule: null, reason, createdAt: batchTimestamp }];
   }
 
   const executedRules: RunRulesResult[] = [];
@@ -121,6 +123,7 @@ export async function runRules({
         const executedRule: RunRulesResult = {
           rule: null,
           reason: statusReason || "No enabled conversation status rule found",
+          createdAt: batchTimestamp,
         };
 
         executedRules.push(executedRule);
@@ -147,6 +150,7 @@ export async function runRules({
       result.matchReasons,
       isTest,
       modelType,
+      batchTimestamp,
     );
 
     executedRules.push(executedRule);
@@ -197,6 +201,7 @@ async function executeMatchedRule(
   matchReasons: MatchReason[] | undefined,
   isTest: boolean,
   modelType: ModelType,
+  batchTimestamp: Date,
 ) {
   const actionItems = await getActionItemsWithAiArgs({
     message,
@@ -219,6 +224,7 @@ async function executeMatchedRule(
       executedRule: null,
       reason,
       matchReasons,
+      createdAt: batchTimestamp,
     };
   }
 
@@ -244,6 +250,7 @@ async function executeMatchedRule(
       reason,
       rule: rule?.id ? { connect: { id: rule.id } } : undefined,
       emailAccount: { connect: { id: emailAccount.id } },
+      createdAt: batchTimestamp, // Use batch timestamp for grouping
     },
     include: { actionItems: true },
   });
@@ -316,6 +323,7 @@ async function executeMatchedRule(
     executedRule,
     reason,
     matchReasons,
+    createdAt: batchTimestamp,
   };
 }
 

From 19f92be59f4fe2f7a53d56f5b9cc876c46d77914 Mon Sep 17 00:00:00 2001
From: Eliezer Steinbock <3090527+elie222@users.noreply.github.com>
Date: Mon, 20 Oct 2025 16:40:28 +0300
Subject: [PATCH 31/40] message

---
 .../assistant/ProcessResultDisplay.tsx        | 45 ++++++++++---------
 1 file changed, 25 insertions(+), 20 deletions(-)

diff --git a/apps/web/app/(app)/[emailAccountId]/assistant/ProcessResultDisplay.tsx b/apps/web/app/(app)/[emailAccountId]/assistant/ProcessResultDisplay.tsx
index 2aff598852..97cdb463e4 100644
--- a/apps/web/app/(app)/[emailAccountId]/assistant/ProcessResultDisplay.tsx
+++ b/apps/web/app/(app)/[emailAccountId]/assistant/ProcessResultDisplay.tsx
@@ -64,26 +64,31 @@ export function ProcessResultDisplay({
 
   return (
     <div className="flex flex-col gap-2">
-      {sortedBatches.map(([date, batchResults]) => (
-        <div key={date} className="flex gap-1">
-          {batchResults.map((result, resultIndex) => (
-            <HoverCard
-              key={`${date}-${resultIndex}`}
-              className="w-auto max-w-5xl"
-              content={
-                <ActionSummaryCard
-                  result={result}
-                  onViewRule={handleViewRule}
-                />
-              }
-            >
-              <Badge color="green">
-                {prefix ? prefix : ""}
-                {result.rule?.name}
-                <EyeIcon className="ml-1.5 size-3.5 opacity-70" />
-              </Badge>
-            </HoverCard>
-          ))}
+      {sortedBatches.map(([date, batchResults], batchIndex) => (
+        <div key={date}>
+          {batchIndex === 1 && sortedBatches.length > 1 && (
+            <div className="mb-1 text-xs text-muted-foreground">Previous:</div>
+          )}
+          <div className="flex gap-1">
+            {batchResults.map((result, resultIndex) => (
+              <HoverCard
+                key={`${date}-${resultIndex}`}
+                className="w-auto max-w-5xl"
+                content={
+                  <ActionSummaryCard
+                    result={result}
+                    onViewRule={handleViewRule}
+                  />
+                }
+              >
+                <Badge color="green">
+                  {prefix ? prefix : ""}
+                  {result.rule?.name}
+                  <EyeIcon className="ml-1.5 size-3.5 opacity-70" />
+                </Badge>
+              </HoverCard>
+            ))}
+          </div>
         </div>
       ))}
       <RuleDialogComponent />

From fb2636fbb9922cc373a0dd6df96a14fa4bb69f80 Mon Sep 17 00:00:00 2001
From: Eliezer Steinbock <3090527+elie222@users.noreply.github.com>
Date: Tue, 21 Oct 2025 13:19:22 +0300
Subject: [PATCH 32/40] simplify chat fix by sending context as tag

---
 .../assistant/FixWithChat.tsx                 | 123 +++++++++---------
 apps/web/app/api/chat/route.ts                |   5 +-
 apps/web/app/api/chat/validation.ts           |  32 +++++
 apps/web/components/assistant-chat/chat.tsx   |  31 ++++-
 apps/web/providers/ChatProvider.tsx           |  11 +-
 apps/web/utils/ai/assistant/chat.ts           |  34 +++++
 6 files changed, 168 insertions(+), 68 deletions(-)
 create mode 100644 apps/web/app/api/chat/validation.ts

diff --git a/apps/web/app/(app)/[emailAccountId]/assistant/FixWithChat.tsx b/apps/web/app/(app)/[emailAccountId]/assistant/FixWithChat.tsx
index 04749db116..6e7d655092 100644
--- a/apps/web/app/(app)/[emailAccountId]/assistant/FixWithChat.tsx
+++ b/apps/web/app/(app)/[emailAccountId]/assistant/FixWithChat.tsx
@@ -1,9 +1,8 @@
 import { MessageCircleIcon } from "lucide-react";
-import { useState } from "react";
+import { useMemo, useState } from "react";
 import { Button } from "@/components/ui/button";
 import type { ParsedMessage } from "@/utils/types";
 import type { RunRulesResult } from "@/utils/ai/choose-rule/run-rules";
-import { truncate } from "@/utils/string";
 import {
   Dialog,
   DialogContent,
@@ -23,6 +22,12 @@ import { NONE_RULE_ID } from "@/app/(app)/[emailAccountId]/assistant/consts";
 import { useSidebar } from "@/components/ui/sidebar";
 import { Textarea } from "@/components/ui/textarea";
 import { Badge } from "@/components/ui/badge";
+import { useChat } from "@/providers/ChatProvider";
+import {
+  NEW_RULE_ID as CONST_NEW_RULE_ID,
+  NONE_RULE_ID as CONST_NONE_RULE_ID,
+} from "@/app/(app)/[emailAccountId]/assistant/consts";
+import type { MessageContext } from "@/app/api/chat/validation";
 
 export function FixWithChat({
   setInput,
@@ -40,6 +45,14 @@ export function FixWithChat({
   const [showExplanation, setShowExplanation] = useState(false);
 
   const { setOpen } = useSidebar();
+  const { setContext: setNextContext } = useChat();
+
+  const selectedRuleName = useMemo(() => {
+    if (!data) return null;
+    if (selectedRuleId === NEW_RULE_ID) return "New rule";
+    if (selectedRuleId === NONE_RULE_ID) return "None";
+    return data.find((r) => r.id === selectedRuleId)?.name ?? null;
+  }, [data, selectedRuleId]);
 
   const handleRuleSelect = (ruleId: string | null) => {
     setSelectedRuleId(ruleId);
@@ -50,24 +63,55 @@ export function FixWithChat({
     if (!selectedRuleId) return;
 
     let input: string;
-    if (selectedRuleId === NEW_RULE_ID) {
-      input = getFixMessage({
-        message,
-        results,
-        expectedRuleName: NEW_RULE_ID,
-        explanation,
-      });
+
+    if (selectedRuleId === CONST_NEW_RULE_ID) {
+      input = explanation?.trim()
+        ? `Create a new rule for emails like this: ${explanation.trim()}`
+        : "Create a new rule for emails like this: ";
+    } else if (selectedRuleId === CONST_NONE_RULE_ID) {
+      input = explanation?.trim()
+        ? `This email shouldn't have matched any rule because ${explanation.trim()}`
+        : "This email shouldn't have matched any rule because ";
     } else {
-      const expectedRule = data?.find((rule) => rule.id === selectedRuleId);
-
-      input = getFixMessage({
-        message,
-        results,
-        expectedRuleName: expectedRule?.name ?? null,
-        explanation,
-      });
+      const rulePart = selectedRuleName
+        ? `the "${selectedRuleName}" rule`
+        : "a different rule";
+      input = explanation?.trim()
+        ? `This email should have matched ${rulePart} because ${explanation.trim()}`
+        : `This email should have matched ${rulePart} because `;
     }
 
+    const context: MessageContext = {
+      type: "fix-rule",
+      message: {
+        id: message.id,
+        threadId: message.threadId,
+        snippet: message.snippet,
+        textPlain: message.textPlain,
+        textHtml: message.textHtml,
+        headers: {
+          from: message.headers.from,
+          to: message.headers.to,
+          subject: message.headers.subject,
+          cc: message.headers.cc,
+          date: message.headers.date,
+          "reply-to": message.headers["reply-to"],
+        },
+        internalDate: message.internalDate,
+      },
+      results: results.map((r) => ({
+        ruleName: r.rule?.name ?? null,
+        reason: r.reason ?? "",
+      })),
+      expected:
+        selectedRuleId === CONST_NEW_RULE_ID
+          ? "new"
+          : selectedRuleId === CONST_NONE_RULE_ID
+            ? "none"
+            : { name: selectedRuleName || "Unknown" },
+    };
+    setNextContext(context);
+
     setInput(input);
     setOpen((arr) => [...arr, "chat-sidebar"]);
     setIsModalOpen(false);
@@ -165,51 +209,6 @@ export function FixWithChat({
   );
 }
 
-// TODO: tag rule like in Cursor so we don't need to show the email contents
-function getFixMessage({
-  message,
-  results,
-  expectedRuleName,
-  explanation,
-}: {
-  message: ParsedMessage;
-  results: RunRulesResult[];
-  expectedRuleName: string | null;
-  explanation?: string;
-}) {
-  // Truncate content if it's too long
-  // TODO: HTML text / text plain
-  const getMessageContent = () => {
-    const content = message.snippet || message.textPlain || "";
-    return truncate(content, 500).trim();
-  };
-
-  return `You applied the wrong rule to this email.
-Fix our rules so this type of email is handled correctly in the future.
-
-Email details:
-*From*: ${message.headers.from}
-*Subject*: ${message.headers.subject}
-*Content*: ${getMessageContent()}
-
-Current rules applied and the reasons they were chosen:
-
-${results
-  .map(
-    (r) => `- Rule: ${r.rule?.name || "No rule"}
-- Reason: ${r.reason}`,
-  )
-  .join("\n")}
-
-${
-  expectedRuleName === NEW_RULE_ID
-    ? "I'd like to create a new rule to handle this type of email."
-    : expectedRuleName
-      ? `The rule that should have been applied was: "${expectedRuleName}"`
-      : "Instead, no rule should have been applied."
-}${explanation ? `\n\nExplanation: ${explanation}` : ""}`.trim();
-}
-
 function RuleMismatch({
   results,
   rules,
diff --git a/apps/web/app/api/chat/route.ts b/apps/web/app/api/chat/route.ts
index b95868994d..0af68609c0 100644
--- a/apps/web/app/api/chat/route.ts
+++ b/apps/web/app/api/chat/route.ts
@@ -9,6 +9,7 @@ import prisma from "@/utils/prisma";
 import type { Prisma } from "@prisma/client";
 import { convertToUIMessages } from "@/components/assistant-chat/helpers";
 import { captureException } from "@/utils/error";
+import { messageContextSchema } from "@/app/api/chat/validation";
 
 export const maxDuration = 120;
 
@@ -26,6 +27,7 @@ const assistantInputSchema = z.object({
     role: z.enum(["user"]),
     parts: z.array(textPartSchema),
   }),
+  context: messageContextSchema.optional(),
 });
 
 export const POST = withEmailAccount(async (request) => {
@@ -58,7 +60,7 @@ export const POST = withEmailAccount(async (request) => {
     );
   }
 
-  const { message } = data;
+  const { message, context } = data;
   const uiMessages = [...convertToUIMessages(chat), message];
 
   await saveChatMessage({
@@ -73,6 +75,7 @@ export const POST = withEmailAccount(async (request) => {
       messages: convertToModelMessages(uiMessages),
       emailAccountId,
       user,
+      context,
     });
 
     return result.toUIMessageStreamResponse({
diff --git a/apps/web/app/api/chat/validation.ts b/apps/web/app/api/chat/validation.ts
new file mode 100644
index 0000000000..005352e400
--- /dev/null
+++ b/apps/web/app/api/chat/validation.ts
@@ -0,0 +1,32 @@
+import { z } from "zod";
+
+const parsedMessageSchema = z.object({
+  id: z.string(),
+  threadId: z.string(),
+  snippet: z.string(),
+  textPlain: z.string().optional(),
+  textHtml: z.string().optional(),
+  headers: z.object({
+    from: z.string(),
+    to: z.string(),
+    subject: z.string(),
+    cc: z.string().optional(),
+    date: z.string(),
+    "reply-to": z.string().optional(),
+  }),
+  internalDate: z.string().optional().nullable(),
+});
+
+export const messageContextSchema = z.object({
+  type: z.literal("fix-rule"),
+  message: parsedMessageSchema,
+  results: z.array(
+    z.object({ ruleName: z.string().nullable(), reason: z.string() }),
+  ),
+  expected: z.union([
+    z.literal("new"),
+    z.literal("none"),
+    z.object({ name: z.string() }),
+  ]),
+});
+export type MessageContext = z.infer<typeof messageContextSchema>;
diff --git a/apps/web/components/assistant-chat/chat.tsx b/apps/web/components/assistant-chat/chat.tsx
index 7763a057c0..1e9a2446f6 100644
--- a/apps/web/components/assistant-chat/chat.tsx
+++ b/apps/web/components/assistant-chat/chat.tsx
@@ -26,7 +26,16 @@ import { useLocalStorage } from "usehooks-ts";
 const MAX_MESSAGES = 20;
 
 export function Chat() {
-  const { chat, chatId, input, setInput, handleSubmit, setNewChat } = useChat();
+  const {
+    chat,
+    chatId,
+    input,
+    setInput,
+    handleSubmit,
+    setNewChat,
+    context: nextContext,
+    setContext: setNextContext,
+  } = useChat();
   const { messages, status, stop, regenerate, setMessages } = chat;
   const [localStorageInput, setLocalStorageInput] = useLocalStorage(
     "input",
@@ -81,10 +90,26 @@ export function Chat() {
       />
 
       <div className="mx-auto w-full px-4 pb-4 md:max-w-3xl md:pb-6">
+        {nextContext ? (
+          <div className="mb-2 flex items-center gap-2">
+            <span className="inline-flex items-center gap-2 rounded-full bg-muted px-3 py-1 text-xs text-muted-foreground">
+              Fix: {nextContext.message.headers.subject.slice(0, 60)}
+              {nextContext.message.headers.subject.length > 60 ? "..." : ""}
+              <button
+                type="button"
+                aria-label="Remove context"
+                className="ml-1 rounded p-0.5 hover:bg-muted-foreground/10"
+                onClick={() => setNextContext(null)}
+              >
+                ×
+              </button>
+            </span>
+          </div>
+        ) : null}
         <PromptInput
           onSubmit={(e) => {
             e.preventDefault();
-            if (input.trim() && status === "ready") {
+            if ((input.trim() || nextContext) && status === "ready") {
               handleSubmit();
               setLocalStorageInput("");
             }
@@ -105,7 +130,7 @@ export function Chat() {
                   ? "submitted"
                   : "ready"
             }
-            disabled={!input.trim() || status !== "ready"}
+            disabled={(!input.trim() && !nextContext) || status !== "ready"}
             className="absolute bottom-1 right-1"
             onClick={(e) => {
               if (status === "streaming") {
diff --git a/apps/web/providers/ChatProvider.tsx b/apps/web/providers/ChatProvider.tsx
index 86854135dd..3b2b7b9dde 100644
--- a/apps/web/providers/ChatProvider.tsx
+++ b/apps/web/providers/ChatProvider.tsx
@@ -17,6 +17,7 @@ import type { ChatMessage } from "@/components/assistant-chat/types";
 import { useChatMessages } from "@/hooks/useChatMessages";
 import { useAccount } from "@/providers/EmailAccountProvider";
 import { EMAIL_ACCOUNT_HEADER } from "@/utils/config";
+import type { MessageContext } from "@/app/api/chat/validation";
 
 export type Chat = ReturnType<typeof useAiChat<ChatMessage>>;
 
@@ -28,6 +29,8 @@ type ChatContextType = {
   setChatId: (chatId: string | null) => void;
   setNewChat: () => void;
   handleSubmit: () => void;
+  context: MessageContext | null;
+  setContext: (context: MessageContext | null) => void;
 };
 
 const ChatContext = createContext<ChatContextType | undefined>(undefined);
@@ -38,6 +41,7 @@ export function ChatProvider({ children }: { children: React.ReactNode }) {
 
   const [input, setInput] = useState<string>("");
   const [chatId, setChatId] = useQueryState("chatId", parseAsString);
+  const [nextContext, setNextContext] = useState<MessageContext | null>(null);
 
   const { data } = useChatMessages(chatId);
 
@@ -57,6 +61,7 @@ export function ChatProvider({ children }: { children: React.ReactNode }) {
           body: {
             id,
             message: messages.at(-1),
+            context: nextContext ?? undefined,
             ...body,
           },
         };
@@ -88,13 +93,13 @@ export function ChatProvider({ children }: { children: React.ReactNode }) {
       parts: [
         {
           type: "text",
-          text: input,
+          text: input.trim(),
         },
       ],
     });
 
     setInput("");
-  }, [chat.sendMessage, input]);
+  }, [chat.sendMessage, input, nextContext]);
 
   return (
     <ChatContext.Provider
@@ -106,6 +111,8 @@ export function ChatProvider({ children }: { children: React.ReactNode }) {
         setChatId,
         setNewChat,
         handleSubmit,
+        context: nextContext,
+        setContext: setNextContext,
       }}
     >
       {children}
diff --git a/apps/web/utils/ai/assistant/chat.ts b/apps/web/utils/ai/assistant/chat.ts
index 4d183dbc7f..ac82f36e46 100644
--- a/apps/web/utils/ai/assistant/chat.ts
+++ b/apps/web/utils/ai/assistant/chat.ts
@@ -17,6 +17,10 @@ import { chatCompletionStream } from "@/utils/llms";
 import { filterNullProperties } from "@/utils";
 import { delayInMinutesSchema } from "@/utils/actions/rule.validation";
 import { isMicrosoftProvider } from "@/utils/email/provider-types";
+import type { MessageContext } from "@/app/api/chat/validation";
+import { stringifyEmail } from "@/utils/stringify-email";
+import { getEmailForLLM } from "@/utils/get-email-from-message";
+import type { ParsedMessage } from "@/utils/types";
 
 const logger = createScopedLogger("ai/assistant/chat");
 
@@ -662,10 +666,12 @@ export async function aiProcessAssistantChat({
   messages,
   emailAccountId,
   user,
+  context,
 }: {
   messages: ModelMessage[];
   emailAccountId: string;
   user: EmailAccountWithAI;
+  context?: MessageContext;
 }) {
   const system = `You are an assistant that helps create and update rules to manage a user's inbox. Our platform is called Inbox Zero.
   
@@ -919,6 +925,33 @@ Examples:
     provider: user.account.provider,
   };
 
+  const hiddenContextMessage =
+    context && context.type === "fix-rule"
+      ? [
+          {
+            role: "system" as const,
+            content:
+              "Hidden context for the user's request (do not repeat this to the user):\n\n" +
+              `<email>\n${stringifyEmail(
+                getEmailForLLM(context.message as ParsedMessage, {
+                  maxLength: 3000,
+                }),
+                3000,
+              )}\n</email>\n\n` +
+              `Rules that were applied:\n${context.results
+                .map((r) => `- ${r.ruleName ?? "None"}: ${r.reason}`)
+                .join("\n")}\n\n` +
+              `Expected outcome: ${
+                context.expected === "new"
+                  ? "Create a new rule"
+                  : context.expected === "none"
+                    ? "No rule should be applied"
+                    : `Should match the "${context.expected.name}" rule`
+              }`,
+          },
+        ]
+      : [];
+
   const result = chatCompletionStream({
     userAi: user.user,
     userEmail: user.email,
@@ -929,6 +962,7 @@ Examples:
         role: "system",
         content: system,
       },
+      ...hiddenContextMessage,
       ...messages,
     ],
     onStepFinish: async ({ text, toolCalls }) => {

From ebc920264f1bab4f0e902cc141134a557a8461f7 Mon Sep 17 00:00:00 2001
From: Eliezer Steinbock <3090527+elie222@users.noreply.github.com>
Date: Tue, 21 Oct 2025 13:37:07 +0300
Subject: [PATCH 33/40] fix ai tests

---
 apps/web/__tests__/ai-choose-rule.test.ts | 185 ++++++++++++++++++----
 apps/web/__tests__/helpers.ts             |   8 +-
 2 files changed, 158 insertions(+), 35 deletions(-)

diff --git a/apps/web/__tests__/ai-choose-rule.test.ts b/apps/web/__tests__/ai-choose-rule.test.ts
index bb1a03a934..a846598abc 100644
--- a/apps/web/__tests__/ai-choose-rule.test.ts
+++ b/apps/web/__tests__/ai-choose-rule.test.ts
@@ -40,9 +40,13 @@ describe.runIf(isAiTest)("aiChooseRule", () => {
   test("Should return correct rule when multiple rules passed", async () => {
     const rule1 = getRule(
       "Match emails that have the word 'test' in the subject line",
+      [],
+      "Test emails",
     );
     const rule2 = getRule(
       "Match emails that have the word 'remember' in the subject line",
+      [],
+      "Remember emails",
     );
 
     const result = await aiChooseRule({
@@ -59,27 +63,33 @@ describe.runIf(isAiTest)("aiChooseRule", () => {
   test("Should select the correct rule and provide a reason", async () => {
     const rule1 = getRule(
       "Match emails that have the word 'question' in the subject line",
+      [],
+      "Question emails",
+    );
+    const rule2 = getRule(
+      "Match emails asking for a joke",
+      [
+        {
+          id: "id",
+          createdAt: new Date(),
+          updatedAt: new Date(),
+          type: ActionType.REPLY,
+          ruleId: "ruleId",
+          label: null,
+          labelId: null,
+          subject: null,
+          content: "{{Write a joke}}",
+          to: null,
+          cc: null,
+          bcc: null,
+          url: null,
+          folderName: null,
+          delayInMinutes: null,
+          folderId: null,
+        },
+      ],
+      "Joke requests",
     );
-    const rule2 = getRule("Match emails asking for a joke", [
-      {
-        id: "id",
-        createdAt: new Date(),
-        updatedAt: new Date(),
-        type: ActionType.REPLY,
-        ruleId: "ruleId",
-        label: null,
-        labelId: null,
-        subject: null,
-        content: "{{Write a joke}}",
-        to: null,
-        cc: null,
-        bcc: null,
-        url: null,
-        folderName: null,
-        delayInMinutes: null,
-        folderId: null,
-      },
-    ]);
 
     const result = await aiChooseRule({
       rules: [rule1, rule2],
@@ -98,37 +108,69 @@ describe.runIf(isAiTest)("aiChooseRule", () => {
   describe("Complex real-world rule scenarios", () => {
     const recruiters = getRule(
       "Match emails from recruiters or about job opportunities",
+      [],
+      "Recruiters",
     );
     const legal = getRule(
       "Match emails containing legal documents or contracts",
+      [],
+      "Legal",
+    );
+    const requiresResponse = getRule(
+      "Match emails requiring a response",
+      [],
+      "Requires Response",
     );
-    const requiresResponse = getRule("Match emails requiring a response");
     const productUpdates = getRule(
       "Match emails about product updates or feature announcements",
+      [],
+      "Product Updates",
     );
     const financial = getRule(
       "Match emails containing financial information or invoices",
+      [],
+      "Financial",
     );
     const technicalIssues = getRule(
       "Match emails about technical issues like server downtime or bug reports",
+      [],
+      "Technical Issues",
     );
     const marketing = getRule(
       "Match emails containing marketing or promotional content",
+      [],
+      "Marketing",
     );
     const teamUpdates = getRule(
       "Match emails about team updates or internal communications",
+      [],
+      "Team Updates",
     );
     const customerFeedback = getRule(
       "Match emails about customer feedback or support requests",
+      [],
+      "Customer Feedback",
     );
     const events = getRule(
       "Match emails containing event invitations or RSVPs",
+      [],
+      "Events",
     );
     const projectDeadlines = getRule(
       "Match emails about project deadlines or milestones",
+      [],
+      "Project Deadlines",
+    );
+    const urgent = getRule(
+      "Match urgent emails requiring immediate attention",
+      [],
+      "Urgent",
+    );
+    const catchAll = getRule(
+      "Match emails that don't fit any other category",
+      [],
+      "Catch All",
     );
-    const urgent = getRule("Match urgent emails requiring immediate attention");
-    const catchAll = getRule("Match emails that don't fit any other category");
 
     const rules = [
       recruiters,
@@ -173,8 +215,23 @@ describe.runIf(isAiTest)("aiChooseRule", () => {
         emailAccount: getEmailAccount(),
       });
 
-      expect(result.rules).toHaveLength(1);
-      expect(result.rules[0].rule).toEqual(technicalIssues);
+      // Log if multiple rules were matched
+      if (result.rules.length > 1) {
+        console.log("⚠️  Technical Issues test matched multiple rules:");
+        console.log(
+          result.rules.map((r) => ({
+            name: r.rule.name,
+            isPrimary: r.isPrimary,
+          })),
+        );
+        console.log("Reasoning:", result.reason);
+      }
+
+      // AI may match multiple rules (e.g., Technical Issues + Urgent)
+      // Verify the primary match is Technical Issues
+      const primaryRule = result.rules.find((r) => r.isPrimary);
+      expect(primaryRule).toBeDefined();
+      expect(primaryRule?.rule).toEqual(technicalIssues);
       expect(result.reason).toBeTruthy();
     });
 
@@ -219,8 +276,23 @@ describe.runIf(isAiTest)("aiChooseRule", () => {
         emailAccount: getEmailAccount(),
       });
 
-      expect(result.rules).toHaveLength(1);
-      expect(result.rules[0].rule).toEqual(legal);
+      // Log if multiple rules were matched
+      if (result.rules.length > 1) {
+        console.log("⚠️  Legal Documents test matched multiple rules:");
+        console.log(
+          result.rules.map((r) => ({
+            name: r.rule.name,
+            isPrimary: r.isPrimary,
+          })),
+        );
+        console.log("Reasoning:", result.reason);
+      }
+
+      // AI may match multiple rules (e.g., Legal + Requires Response)
+      // Verify the primary match is Legal
+      const primaryRule = result.rules.find((r) => r.isPrimary);
+      expect(primaryRule).toBeDefined();
+      expect(primaryRule?.rule).toEqual(legal);
       expect(result.reason).toBeTruthy();
     });
 
@@ -234,8 +306,25 @@ describe.runIf(isAiTest)("aiChooseRule", () => {
         emailAccount: getEmailAccount(),
       });
 
-      expect(result.rules).toHaveLength(1);
-      expect(result.rules[0].rule).toEqual(requiresResponse);
+      // Log if multiple rules were matched
+      if (result.rules.length > 1) {
+        console.log(
+          "⚠️  Emails Requiring Response test matched multiple rules:",
+        );
+        console.log(
+          result.rules.map((r) => ({
+            name: r.rule.name,
+            isPrimary: r.isPrimary,
+          })),
+        );
+        console.log("Reasoning:", result.reason);
+      }
+
+      // AI may match multiple rules (e.g., Requires Response + Team Updates)
+      // Verify the primary match is Requires Response
+      const primaryRule = result.rules.find((r) => r.isPrimary);
+      expect(primaryRule).toBeDefined();
+      expect(primaryRule?.rule).toEqual(requiresResponse);
       expect(result.reason).toBeTruthy();
     });
 
@@ -294,8 +383,23 @@ describe.runIf(isAiTest)("aiChooseRule", () => {
         emailAccount: getEmailAccount(),
       });
 
-      expect(result.rules).toHaveLength(1);
-      expect(result.rules[0].rule).toEqual(customerFeedback);
+      // Log if multiple rules were matched
+      if (result.rules.length > 1) {
+        console.log("⚠️  Customer Feedback test matched multiple rules:");
+        console.log(
+          result.rules.map((r) => ({
+            name: r.rule.name,
+            isPrimary: r.isPrimary,
+          })),
+        );
+        console.log("Reasoning:", result.reason);
+      }
+
+      // AI may match multiple rules (e.g., Customer Feedback + Technical Issues + Requires Response)
+      // Verify the primary match is Customer Feedback
+      const primaryRule = result.rules.find((r) => r.isPrimary);
+      expect(primaryRule).toBeDefined();
+      expect(primaryRule?.rule).toEqual(customerFeedback);
       expect(result.reason).toBeTruthy();
     });
 
@@ -309,8 +413,23 @@ describe.runIf(isAiTest)("aiChooseRule", () => {
         emailAccount: getEmailAccount(),
       });
 
-      expect(result.rules).toHaveLength(1);
-      expect(result.rules[0].rule).toEqual(events);
+      // Log if multiple rules were matched
+      if (result.rules.length > 1) {
+        console.log("⚠️  Event Invitations test matched multiple rules:");
+        console.log(
+          result.rules.map((r) => ({
+            name: r.rule.name,
+            isPrimary: r.isPrimary,
+          })),
+        );
+        console.log("Reasoning:", result.reason);
+      }
+
+      // AI may match multiple rules (e.g., Events + Requires Response)
+      // Verify the primary match is Events
+      const primaryRule = result.rules.find((r) => r.isPrimary);
+      expect(primaryRule).toBeDefined();
+      expect(primaryRule?.rule).toEqual(events);
       expect(result.reason).toBeTruthy();
     });
   });
diff --git a/apps/web/__tests__/helpers.ts b/apps/web/__tests__/helpers.ts
index 3207be1440..9c418220fd 100644
--- a/apps/web/__tests__/helpers.ts
+++ b/apps/web/__tests__/helpers.ts
@@ -41,10 +41,14 @@ export function getEmail({
   };
 }
 
-export function getRule(instructions: string, actions: Action[] = []) {
+export function getRule(
+  instructions: string,
+  actions: Action[] = [],
+  name?: string,
+) {
   return {
     instructions,
-    name: "Joke requests",
+    name: name || "Joke requests",
     actions,
     id: "id",
     userId: "userId",

From cf18bdec9c0175cc2f1199d61f68869ec6600856 Mon Sep 17 00:00:00 2001
From: Eliezer Steinbock <3090527+elie222@users.noreply.github.com>
Date: Tue, 21 Oct 2025 13:41:21 +0300
Subject: [PATCH 34/40] update sort and tests

---
 apps/web/__tests__/ai-choose-rule.test.ts     | 31 +++++++++++++++++++
 .../assistant/ProcessResultDisplay.tsx        |  9 ++++--
 2 files changed, 37 insertions(+), 3 deletions(-)

diff --git a/apps/web/__tests__/ai-choose-rule.test.ts b/apps/web/__tests__/ai-choose-rule.test.ts
index a846598abc..687c82da5b 100644
--- a/apps/web/__tests__/ai-choose-rule.test.ts
+++ b/apps/web/__tests__/ai-choose-rule.test.ts
@@ -432,5 +432,36 @@ describe.runIf(isAiTest)("aiChooseRule", () => {
       expect(primaryRule?.rule).toEqual(events);
       expect(result.reason).toBeTruthy();
     });
+
+    test("Should return no match when email doesn't fit any rule", async () => {
+      // Use a subset of rules WITHOUT the catch-all rule to test true no-match scenario
+      const rulesWithoutCatchAll = [
+        recruiters,
+        legal,
+        productUpdates,
+        financial,
+        technicalIssues,
+        marketing,
+        teamUpdates,
+        customerFeedback,
+        events,
+        projectDeadlines,
+      ];
+
+      const result = await aiChooseRule({
+        rules: rulesWithoutCatchAll,
+        email: getEmail({
+          subject: "Weather Update: Sunny skies ahead",
+          content:
+            "Today's forecast: Clear skies with temperatures reaching 75°F. Perfect day for outdoor activities!\n\nUV Index: Moderate\nWind: 5-10 mph",
+        }),
+        emailAccount: getEmailAccount(),
+      });
+
+      // This is a weather notification that doesn't match any of our business rules
+      // Should return empty array with no reason
+      expect(result.rules).toEqual([]);
+      expect(result.reason).toBe("");
+    });
   });
 });
diff --git a/apps/web/app/(app)/[emailAccountId]/assistant/ProcessResultDisplay.tsx b/apps/web/app/(app)/[emailAccountId]/assistant/ProcessResultDisplay.tsx
index 97cdb463e4..8e1b0549fc 100644
--- a/apps/web/app/(app)/[emailAccountId]/assistant/ProcessResultDisplay.tsx
+++ b/apps/web/app/(app)/[emailAccountId]/assistant/ProcessResultDisplay.tsx
@@ -58,9 +58,12 @@ export function ProcessResultDisplay({
     return result.createdAt.toString();
   });
 
-  const sortedBatches = sortBy(Object.entries(groupedResults), ([date]) => {
-    return -new Date(date).getTime(); // Negative for descending order
-  });
+  const sortedBatches = sortBy(
+    Object.entries(groupedResults),
+    ([, batchResults]) => {
+      return -batchResults[0]?.createdAt.getTime(); // Negative for descending order
+    },
+  );
 
   return (
     <div className="flex flex-col gap-2">

From d6fe48aa496f5aabab19aaaa9ac835d8a82756e3 Mon Sep 17 00:00:00 2001
From: Eliezer Steinbock <3090527+elie222@users.noreply.github.com>
Date: Tue, 21 Oct 2025 15:13:41 +0300
Subject: [PATCH 35/40] fix history executed at

---
 .../assistant/ExecutedRulesTable.tsx          | 11 ++-
 .../[emailAccountId]/assistant/History.tsx    | 36 ++++----
 .../web/app/api/user/planned/history/route.ts | 89 +++++++++++++++++--
 apps/web/hooks/useExecutedRules.tsx           | 14 +++
 4 files changed, 122 insertions(+), 28 deletions(-)
 create mode 100644 apps/web/hooks/useExecutedRules.tsx

diff --git a/apps/web/app/(app)/[emailAccountId]/assistant/ExecutedRulesTable.tsx b/apps/web/app/(app)/[emailAccountId]/assistant/ExecutedRulesTable.tsx
index cc6b401b42..946cf23e91 100644
--- a/apps/web/app/(app)/[emailAccountId]/assistant/ExecutedRulesTable.tsx
+++ b/apps/web/app/(app)/[emailAccountId]/assistant/ExecutedRulesTable.tsx
@@ -1,6 +1,6 @@
 import Link from "next/link";
 import { ExternalLinkIcon, EyeIcon } from "lucide-react";
-import type { PlanHistoryResponse } from "@/app/api/user/planned/history/route";
+import type { GetExecutedRulesResponse } from "@/app/api/user/planned/history/route";
 import { decodeSnippet } from "@/utils/gmail/decode";
 import { ActionBadgeExpanded } from "@/components/PlanBadge";
 import { Tooltip } from "@/components/Tooltip";
@@ -18,6 +18,7 @@ import { FixWithChat } from "@/app/(app)/[emailAccountId]/assistant/FixWithChat"
 import { useAccount } from "@/providers/EmailAccountProvider";
 import { isGoogleProvider } from "@/utils/email/provider-types";
 import { useRuleDialog } from "@/app/(app)/[emailAccountId]/assistant/RuleDialog";
+import { RunRulesResult } from "@/utils/ai/choose-rule/run-rules";
 
 export function EmailCell({
   from,
@@ -63,12 +64,14 @@ export function EmailCell({
 
 export function RuleCell({
   rule,
+  executedAt,
   status,
   reason,
   message,
   setInput,
 }: {
-  rule: PlanHistoryResponse["executedRules"][number]["rule"];
+  rule: GetExecutedRulesResponse["executedRules"][number]["rule"];
+  executedAt: Date;
   status: ExecutedRuleStatus;
   reason?: string | null;
   message: ParsedMessage;
@@ -136,7 +139,7 @@ export function RuleCell({
       <FixWithChat
         setInput={setInput}
         message={message}
-        results={[{ rule, reason }]}
+        results={[{ rule, reason, createdAt: executedAt }]}
       />
       <RuleDialogComponent />
     </div>
@@ -147,7 +150,7 @@ export function ActionItemsCell({
   actionItems,
   provider,
 }: {
-  actionItems: PlanHistoryResponse["executedRules"][number]["actionItems"];
+  actionItems: GetExecutedRulesResponse["executedRules"][number]["actionItems"];
   provider: string;
 }) {
   return (
diff --git a/apps/web/app/(app)/[emailAccountId]/assistant/History.tsx b/apps/web/app/(app)/[emailAccountId]/assistant/History.tsx
index f3124576ee..6e5d8d1560 100644
--- a/apps/web/app/(app)/[emailAccountId]/assistant/History.tsx
+++ b/apps/web/app/(app)/[emailAccountId]/assistant/History.tsx
@@ -3,7 +3,7 @@
 import useSWR from "swr";
 import { useQueryState, parseAsInteger, parseAsString } from "nuqs";
 import { LoadingContent } from "@/components/LoadingContent";
-import type { PlanHistoryResponse } from "@/app/api/user/planned/history/route";
+import type { GetExecutedRulesResponse } from "@/app/api/user/planned/history/route";
 import { AlertBasic } from "@/components/Alert";
 import { Card } from "@/components/ui/card";
 import {
@@ -23,14 +23,13 @@ import { Badge } from "@/components/Badge";
 import { RulesSelect } from "@/app/(app)/[emailAccountId]/assistant/RulesSelect";
 import { useAccount } from "@/providers/EmailAccountProvider";
 import { useChat } from "@/providers/ChatProvider";
+import { useExecutedRules } from "@/hooks/useExecutedRules";
 
 export function History() {
   const [page] = useQueryState("page", parseAsInteger.withDefault(1));
   const [ruleId] = useQueryState("ruleId", parseAsString.withDefault("all"));
 
-  const { data, isLoading, error } = useSWR<PlanHistoryResponse>(
-    `/api/user/planned/history?page=${page}&ruleId=${ruleId}`,
-  );
+  const { data, isLoading, error } = useExecutedRules({ page, ruleId });
 
   return (
     <>
@@ -62,7 +61,7 @@ function HistoryTable({
   data,
   totalPages,
 }: {
-  data: PlanHistoryResponse["executedRules"];
+  data: GetExecutedRulesResponse["executedRules"];
   totalPages: number;
 }) {
   const { userEmail } = useAccount();
@@ -78,19 +77,19 @@ function HistoryTable({
           </TableRow>
         </TableHeader>
         <TableBody>
-          {data.map((p) => (
-            <TableRow key={p.id}>
+          {data.map((er) => (
+            <TableRow key={er.id}>
               <TableCell>
                 <EmailCell
-                  from={p.message.headers.from}
-                  subject={p.message.headers.subject}
-                  snippet={p.message.snippet}
-                  threadId={p.message.threadId}
-                  messageId={p.message.id}
+                  from={er.message.headers.from}
+                  subject={er.message.headers.subject}
+                  snippet={er.message.snippet}
+                  threadId={er.message.threadId}
+                  messageId={er.message.id}
                   userEmail={userEmail}
-                  createdAt={p.createdAt}
+                  createdAt={er.createdAt}
                 />
-                {!p.automated && (
+                {!er.automated && (
                   <Badge color="yellow" className="mt-2">
                     Applied manually
                   </Badge>
@@ -98,10 +97,11 @@ function HistoryTable({
               </TableCell>
               <TableCell>
                 <RuleCell
-                  rule={p.rule}
-                  status={p.status}
-                  reason={p.reason}
-                  message={p.message}
+                  rule={er.rule}
+                  executedAt={er.createdAt}
+                  status={er.status}
+                  reason={er.reason}
+                  message={er.message}
                   setInput={setInput}
                 />
                 {/* <ActionItemsCell actionItems={p.actionItems} /> */}
diff --git a/apps/web/app/api/user/planned/history/route.ts b/apps/web/app/api/user/planned/history/route.ts
index aaa2889f9a..9e7f91189c 100644
--- a/apps/web/app/api/user/planned/history/route.ts
+++ b/apps/web/app/api/user/planned/history/route.ts
@@ -1,11 +1,18 @@
 import { NextResponse } from "next/server";
 import { withEmailProvider } from "@/utils/middleware";
-import { ExecutedRuleStatus } from "@prisma/client";
-import { getExecutedRules } from "@/app/api/user/planned/get-executed-rules";
+import { isDefined } from "@/utils/types";
+import prisma from "@/utils/prisma";
+import { ExecutedRuleStatus, type Prisma } from "@prisma/client";
+import { createScopedLogger } from "@/utils/logger";
+import type { EmailProvider } from "@/utils/email/types";
+
+const LIMIT = 50;
 
 export const dynamic = "force-dynamic";
 
-export type PlanHistoryResponse = Awaited<ReturnType<typeof getExecutedRules>>;
+export type GetExecutedRulesResponse = Awaited<
+  ReturnType<typeof getExecutedRules>
+>;
 
 export const GET = withEmailProvider(async (request) => {
   const emailAccountId = request.auth.emailAccountId;
@@ -14,13 +21,83 @@ export const GET = withEmailProvider(async (request) => {
   const page = Number.parseInt(url.searchParams.get("page") || "1");
   const ruleId = url.searchParams.get("ruleId") || "all";
 
-  const messages = await getExecutedRules({
-    status: ExecutedRuleStatus.APPLIED,
+  const result = await getExecutedRules({
     page,
     ruleId,
     emailAccountId,
     emailProvider: request.emailProvider,
   });
 
-  return NextResponse.json(messages);
+  return NextResponse.json(result);
 });
+
+async function getExecutedRules({
+  page,
+  ruleId,
+  emailAccountId,
+  emailProvider,
+}: {
+  page: number;
+  ruleId?: string;
+  emailAccountId: string;
+  emailProvider: EmailProvider;
+}) {
+  const logger = createScopedLogger("api/user/planned/history").with({
+    emailAccountId,
+    ruleId,
+  });
+
+  const where: Prisma.ExecutedRuleWhereInput = {
+    emailAccountId,
+    status: ExecutedRuleStatus.APPLIED,
+    rule: ruleId === "skipped" ? undefined : { isNot: null },
+    ruleId: ruleId === "all" || ruleId === "skipped" ? undefined : ruleId,
+  };
+
+  const [executedRules, total] = await Promise.all([
+    prisma.executedRule.findMany({
+      where,
+      take: LIMIT,
+      skip: (page - 1) * LIMIT,
+      orderBy: { createdAt: "desc" },
+      select: {
+        id: true,
+        messageId: true,
+        threadId: true,
+        rule: {
+          include: {
+            group: { select: { name: true } },
+          },
+        },
+        actionItems: true,
+        status: true,
+        reason: true,
+        automated: true,
+        createdAt: true,
+      },
+    }),
+    prisma.executedRule.count({ where }),
+  ]);
+
+  const executedRulesWithMessages = await Promise.all(
+    executedRules.map(async (p) => {
+      try {
+        return {
+          ...p,
+          message: await emailProvider.getMessage(p.messageId),
+        };
+      } catch (error) {
+        logger.error("Error getting message", {
+          error,
+          messageId: p.messageId,
+          threadId: p.threadId,
+        });
+      }
+    }),
+  );
+
+  return {
+    executedRules: executedRulesWithMessages.filter(isDefined),
+    totalPages: Math.ceil(total / LIMIT),
+  };
+}
diff --git a/apps/web/hooks/useExecutedRules.tsx b/apps/web/hooks/useExecutedRules.tsx
new file mode 100644
index 0000000000..51834d652a
--- /dev/null
+++ b/apps/web/hooks/useExecutedRules.tsx
@@ -0,0 +1,14 @@
+import useSWR from "swr";
+import type { GetExecutedRulesResponse } from "@/app/api/user/planned/history/route";
+
+export function useExecutedRules({
+  page,
+  ruleId,
+}: {
+  page: number;
+  ruleId: string;
+}) {
+  return useSWR<GetExecutedRulesResponse>(
+    `/api/user/planned/history?page=${page}&ruleId=${ruleId}`,
+  );
+}

From bb89ecccd252d745c699a555f231c69cf753c3bc Mon Sep 17 00:00:00 2001
From: Eliezer Steinbock <3090527+elie222@users.noreply.github.com>
Date: Tue, 21 Oct 2025 15:20:58 +0300
Subject: [PATCH 36/40] fixes

---
 .../(app)/[emailAccountId]/assistant/ProcessResultDisplay.tsx   | 2 +-
 apps/web/components/assistant-chat/chat.tsx                     | 2 +-
 version.txt                                                     | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/apps/web/app/(app)/[emailAccountId]/assistant/ProcessResultDisplay.tsx b/apps/web/app/(app)/[emailAccountId]/assistant/ProcessResultDisplay.tsx
index 8e1b0549fc..f6ee562dec 100644
--- a/apps/web/app/(app)/[emailAccountId]/assistant/ProcessResultDisplay.tsx
+++ b/apps/web/app/(app)/[emailAccountId]/assistant/ProcessResultDisplay.tsx
@@ -85,7 +85,7 @@ export function ProcessResultDisplay({
                 }
               >
                 <Badge color="green">
-                  {prefix ? prefix : ""}
+                  {prefix ?? ""}
                   {result.rule?.name}
                   <EyeIcon className="ml-1.5 size-3.5 opacity-70" />
                 </Badge>
diff --git a/apps/web/components/assistant-chat/chat.tsx b/apps/web/components/assistant-chat/chat.tsx
index 1e9a2446f6..bf526e9077 100644
--- a/apps/web/components/assistant-chat/chat.tsx
+++ b/apps/web/components/assistant-chat/chat.tsx
@@ -109,7 +109,7 @@ export function Chat() {
         <PromptInput
           onSubmit={(e) => {
             e.preventDefault();
-            if ((input.trim() || nextContext) && status === "ready") {
+            if (input.trim() && status === "ready") {
               handleSubmit();
               setLocalStorageInput("");
             }
diff --git a/version.txt b/version.txt
index 7728c4ba0a..c0436dea50 100644
--- a/version.txt
+++ b/version.txt
@@ -1 +1 @@
-v2.16.11
+v2.17.0

From 9c9a8480648f4ebc126c3818fdec9c1a1d05006a Mon Sep 17 00:00:00 2001
From: Eliezer Steinbock <3090527+elie222@users.noreply.github.com>
Date: Tue, 21 Oct 2025 15:25:18 +0300
Subject: [PATCH 37/40] rename files

---
 .../assistant/ExecutedRulesTable.tsx          |  2 +-
 .../[emailAccountId]/assistant/History.tsx    |  3 +-
 .../history/route.ts                          |  2 +-
 .../api/user/planned/get-executed-rules.ts    | 80 -------------------
 apps/web/hooks/useExecutedRules.tsx           |  4 +-
 5 files changed, 5 insertions(+), 86 deletions(-)
 rename apps/web/app/api/user/{planned => executed-rules}/history/route.ts (97%)
 delete mode 100644 apps/web/app/api/user/planned/get-executed-rules.ts

diff --git a/apps/web/app/(app)/[emailAccountId]/assistant/ExecutedRulesTable.tsx b/apps/web/app/(app)/[emailAccountId]/assistant/ExecutedRulesTable.tsx
index 946cf23e91..9bbd2e686f 100644
--- a/apps/web/app/(app)/[emailAccountId]/assistant/ExecutedRulesTable.tsx
+++ b/apps/web/app/(app)/[emailAccountId]/assistant/ExecutedRulesTable.tsx
@@ -1,6 +1,6 @@
 import Link from "next/link";
 import { ExternalLinkIcon, EyeIcon } from "lucide-react";
-import type { GetExecutedRulesResponse } from "@/app/api/user/planned/history/route";
+import type { GetExecutedRulesResponse } from "@/app/api/user/executed-rules/history/route";
 import { decodeSnippet } from "@/utils/gmail/decode";
 import { ActionBadgeExpanded } from "@/components/PlanBadge";
 import { Tooltip } from "@/components/Tooltip";
diff --git a/apps/web/app/(app)/[emailAccountId]/assistant/History.tsx b/apps/web/app/(app)/[emailAccountId]/assistant/History.tsx
index 6e5d8d1560..3342290c8d 100644
--- a/apps/web/app/(app)/[emailAccountId]/assistant/History.tsx
+++ b/apps/web/app/(app)/[emailAccountId]/assistant/History.tsx
@@ -1,9 +1,8 @@
 "use client";
 
-import useSWR from "swr";
 import { useQueryState, parseAsInteger, parseAsString } from "nuqs";
 import { LoadingContent } from "@/components/LoadingContent";
-import type { GetExecutedRulesResponse } from "@/app/api/user/planned/history/route";
+import type { GetExecutedRulesResponse } from "@/app/api/user/executed-rules/history/route";
 import { AlertBasic } from "@/components/Alert";
 import { Card } from "@/components/ui/card";
 import {
diff --git a/apps/web/app/api/user/planned/history/route.ts b/apps/web/app/api/user/executed-rules/history/route.ts
similarity index 97%
rename from apps/web/app/api/user/planned/history/route.ts
rename to apps/web/app/api/user/executed-rules/history/route.ts
index 9e7f91189c..99f5f29a23 100644
--- a/apps/web/app/api/user/planned/history/route.ts
+++ b/apps/web/app/api/user/executed-rules/history/route.ts
@@ -42,7 +42,7 @@ async function getExecutedRules({
   emailAccountId: string;
   emailProvider: EmailProvider;
 }) {
-  const logger = createScopedLogger("api/user/planned/history").with({
+  const logger = createScopedLogger("api/user/executed-rules/history").with({
     emailAccountId,
     ruleId,
   });
diff --git a/apps/web/app/api/user/planned/get-executed-rules.ts b/apps/web/app/api/user/planned/get-executed-rules.ts
deleted file mode 100644
index 4aacb34f31..0000000000
--- a/apps/web/app/api/user/planned/get-executed-rules.ts
+++ /dev/null
@@ -1,80 +0,0 @@
-import { isDefined } from "@/utils/types";
-import prisma from "@/utils/prisma";
-import { ExecutedRuleStatus } from "@prisma/client";
-import { createScopedLogger } from "@/utils/logger";
-import type { EmailProvider } from "@/utils/email/types";
-
-const logger = createScopedLogger("api/user/planned/get-executed-rules");
-
-const LIMIT = 50;
-
-export async function getExecutedRules({
-  status,
-  page,
-  ruleId,
-  emailAccountId,
-  emailProvider,
-}: {
-  status: ExecutedRuleStatus;
-  page: number;
-  ruleId?: string;
-  emailAccountId: string;
-  emailProvider: EmailProvider;
-}) {
-  const where = {
-    emailAccountId,
-    status: ruleId === "skipped" ? ExecutedRuleStatus.SKIPPED : status,
-    rule: ruleId === "skipped" ? undefined : { isNot: null },
-    ruleId: ruleId === "all" || ruleId === "skipped" ? undefined : ruleId,
-  };
-  logger.info("getExecutedRules query", { where });
-
-  const [executedRules, total] = await Promise.all([
-    prisma.executedRule.findMany({
-      where,
-      take: LIMIT,
-      skip: (page - 1) * LIMIT,
-      orderBy: { createdAt: "desc" },
-      select: {
-        id: true,
-        messageId: true,
-        threadId: true,
-        rule: {
-          include: {
-            group: { select: { name: true } },
-          },
-        },
-        actionItems: true,
-        status: true,
-        reason: true,
-        automated: true,
-        createdAt: true,
-      },
-    }),
-    prisma.executedRule.count({ where }),
-  ]);
-
-  const executedRulesWithMessages = await Promise.all(
-    executedRules.map(async (p) => {
-      try {
-        return {
-          ...p,
-          message: await emailProvider.getMessage(p.messageId),
-        };
-      } catch (error) {
-        logger.error("Error getting message", {
-          error,
-          messageId: p.messageId,
-          threadId: p.threadId,
-          emailAccountId,
-          ruleId,
-        });
-      }
-    }),
-  );
-
-  return {
-    executedRules: executedRulesWithMessages.filter(isDefined),
-    totalPages: Math.ceil(total / LIMIT),
-  };
-}
diff --git a/apps/web/hooks/useExecutedRules.tsx b/apps/web/hooks/useExecutedRules.tsx
index 51834d652a..fd575c0e95 100644
--- a/apps/web/hooks/useExecutedRules.tsx
+++ b/apps/web/hooks/useExecutedRules.tsx
@@ -1,5 +1,5 @@
 import useSWR from "swr";
-import type { GetExecutedRulesResponse } from "@/app/api/user/planned/history/route";
+import type { GetExecutedRulesResponse } from "@/app/api/user/executed-rules/history/route";
 
 export function useExecutedRules({
   page,
@@ -9,6 +9,6 @@ export function useExecutedRules({
   ruleId: string;
 }) {
   return useSWR<GetExecutedRulesResponse>(
-    `/api/user/planned/history?page=${page}&ruleId=${ruleId}`,
+    `/api/user/executed-rules/history?page=${page}&ruleId=${ruleId}`,
   );
 }

From 229ab4b889dcfd9c697367264d3acca537f0594e Mon Sep 17 00:00:00 2001
From: Eliezer Steinbock <3090527+elie222@users.noreply.github.com>
Date: Tue, 21 Oct 2025 15:27:51 +0300
Subject: [PATCH 38/40] rename var

---
 .../assistant/ExecutedRulesTable.tsx               |  1 -
 .../[emailAccountId]/assistant/FixWithChat.tsx     |  4 ++--
 apps/web/components/assistant-chat/chat.tsx        | 14 +++++++-------
 apps/web/providers/ChatProvider.tsx                | 10 +++++-----
 4 files changed, 14 insertions(+), 15 deletions(-)

diff --git a/apps/web/app/(app)/[emailAccountId]/assistant/ExecutedRulesTable.tsx b/apps/web/app/(app)/[emailAccountId]/assistant/ExecutedRulesTable.tsx
index 9bbd2e686f..e0fc88f0cd 100644
--- a/apps/web/app/(app)/[emailAccountId]/assistant/ExecutedRulesTable.tsx
+++ b/apps/web/app/(app)/[emailAccountId]/assistant/ExecutedRulesTable.tsx
@@ -18,7 +18,6 @@ import { FixWithChat } from "@/app/(app)/[emailAccountId]/assistant/FixWithChat"
 import { useAccount } from "@/providers/EmailAccountProvider";
 import { isGoogleProvider } from "@/utils/email/provider-types";
 import { useRuleDialog } from "@/app/(app)/[emailAccountId]/assistant/RuleDialog";
-import { RunRulesResult } from "@/utils/ai/choose-rule/run-rules";
 
 export function EmailCell({
   from,
diff --git a/apps/web/app/(app)/[emailAccountId]/assistant/FixWithChat.tsx b/apps/web/app/(app)/[emailAccountId]/assistant/FixWithChat.tsx
index 6e7d655092..9534436d06 100644
--- a/apps/web/app/(app)/[emailAccountId]/assistant/FixWithChat.tsx
+++ b/apps/web/app/(app)/[emailAccountId]/assistant/FixWithChat.tsx
@@ -45,7 +45,7 @@ export function FixWithChat({
   const [showExplanation, setShowExplanation] = useState(false);
 
   const { setOpen } = useSidebar();
-  const { setContext: setNextContext } = useChat();
+  const { setContext } = useChat();
 
   const selectedRuleName = useMemo(() => {
     if (!data) return null;
@@ -110,7 +110,7 @@ export function FixWithChat({
             ? "none"
             : { name: selectedRuleName || "Unknown" },
     };
-    setNextContext(context);
+    setContext(context);
 
     setInput(input);
     setOpen((arr) => [...arr, "chat-sidebar"]);
diff --git a/apps/web/components/assistant-chat/chat.tsx b/apps/web/components/assistant-chat/chat.tsx
index bf526e9077..1c9545e159 100644
--- a/apps/web/components/assistant-chat/chat.tsx
+++ b/apps/web/components/assistant-chat/chat.tsx
@@ -33,8 +33,8 @@ export function Chat() {
     setInput,
     handleSubmit,
     setNewChat,
-    context: nextContext,
-    setContext: setNextContext,
+    context,
+    setContext,
   } = useChat();
   const { messages, status, stop, regenerate, setMessages } = chat;
   const [localStorageInput, setLocalStorageInput] = useLocalStorage(
@@ -90,16 +90,16 @@ export function Chat() {
       />
 
       <div className="mx-auto w-full px-4 pb-4 md:max-w-3xl md:pb-6">
-        {nextContext ? (
+        {context ? (
           <div className="mb-2 flex items-center gap-2">
             <span className="inline-flex items-center gap-2 rounded-full bg-muted px-3 py-1 text-xs text-muted-foreground">
-              Fix: {nextContext.message.headers.subject.slice(0, 60)}
-              {nextContext.message.headers.subject.length > 60 ? "..." : ""}
+              Fix: {context.message.headers.subject.slice(0, 60)}
+              {context.message.headers.subject.length > 60 ? "..." : ""}
               <button
                 type="button"
                 aria-label="Remove context"
                 className="ml-1 rounded p-0.5 hover:bg-muted-foreground/10"
-                onClick={() => setNextContext(null)}
+                onClick={() => setContext(null)}
               >
                 ×
               </button>
@@ -130,7 +130,7 @@ export function Chat() {
                   ? "submitted"
                   : "ready"
             }
-            disabled={(!input.trim() && !nextContext) || status !== "ready"}
+            disabled={(!input.trim() && !context) || status !== "ready"}
             className="absolute bottom-1 right-1"
             onClick={(e) => {
               if (status === "streaming") {
diff --git a/apps/web/providers/ChatProvider.tsx b/apps/web/providers/ChatProvider.tsx
index 3b2b7b9dde..fc4825cb32 100644
--- a/apps/web/providers/ChatProvider.tsx
+++ b/apps/web/providers/ChatProvider.tsx
@@ -41,7 +41,7 @@ export function ChatProvider({ children }: { children: React.ReactNode }) {
 
   const [input, setInput] = useState<string>("");
   const [chatId, setChatId] = useQueryState("chatId", parseAsString);
-  const [nextContext, setNextContext] = useState<MessageContext | null>(null);
+  const [context, setContext] = useState<MessageContext | null>(null);
 
   const { data } = useChatMessages(chatId);
 
@@ -61,7 +61,7 @@ export function ChatProvider({ children }: { children: React.ReactNode }) {
           body: {
             id,
             message: messages.at(-1),
-            context: nextContext ?? undefined,
+            context: context ?? undefined,
             ...body,
           },
         };
@@ -99,7 +99,7 @@ export function ChatProvider({ children }: { children: React.ReactNode }) {
     });
 
     setInput("");
-  }, [chat.sendMessage, input, nextContext]);
+  }, [chat.sendMessage, input, context]);
 
   return (
     <ChatContext.Provider
@@ -111,8 +111,8 @@ export function ChatProvider({ children }: { children: React.ReactNode }) {
         setChatId,
         setNewChat,
         handleSubmit,
-        context: nextContext,
-        setContext: setNextContext,
+        context: context,
+        setContext: setContext,
       }}
     >
       {children}

From 2048c4c492171d642c4bccd4d7da05d0e1e48bf0 Mon Sep 17 00:00:00 2001
From: Eliezer Steinbock <3090527+elie222@users.noreply.github.com>
Date: Tue, 21 Oct 2025 15:39:09 +0300
Subject: [PATCH 39/40] Add migration

---
 apps/web/package.json                         |  2 -
 .../migration.sql                             |  8 ++++
 apps/web/providers/ChatProvider.tsx           |  9 ++--
 pnpm-lock.yaml                                | 43 -------------------
 4 files changed, 12 insertions(+), 50 deletions(-)
 create mode 100644 apps/web/prisma/migrations/20251021123040_drop_executed_rule_unique/migration.sql

diff --git a/apps/web/package.json b/apps/web/package.json
index 88a97b66cd..20025439af 100644
--- a/apps/web/package.json
+++ b/apps/web/package.json
@@ -122,7 +122,6 @@
     "lodash": "4.17.21",
     "lucide-react": "0.542.0",
     "motion": "12.23.24",
-    "nanoid": "5.1.5",
     "next": "15.5.2",
     "next-axiom": "1.9.2",
     "next-safe-action": "7.10.8",
@@ -161,7 +160,6 @@
     "tailwind-merge": "2.6.0",
     "tailwindcss-animate": "1.0.7",
     "tiptap-markdown": "0.8.10",
-    "tokenlens": "1.3.1",
     "typescript": "5.9.2",
     "use-stick-to-bottom": "1.1.1",
     "usehooks-ts": "3.1.1",
diff --git a/apps/web/prisma/migrations/20251021123040_drop_executed_rule_unique/migration.sql b/apps/web/prisma/migrations/20251021123040_drop_executed_rule_unique/migration.sql
new file mode 100644
index 0000000000..1710a659fb
--- /dev/null
+++ b/apps/web/prisma/migrations/20251021123040_drop_executed_rule_unique/migration.sql
@@ -0,0 +1,8 @@
+-- DropIndex
+DROP INDEX "ExecutedRule_emailAccountId_threadId_messageId_key";
+
+-- CreateIndex
+CREATE INDEX "ExecutedRule_emailAccountId_threadId_messageId_ruleId_idx" ON "ExecutedRule"("emailAccountId", "threadId", "messageId", "ruleId");
+
+-- CreateIndex
+CREATE INDEX "ExecutedRule_emailAccountId_messageId_idx" ON "ExecutedRule"("emailAccountId", "messageId");
diff --git a/apps/web/providers/ChatProvider.tsx b/apps/web/providers/ChatProvider.tsx
index fc4825cb32..54e2d23f21 100644
--- a/apps/web/providers/ChatProvider.tsx
+++ b/apps/web/providers/ChatProvider.tsx
@@ -67,8 +67,7 @@ export function ChatProvider({ children }: { children: React.ReactNode }) {
         };
       },
     }),
-    // TODO: couldn't get this to work
-    // messages: initialMessages,
+    // messages: initialMessages, // NOTE: couldn't get this to work
     experimental_throttle: 100,
     generateId: generateUUID,
     onFinish: () => {
@@ -99,7 +98,7 @@ export function ChatProvider({ children }: { children: React.ReactNode }) {
     });
 
     setInput("");
-  }, [chat.sendMessage, input, context]);
+  }, [chat.sendMessage, input]);
 
   return (
     <ChatContext.Provider
@@ -111,8 +110,8 @@ export function ChatProvider({ children }: { children: React.ReactNode }) {
         setChatId,
         setNewChat,
         handleSubmit,
-        context: context,
-        setContext: setContext,
+        context,
+        setContext,
       }}
     >
       {children}
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index f189de136b..a22eaacce8 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -417,9 +417,6 @@ importers:
       motion:
         specifier: 12.23.24
         version: 12.23.24(@emotion/is-prop-valid@1.2.2)(react-dom@19.1.1(react@19.1.1))(react@19.1.1)
-      nanoid:
-        specifier: 5.1.5
-        version: 5.1.5
       next:
         specifier: 15.5.2
         version: 15.5.2(@babel/core@7.28.3)(@opentelemetry/api@1.9.0)(react-dom@19.1.1(react@19.1.1))(react@19.1.1)
@@ -534,9 +531,6 @@ importers:
       tiptap-markdown:
         specifier: 0.8.10
         version: 0.8.10(@tiptap/core@2.26.1(@tiptap/pm@2.26.1))
-      tokenlens:
-        specifier: 1.3.1
-        version: 1.3.1
       typescript:
         specifier: 5.9.2
         version: 5.9.2
@@ -4504,18 +4498,6 @@ packages:
       '@tiptap/core': ^2.7.0
       '@tiptap/pm': ^2.7.0
 
-  '@tokenlens/core@1.3.0':
-    resolution: {integrity: sha512-d8YNHNC+q10bVpi95fELJwJyPVf1HfvBEI18eFQxRSZTdByXrP+f/ZtlhSzkx0Jl0aEmYVeBA5tPeeYRioLViQ==}
-
-  '@tokenlens/fetch@1.3.0':
-    resolution: {integrity: sha512-RONDRmETYly9xO8XMKblmrZjKSwCva4s5ebJwQNfNlChZoA5kplPoCgnWceHnn1J1iRjLVlrCNB43ichfmGBKQ==}
-
-  '@tokenlens/helpers@1.3.1':
-    resolution: {integrity: sha512-t6yL8N6ES8337E6eVSeH4hCKnPdWkZRFpupy9w5E66Q9IeqQ9IO7XQ6gh12JKjvWiRHuyyJ8MBP5I549Cr41EQ==}
-
-  '@tokenlens/models@1.3.0':
-    resolution: {integrity: sha512-9mx7ZGeewW4ndXAiD7AT1bbCk4OpJeortbjHHyNkgap+pMPPn1chY6R5zqe1ggXIUzZ2l8VOAKfPqOvpcrisJw==}
-
   '@tootallnate/quickjs-emscripten@0.23.0':
     resolution: {integrity: sha512-C5Mc6rdnsaJDjO3UpGW/CQTHtCKaYlScZTly4JIu97Jxo/odCiH0ITnDXSJPTOrEKk/ycSZ0AOgTmkDtkOsvIA==}
 
@@ -10587,9 +10569,6 @@ packages:
     resolution: {integrity: sha512-o5sSPKEkg/DIQNmH43V0/uerLrpzVedkUh8tGNvaeXpfpuwjKenlSox/2O/BTlZUtEe+JG7s5YhEz608PlAHRA==}
     engines: {node: '>=0.6'}
 
-  tokenlens@1.3.1:
-    resolution: {integrity: sha512-7oxmsS5PNCX3z+b+z07hL5vCzlgHKkCGrEQjQmWl5l+v5cUrtL7S1cuST4XThaL1XyjbTX8J5hfP0cjDJRkaLA==}
-
   totalist@3.0.1:
     resolution: {integrity: sha512-sf4i37nQ2LBx4m3wB74y+ubopq6W/dIzXg0FDGjsYnZHVa1Da8FH853wlL2gtUhg+xJXjfk3kUZS3BRoQeoQBQ==}
     engines: {node: '>=6'}
@@ -15891,21 +15870,6 @@ snapshots:
       '@tiptap/core': 2.26.1(@tiptap/pm@2.26.1)
       '@tiptap/pm': 2.26.1
 
-  '@tokenlens/core@1.3.0': {}
-
-  '@tokenlens/fetch@1.3.0':
-    dependencies:
-      '@tokenlens/core': 1.3.0
-
-  '@tokenlens/helpers@1.3.1':
-    dependencies:
-      '@tokenlens/core': 1.3.0
-      '@tokenlens/fetch': 1.3.0
-
-  '@tokenlens/models@1.3.0':
-    dependencies:
-      '@tokenlens/core': 1.3.0
-
   '@tootallnate/quickjs-emscripten@0.23.0': {}
 
   '@tremor/react@3.18.7(react-dom@19.1.1(react@19.1.1))(react@19.1.1)':
@@ -23181,13 +23145,6 @@ snapshots:
 
   toidentifier@1.0.1: {}
 
-  tokenlens@1.3.1:
-    dependencies:
-      '@tokenlens/core': 1.3.0
-      '@tokenlens/fetch': 1.3.0
-      '@tokenlens/helpers': 1.3.1
-      '@tokenlens/models': 1.3.0
-
   totalist@3.0.1: {}
 
   tough-cookie@4.1.4:

From 8a648e67752714200646d380c739961c2b673b7d Mon Sep 17 00:00:00 2001
From: Eliezer Steinbock <3090527+elie222@users.noreply.github.com>
Date: Tue, 21 Oct 2025 15:41:56 +0300
Subject: [PATCH 40/40] fix skipped

---
 apps/web/app/api/user/executed-rules/history/route.ts | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/apps/web/app/api/user/executed-rules/history/route.ts b/apps/web/app/api/user/executed-rules/history/route.ts
index 99f5f29a23..ee5ecba4f4 100644
--- a/apps/web/app/api/user/executed-rules/history/route.ts
+++ b/apps/web/app/api/user/executed-rules/history/route.ts
@@ -49,7 +49,10 @@ async function getExecutedRules({
 
   const where: Prisma.ExecutedRuleWhereInput = {
     emailAccountId,
-    status: ExecutedRuleStatus.APPLIED,
+    status:
+      ruleId === "skipped"
+        ? ExecutedRuleStatus.SKIPPED
+        : ExecutedRuleStatus.APPLIED,
     rule: ruleId === "skipped" ? undefined : { isNot: null },
     ruleId: ruleId === "all" || ruleId === "skipped" ? undefined : ruleId,
   };