inboxctl 0.1.2 → 0.3.0

package/dist/{chunk-EY6VV43S.js → chunk-OLL3OA5B.js}

@@ -8,7 +8,7 @@ var __export = (target, all) => {
 // src/mcp/server.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { z as z2 } from "zod";
+import { z as z4 } from "zod";
 
 // src/core/actions/audit.ts
 import { randomUUID } from "crypto";
@@ -436,7 +436,7 @@ function getDatabase() {
   return getSqlite(config.dbPath);
 }
 function ensureValidSourceType(sourceType) {
-  if (sourceType !== "manual" && sourceType !== "rule") {
+  if (sourceType !== "manual" && sourceType !== "rule" && sourceType !== "unsubscribe") {
     throw new Error(`Invalid execution source type: ${sourceType}`);
   }
 }
@@ -2041,6 +2041,322 @@ async function undoRun(runId) {
   };
 }
 
+// src/core/gmail/batch.ts
+var MESSAGE_FETCH_HEADERS2 = ["From", "To", "Subject", "Date", "List-Unsubscribe"];
+function makePlaceholders2(values) {
+  return values.map(() => "?").join(", ");
+}
+function parseJsonArray2(raw) {
+  if (!raw) {
+    return [];
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    return Array.isArray(parsed) ? parsed.filter((value) => typeof value === "string") : [];
+  } catch {
+    return [];
+  }
+}
+function rowToEmail2(row) {
+  return {
+    id: row.id,
+    threadId: row.thread_id || "",
+    fromAddress: row.from_address || "",
+    fromName: row.from_name || "",
+    toAddresses: parseJsonArray2(row.to_addresses),
+    subject: row.subject || "",
+    snippet: row.snippet || "",
+    date: row.date || 0,
+    isRead: row.is_read === 1,
+    isStarred: row.is_starred === 1,
+    labelIds: parseJsonArray2(row.label_ids),
+    sizeEstimate: row.size_estimate || 0,
+    hasAttachments: row.has_attachments === 1,
+    listUnsubscribe: row.list_unsubscribe
+  };
+}
+function uniqueStrings(values) {
+  return Array.from(new Set(values.map((value) => value.trim()).filter(Boolean)));
+}
+function actionSignature(action) {
+  switch (action.type) {
+    case "label":
+      return `label:${action.label}`;
+    default:
+      return action.type;
+  }
+}
+function combineItemStatus(current, next) {
+  if (current === "error" || next === "error") {
+    return "error";
+  }
+  if (current === "warning" || next === "warning") {
+    return "warning";
+  }
+  return "applied";
+}
+function resolveExecutionStatus(items, dryRun) {
+  if (dryRun) {
+    return "planned";
+  }
+  if (items.length === 0) {
+    return "applied";
+  }
+  if (items.every((item) => item.status === "applied")) {
+    return "applied";
+  }
+  if (items.some((item) => item.status === "applied" || item.status === "warning")) {
+    return "partial";
+  }
+  return "error";
+}
+function normalizeGroups(groups) {
+  if (groups.length === 0) {
+    throw new Error("Provide at least one action group.");
+  }
+  if (groups.length > 20) {
+    throw new Error("A batch may contain at most 20 groups.");
+  }
+  const seenEmailIds = /* @__PURE__ */ new Set();
+  return groups.map((group, index2) => {
+    const emailIds = uniqueStrings(group.emailIds);
+    const actionMap = /* @__PURE__ */ new Map();
+    for (const action of group.actions) {
+      if (action.type === "label" && !action.label.trim()) {
+        throw new Error(`Group ${index2 + 1}: label actions require a label name.`);
+      }
+      actionMap.set(actionSignature(action), action);
+    }
+    if (emailIds.length === 0) {
+      throw new Error(`Group ${index2 + 1}: provide at least one email ID.`);
+    }
+    if (emailIds.length > 500) {
+      throw new Error(`Group ${index2 + 1}: a group may contain at most 500 email IDs.`);
+    }
+    const actions = [...actionMap.values()];
+    if (actions.length === 0) {
+      throw new Error(`Group ${index2 + 1}: provide at least one action.`);
+    }
+    if (actions.length > 5) {
+      throw new Error(`Group ${index2 + 1}: a group may contain at most 5 actions.`);
+    }
+    for (const emailId of emailIds) {
+      if (seenEmailIds.has(emailId)) {
+        throw new Error(`Email ${emailId} appears in more than one group. Each email may only be targeted once per batch.`);
+      }
+      seenEmailIds.add(emailId);
+    }
+    return {
+      emailIds,
+      actions
+    };
+  });
+}
+async function resolveContext3(options) {
+  const config = options?.config || loadConfig();
+  const transport = options?.transport || await getGmailTransport(config);
+  return { config, transport };
+}
+function readSnapshotEmails(config, ids) {
+  const sqlite = getSqlite(config.dbPath);
+  const rows = sqlite.prepare(
+    `
+      SELECT id, thread_id, from_address, from_name, to_addresses, subject, snippet, date,
+             is_read, is_starred, label_ids, size_estimate, has_attachments, list_unsubscribe
+      FROM emails
+      WHERE id IN (${makePlaceholders2(ids)})
+      `
+  ).all(...ids);
+  return new Map(rows.map((row) => [row.id, rowToEmail2(row)]));
+}
+async function fetchMissingSnapshotEmails(transport, ids, snapshots) {
+  const missingIds = ids.filter((id) => !snapshots.has(id));
+  const fetched = await Promise.all(
+    missingIds.map(async (id) => {
+      const response = await transport.getMessage({
+        id,
+        format: "metadata",
+        metadataHeaders: MESSAGE_FETCH_HEADERS2
+      });
+      if (!response.id) {
+        throw new Error(`Gmail message not found: ${id}`);
+      }
+      return parseMessage(response);
+    })
+  );
+  for (const email of fetched) {
+    snapshots.set(email.id, email);
+  }
+}
+async function loadSnapshots(ids, context) {
+  const snapshots = readSnapshotEmails(context.config, ids);
+  await fetchMissingSnapshotEmails(context.transport, ids, snapshots);
+  return snapshots;
+}
+async function executeAction(action, emailIds, context) {
+  switch (action.type) {
+    case "archive":
+      return (await archiveEmails(emailIds, context)).items;
+    case "label":
+      await createLabel(action.label, void 0, context);
+      return (await labelEmails(emailIds, action.label, context)).items;
+    case "mark_read":
+      return (await markRead(emailIds, context)).items;
+    case "mark_spam":
+      return (await markSpam(emailIds, context)).items;
+  }
+}
+async function executeGroup(group, context, dryRun) {
+  const summary = {
+    emailCount: group.emailIds.length,
+    actionsApplied: group.actions.map(actionSignature),
+    status: dryRun ? "planned" : "applied"
+  };
+  if (dryRun) {
+    return {
+      summary,
+      items: []
+    };
+  }
+  const items = group.emailIds.map((emailId) => ({
+    emailId,
+    status: "applied",
+    appliedActions: [],
+    beforeLabelIds: [],
+    afterLabelIds: [],
+    errorMessage: null
+  }));
+  const itemMap = new Map(items.map((item) => [item.emailId, item]));
+  try {
+    const snapshots = await loadSnapshots(group.emailIds, context);
+    for (const emailId of group.emailIds) {
+      const snapshot = snapshots.get(emailId);
+      const item = itemMap.get(emailId);
+      if (!item) {
+        continue;
+      }
+      if (!snapshot) {
+        item.status = "error";
+        item.errorMessage = `Unable to resolve Gmail message snapshot for ${emailId}`;
+        continue;
+      }
+      item.beforeLabelIds = [...snapshot.labelIds];
+      item.afterLabelIds = [...snapshot.labelIds];
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    for (const item of items) {
+      item.status = "error";
+      item.errorMessage = message;
+    }
+    summary.status = resolveExecutionStatus(items, false);
+    return { summary, items };
+  }
+  for (const action of group.actions) {
+    const activeIds = items.filter((item) => item.status !== "error").map((item) => item.emailId);
+    if (activeIds.length === 0) {
+      break;
+    }
+    try {
+      const results = await executeAction(action, activeIds, context);
+      const resultMap = new Map(results.map((result) => [result.emailId, result]));
+      for (const emailId of activeIds) {
+        const item = itemMap.get(emailId);
+        if (!item) {
+          continue;
+        }
+        const result = resultMap.get(emailId);
+        if (!result) {
+          item.status = "error";
+          item.errorMessage = `Missing Gmail mutation result for ${emailId}`;
+          continue;
+        }
+        item.status = combineItemStatus(item.status, result.status);
+        item.afterLabelIds = [...result.afterLabelIds];
+        item.appliedActions = [...item.appliedActions, ...result.appliedActions];
+        item.errorMessage = result.errorMessage ?? item.errorMessage;
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      for (const emailId of activeIds) {
+        const item = itemMap.get(emailId);
+        if (!item) {
+          continue;
+        }
+        item.status = "error";
+        item.errorMessage = message;
+      }
+      break;
+    }
+  }
+  summary.status = resolveExecutionStatus(items, false);
+  return {
+    summary,
+    items
+  };
+}
+function collectRequestedActions(groups) {
+  const actions = /* @__PURE__ */ new Map();
+  for (const group of groups) {
+    for (const action of group.actions) {
+      actions.set(actionSignature(action), action);
+    }
+  }
+  return [...actions.values()];
+}
+async function batchApplyActions(options) {
+  const groups = normalizeGroups(options.groups);
+  const dryRun = options.dryRun ?? false;
+  if (dryRun) {
+    const summaries2 = groups.map((group) => ({
+      emailCount: group.emailIds.length,
+      actionsApplied: group.actions.map(actionSignature),
+      status: "planned"
+    }));
+    return {
+      runId: null,
+      dryRun: true,
+      groups: summaries2,
+      totalEmailsAffected: summaries2.reduce((sum, group) => sum + group.emailCount, 0),
+      undoAvailable: false
+    };
+  }
+  const context = await resolveContext3(options);
+  const summaries = [];
+  const executionItems2 = [];
+  for (const group of groups) {
+    const result = await executeGroup(group, context, false);
+    summaries.push(result.summary);
+    executionItems2.push(...result.items);
+  }
+  const status = resolveExecutionStatus(executionItems2, false);
+  const run = await createExecutionRun({
+    sourceType: options.sourceType ?? "manual",
+    dryRun: false,
+    requestedActions: collectRequestedActions(groups),
+    query: options.query ?? null,
+    status
+  });
+  await addExecutionItems(
+    run.id,
+    executionItems2.map((item) => ({
+      emailId: item.emailId,
+      status: item.status,
+      appliedActions: item.appliedActions,
+      beforeLabelIds: item.beforeLabelIds,
+      afterLabelIds: item.afterLabelIds,
+      errorMessage: item.errorMessage
+    }))
+  );
+  return {
+    runId: run.id,
+    dryRun: false,
+    groups: summaries,
+    totalEmailsAffected: summaries.reduce((sum, group) => sum + group.emailCount, 0),
+    undoAvailable: status === "applied" || status === "partial" || status === "error"
+  };
+}
+
 // src/core/gmail/threads.ts
 async function getThread(id) {
   const config = loadConfig();
@@ -2055,8 +2371,224 @@ async function getThread(id) {
   };
 }
 
+// src/core/unsubscribe.ts
+function uniqueStrings2(values) {
+  return Array.from(new Set(values.map((value) => value.trim()).filter(Boolean)));
+}
+function extractCandidates(value) {
+  const matches = [...value.matchAll(/<([^>]+)>/g)].map((match) => match[1]?.trim() || "").filter(Boolean);
+  if (matches.length > 0) {
+    return matches;
+  }
+  return value.split(",").map((entry) => entry.trim()).filter(Boolean);
+}
+function parseListUnsubscribeValues(...values) {
+  const links = [];
+  const mailtos = [];
+  for (const rawValue of values) {
+    if (!rawValue?.trim()) {
+      continue;
+    }
+    for (const candidate of extractCandidates(rawValue)) {
+      const normalized = candidate.trim();
+      if (/^mailto:/i.test(normalized)) {
+        mailtos.push(normalized);
+        continue;
+      }
+      if (/^https?:\/\//i.test(normalized)) {
+        links.push(normalized);
+      }
+    }
+  }
+  return {
+    links: uniqueStrings2(links),
+    mailtos: uniqueStrings2(mailtos)
+  };
+}
+function resolveUnsubscribeTarget(...values) {
+  const parsed = parseListUnsubscribeValues(...values);
+  if (parsed.links.length > 0 && parsed.mailtos.length > 0) {
+    return {
+      unsubscribeLink: parsed.links[0] || null,
+      unsubscribeMethod: "both"
+    };
+  }
+  if (parsed.links.length > 0) {
+    return {
+      unsubscribeLink: parsed.links[0] || null,
+      unsubscribeMethod: "link"
+    };
+  }
+  if (parsed.mailtos.length > 0) {
+    return {
+      unsubscribeLink: parsed.mailtos[0] || null,
+      unsubscribeMethod: "mailto"
+    };
+  }
+  return {
+    unsubscribeLink: null,
+    unsubscribeMethod: null
+  };
+}
+function buildUnsubscribeReason(unreadRate, messageCount) {
+  if (unreadRate >= 90) {
+    return `${unreadRate}% unread across ${messageCount} emails \u2014 you never engage with this sender`;
+  }
+  if (unreadRate >= 50) {
+    return `${unreadRate}% unread across ${messageCount} emails \u2014 you rarely engage with this sender`;
+  }
+  if (unreadRate >= 25) {
+    return `${unreadRate}% unread across ${messageCount} emails \u2014 you sometimes read this sender`;
+  }
+  return `High volume sender (${messageCount} emails) with ${unreadRate}% unread`;
+}
+
+// src/core/gmail/unsubscribe.ts
+function resolveContext4(options) {
+  return {
+    config: options.config || loadConfig(),
+    transport: options.transport
+  };
+}
+function buildInstruction(method, archivedCount, labeledCount) {
+  const cleanupParts = [];
+  if (labeledCount > 0) {
+    cleanupParts.push(`${labeledCount} emails labeled`);
+  }
+  if (archivedCount > 0) {
+    cleanupParts.push(`${archivedCount} emails archived`);
+  }
+  const cleanup = cleanupParts.length > 0 ? `${cleanupParts.join(" and ")}. ` : "";
+  if (method === "mailto") {
+    return `${cleanup}Open this mailto link in your email client to complete the unsubscribe process. inboxctl cannot auto-submit unsubscribe forms.`;
+  }
+  return `${cleanup}Open this link in your browser to complete the unsubscribe process. inboxctl cannot auto-submit unsubscribe forms.`;
+}
+function getSenderAggregate(sqlite, senderEmail) {
+  const row = sqlite.prepare(
+    `
+      SELECT
+        COUNT(*) AS messageCount,
+        MAX(NULLIF(TRIM(ns.unsubscribe_link), '')) AS newsletterUnsubscribeLink,
+        GROUP_CONCAT(NULLIF(TRIM(e.list_unsubscribe), ''), '
+') AS emailUnsubscribeHeaders
+      FROM emails AS e
+      LEFT JOIN newsletter_senders AS ns
+        ON LOWER(ns.email) = LOWER(e.from_address)
+      WHERE LOWER(e.from_address) = LOWER(?)
+      GROUP BY LOWER(e.from_address)
+      `
+  ).get(senderEmail);
+  return row || null;
+}
+function getSenderEmailIds(sqlite, senderEmail) {
+  const rows = sqlite.prepare(
+    `
+      SELECT id
+      FROM emails
+      WHERE LOWER(from_address) = LOWER(?)
+      ORDER BY COALESCE(date, 0) DESC, id ASC
+      `
+  ).all(senderEmail);
+  return rows.map((row) => row.id);
+}
+async function unsubscribe(options) {
+  const senderEmail = options.senderEmail.trim();
+  if (!senderEmail) {
+    throw new Error("senderEmail is required");
+  }
+  const context = resolveContext4(options);
+  const sqlite = getSqlite(context.config.dbPath);
+  const aggregate = getSenderAggregate(sqlite, senderEmail);
+  if (!aggregate) {
+    throw new Error(`No emails found from ${senderEmail}`);
+  }
+  const unsubscribeTarget = resolveUnsubscribeTarget(
+    aggregate.newsletterUnsubscribeLink,
+    aggregate.emailUnsubscribeHeaders
+  );
+  if (!unsubscribeTarget.unsubscribeLink || !unsubscribeTarget.unsubscribeMethod) {
+    throw new Error(
+      `No unsubscribe link found for ${senderEmail}. This sender does not include List-Unsubscribe headers.`
+    );
+  }
+  const alsoLabel = options.alsoLabel?.trim() || void 0;
+  const actions = [];
+  if (alsoLabel) {
+    actions.push({ type: "label", label: alsoLabel });
+  }
+  if (options.alsoArchive) {
+    actions.push({ type: "archive" });
+  }
+  const emailIds = actions.length > 0 ? getSenderEmailIds(sqlite, senderEmail) : [];
+  const batchResult = actions.length > 0 ? await batchApplyActions({
+    groups: [{ emailIds, actions }],
+    config: context.config,
+    transport: context.transport,
+    sourceType: "unsubscribe",
+    query: senderEmail
+  }) : null;
+  const archivedCount = options.alsoArchive ? aggregate.messageCount : 0;
+  const labeledCount = alsoLabel ? aggregate.messageCount : 0;
+  return {
+    sender: senderEmail,
+    unsubscribeLink: unsubscribeTarget.unsubscribeLink,
+    unsubscribeMethod: unsubscribeTarget.unsubscribeMethod,
+    messageCount: aggregate.messageCount,
+    archivedCount,
+    labeledCount,
+    ...batchResult?.runId ? {
+      runId: batchResult.runId,
+      undoAvailable: batchResult.undoAvailable
+    } : {},
+    instruction: buildInstruction(
+      unsubscribeTarget.unsubscribeMethod,
+      archivedCount,
+      labeledCount
+    )
+  };
+}
+
+// src/core/stats/anomalies.ts
+import { z } from "zod";
+
 // src/core/stats/common.ts
 var DAY_MS = 24 * 60 * 60 * 1e3;
+var SYSTEM_LABEL_IDS = [
+  "INBOX",
+  "UNREAD",
+  "STARRED",
+  "IMPORTANT",
+  "SENT",
+  "DRAFT",
+  "TRASH",
+  "SPAM",
+  "ALL_MAIL",
+  "SNOOZED",
+  "CHAT",
+  "CATEGORY_PERSONAL",
+  "CATEGORY_SOCIAL",
+  "CATEGORY_PROMOTIONS",
+  "CATEGORY_UPDATES",
+  "CATEGORY_FORUMS"
+];
+var CATEGORY_LABEL_PREFIX = "CATEGORY_";
+var SYSTEM_LABEL_ID_SET = new Set(SYSTEM_LABEL_IDS);
+var AUTOMATED_ADDRESS_MARKERS = [
+  "noreply",
+  "no-reply",
+  "no_reply",
+  "newsletter",
+  "notifications",
+  "notification",
+  "mailer",
+  "info@",
+  "hello@",
+  "support@",
+  "marketing",
+  "promo",
+  "updates"
+];
 var SYSTEM_LABEL_NAMES = /* @__PURE__ */ new Map([
   ["INBOX", "Inbox"],
   ["UNREAD", "Unread"],
@@ -2114,6 +2646,14 @@ function getPeriodStart(period = "all", now2 = Date.now()) {
 function resolveLabelName(labelId) {
   return SYSTEM_LABEL_NAMES.get(labelId) || getCachedLabelName(labelId) || labelId;
 }
+function isUserLabel(labelId) {
+  const trimmed = labelId.trim();
+  return trimmed.length > 0 && !SYSTEM_LABEL_ID_SET.has(trimmed) && !trimmed.startsWith(CATEGORY_LABEL_PREFIX);
+}
+function isLikelyAutomatedSenderAddress(sender) {
+  const normalized = sender.trim().toLowerCase();
+  return AUTOMATED_ADDRESS_MARKERS.some((marker) => normalized.includes(marker));
+}
 function startOfLocalDay(now2 = Date.now()) {
   const date = new Date(now2);
   date.setHours(0, 0, 0, 0);
@@ -2133,28 +2673,6 @@ function startOfLocalMonth(now2 = Date.now()) {
   return date.getTime();
 }
 
-// src/core/stats/labels.ts
-async function getLabelDistribution() {
-  const sqlite = getStatsSqlite();
-  const rows = sqlite.prepare(
-    `
-      SELECT
-        label.value AS labelId,
-        COUNT(*) AS totalMessages,
-        SUM(CASE WHEN e.is_read = 0 THEN 1 ELSE 0 END) AS unreadMessages
-      FROM emails AS e, json_each(e.label_ids) AS label
-      GROUP BY label.value
-      ORDER BY totalMessages DESC, unreadMessages DESC, label.value ASC
-      `
-  ).all();
-  return rows.map((row) => ({
-    labelId: row.labelId,
-    labelName: resolveLabelName(row.labelId),
-    totalMessages: row.totalMessages,
-    unreadMessages: row.unreadMessages
-  }));
-}
-
 // src/core/stats/newsletters.ts
 import { randomUUID as randomUUID2 } from "crypto";
 var KNOWN_NEWSLETTER_LOCAL_PART = /^(newsletter|digest|noreply|no-reply|updates|news)([+._-].*)?$/i;
@@ -2318,14 +2836,822 @@ async function getNewsletters(options = {}) {
   return rows.map(mapNewsletterRow);
 }
 
-// src/core/stats/sender.ts
-function buildSenderWhereClause(period) {
-  const whereParts = [
-    "from_address IS NOT NULL",
-    "TRIM(from_address) <> ''"
-  ];
-  const params = [];
-  const periodStart = getPeriodStart(period);
+// src/core/stats/anomalies.ts
+var DAY_MS2 = 24 * 60 * 60 * 1e3;
+var BULK_LABELS = /* @__PURE__ */ new Set([
+  "newsletter",
+  "newsletters",
+  "promotion",
+  "promotions",
+  "social"
+]);
+var reviewCategorizedInputSchema = z.object({
+  since: z.string().min(1).optional(),
+  limit: z.number().int().positive().max(200).optional()
+}).strict();
+function toIsoString(value) {
+  if (!value) {
+    return null;
+  }
+  return new Date(value).toISOString();
+}
+function parseJsonArray3(raw) {
+  if (!raw) {
+    return [];
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    return Array.isArray(parsed) ? parsed.filter((value) => typeof value === "string") : [];
+  } catch {
+    return [];
+  }
+}
+function parseActions(raw) {
+  try {
+    const parsed = JSON.parse(raw);
+    return Array.isArray(parsed) ? parsed : [];
+  } catch {
+    return [];
+  }
+}
+function resolveSinceTimestamp(since) {
+  if (!since) {
+    return Date.now() - 7 * DAY_MS2;
+  }
+  const parsed = Date.parse(since);
+  if (Number.isNaN(parsed)) {
+    throw new Error(`Invalid since value: ${since}`);
+  }
+  return parsed;
+}
+function isArchived(actions, beforeLabelIds, afterLabelIds) {
+  if (actions.some((action) => action.type === "archive")) {
+    return true;
+  }
+  return beforeLabelIds.includes("INBOX") && !afterLabelIds.includes("INBOX");
+}
+function resolveAssignedLabel(actions, beforeLabelIds, afterLabelIds) {
+  const labelAction = actions.find(
+    (action) => action.type === "label" && typeof action.label === "string" && action.label.trim().length > 0
+  );
+  if (labelAction) {
+    return labelAction.label.trim();
+  }
+  const beforeUserLabels = new Set(beforeLabelIds.filter(isUserLabel));
+  const afterUserLabels = afterLabelIds.filter(isUserLabel);
+  const addedLabel = afterUserLabels.find((label) => !beforeUserLabels.has(label));
+  return addedLabel || afterUserLabels[0] || null;
+}
+function resolvePrimaryAction(actions) {
+  if (actions.some((action) => action.type === "archive")) {
+    return "archive";
+  }
+  if (actions.some((action) => action.type === "label")) {
+    return "label";
+  }
+  return actions[0]?.type || "unknown";
+}
+function summarizeReview(totalReviewed, anomalyCount, highCount, mediumCount) {
+  if (anomalyCount === 0) {
+    return `Reviewed ${totalReviewed} recently categorised emails. Found no potential misclassifications.`;
+  }
+  const severityParts = [];
+  if (highCount > 0) {
+    severityParts.push(`${highCount} high severity`);
+  }
+  if (mediumCount > 0) {
+    severityParts.push(`${mediumCount} medium`);
+  }
+  return `Reviewed ${totalReviewed} recently categorised emails. Found ${anomalyCount} potential misclassifications (${severityParts.join(", ")}).`;
+}
+function detectAnomaly(row) {
+  const actions = parseActions(row.appliedActions);
+  const beforeLabelIds = parseJsonArray3(row.beforeLabelIds);
+  const afterLabelIds = parseJsonArray3(row.afterLabelIds);
+  const archived = isArchived(actions, beforeLabelIds, afterLabelIds);
+  const assignedLabel = resolveAssignedLabel(actions, beforeLabelIds, afterLabelIds);
+  const action = resolvePrimaryAction(actions);
+  const totalFromSender = row.totalFromSender ?? 0;
+  const hasNewsletterSignals = Boolean(row.detectionReason) || Boolean(row.listUnsubscribe?.trim());
+  const isBulkLabel = assignedLabel ? BULK_LABELS.has(assignedLabel.toLowerCase()) : false;
+  const automatedSender = isLikelyAutomatedSenderAddress(row.sender || "");
+  const undoAvailable = row.runDryRun !== 1 && row.runStatus !== "undone" && row.runUndoneAt === null && row.itemUndoneAt === null;
+  if (archived && totalFromSender <= 3) {
+    return {
+      emailId: row.emailId,
+      from: row.sender || "",
+      subject: row.subject || "",
+      date: toIsoString(row.date),
+      assignedLabel: assignedLabel || "Unlabeled",
+      action,
+      runId: row.runId,
+      severity: "high",
+      rule: "rare_sender_archived",
+      reason: `Archived email from a rare sender with only ${totalFromSender} total email${totalFromSender === 1 ? "" : "s"}. Rare senders should be reviewed before archiving.`,
+      undoAvailable
+    };
+  }
+  if (isBulkLabel && !hasNewsletterSignals) {
+    return {
+      emailId: row.emailId,
+      from: row.sender || "",
+      subject: row.subject || "",
+      date: toIsoString(row.date),
+      assignedLabel: assignedLabel || "Unlabeled",
+      action,
+      runId: row.runId,
+      severity: "high",
+      rule: "no_newsletter_signals_as_newsletter",
+      reason: `Labeled as ${assignedLabel} but sender has no List-Unsubscribe header and no newsletter detection signals. Sender has only sent ${totalFromSender} total email${totalFromSender === 1 ? "" : "s"}.`,
+      undoAvailable
+    };
+  }
+  if (archived && !automatedSender && totalFromSender < 5) {
+    return {
+      emailId: row.emailId,
+      from: row.sender || "",
+      subject: row.subject || "",
+      date: toIsoString(row.date),
+      assignedLabel: assignedLabel || "Unlabeled",
+      action,
+      runId: row.runId,
+      severity: "high",
+      rule: "personal_address_archived",
+      reason: `Archived email from a likely personal sender address with fewer than 5 total emails. This address does not look automated and should stay visible.`,
+      undoAvailable
+    };
+  }
+  if (isBulkLabel && totalFromSender < 5) {
+    return {
+      emailId: row.emailId,
+      from: row.sender || "",
+      subject: row.subject || "",
+      date: toIsoString(row.date),
+      assignedLabel: assignedLabel || "Unlabeled",
+      action,
+      runId: row.runId,
+      severity: "medium",
+      rule: "low_volume_bulk_label",
+      reason: `Labeled as ${assignedLabel} even though the sender has only ${totalFromSender} total email${totalFromSender === 1 ? "" : "s"}. Bulk labels are safer for higher-volume senders.`,
+      undoAvailable
+    };
+  }
+  if (archived && totalFromSender === 1) {
+    return {
+      emailId: row.emailId,
+      from: row.sender || "",
+      subject: row.subject || "",
+      date: toIsoString(row.date),
+      assignedLabel: assignedLabel || "Unlabeled",
+      action,
+      runId: row.runId,
+      severity: "medium",
+      rule: "first_time_sender_archived",
+      reason: "Archived an email from a first-time sender. First-time senders are better surfaced for review before cleanup.",
+      undoAvailable
+    };
+  }
+  return null;
+}
+async function reviewCategorized(options = {}) {
+  const parsed = reviewCategorizedInputSchema.parse(options);
+  await detectNewsletters();
+  const sqlite = getStatsSqlite();
+  const sinceTimestamp = resolveSinceTimestamp(parsed.since);
+  const limit = Math.min(200, normalizeLimit(parsed.limit, 50));
+  const rows = sqlite.prepare(
+    `
+      SELECT
+        ei.email_id AS emailId,
+        e.from_address AS sender,
+        e.subject AS subject,
+        e.date AS date,
+        e.list_unsubscribe AS listUnsubscribe,
+        ei.before_label_ids AS beforeLabelIds,
+        ei.after_label_ids AS afterLabelIds,
+        ei.applied_actions AS appliedActions,
+        ei.executed_at AS executedAt,
+        ei.undone_at AS itemUndoneAt,
+        ei.run_id AS runId,
+        er.status AS runStatus,
+        er.dry_run AS runDryRun,
+        er.undone_at AS runUndoneAt,
+        ns.detection_reason AS detectionReason,
+        sender_stats.totalFromSender AS totalFromSender
+      FROM execution_items AS ei
+      INNER JOIN emails AS e
+        ON e.id = ei.email_id
+      INNER JOIN execution_runs AS er
+        ON er.id = ei.run_id
+      LEFT JOIN newsletter_senders AS ns
+        ON LOWER(ns.email) = LOWER(e.from_address)
+      LEFT JOIN (
+        SELECT
+          LOWER(from_address) AS senderKey,
+          COUNT(*) AS totalFromSender
+        FROM emails
+        WHERE from_address IS NOT NULL
+          AND TRIM(from_address) <> ''
+        GROUP BY LOWER(from_address)
+      ) AS sender_stats
+        ON sender_stats.senderKey = LOWER(e.from_address)
+      WHERE ei.status = 'applied'
+        AND er.status IN ('applied', 'partial')
+        AND COALESCE(er.dry_run, 0) = 0
+        AND er.undone_at IS NULL
+        AND ei.undone_at IS NULL
+        AND COALESCE(ei.executed_at, 0) >= ?
+      ORDER BY COALESCE(ei.executed_at, 0) DESC, ei.email_id ASC
+      `
+  ).all(sinceTimestamp);
+  const reviewedRows = rows.filter((row) => {
+    const actions = parseActions(row.appliedActions);
+    const beforeLabelIds = parseJsonArray3(row.beforeLabelIds);
+    const afterLabelIds = parseJsonArray3(row.afterLabelIds);
+    return actions.length > 0 && (resolveAssignedLabel(actions, beforeLabelIds, afterLabelIds) !== null || isArchived(actions, beforeLabelIds, afterLabelIds));
+  });
+  const anomalies = reviewedRows.map((row) => detectAnomaly(row)).filter((anomaly) => anomaly !== null).sort(
+    (left, right) => (left.severity === "high" ? 1 : 0) === (right.severity === "high" ? 1 : 0) ? (right.date || "").localeCompare(left.date || "") || left.emailId.localeCompare(right.emailId) : left.severity === "high" ? -1 : 1
+  );
+  const highCount = anomalies.filter((anomaly) => anomaly.severity === "high").length;
+  const mediumCount = anomalies.filter((anomaly) => anomaly.severity === "medium").length;
+  return {
+    anomalies: anomalies.slice(0, limit),
+    totalReviewed: reviewedRows.length,
+    anomalyCount: anomalies.length,
+    summary: summarizeReview(reviewedRows.length, anomalies.length, highCount, mediumCount)
+  };
+}
+
+// src/core/stats/labels.ts
+async function getLabelDistribution() {
+  const sqlite = getStatsSqlite();
+  const rows = sqlite.prepare(
+    `
+      SELECT
+        label.value AS labelId,
+        COUNT(*) AS totalMessages,
+        SUM(CASE WHEN e.is_read = 0 THEN 1 ELSE 0 END) AS unreadMessages
+      FROM emails AS e, json_each(e.label_ids) AS label
+      GROUP BY label.value
+      ORDER BY totalMessages DESC, unreadMessages DESC, label.value ASC
+      `
+  ).all();
+  return rows.map((row) => ({
+    labelId: row.labelId,
+    labelName: resolveLabelName(row.labelId),
+    totalMessages: row.totalMessages,
+    unreadMessages: row.unreadMessages
+  }));
+}
+
+// src/core/stats/noise.ts
+var DAY_MS3 = 24 * 60 * 60 * 1e3;
+var SUGGESTED_CATEGORY_RULES = [
+  { category: "Receipts", keywords: ["receipt", "invoice", "payment", "order"] },
+  { category: "Shipping", keywords: ["shipping", "tracking", "delivery", "dispatch"] },
+  { category: "Newsletters", keywords: ["newsletter", "digest", "weekly", "update"] },
+  { category: "Notifications", keywords: ["noreply", "notification", "alert"] },
+  { category: "Promotions", keywords: ["promo", "offer", "deal", "sale", "marketing"] },
+  { category: "Social", keywords: ["linkedin", "facebook", "twitter", "social"] }
+];
+function toIsoString2(value) {
+  if (!value) {
+    return null;
+  }
+  return new Date(value).toISOString();
+}
+function roundNoiseScore(messageCount, unreadRate) {
+  return Math.round(messageCount * unreadRate * 10 / 100) / 10;
+}
+function getSuggestedCategory(email, name) {
+  const haystack = `${email} ${name}`.toLowerCase();
+  for (const rule of SUGGESTED_CATEGORY_RULES) {
+    if (rule.keywords.some((keyword) => haystack.includes(keyword))) {
+      return rule.category;
+    }
+  }
+  return "Other";
+}
+function compareNoiseSenders(sortBy) {
+  return (left, right) => {
+    switch (sortBy) {
+      case "all_time_noise_score":
+        return right.allTimeNoiseScore - left.allTimeNoiseScore || right.noiseScore - left.noiseScore || right.allTimeMessageCount - left.allTimeMessageCount || (right.lastSeen || "").localeCompare(left.lastSeen || "") || left.email.localeCompare(right.email);
+      case "message_count":
+        return right.messageCount - left.messageCount || right.noiseScore - left.noiseScore || right.allTimeMessageCount - left.allTimeMessageCount || (right.lastSeen || "").localeCompare(left.lastSeen || "") || left.email.localeCompare(right.email);
+      case "unread_rate":
+        return right.unreadRate - left.unreadRate || right.noiseScore - left.noiseScore || right.messageCount - left.messageCount || (right.lastSeen || "").localeCompare(left.lastSeen || "") || left.email.localeCompare(right.email);
+      case "noise_score":
+      default:
+        return right.noiseScore - left.noiseScore || right.allTimeNoiseScore - left.allTimeNoiseScore || right.messageCount - left.messageCount || (right.lastSeen || "").localeCompare(left.lastSeen || "") || left.email.localeCompare(right.email);
+    }
+  };
+}
+async function getNoiseSenders(options = {}) {
+  await detectNewsletters();
+  const sqlite = getStatsSqlite();
+  const limit = Math.min(50, normalizeLimit(options.limit, 20));
+  const minNoiseScore = options.minNoiseScore ?? 5;
+  const activeDays = Math.max(1, Math.floor(options.activeDays ?? 90));
+  const activeSince = Date.now() - activeDays * DAY_MS3;
+  const sortBy = options.sortBy ?? "noise_score";
+  const rows = sqlite.prepare(
+    `
+      SELECT
+        e.from_address AS email,
+        COALESCE(MAX(NULLIF(TRIM(e.from_name), '')), e.from_address) AS name,
+        COUNT(*) AS messageCount,
+        SUM(CASE WHEN e.is_read = 0 THEN 1 ELSE 0 END) AS unreadCount,
+        MAX(e.date) AS lastSeen,
+        MAX(NULLIF(TRIM(ns.unsubscribe_link), '')) AS newsletterUnsubscribeLink,
+        GROUP_CONCAT(NULLIF(TRIM(e.list_unsubscribe), ''), '
+') AS emailUnsubscribeHeaders,
+        MAX(CASE WHEN ns.email IS NOT NULL THEN 1 ELSE 0 END) AS isNewsletter,
+        COALESCE(MAX(all_time.allTimeCount), COUNT(*)) AS allTimeMessageCount,
+        COALESCE(
+          MAX(all_time.allTimeUnreadCount),
+          SUM(CASE WHEN e.is_read = 0 THEN 1 ELSE 0 END)
+        ) AS allTimeUnreadCount
+      FROM emails AS e
+      LEFT JOIN newsletter_senders AS ns
+        ON LOWER(ns.email) = LOWER(e.from_address)
+      LEFT JOIN (
+        SELECT
+          LOWER(from_address) AS senderKey,
+          COUNT(*) AS allTimeCount,
+          SUM(CASE WHEN is_read = 0 THEN 1 ELSE 0 END) AS allTimeUnreadCount
+        FROM emails
+        WHERE from_address IS NOT NULL
+          AND TRIM(from_address) <> ''
+        GROUP BY LOWER(from_address)
+      ) AS all_time
+        ON all_time.senderKey = LOWER(e.from_address)
+      WHERE e.from_address IS NOT NULL
+        AND TRIM(e.from_address) <> ''
+        AND COALESCE(e.date, 0) >= ?
+      GROUP BY LOWER(e.from_address)
+      `
+  ).all(activeSince);
+  const senders = rows.map((row) => {
+    const unreadRate = roundPercent(row.unreadCount, row.messageCount);
+    const allTimeMessageCount = row.allTimeMessageCount ?? row.messageCount;
+    const allTimeUnreadCount = row.allTimeUnreadCount ?? row.unreadCount;
+    const allTimeUnreadRate = roundPercent(allTimeUnreadCount, allTimeMessageCount);
+    const noiseScore = roundNoiseScore(row.messageCount, unreadRate);
+    const allTimeNoiseScore = roundNoiseScore(allTimeMessageCount, allTimeUnreadRate);
+    const unsubscribe2 = resolveUnsubscribeTarget(
+      row.newsletterUnsubscribeLink,
+      row.emailUnsubscribeHeaders
+    );
+    return {
+      email: row.email,
+      name: row.name?.trim() || row.email,
+      messageCount: row.messageCount,
+      allTimeMessageCount,
+      unreadCount: row.unreadCount,
+      unreadRate,
+      noiseScore,
+      allTimeNoiseScore,
+      lastSeen: toIsoString2(row.lastSeen),
+      isNewsletter: row.isNewsletter === 1,
+      hasUnsubscribeLink: Boolean(unsubscribe2.unsubscribeLink),
+      unsubscribeLink: unsubscribe2.unsubscribeLink,
+      suggestedCategory: getSuggestedCategory(row.email, row.name?.trim() || row.email)
+    };
+  }).filter((sender) => sender.noiseScore >= minNoiseScore).sort(compareNoiseSenders(sortBy)).slice(0, limit);
+  return { senders };
+}
+
+// src/core/stats/query.ts
+import { z as z2 } from "zod";
+var QUERY_EMAIL_GROUP_BY_VALUES = [
+  "sender",
+  "domain",
+  "label",
+  "year_month",
+  "year_week",
+  "day_of_week",
+  "is_read",
+  "is_newsletter"
+];
+var QUERY_EMAIL_AGGREGATE_VALUES = [
+  "count",
+  "unread_count",
+  "read_count",
+  "unread_rate",
+  "oldest",
+  "newest",
+  "sender_count"
+];
+var QUERY_EMAIL_HAVING_FIELDS = [
+  "count",
+  "unread_count",
+  "unread_rate",
+  "sender_count"
+];
+var CATEGORY_LABEL_LIKE_PATTERN = `${CATEGORY_LABEL_PREFIX.replace(/_/g, "\\_")}%`;
+var SYSTEM_LABEL_SQL = SYSTEM_LABEL_IDS.map((label) => `'${label}'`).join(", ");
+var DOMAIN_SQL = `
+  LOWER(
+    CASE
+      WHEN INSTR(COALESCE(e.from_address, ''), '@') > 0
+        THEN SUBSTR(e.from_address, INSTR(e.from_address, '@') + 1)
+      ELSE ''
+    END
+  )
+`;
+var queryEmailsFiltersSchema = z2.object({
+  from: z2.string().optional(),
+  from_contains: z2.string().optional(),
+  domain: z2.string().optional(),
+  domain_contains: z2.string().optional(),
+  subject_contains: z2.string().optional(),
+  date_after: z2.string().optional(),
+  date_before: z2.string().optional(),
+  is_read: z2.boolean().optional(),
+  is_newsletter: z2.boolean().optional(),
+  has_label: z2.boolean().optional(),
+  label: z2.string().optional(),
+  has_unsubscribe: z2.boolean().optional(),
+  min_sender_messages: z2.number().int().positive().optional()
+}).strict();
+var havingConditionSchema = z2.object({
+  gte: z2.number().optional(),
+  lte: z2.number().optional()
+}).strict().refine(
+  (value) => value.gte !== void 0 || value.lte !== void 0,
+  { message: "Provide at least one of gte or lte." }
+);
+var queryEmailsHavingSchema = z2.object({
+  count: havingConditionSchema.optional(),
+  unread_count: havingConditionSchema.optional(),
+  unread_rate: havingConditionSchema.optional(),
+  sender_count: havingConditionSchema.optional()
+}).strict();
+var queryEmailsInputSchema = z2.object({
+  filters: queryEmailsFiltersSchema.optional(),
+  group_by: z2.enum(QUERY_EMAIL_GROUP_BY_VALUES).optional(),
+  aggregates: z2.array(z2.enum(QUERY_EMAIL_AGGREGATE_VALUES)).min(1).optional(),
+  having: queryEmailsHavingSchema.optional(),
+  order_by: z2.string().optional(),
+  limit: z2.number().int().positive().max(500).optional()
+}).strict();
+var QUERY_EMAILS_FIELD_SCHEMA = {
+  description: "Available fields for the query_emails tool.",
+  filters: {
+    from: { type: "string", description: "Exact sender email (case-insensitive)" },
+    from_contains: { type: "string", description: "Partial match on sender email" },
+    domain: { type: "string", description: "Exact sender domain" },
+    domain_contains: { type: "string", description: "Partial match on sender domain" },
+    subject_contains: { type: "string", description: "Partial match on subject line" },
+    date_after: { type: "string", description: "ISO date \u2014 emails after this date" },
+    date_before: { type: "string", description: "ISO date \u2014 emails before this date" },
+    is_read: { type: "boolean", description: "Filter by read/unread state" },
+    is_newsletter: { type: "boolean", description: "Sender detected as newsletter" },
+    has_label: { type: "boolean", description: "Has any user-applied label" },
+    label: { type: "string", description: "Has this specific label" },
+    has_unsubscribe: { type: "boolean", description: "Has List-Unsubscribe header" },
+    min_sender_messages: { type: "integer", description: "Sender has at least this many total emails" }
+  },
+  group_by: [
+    { value: "sender", description: "Group by sender email address" },
+    { value: "domain", description: "Group by sender domain" },
+    { value: "label", description: "Group by applied label (expands multi-label emails)" },
+    { value: "year_month", description: "Group by month (YYYY-MM)" },
+    { value: "year_week", description: "Group by week (YYYY-WNN)" },
+    { value: "day_of_week", description: "Group by day of week (0=Sunday)" },
+    { value: "is_read", description: "Group by read/unread state" },
+    { value: "is_newsletter", description: "Group by newsletter detection" }
+  ],
+  aggregates: [
+    { value: "count", description: "Number of emails" },
+    { value: "unread_count", description: "Number of unread emails" },
+    { value: "read_count", description: "Number of read emails" },
+    { value: "unread_rate", description: "Percentage of emails that are unread" },
+    { value: "oldest", description: "Earliest email date (ISO string)" },
+    { value: "newest", description: "Latest email date (ISO string)" },
+    { value: "sender_count", description: "Count of distinct senders" }
+  ],
+  having_fields: [...QUERY_EMAIL_HAVING_FIELDS],
+  example_queries: [
+    {
+      description: "Monthly volume trend for Amazon",
+      query: {
+        filters: { domain_contains: "amazon" },
+        group_by: "year_month",
+        aggregates: ["count", "unread_rate"],
+        order_by: "year_month asc"
+      }
+    },
+    {
+      description: "Domains with 95%+ unread rate and 50+ emails",
+      query: {
+        group_by: "domain",
+        aggregates: ["count", "unread_rate"],
+        having: { count: { gte: 50 }, unread_rate: { gte: 95 } }
+      }
+    },
+    {
+      description: "What day of the week gets the most email?",
+      query: {
+        group_by: "day_of_week",
+        aggregates: ["count", "sender_count"]
+      }
+    }
+  ]
+};
+var GROUP_BY_SQL_MAP = {
+  sender: "LOWER(COALESCE(e.from_address, ''))",
+  domain: DOMAIN_SQL,
+  label: "CAST(grouped_label.value AS TEXT)",
+  year_month: "STRFTIME('%Y-%m', e.date / 1000, 'unixepoch')",
+  year_week: "STRFTIME('%Y-W%W', e.date / 1000, 'unixepoch')",
+  day_of_week: "CAST(STRFTIME('%w', e.date / 1000, 'unixepoch') AS INTEGER)",
+  is_read: "COALESCE(e.is_read, 0)",
+  is_newsletter: "CASE WHEN ns.email IS NOT NULL THEN 1 ELSE 0 END"
+};
+var AGGREGATE_SQL_MAP = {
+  count: "COUNT(*)",
+  unread_count: "SUM(CASE WHEN COALESCE(e.is_read, 0) = 0 THEN 1 ELSE 0 END)",
+  read_count: "SUM(CASE WHEN COALESCE(e.is_read, 0) = 1 THEN 1 ELSE 0 END)",
+  unread_rate: `
+    ROUND(
+      CASE
+        WHEN COUNT(*) = 0 THEN 0
+        ELSE 100.0 * SUM(CASE WHEN COALESCE(e.is_read, 0) = 0 THEN 1 ELSE 0 END) / COUNT(*)
+      END,
+      1
+    )
+  `,
+  oldest: "MIN(e.date)",
+  newest: "MAX(e.date)",
+  sender_count: `
+    COUNT(
+      DISTINCT CASE
+        WHEN e.from_address IS NOT NULL AND TRIM(e.from_address) <> ''
+          THEN LOWER(e.from_address)
+        ELSE NULL
+      END
+    )
+  `
+};
+function userLabelPredicate(column) {
+  return `
+    ${column} IS NOT NULL
+    AND TRIM(CAST(${column} AS TEXT)) <> ''
+    AND CAST(${column} AS TEXT) NOT IN (${SYSTEM_LABEL_SQL})
+    AND CAST(${column} AS TEXT) NOT LIKE '${CATEGORY_LABEL_LIKE_PATTERN}' ESCAPE '\\'
+  `;
+}
+function toIsoString3(value) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
+    return null;
+  }
+  return new Date(value).toISOString();
+}
+function normalizeGroupValue(groupBy, value) {
+  switch (groupBy) {
+    case "is_read":
+    case "is_newsletter":
+      return Number(value ?? 0) === 1;
+    case "day_of_week":
+      return Number(value ?? 0);
+    case "sender":
+    case "domain":
+    case "label":
+    case "year_month":
+    case "year_week":
+      return typeof value === "string" ? value : value == null ? null : String(value);
+  }
+}
+function normalizeAggregateValue(aggregate, value) {
+  switch (aggregate) {
+    case "oldest":
+    case "newest":
+      return toIsoString3(value);
+    case "count":
+    case "unread_count":
+    case "read_count":
+    case "sender_count":
+      return Number(value ?? 0);
+    case "unread_rate":
+      return Number(value ?? 0);
+  }
+}
+function parseDateFilter(field, value) {
+  const timestamp = Date.parse(value);
+  if (Number.isNaN(timestamp)) {
+    throw new Error(`Invalid ${field} value: ${value}`);
+  }
+  return timestamp;
+}
+function resolveAggregates(aggregates) {
+  return Array.from(new Set(aggregates && aggregates.length > 0 ? aggregates : ["count"]));
+}
+function resolveOrderBy(orderBy, groupBy, aggregates) {
+  const defaultField = aggregates.includes("count") ? "count" : aggregates[0];
+  const rawValue = (orderBy || `${defaultField} desc`).trim();
+  const match = rawValue.match(/^([a-z_]+)\s+(asc|desc)$/i);
+  if (!match) {
+    throw new Error(`Invalid order_by value: ${rawValue}`);
+  }
+  const [, field, direction] = match;
+  const allowedFields = new Set(aggregates);
+  if (groupBy) {
+    allowedFields.add(groupBy);
+  }
+  if (!allowedFields.has(field)) {
+    throw new Error(`Invalid order_by field: ${field}`);
+  }
+  return `${field} ${direction.toLowerCase()}`;
+}
+function buildWhereClauses(filters, groupBy) {
+  const whereParts = [];
+  const params = [];
+  if (filters.from !== void 0) {
+    whereParts.push("LOWER(COALESCE(e.from_address, '')) = LOWER(?)");
+    params.push(filters.from);
+  }
+  if (filters.from_contains !== void 0) {
+    whereParts.push("LOWER(COALESCE(e.from_address, '')) LIKE '%' || LOWER(?) || '%'");
+    params.push(filters.from_contains);
+  }
+  if (filters.domain !== void 0) {
+    whereParts.push(`${DOMAIN_SQL} = LOWER(?)`);
+    params.push(filters.domain);
+  }
+  if (filters.domain_contains !== void 0) {
+    whereParts.push(`${DOMAIN_SQL} LIKE '%' || LOWER(?) || '%'`);
+    params.push(filters.domain_contains);
+  }
+  if (filters.subject_contains !== void 0) {
+    whereParts.push("LOWER(COALESCE(e.subject, '')) LIKE '%' || LOWER(?) || '%'");
+    params.push(filters.subject_contains);
+  }
+  if (filters.date_after !== void 0) {
+    whereParts.push("COALESCE(e.date, 0) >= ?");
+    params.push(parseDateFilter("date_after", filters.date_after));
+  }
+  if (filters.date_before !== void 0) {
+    whereParts.push("COALESCE(e.date, 0) <= ?");
+    params.push(parseDateFilter("date_before", filters.date_before));
+  }
+  if (filters.is_read !== void 0) {
+    whereParts.push("COALESCE(e.is_read, 0) = ?");
+    params.push(filters.is_read ? 1 : 0);
+  }
+  if (filters.is_newsletter !== void 0) {
+    whereParts.push(filters.is_newsletter ? "ns.email IS NOT NULL" : "ns.email IS NULL");
+  }
+  if (filters.has_label !== void 0) {
+    whereParts.push(
+      filters.has_label ? `EXISTS (
+            SELECT 1
+            FROM json_each(COALESCE(e.label_ids, '[]')) AS label_filter
+            WHERE ${userLabelPredicate("label_filter.value")}
+          )` : `NOT EXISTS (
+            SELECT 1
+            FROM json_each(COALESCE(e.label_ids, '[]')) AS label_filter
+            WHERE ${userLabelPredicate("label_filter.value")}
+          )`
+    );
+  }
+  if (filters.label !== void 0) {
+    whereParts.push(`
+      EXISTS (
+        SELECT 1
+        FROM json_each(COALESCE(e.label_ids, '[]')) AS label_filter
+        WHERE LOWER(CAST(label_filter.value AS TEXT)) = LOWER(?)
+      )
+    `);
+    params.push(filters.label);
+  }
+  if (filters.has_unsubscribe !== void 0) {
+    whereParts.push(
+      filters.has_unsubscribe ? "NULLIF(TRIM(e.list_unsubscribe), '') IS NOT NULL" : "(e.list_unsubscribe IS NULL OR TRIM(e.list_unsubscribe) = '')"
+    );
+  }
+  if (filters.min_sender_messages !== void 0) {
+    whereParts.push("COALESCE(sender_stats.totalFromSender, 0) >= ?");
+    params.push(filters.min_sender_messages);
+  }
+  if (groupBy === "label") {
+    whereParts.push(userLabelPredicate("grouped_label.value"));
+  }
+  return {
+    sql: whereParts.length > 0 ? `WHERE ${whereParts.join("\n  AND ")}` : "",
+    params
+  };
+}
+function buildHavingClause(having) {
+  const parts = [];
+  for (const field of QUERY_EMAIL_HAVING_FIELDS) {
+    const condition = having[field];
+    if (!condition) {
+      continue;
+    }
+    const expression = AGGREGATE_SQL_MAP[field];
+    if (condition.gte !== void 0) {
+      parts.push(`${expression} >= ${condition.gte}`);
+    }
+    if (condition.lte !== void 0) {
+      parts.push(`${expression} <= ${condition.lte}`);
+    }
+  }
+  return parts.length > 0 ? `HAVING ${parts.join("\n  AND ")}` : "";
+}
+function normalizeRow(row, groupBy, aggregates) {
+  const normalized = {};
+  if (groupBy) {
+    normalized[groupBy] = normalizeGroupValue(groupBy, row[groupBy]);
+  }
+  for (const aggregate of aggregates) {
+    normalized[aggregate] = normalizeAggregateValue(aggregate, row[aggregate]);
+  }
+  return normalized;
+}
+async function queryEmails(options = {}) {
+  const parsed = queryEmailsInputSchema.parse(options);
+  await detectNewsletters();
+  const sqlite = getStatsSqlite();
+  const filters = parsed.filters ?? {};
+  const groupBy = parsed.group_by;
+  const aggregates = resolveAggregates(parsed.aggregates);
+  const having = parsed.having ?? {};
+  const orderBy = resolveOrderBy(parsed.order_by, groupBy, aggregates);
+  const limit = Math.min(500, normalizeLimit(parsed.limit, 50));
+  const { sql: whereSql, params } = buildWhereClauses(filters, groupBy);
+  const havingSql = buildHavingClause(having);
+  const fromSql = [
+    "FROM emails AS e",
+    "LEFT JOIN newsletter_senders AS ns ON LOWER(ns.email) = LOWER(e.from_address)",
+    `LEFT JOIN (
+      SELECT
+        LOWER(from_address) AS senderKey,
+        COUNT(*) AS totalFromSender
+      FROM emails
+      WHERE from_address IS NOT NULL
+        AND TRIM(from_address) <> ''
+      GROUP BY LOWER(from_address)
+    ) AS sender_stats ON sender_stats.senderKey = LOWER(e.from_address)`,
+    groupBy === "label" ? "JOIN json_each(COALESCE(e.label_ids, '[]')) AS grouped_label" : ""
+  ].filter(Boolean).join("\n");
+  const selectParts = [];
+  if (groupBy) {
+    selectParts.push(`${GROUP_BY_SQL_MAP[groupBy]} AS ${groupBy}`);
+  }
+  for (const aggregate of aggregates) {
+    selectParts.push(`${AGGREGATE_SQL_MAP[aggregate]} AS ${aggregate}`);
+  }
+  const groupBySql = groupBy ? `GROUP BY ${GROUP_BY_SQL_MAP[groupBy]}` : "";
+  const orderBySql = `ORDER BY ${orderBy.split(" ")[0]} ${orderBy.split(" ")[1].toUpperCase()}`;
+  const totalRow = groupBy ? sqlite.prepare(
+    `
+        SELECT COUNT(*) AS totalRows
+        FROM (
+          SELECT 1
+          ${fromSql}
+          ${whereSql}
+          ${groupBySql}
+          ${havingSql}
+        ) AS grouped_rows
+        `
+  ).get(...params) : void 0;
+  const rows = sqlite.prepare(
+    `
+      SELECT
+        ${selectParts.join(",\n        ")}
+      ${fromSql}
+      ${whereSql}
+      ${groupBySql}
+      ${havingSql}
+      ${orderBySql}
+      LIMIT ?
+      `
+  ).all(...params, limit);
+  return {
+    rows: rows.map((row) => normalizeRow(row, groupBy, aggregates)),
+    totalRows: groupBy ? totalRow?.totalRows ?? 0 : rows.length,
+    query: {
+      filters,
+      group_by: groupBy ?? null,
+      aggregates,
+      having,
+      order_by: orderBy,
+      limit
+    }
+  };
+}
+
+// src/core/stats/sender.ts
+function buildSenderWhereClause(period) {
+  const whereParts = [
+    "from_address IS NOT NULL",
+    "TRIM(from_address) <> ''"
+  ];
+  const params = [];
+  const periodStart = getPeriodStart(period);
   if (periodStart !== null) {
     whereParts.push("date >= ?");
     params.push(periodStart);
@@ -2476,6 +3802,270 @@ async function getSenderStats(emailOrDomain) {
   };
 }
 
+// src/core/stats/uncategorized.ts
+var SYSTEM_LABEL_IDS2 = [
+  "INBOX",
+  "UNREAD",
+  "IMPORTANT",
+  "SENT",
+  "DRAFT",
+  "SPAM",
+  "TRASH",
+  "STARRED"
+];
+var CATEGORY_LABEL_PATTERN = "CATEGORY\\_%";
+function toIsoString4(value) {
+  if (!value) {
+    return null;
+  }
+  return new Date(value).toISOString();
+}
+function parseJsonArray4(raw) {
+  if (!raw) {
+    return [];
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    return Array.isArray(parsed) ? parsed.filter((value) => typeof value === "string") : [];
+  } catch {
+    return [];
+  }
+}
+function resolveSinceTimestamp2(since) {
+  if (!since) {
+    return null;
+  }
+  const parsed = Date.parse(since);
+  if (Number.isNaN(parsed)) {
+    throw new Error(`Invalid since value: ${since}`);
+  }
+  return parsed;
+}
+function computeConfidence(row) {
+  const signals = [];
+  let score = 0;
+  const hasDefinitiveNewsletterSignal = Boolean(row.listUnsubscribe && row.listUnsubscribe.trim()) || Boolean(row.detectionReason?.includes("list_unsubscribe"));
+  if (row.listUnsubscribe && row.listUnsubscribe.trim()) {
+    signals.push("list_unsubscribe_header");
+    score += 3;
+  }
+  if (row.detectionReason?.includes("list_unsubscribe")) {
+    signals.push("newsletter_list_header");
+    score += 2;
+  }
+  if ((row.totalFromSender ?? 0) >= 20) {
+    signals.push("high_volume_sender");
+    score += 2;
+  } else if ((row.totalFromSender ?? 0) >= 5) {
+    signals.push("moderate_volume_sender");
+    score += 1;
+  }
+  if (row.detectionReason?.includes("known_sender_pattern")) {
+    signals.push("automated_sender_pattern");
+    score += 1;
+  }
+  if (row.detectionReason?.includes("bulk_sender_pattern")) {
+    signals.push("bulk_sender_pattern");
+    score += 1;
+  }
+  if ((row.totalFromSender ?? 0) <= 2 && !hasDefinitiveNewsletterSignal) {
+    signals.push("rare_sender");
+    score -= 3;
+  }
+  if (!row.detectionReason) {
+    signals.push("no_newsletter_signals");
+    score -= 2;
+  }
+  if (!row.detectionReason && !isLikelyAutomatedSenderAddress(row.sender || "")) {
+    signals.push("personal_sender_address");
+    score -= 2;
+  }
+  return {
+    confidence: score >= 3 ? "high" : score >= 0 ? "medium" : "low",
+    signals
+  };
+}
+function buildWhereClause(options) {
+  const whereParts = [
+    `
+    NOT EXISTS (
+      SELECT 1
+      FROM json_each(COALESCE(e.label_ids, '[]')) AS label
+      WHERE label.value IS NOT NULL
+        AND TRIM(CAST(label.value AS TEXT)) <> ''
+        AND label.value NOT IN (${SYSTEM_LABEL_IDS2.map(() => "?").join(", ")})
+        AND label.value NOT LIKE ? ESCAPE '\\'
+    )
+    `
+  ];
+  const params = [...SYSTEM_LABEL_IDS2, CATEGORY_LABEL_PATTERN];
+  if (options.unreadOnly) {
+    whereParts.push("COALESCE(e.is_read, 0) = 0");
+  }
+  if (options.sinceTimestamp !== null) {
+    whereParts.push("COALESCE(e.date, 0) >= ?");
+    params.push(options.sinceTimestamp);
+  }
+  return {
+    clause: whereParts.join(" AND "),
+    params
+  };
+}
+async function getUncategorizedEmails(options = {}) {
+  await detectNewsletters();
+  const sqlite = getStatsSqlite();
+  const limit = Math.min(1e3, normalizeLimit(options.limit, 50));
+  const offset = Math.max(0, Math.floor(options.offset ?? 0));
+  const sinceTimestamp = resolveSinceTimestamp2(options.since);
+  const { clause, params } = buildWhereClause({
+    sinceTimestamp,
+    unreadOnly: options.unreadOnly ?? false
+  });
+  const totalRow = sqlite.prepare(
+    `
+      SELECT COUNT(*) AS total
+      FROM emails AS e
+      WHERE ${clause}
+      `
+  ).get(...params);
+  const rows = sqlite.prepare(
+    `
+      SELECT
+        e.id AS id,
+        e.thread_id AS threadId,
+        e.from_address AS sender,
+        e.subject AS subject,
+        e.date AS date,
+        e.snippet AS snippet,
+        e.label_ids AS labelIds,
+        e.is_read AS isRead,
+        sender_stats.totalFromSender AS totalFromSender,
+        sender_stats.unreadFromSender AS unreadFromSender,
+        ns.detection_reason AS detectionReason,
+        e.list_unsubscribe AS listUnsubscribe
+      FROM emails AS e
+      LEFT JOIN (
+        SELECT
+          LOWER(from_address) AS senderKey,
+          COUNT(*) AS totalFromSender,
+          SUM(CASE WHEN is_read = 0 THEN 1 ELSE 0 END) AS unreadFromSender
+        FROM emails
+        WHERE from_address IS NOT NULL
+          AND TRIM(from_address) <> ''
+        GROUP BY LOWER(from_address)
+      ) AS sender_stats
+        ON sender_stats.senderKey = LOWER(e.from_address)
+      LEFT JOIN newsletter_senders AS ns
+        ON LOWER(ns.email) = LOWER(e.from_address)
+      WHERE ${clause}
+      ORDER BY COALESCE(e.date, 0) DESC, e.id ASC
+      LIMIT ?
+      OFFSET ?
+      `
+  ).all(...params, limit, offset);
+  const emails2 = rows.map((row) => {
+    const totalFromSender = row.totalFromSender ?? 0;
+    const unreadFromSender = row.unreadFromSender ?? 0;
+    const confidence = computeConfidence(row);
+    return {
+      id: row.id,
+      threadId: row.threadId || "",
+      from: row.sender || "",
+      subject: row.subject || "",
+      date: toIsoString4(row.date),
+      snippet: row.snippet || "",
+      labels: parseJsonArray4(row.labelIds),
+      isRead: row.isRead === 1,
+      senderContext: {
+        totalFromSender,
+        unreadRate: roundPercent(unreadFromSender, totalFromSender),
+        isNewsletter: Boolean(row.detectionReason),
+        detectionReason: row.detectionReason,
+        confidence: confidence.confidence,
+        signals: confidence.signals
+      }
+    };
+  });
+  return {
+    totalUncategorized: totalRow?.total ?? 0,
+    returned: emails2.length,
+    offset,
+    hasMore: offset + emails2.length < (totalRow?.total ?? 0),
+    emails: emails2
+  };
+}
+
+// src/core/stats/unsubscribe.ts
+function toIsoString5(value) {
+  if (!value) {
+    return null;
+  }
+  return new Date(value).toISOString();
+}
+function roundImpactScore(messageCount, unreadRate) {
+  return Math.round(messageCount * unreadRate * 10 / 100) / 10;
+}
+async function getUnsubscribeSuggestions(options = {}) {
+  await detectNewsletters();
+  const sqlite = getStatsSqlite();
+  const limit = Math.min(50, normalizeLimit(options.limit, 20));
+  const minMessages = normalizeLimit(options.minMessages, 5);
+  const rows = sqlite.prepare(
+    `
+      SELECT
+        e.from_address AS email,
+        COALESCE(MAX(NULLIF(TRIM(e.from_name), '')), e.from_address) AS name,
+        COUNT(*) AS messageCount,
+        SUM(CASE WHEN e.is_read = 0 THEN 1 ELSE 0 END) AS unreadCount,
+        MAX(CASE WHEN e.is_read = 1 THEN e.date ELSE NULL END) AS lastRead,
+        MAX(e.date) AS lastReceived,
+        MAX(NULLIF(TRIM(ns.unsubscribe_link), '')) AS newsletterUnsubscribeLink,
+        GROUP_CONCAT(NULLIF(TRIM(e.list_unsubscribe), ''), '
+') AS emailUnsubscribeHeaders
+      FROM emails AS e
+      LEFT JOIN newsletter_senders AS ns
+        ON LOWER(ns.email) = LOWER(e.from_address)
+      WHERE e.from_address IS NOT NULL
+        AND TRIM(e.from_address) <> ''
+      GROUP BY LOWER(e.from_address)
+      HAVING COUNT(*) >= ?
+      `
+  ).all(minMessages);
+  const suggestions = rows.map((row) => {
+    const unsubscribe2 = resolveUnsubscribeTarget(
+      row.newsletterUnsubscribeLink,
+      row.emailUnsubscribeHeaders
+    );
+    if (!unsubscribe2.unsubscribeLink || !unsubscribe2.unsubscribeMethod) {
+      return null;
+    }
+    const unreadRate = roundPercent(row.unreadCount, row.messageCount);
+    const readRate = roundPercent(row.messageCount - row.unreadCount, row.messageCount);
+    return {
+      email: row.email,
+      name: row.name?.trim() || row.email,
+      allTimeMessageCount: row.messageCount,
+      unreadCount: row.unreadCount,
+      unreadRate,
+      readRate,
+      lastRead: toIsoString5(row.lastRead),
+      lastReceived: toIsoString5(row.lastReceived),
+      unsubscribeLink: unsubscribe2.unsubscribeLink,
+      unsubscribeMethod: unsubscribe2.unsubscribeMethod,
+      impactScore: roundImpactScore(row.messageCount, unreadRate),
+      reason: buildUnsubscribeReason(unreadRate, row.messageCount)
+    };
+  }).filter((suggestion) => suggestion !== null).filter(
+    (suggestion) => options.unreadOnlySenders ? suggestion.unreadCount === suggestion.allTimeMessageCount : true
+  ).sort(
+    (left, right) => right.impactScore - left.impactScore || right.allTimeMessageCount - left.allTimeMessageCount || right.unreadRate - left.unreadRate || (right.lastReceived || "").localeCompare(left.lastReceived || "") || left.email.localeCompare(right.email)
+  );
+  return {
+    suggestions: suggestions.slice(0, limit),
+    totalWithUnsubscribeLinks: suggestions.length
+  };
+}
+
 // src/core/stats/volume.ts
 function getBucketExpression(granularity) {
   switch (granularity) {
@@ -2588,6 +4178,18 @@ async function getExecutionHistory(ruleId, limit = 20) {
   const runs = ruleId ? await getRunsByRule(ruleId) : await getRecentRuns(limit);
   return runs.slice(0, limit);
 }
+async function getExecutionStats(ruleId) {
+  const runs = ruleId ? await getRunsByRule(ruleId) : await getRecentRuns(1e4);
+  return {
+    totalRuns: runs.length,
+    plannedRuns: runs.filter((run) => run.status === "planned").length,
+    appliedRuns: runs.filter((run) => run.status === "applied").length,
+    partialRuns: runs.filter((run) => run.status === "partial").length,
+    errorRuns: runs.filter((run) => run.status === "error").length,
+    undoneRuns: runs.filter((run) => run.status === "undone").length,
+    lastExecutionAt: runs[0]?.createdAt ?? null
+  };
+}
 
 // src/core/rules/deploy.ts
 import { randomUUID as randomUUID3 } from "crypto";
@@ -2599,67 +4201,67 @@ import { join as join2 } from "path";
 import YAML from "yaml";
 
 // src/core/rules/types.ts
-import { z } from "zod";
-var RuleNameSchema = z.string().min(1, "Rule name is required").regex(
+import { z as z3 } from "zod";
+var RuleNameSchema = z3.string().min(1, "Rule name is required").regex(
   /^[a-z0-9]+(?:-[a-z0-9]+)*$/,
   "Rule name must be kebab-case (lowercase letters, numbers, and single hyphens)"
 );
-var RuleFieldSchema = z.enum(["from", "to", "subject", "snippet", "labels"]);
-var RegexStringSchema = z.string().min(1, "Pattern must not be empty").superRefine((value, ctx) => {
+var RuleFieldSchema = z3.enum(["from", "to", "subject", "snippet", "labels"]);
+var RegexStringSchema = z3.string().min(1, "Pattern must not be empty").superRefine((value, ctx) => {
   try {
     new RegExp(value);
   } catch (error) {
     ctx.addIssue({
-      code: z.ZodIssueCode.custom,
+      code: z3.ZodIssueCode.custom,
       message: `Invalid regular expression: ${error instanceof Error ? error.message : String(error)}`
     });
   }
 });
-var MatcherSchema = z.object({
+var MatcherSchema = z3.object({
   // `snippet` is the only cached free-text matcher in MVP.
   field: RuleFieldSchema,
   pattern: RegexStringSchema.optional(),
-  contains: z.array(z.string().min(1)).min(1).optional(),
-  values: z.array(z.string().min(1)).min(1).optional(),
-  exclude: z.boolean().default(false)
+  contains: z3.array(z3.string().min(1)).min(1).optional(),
+  values: z3.array(z3.string().min(1)).min(1).optional(),
+  exclude: z3.boolean().default(false)
 }).strict().superRefine((value, ctx) => {
   if (!value.pattern && !value.contains && !value.values) {
     ctx.addIssue({
-      code: z.ZodIssueCode.custom,
+      code: z3.ZodIssueCode.custom,
       message: "Matcher must provide at least one of pattern, contains, or values",
       path: ["pattern"]
     });
   }
 });
-var ConditionsSchema = z.object({
-  operator: z.enum(["AND", "OR"]),
-  matchers: z.array(MatcherSchema).min(1, "At least one matcher is required")
+var ConditionsSchema = z3.object({
+  operator: z3.enum(["AND", "OR"]),
+  matchers: z3.array(MatcherSchema).min(1, "At least one matcher is required")
 }).strict();
-var LabelActionSchema = z.object({
-  type: z.literal("label"),
-  label: z.string().min(1, "Label name is required")
+var LabelActionSchema = z3.object({
+  type: z3.literal("label"),
+  label: z3.string().min(1, "Label name is required")
 });
-var ArchiveActionSchema = z.object({ type: z.literal("archive") });
-var MarkReadActionSchema = z.object({ type: z.literal("mark_read") });
-var ForwardActionSchema = z.object({
-  type: z.literal("forward"),
-  to: z.string().email("Forward destination must be a valid email address")
+var ArchiveActionSchema = z3.object({ type: z3.literal("archive") });
+var MarkReadActionSchema = z3.object({ type: z3.literal("mark_read") });
+var ForwardActionSchema = z3.object({
+  type: z3.literal("forward"),
+  to: z3.string().email("Forward destination must be a valid email address")
 });
-var MarkSpamActionSchema = z.object({ type: z.literal("mark_spam") });
-var ActionSchema = z.discriminatedUnion("type", [
+var MarkSpamActionSchema = z3.object({ type: z3.literal("mark_spam") });
+var ActionSchema = z3.discriminatedUnion("type", [
   LabelActionSchema,
   ArchiveActionSchema,
   MarkReadActionSchema,
   ForwardActionSchema,
   MarkSpamActionSchema
 ]);
-var RuleSchema = z.object({
+var RuleSchema = z3.object({
   name: RuleNameSchema,
-  description: z.string(),
-  enabled: z.boolean().default(true),
-  priority: z.number().int().min(0).default(50),
+  description: z3.string(),
+  enabled: z3.boolean().default(true),
+  priority: z3.number().int().min(0).default(50),
   conditions: ConditionsSchema,
-  actions: z.array(ActionSchema).min(1, "At least one action is required")
+  actions: z3.array(ActionSchema).min(1, "At least one action is required")
 }).strict();
 
 // src/core/rules/loader.ts
@@ -2989,7 +4591,7 @@ function getDatabase4() {
   const config = loadConfig();
   return getSqlite(config.dbPath);
 }
-function parseJsonArray2(value) {
+function parseJsonArray5(value) {
   if (!value) {
     return [];
   }
@@ -3000,19 +4602,19 @@ function parseJsonArray2(value) {
     return [];
   }
 }
-function rowToEmail2(row) {
+function rowToEmail3(row) {
   return {
     id: row.id,
     threadId: row.thread_id ?? "",
     fromAddress: row.from_address ?? "",
     fromName: row.from_name ?? "",
-    toAddresses: parseJsonArray2(row.to_addresses),
+    toAddresses: parseJsonArray5(row.to_addresses),
     subject: row.subject ?? "",
     snippet: row.snippet ?? "",
     date: row.date ?? 0,
     isRead: row.is_read === 1,
     isStarred: row.is_starred === 1,
-    labelIds: parseJsonArray2(row.label_ids),
+    labelIds: parseJsonArray5(row.label_ids),
     sizeEstimate: row.size_estimate ?? 0,
     hasAttachments: row.has_attachments === 1,
     listUnsubscribe: row.list_unsubscribe
@@ -3121,7 +4723,7 @@ async function findMatchingEmails(ruleOrConditions, limit) {
   ).all();
   const matches = [];
   for (const row of rows) {
-    const email = rowToEmail2(row);
+    const email = rowToEmail3(row);
     const result = matchEmail(email, conditions);
     if (!result.matches) {
       continue;
@@ -3186,7 +4788,7 @@ async function loadMatchedItems(rule, options) {
     errorMessage: null
   }));
 }
-async function executeAction(emailId, action, options) {
+async function executeAction2(emailId, action, options) {
   switch (action.type) {
     case "archive":
       return (await archiveEmails([emailId], options)).items[0];
@@ -3207,7 +4809,7 @@ async function applyRuleActions(item, actions, options) {
   };
   for (const action of actions) {
     try {
-      const result = await executeAction(item.emailId, action, options);
+      const result = await executeAction2(item.emailId, action, options);
       current = {
         ...current,
         status: result.status,
@@ -3335,7 +4937,7 @@ async function runAllRules(options) {
 }
 
 // src/core/gmail/filters.ts
-async function resolveContext3(options) {
+async function resolveContext5(options) {
   const config = options?.config ?? loadConfig();
   const transport = options?.transport ?? await getGmailTransport(config);
   return { config, transport };
@@ -3385,7 +4987,7 @@ async function buildLabelMap(context) {
   return map;
 }
 async function listFilters(options) {
-  const context = await resolveContext3(options);
+  const context = await resolveContext5(options);
   const [response, labelMap] = await Promise.all([
     context.transport.listFilters(),
     buildLabelMap(context)
@@ -3394,7 +4996,7 @@ async function listFilters(options) {
   return raw.map((f) => toGmailFilter(f, labelMap)).filter((f) => f !== null);
 }
 async function getFilter(id, options) {
-  const context = await resolveContext3(options);
+  const context = await resolveContext5(options);
   const [raw, labelMap] = await Promise.all([
     context.transport.getFilter(id),
     buildLabelMap(context)
@@ -3418,7 +5020,7 @@ async function createFilter(input, options) {
       "At least one action is required (labelName, archive, markRead, star, or forward)"
     );
   }
-  const context = await resolveContext3(options);
+  const context = await resolveContext5(options);
   const addLabelIds = [];
   if (input.star) {
     addLabelIds.push("STARRED");
@@ -3457,7 +5059,7 @@ async function createFilter(input, options) {
   return filter;
 }
 async function deleteFilter(id, options) {
-  const context = await resolveContext3(options);
+  const context = await resolveContext5(options);
   await context.transport.deleteFilter(id);
 }
 
@@ -3949,8 +5551,8 @@ async function getSyncStatus() {
 }
 
 // src/mcp/server.ts
-var DAY_MS2 = 24 * 60 * 60 * 1e3;
-var MCP_VERSION = "0.1.0";
+var DAY_MS4 = 24 * 60 * 60 * 1e3;
+var MCP_VERSION = "0.3.0";
 var MCP_TOOLS = [
   "search_emails",
   "get_email",
@@ -3959,6 +5561,7 @@ var MCP_TOOLS = [
   "archive_emails",
   "label_emails",
   "mark_read",
+  "batch_apply_actions",
   "forward_email",
   "undo_run",
   "get_labels",
@@ -3967,6 +5570,12 @@ var MCP_TOOLS = [
   "get_top_senders",
   "get_sender_stats",
   "get_newsletter_senders",
+  "get_uncategorized_emails",
+  "review_categorized",
+  "query_emails",
+  "get_noise_senders",
+  "get_unsubscribe_suggestions",
+  "unsubscribe",
   "deploy_rule",
   "list_rules",
   "run_rule",
@@ -3980,6 +5589,8 @@ var MCP_TOOLS = [
 var MCP_RESOURCES = [
   "inbox://recent",
   "inbox://summary",
+  "inbox://action-log",
+  "schema://query-fields",
   "rules://deployed",
   "rules://history",
   "stats://senders",
@@ -3990,7 +5601,8 @@ var MCP_PROMPTS = [
   "review-senders",
   "find-newsletters",
   "suggest-rules",
-  "triage-inbox"
+  "triage-inbox",
+  "categorize-emails"
 ];
 function toTextResult(value) {
   return {
@@ -4064,12 +5676,22 @@ function buildSearchQuery(query, label) {
   }
   return trimmedQuery;
 }
-function uniqueStrings(values) {
+function uniqueStrings3(values) {
   return Array.from(new Set((values || []).map((value) => value.trim()).filter(Boolean)));
 }
 function resolveResourceUri(uri, fallback) {
   return typeof uri === "string" ? uri : fallback;
 }
+function formatActionSummary(action) {
+  switch (action.type) {
+    case "label":
+      return action.label ? `label:${action.label}` : "label";
+    case "forward":
+      return action.to ? `forward:${action.to}` : "forward";
+    default:
+      return action.type;
+  }
+}
 async function buildStartupWarnings() {
   const config = loadConfig();
   initializeDb(config.dbPath);
@@ -4090,7 +5712,7 @@ async function buildStartupWarnings() {
   }
   if (!latestSync) {
     warnings.push("Inbox cache has not been synced yet. Stats and resources will be empty until `sync_inbox` runs.");
-  } else if (Date.now() - latestSync > DAY_MS2) {
+  } else if (Date.now() - latestSync > DAY_MS4) {
     warnings.push("Inbox cache appears stale (last sync older than 24 hours). Call `sync_inbox` if freshness matters.");
   }
   return warnings;
@@ -4101,7 +5723,7 @@ async function buildStatsOverview() {
     topSenders: await getTopSenders({ limit: 10 }),
     labelDistribution: (await getLabelDistribution()).slice(0, 10),
     dailyVolume: await getVolumeByPeriod("day", {
-      start: Date.now() - 30 * DAY_MS2,
+      start: Date.now() - 30 * DAY_MS4,
       end: Date.now()
     })
   };
@@ -4113,6 +5735,23 @@ async function buildRuleHistory() {
     recentRuns: await getRecentRuns(20)
   };
 }
+async function buildActionLog() {
+  const recentRuns = await getRecentRuns(10);
+  const stats = await getExecutionStats();
+  return {
+    recentRuns: recentRuns.map((run) => ({
+      runId: run.id,
+      createdAt: new Date(run.createdAt).toISOString(),
+      sourceType: run.sourceType,
+      dryRun: run.dryRun,
+      status: run.status,
+      emailCount: run.itemCount,
+      actions: run.requestedActions.map(formatActionSummary),
+      undoAvailable: !run.dryRun && run.undoneAt === null && run.status !== "planned" && run.status !== "undone" && run.itemCount > 0
+    })),
+    totalRuns: stats.totalRuns
+  };
+}
 async function createMcpServer() {
   const warnings = await buildStartupWarnings();
   const server = new McpServer({
@@ -4124,9 +5763,9 @@ async function createMcpServer() {
     {
       description: "Search Gmail using Gmail query syntax and return matching email metadata.",
       inputSchema: {
-        query: z2.string().min(1),
-        max_results: z2.number().int().positive().max(100).optional(),
-        label: z2.string().min(1).optional()
+        query: z4.string().min(1),
+        max_results: z4.number().int().positive().max(100).optional(),
+        label: z4.string().min(1).optional()
       },
       annotations: {
         readOnlyHint: true
@@ -4141,7 +5780,7 @@ async function createMcpServer() {
     {
       description: "Fetch a single email with full content by Gmail message ID.",
       inputSchema: {
-        email_id: z2.string().min(1)
+        email_id: z4.string().min(1)
       },
       annotations: {
         readOnlyHint: true
@@ -4154,7 +5793,7 @@ async function createMcpServer() {
     {
       description: "Fetch a full Gmail thread by thread ID.",
       inputSchema: {
-        thread_id: z2.string().min(1)
+        thread_id: z4.string().min(1)
       },
       annotations: {
         readOnlyHint: true
@@ -4167,7 +5806,7 @@ async function createMcpServer() {
     {
       description: "Run inbox sync. Uses incremental sync by default and full sync when requested.",
       inputSchema: {
-        full: z2.boolean().optional()
+        full: z4.boolean().optional()
       },
       annotations: {
         readOnlyHint: false,
@@ -4181,23 +5820,23 @@ async function createMcpServer() {
     {
       description: "Archive one or more Gmail messages by removing the INBOX label.",
       inputSchema: {
-        email_ids: z2.array(z2.string().min(1)).min(1)
+        email_ids: z4.array(z4.string().min(1)).min(1)
       },
       annotations: {
         readOnlyHint: false,
         destructiveHint: false
       }
     },
-    toolHandler(async ({ email_ids }) => archiveEmails(uniqueStrings(email_ids)))
+    toolHandler(async ({ email_ids }) => archiveEmails(uniqueStrings3(email_ids)))
   );
   server.registerTool(
     "label_emails",
     {
       description: "Add and/or remove Gmail labels on one or more messages.",
       inputSchema: {
-        email_ids: z2.array(z2.string().min(1)).min(1),
-        add_labels: z2.array(z2.string().min(1)).optional(),
-        remove_labels: z2.array(z2.string().min(1)).optional()
+        email_ids: z4.array(z4.string().min(1)).min(1),
+        add_labels: z4.array(z4.string().min(1)).optional(),
+        remove_labels: z4.array(z4.string().min(1)).optional()
       },
       annotations: {
         readOnlyHint: false,
@@ -4205,9 +5844,9 @@ async function createMcpServer() {
       }
     },
     toolHandler(async ({ email_ids, add_labels, remove_labels }) => {
-      const ids = uniqueStrings(email_ids);
-      const addLabels = uniqueStrings(add_labels);
-      const removeLabels = uniqueStrings(remove_labels);
+      const ids = uniqueStrings3(email_ids);
+      const addLabels = uniqueStrings3(add_labels);
+      const removeLabels = uniqueStrings3(remove_labels);
       if (addLabels.length === 0 && removeLabels.length === 0) {
         throw new Error("Provide at least one label to add or remove.");
       }
@@ -4231,8 +5870,8 @@ async function createMcpServer() {
     {
       description: "Mark one or more Gmail messages as read or unread.",
       inputSchema: {
-        email_ids: z2.array(z2.string().min(1)).min(1),
-        read: z2.boolean()
+        email_ids: z4.array(z4.string().min(1)).min(1),
+        read: z4.boolean()
       },
       annotations: {
         readOnlyHint: false,
@@ -4240,17 +5879,53 @@ async function createMcpServer() {
       }
     },
     toolHandler(async ({ email_ids, read }) => {
-      const ids = uniqueStrings(email_ids);
+      const ids = uniqueStrings3(email_ids);
       return read ? markRead(ids) : markUnread(ids);
     })
   );
+  server.registerTool(
+    "batch_apply_actions",
+    {
+      description: "Apply grouped inbox actions in one call for faster AI-driven triage and categorization.",
+      inputSchema: {
+        groups: z4.array(
+          z4.object({
+            email_ids: z4.array(z4.string().min(1)).min(1).max(500),
+            actions: z4.array(
+              z4.discriminatedUnion("type", [
+                z4.object({
+                  type: z4.literal("label"),
+                  label: z4.string().min(1)
+                }),
+                z4.object({ type: z4.literal("archive") }),
+                z4.object({ type: z4.literal("mark_read") }),
+                z4.object({ type: z4.literal("mark_spam") })
+              ])
+            ).min(1).max(5)
+          })
+        ).min(1).max(20),
+        dry_run: z4.boolean().optional()
+      },
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false
+      }
+    },
+    toolHandler(async ({ groups, dry_run }) => batchApplyActions({
+      groups: groups.map((group) => ({
+        emailIds: uniqueStrings3(group.email_ids),
+        actions: group.actions
+      })),
+      dryRun: dry_run
+    }))
+  );
   server.registerTool(
     "forward_email",
     {
       description: "Forward a Gmail message to another address.",
       inputSchema: {
-        email_id: z2.string().min(1),
-        to: z2.string().email()
+        email_id: z4.string().min(1),
+        to: z4.string().email()
       },
       annotations: {
         readOnlyHint: false,
@@ -4264,7 +5939,7 @@ async function createMcpServer() {
     {
       description: "Undo a prior inboxctl action run when the underlying Gmail mutations are reversible.",
       inputSchema: {
-        run_id: z2.string().min(1)
+        run_id: z4.string().min(1)
       },
       annotations: {
         readOnlyHint: false,
@@ -4288,8 +5963,8 @@ async function createMcpServer() {
     {
       description: "Create a Gmail label if it does not already exist.",
       inputSchema: {
-        name: z2.string().min(1),
-        color: z2.string().min(1).optional()
+        name: z4.string().min(1),
+        color: z4.string().min(1).optional()
       },
       annotations: {
         readOnlyHint: false,
@@ -4321,9 +5996,9 @@ async function createMcpServer() {
     {
       description: "Return top senders ranked by cached email volume.",
       inputSchema: {
-        limit: z2.number().int().positive().max(100).optional(),
-        min_unread_rate: z2.number().min(0).max(100).optional(),
-        period: z2.enum(["day", "week", "month", "year", "all"]).optional()
+        limit: z4.number().int().positive().max(100).optional(),
+        min_unread_rate: z4.number().min(0).max(100).optional(),
+        period: z4.enum(["day", "week", "month", "year", "all"]).optional()
       },
       annotations: {
         readOnlyHint: true
@@ -4340,7 +6015,7 @@ async function createMcpServer() {
     {
       description: "Return detailed stats for a sender email address or an @domain aggregate.",
       inputSchema: {
-        email_or_domain: z2.string().min(1)
+        email_or_domain: z4.string().min(1)
       },
       annotations: {
         readOnlyHint: true
@@ -4360,8 +6035,8 @@ async function createMcpServer() {
     {
       description: "Return senders that look like newsletters or mailing lists based on cached heuristics.",
       inputSchema: {
-        min_messages: z2.number().int().positive().optional(),
-        min_unread_rate: z2.number().min(0).max(100).optional()
+        min_messages: z4.number().int().positive().optional(),
+        min_unread_rate: z4.number().min(0).max(100).optional()
       },
       annotations: {
         readOnlyHint: true
@@ -4372,12 +6047,115 @@ async function createMcpServer() {
       minUnreadRate: min_unread_rate
     }))
   );
+  server.registerTool(
+    "get_uncategorized_emails",
+    {
+      description: "Return cached emails that have only Gmail system labels and no user-applied organization.",
+      inputSchema: {
+        limit: z4.number().int().positive().max(1e3).optional().describe("Max emails to return per page. Default 50. AI clients should start with 50-100 and paginate."),
+        offset: z4.number().int().min(0).optional().describe("Number of results to skip for pagination. Use with totalUncategorized and hasMore."),
+        unread_only: z4.boolean().optional(),
+        since: z4.string().min(1).optional()
+      },
+      annotations: {
+        readOnlyHint: true
+      }
+    },
+    toolHandler(async ({ limit, offset, unread_only, since }) => getUncategorizedEmails({
+      limit,
+      offset,
+      unreadOnly: unread_only,
+      since
+    }))
+  );
+  server.registerTool(
+    "review_categorized",
+    {
+      description: "Scan recently categorized emails for anomalies that suggest a misclassification or over-aggressive archive.",
+      inputSchema: reviewCategorizedInputSchema.shape,
+      annotations: {
+        readOnlyHint: true
+      }
+    },
+    toolHandler(async (args) => reviewCategorized(args))
+  );
+  server.registerTool(
+    "query_emails",
+    {
+      description: "Run structured analytics queries over the cached email dataset using fixed filters, groupings, and aggregates.",
+      inputSchema: queryEmailsInputSchema.shape,
+      annotations: {
+        readOnlyHint: true
+      }
+    },
+    toolHandler(async (args) => queryEmails(args))
+  );
+  server.registerTool(
+    "get_noise_senders",
+    {
+      description: "Return a focused list of active, high-noise senders worth categorizing, filtering, or unsubscribing.",
+      inputSchema: {
+        limit: z4.number().int().positive().max(50).optional(),
+        min_noise_score: z4.number().min(0).optional(),
+        active_days: z4.number().int().positive().optional(),
+        sort_by: z4.enum(["noise_score", "all_time_noise_score", "message_count", "unread_rate"]).optional().describe("Sort order. Default: noise_score. Use all_time_noise_score for lifetime perspective.")
+      },
+      annotations: {
+        readOnlyHint: true
+      }
+    },
+    toolHandler(async ({ limit, min_noise_score, active_days, sort_by }) => getNoiseSenders({
+      limit,
+      minNoiseScore: min_noise_score,
+      activeDays: active_days,
+      sortBy: sort_by
+    }))
+  );
+  server.registerTool(
+    "get_unsubscribe_suggestions",
+    {
+      description: "Return ranked senders with unsubscribe links, sorted by how much inbox noise unsubscribing would remove.",
+      inputSchema: {
+        limit: z4.number().int().positive().max(50).optional(),
+        min_messages: z4.number().int().positive().optional(),
+        unread_only_senders: z4.boolean().optional()
+      },
+      annotations: {
+        readOnlyHint: true
+      }
+    },
+    toolHandler(async ({ limit, min_messages, unread_only_senders }) => getUnsubscribeSuggestions({
+      limit,
+      minMessages: min_messages,
+      unreadOnlySenders: unread_only_senders
+    }))
+  );
+  server.registerTool(
+    "unsubscribe",
+    {
+      description: "Return the unsubscribe target for a sender and optionally label/archive existing emails in one undoable run.",
+      inputSchema: {
+        sender_email: z4.string().min(1),
+        also_archive: z4.boolean().optional(),
+        also_label: z4.string().min(1).optional()
+      },
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false
+      }
+    },
+    toolHandler(async ({ sender_email, also_archive, also_label }) => unsubscribe({
+      senderEmail: sender_email,
+      alsoArchive: also_archive,
+      alsoLabel: also_label
+    }))
+  );
   server.registerTool(
     "deploy_rule",
     {
       description: "Validate and deploy a rule directly from YAML content.",
       inputSchema: {
-        yaml_content: z2.string().min(1)
+        yaml_content: z4.string().min(1)
       },
       annotations: {
         readOnlyHint: false,
@@ -4394,7 +6172,7 @@ async function createMcpServer() {
     {
       description: "List deployed inboxctl rules and their execution status.",
       inputSchema: {
-        enabled_only: z2.boolean().optional()
+        enabled_only: z4.boolean().optional()
       },
       annotations: {
         readOnlyHint: true
@@ -4410,9 +6188,9 @@ async function createMcpServer() {
     {
       description: "Run a deployed rule in dry-run mode by default, or apply it when dry_run is false.",
       inputSchema: {
-        rule_name: z2.string().min(1),
-        dry_run: z2.boolean().optional(),
-        max_emails: z2.number().int().positive().max(1e3).optional()
+        rule_name: z4.string().min(1),
+        dry_run: z4.boolean().optional(),
+        max_emails: z4.number().int().positive().max(1e3).optional()
       },
       annotations: {
         readOnlyHint: false,
@@ -4429,7 +6207,7 @@ async function createMcpServer() {
     {
       description: "Enable a deployed rule by name.",
       inputSchema: {
-        rule_name: z2.string().min(1)
+        rule_name: z4.string().min(1)
       },
       annotations: {
         readOnlyHint: false,
@@ -4443,7 +6221,7 @@ async function createMcpServer() {
     {
       description: "Disable a deployed rule by name.",
       inputSchema: {
-        rule_name: z2.string().min(1)
+        rule_name: z4.string().min(1)
       },
       annotations: {
         readOnlyHint: false,
@@ -4470,6 +6248,24 @@ async function createMcpServer() {
     },
     async (uri) => resourceText(resolveResourceUri(uri, "inbox://summary"), await getInboxOverview())
   );
+  server.registerResource(
+    "inbox-action-log",
+    "inbox://action-log",
+    {
+      description: "Recent action history showing what inboxctl already did and whether undo is still available.",
+      mimeType: "application/json"
+    },
+    async (uri) => resourceText(resolveResourceUri(uri, "inbox://action-log"), await buildActionLog())
+  );
+  server.registerResource(
+    "query-fields",
+    "schema://query-fields",
+    {
+      description: "Field vocabulary, aggregates, and examples for the query_emails analytics tool.",
+      mimeType: "application/json"
+    },
+    async (uri) => resourceText(resolveResourceUri(uri, "schema://query-fields"), QUERY_EMAILS_FIELD_SCHEMA)
+  );
   server.registerResource(
     "deployed-rules",
     "rules://deployed",
@@ -4529,10 +6325,28 @@ async function createMcpServer() {
     async () => promptResult(
       "Review top senders and recommend cleanup actions.",
       [
-        "Use `get_top_senders` and `stats://senders`.",
-        "Focus on senders with high unread rates or high volume.",
-        "For each notable sender, classify them as important, FYI, newsletter, or noise.",
-        "Recommend one of: keep, unsubscribe, archive manually, or create a rule."
+        "Step 0 \u2014 Check for past mistakes:",
+        "  Call `review_categorized` to see if any recent categorisations look incorrect.",
+        "  If anomalies are found, present them first \u2014 fixing past mistakes takes priority over reviewing new senders.",
+        "",
+        "Step 1 \u2014 Gather data:",
+        "  Use `get_noise_senders` for the most actionable noisy senders.",
+        "  Use `rules://deployed` to check for existing rules covering these senders.",
+        "  Use `get_unsubscribe_suggestions` for senders you can unsubscribe from.",
+        "",
+        "Step 2 \u2014 For each noisy sender, recommend one of:",
+        "  KEEP \u2014 important, reduce noise with a label rule",
+        "  RULE \u2014 create a rule to auto-label + mark read (or archive)",
+        "  UNSUBSCRIBE \u2014 stop receiving entirely (has unsubscribe link, high unread rate)",
+        "",
+        "Step 3 \u2014 Present as a table:",
+        "  Sender | Messages | Unread% | Noise Score | Has Unsub | Recommendation | Reason",
+        "",
+        "Step 4 \u2014 Offer to act:",
+        "  For senders marked RULE, offer to generate YAML using the rule schema.",
+        "  Group similar senders (e.g. all shipping senders) into one rule.",
+        "  Present YAML for review before deploying with `deploy_rule`.",
+        "  For senders marked UNSUBSCRIBE, use `unsubscribe` with `also_archive: true` and return the link for the user to follow."
       ].join("\n")
     )
   );
@@ -4559,10 +6373,37 @@ async function createMcpServer() {
     async () => promptResult(
       "Analyze inbox patterns and propose valid inboxctl rule YAML.",
       [
-        "Inspect `rules://deployed`, `stats://senders`, and `get_newsletter_senders` first.",
-        "Look for ignored senders, repetitive notifications, and obvious auto-label opportunities.",
-        "For each recommendation, explain why it is safe and include complete YAML the user could deploy with `deploy_rule`.",
-        "Avoid risky suggestions when the evidence is weak."
+        "First, inspect these data sources:",
+        "- `rules://deployed` \u2014 existing rules (avoid duplicates)",
+        "- `get_noise_senders` \u2014 high-volume low-read senders",
+        "- `get_newsletter_senders` \u2014 detected newsletters and mailing lists",
+        "",
+        "For each recommendation, generate complete YAML using this schema:",
+        "",
+        "  name: kebab-case-name          # lowercase, hyphens only",
+        "  description: What this rule does",
+        "  enabled: true",
+        "  priority: 50                   # 0-100, lower = runs first",
+        "  conditions:",
+        "    operator: AND                # AND or OR",
+        "    matchers:",
+        "      - field: from              # from | to | subject | snippet | labels",
+        "        contains:                # OR use: values (exact), pattern (regex)",
+        '          - "@example.com"',
+        "        exclude: false           # true to negate the match",
+        "  actions:",
+        "    - type: label                # label | archive | mark_read | forward | mark_spam",
+        '      label: "Category/Name"',
+        "    - type: mark_read",
+        "    - type: archive",
+        "",
+        "Matcher fields: `from`, `to`, `subject`, `snippet`, `labels`.",
+        "Match modes (provide exactly one per matcher): `values` (exact), `contains` (substring), `pattern` (regex).",
+        "Action types: `label` (requires `label` field), `archive`, `mark_read`, `forward` (requires `to` field), `mark_spam`.",
+        "",
+        "Group related senders into a single rule where possible (e.g. all shipping notifications in one rule).",
+        "Explain why each rule is safe. Default to `mark_read` + `label` over `archive` unless evidence is strong.",
+        "Present the YAML so the user can review before deploying with `deploy_rule`."
       ].join("\n")
     )
   );
@@ -4574,10 +6415,96 @@ async function createMcpServer() {
     async () => promptResult(
       "Triage unread mail using inboxctl data sources.",
       [
-        "Use `inbox://recent`, `inbox://summary`, and `search_emails` for `is:unread` if needed.",
-        "Group unread mail into ACTION REQUIRED, FYI, and NOISE.",
-        "For NOISE, suggest batch actions or rules that would reduce future inbox load.",
-        "Call out any assumptions when message bodies are unavailable."
+        "Step 1 \u2014 Gather data:",
+        "  Use `get_uncategorized_emails` with `unread_only: true` for uncategorised unread mail.",
+        "  Use `inbox://summary` for overall counts.",
+        "  If totalUncategorized is large, process in pages rather than all at once.",
+        "  If more context is needed on a specific email, use `get_email` or `get_thread`.",
+        "",
+        "Step 2 \u2014 Categorise each email into one of:",
+        "  ACTION REQUIRED \u2014 needs a response or decision from the user",
+        "  FYI \u2014 worth knowing about but no action needed",
+        "  NOISE \u2014 bulk, promotional, or irrelevant",
+        "",
+        "Step 2.5 \u2014 Flag low-confidence items:",
+        '  For any email with `confidence: "low"` in `senderContext`, always categorise it as ACTION REQUIRED.',
+        "  Better to surface a false positive than bury a real personal or work email.",
+        "",
+        "Step 3 \u2014 Present findings:",
+        "  List emails grouped by category with: sender, subject, and one-line reason.",
+        "  For NOISE, suggest a label and whether to archive.",
+        "  For FYI, suggest a label.",
+        "  For ACTION REQUIRED, summarise what action seems needed.",
+        "",
+        "Step 4 \u2014 Offer to apply:",
+        "  If the user approves, use `batch_apply_actions` to apply all decisions in one call.",
+        "  Group emails by their action set (e.g. all `label:Receipts + mark_read` together).",
+        "",
+        "Step 5 \u2014 Offer noise reduction:",
+        "  If NOISE senders appear repeatedly, suggest a rule or `unsubscribe` when a link is available."
+      ].join("\n")
+    )
+  );
+  server.registerPrompt(
+    "categorize-emails",
+    {
+      description: "Systematically categorise uncategorised emails using sender patterns, content, and inbox analytics."
+    },
+    async () => promptResult(
+      "Categorise uncategorised emails in the user's inbox.",
+      [
+        "Step 1 \u2014 Gather data:",
+        "  Use `get_uncategorized_emails` (start with limit 100).",
+        "  If totalUncategorized is more than 500, ask whether to process the recent batch or paginate through the full backlog.",
+        "  Use `get_noise_senders` for sender context.",
+        "  Use `get_unsubscribe_suggestions` for likely unsubscribe candidates.",
+        "  Use `get_labels` to see what labels already exist.",
+        "  Use `rules://deployed` to avoid duplicating existing automation.",
+        "",
+        "Step 2 \u2014 Assign each email a category:",
+        "  Receipts \u2014 purchase confirmations, invoices, payment notifications",
+        "  Shipping \u2014 delivery tracking, dispatch notices, shipping updates",
+        "  Newsletters \u2014 editorial content, digests, weekly roundups",
+        "  Promotions \u2014 marketing, sales, deals, coupons",
+        "  Social \u2014 social network notifications (LinkedIn, Facebook, etc.)",
+        "  Notifications \u2014 automated alerts, system notifications, service updates",
+        "  Finance \u2014 bank statements, investment updates, tax documents",
+        "  Travel \u2014 bookings, itineraries, check-in reminders",
+        "  Important \u2014 personal or work email requiring attention",
+        "",
+        "Step 3 \u2014 Present the categorisation plan:",
+        "  Group emails by assigned category.",
+        "  For each group show: count, senders involved, sample subjects.",
+        "  Note confidence level: HIGH (clear pattern), MEDIUM (reasonable guess), LOW (uncertain).",
+        "  Flag any LOW confidence items for the user to decide.",
+        "  Present the confidence breakdown: X HIGH (auto-apply), Y MEDIUM (label only), Z LOW (review queue).",
+        "  If any LOW confidence emails are present, note why they were flagged from the `signals` array.",
+        "",
+        "Step 3.5 \u2014 Apply confidence gating:",
+        "  HIGH confidence \u2014 safe to apply directly (label, mark_read, archive as appropriate).",
+        "  MEDIUM confidence \u2014 apply the category label only. Do not archive. Keep the email visible in the inbox.",
+        "  LOW confidence \u2014 apply only the label `inboxctl/Review`. Do not archive or mark read.",
+        "  These emails need human review before any further action.",
+        "",
+        "Step 4 \u2014 Apply with user approval:",
+        "  Create labels for any new categories (use `create_label`).",
+        "  Use `batch_apply_actions` to apply labels in one call.",
+        "  For Newsletters and Promotions with high unread rates, suggest mark_read + archive or `unsubscribe` when a link is available.",
+        "  For Receipts/Shipping/Notifications, suggest mark_read only (keep in inbox).",
+        "  For Important, do not mark read or archive.",
+        "",
+        "Step 5 \u2014 Paginate if needed:",
+        "  If hasMore is true, ask whether to continue with the next page using offset.",
+        "  Reuse the same sender categorisations on later pages instead of re-evaluating known senders.",
+        "",
+        "Step 6 \u2014 Suggest ongoing rules:",
+        "  For any category with 3+ emails from the same sender, suggest a YAML rule.",
+        "  This prevents the same categorisation from being needed again.",
+        "  Use `deploy_rule` after user reviews the YAML.",
+        "",
+        "Step 7 \u2014 Post-categorisation audit:",
+        "  After applying actions, call `review_categorized` to check for anomalies.",
+        "  If anomalies are found, present them with the option to undo the relevant run."
       ].join("\n")
     )
   );
@@ -4593,7 +6520,7 @@ async function createMcpServer() {
     {
       description: "Get the details of a specific Gmail server-side filter by ID.",
       inputSchema: {
-        filter_id: z2.string().min(1).describe("Gmail filter ID")
+        filter_id: z4.string().min(1).describe("Gmail filter ID")
       }
     },
     toolHandler(async ({ filter_id }) => getFilter(filter_id))
@@ -4603,20 +6530,20 @@ async function createMcpServer() {
     {
       description: "Create a Gmail server-side filter that applies automatically to all future incoming mail. Useful for simple, always-on rules (e.g. 'label all mail from newsletter@x.com and archive it'). At least one criteria field and one action field are required. Gmail does not support updating filters \u2014 to change one, delete it and create a new one. For regex matching, OR conditions, snippet matching, or processing existing mail, use YAML rules instead.",
       inputSchema: {
-        from: z2.string().optional().describe("Match emails from this address"),
-        to: z2.string().optional().describe("Match emails sent to this address"),
-        subject: z2.string().optional().describe("Match emails with this text in the subject"),
-        query: z2.string().optional().describe("Match using Gmail search syntax (e.g. 'has:attachment')"),
-        negated_query: z2.string().optional().describe("Exclude emails matching this Gmail query"),
-        has_attachment: z2.boolean().optional().describe("Match emails with attachments"),
-        exclude_chats: z2.boolean().optional().describe("Exclude chat messages from matches"),
-        size: z2.number().int().positive().optional().describe("Size threshold in bytes"),
-        size_comparison: z2.enum(["larger", "smaller"]).optional().describe("Use with size: match emails larger or smaller than the threshold"),
-        label: z2.string().optional().describe("Apply this label to matching emails (auto-created if it does not exist)"),
-        archive: z2.boolean().optional().describe("Archive matching emails (remove from inbox)"),
-        mark_read: z2.boolean().optional().describe("Mark matching emails as read"),
-        star: z2.boolean().optional().describe("Star matching emails"),
-        forward: z2.string().email().optional().describe("Forward matching emails to this address (address must be verified in Gmail settings)")
+        from: z4.string().optional().describe("Match emails from this address"),
+        to: z4.string().optional().describe("Match emails sent to this address"),
+        subject: z4.string().optional().describe("Match emails with this text in the subject"),
+        query: z4.string().optional().describe("Match using Gmail search syntax (e.g. 'has:attachment')"),
+        negated_query: z4.string().optional().describe("Exclude emails matching this Gmail query"),
+        has_attachment: z4.boolean().optional().describe("Match emails with attachments"),
+        exclude_chats: z4.boolean().optional().describe("Exclude chat messages from matches"),
+        size: z4.number().int().positive().optional().describe("Size threshold in bytes"),
+        size_comparison: z4.enum(["larger", "smaller"]).optional().describe("Use with size: match emails larger or smaller than the threshold"),
+        label: z4.string().optional().describe("Apply this label to matching emails (auto-created if it does not exist)"),
+        archive: z4.boolean().optional().describe("Archive matching emails (remove from inbox)"),
+        mark_read: z4.boolean().optional().describe("Mark matching emails as read"),
+        star: z4.boolean().optional().describe("Star matching emails"),
+        forward: z4.string().email().optional().describe("Forward matching emails to this address (address must be verified in Gmail settings)")
       }
     },
     toolHandler(
@@ -4643,7 +6570,7 @@ async function createMcpServer() {
     {
       description: "Delete a Gmail server-side filter by ID. The filter stops processing future mail immediately. Already-processed mail is not affected. Use list_filters to find filter IDs.",
       inputSchema: {
-        filter_id: z2.string().min(1).describe("Gmail filter ID to delete")
+        filter_id: z4.string().min(1).describe("Gmail filter ID to delete")
       }
     },
     toolHandler(async ({ filter_id }) => {
@@ -4741,4 +6668,4 @@ export {
   createMcpServer,
   startMcpServer
 };
-//# sourceMappingURL=chunk-EY6VV43S.js.map
+//# sourceMappingURL=chunk-OLL3OA5B.js.map