inboxctl 0.1.2 → 0.2.0

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

@@ -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,6 +2371,184 @@ 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/common.ts
 var DAY_MS = 24 * 60 * 60 * 1e3;
 var SYSTEM_LABEL_NAMES = /* @__PURE__ */ new Map([
@@ -2318,6 +2812,124 @@ async function getNewsletters(options = {}) {
   return rows.map(mapNewsletterRow);
 }
 
+// src/core/stats/noise.ts
+var DAY_MS2 = 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 toIsoString(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_MS2;
+  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: toIsoString(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/sender.ts
 function buildSenderWhereClause(period) {
   const whereParts = [
@@ -2476,6 +3088,222 @@ async function getSenderStats(emailOrDomain) {
   };
 }
 
+// src/core/stats/uncategorized.ts
+var SYSTEM_LABEL_IDS = [
+  "INBOX",
+  "UNREAD",
+  "IMPORTANT",
+  "SENT",
+  "DRAFT",
+  "SPAM",
+  "TRASH",
+  "STARRED"
+];
+var CATEGORY_LABEL_PATTERN = "CATEGORY\\_%";
+function toIsoString2(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 resolveSinceTimestamp(since) {
+  if (!since) {
+    return null;
+  }
+  const parsed = Date.parse(since);
+  if (Number.isNaN(parsed)) {
+    throw new Error(`Invalid since value: ${since}`);
+  }
+  return parsed;
+}
+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_IDS.map(() => "?").join(", ")})
+        AND label.value NOT LIKE ? ESCAPE '\\'
+    )
+    `
+  ];
+  const params = [...SYSTEM_LABEL_IDS, 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 = resolveSinceTimestamp(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
+      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;
+    return {
+      id: row.id,
+      threadId: row.threadId || "",
+      from: row.sender || "",
+      subject: row.subject || "",
+      date: toIsoString2(row.date),
+      snippet: row.snippet || "",
+      labels: parseJsonArray3(row.labelIds),
+      isRead: row.isRead === 1,
+      senderContext: {
+        totalFromSender,
+        unreadRate: roundPercent(unreadFromSender, totalFromSender),
+        isNewsletter: Boolean(row.detectionReason),
+        detectionReason: row.detectionReason
+      }
+    };
+  });
+  return {
+    totalUncategorized: totalRow?.total ?? 0,
+    returned: emails2.length,
+    offset,
+    hasMore: offset + emails2.length < (totalRow?.total ?? 0),
+    emails: emails2
+  };
+}
+
+// src/core/stats/unsubscribe.ts
+function toIsoString3(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: toIsoString3(row.lastRead),
+      lastReceived: toIsoString3(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 +3416,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";
@@ -2989,7 +3829,7 @@ function getDatabase4() {
   const config = loadConfig();
   return getSqlite(config.dbPath);
 }
-function parseJsonArray2(value) {
+function parseJsonArray4(value) {
   if (!value) {
     return [];
   }
@@ -3000,19 +3840,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: parseJsonArray4(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: parseJsonArray4(row.label_ids),
     sizeEstimate: row.size_estimate ?? 0,
     hasAttachments: row.has_attachments === 1,
     listUnsubscribe: row.list_unsubscribe
@@ -3121,7 +3961,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 +4026,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 +4047,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 +4175,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 +4225,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 +4234,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 +4258,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 +4297,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,7 +4789,7 @@ async function getSyncStatus() {
 }
 
 // src/mcp/server.ts
-var DAY_MS2 = 24 * 60 * 60 * 1e3;
+var DAY_MS3 = 24 * 60 * 60 * 1e3;
 var MCP_VERSION = "0.1.0";
 var MCP_TOOLS = [
   "search_emails",
@@ -3959,6 +4799,7 @@ var MCP_TOOLS = [
   "archive_emails",
   "label_emails",
   "mark_read",
+  "batch_apply_actions",
   "forward_email",
   "undo_run",
   "get_labels",
@@ -3967,6 +4808,10 @@ var MCP_TOOLS = [
   "get_top_senders",
   "get_sender_stats",
   "get_newsletter_senders",
+  "get_uncategorized_emails",
+  "get_noise_senders",
+  "get_unsubscribe_suggestions",
+  "unsubscribe",
   "deploy_rule",
   "list_rules",
   "run_rule",
@@ -3980,6 +4825,7 @@ var MCP_TOOLS = [
 var MCP_RESOURCES = [
   "inbox://recent",
   "inbox://summary",
+  "inbox://action-log",
   "rules://deployed",
   "rules://history",
   "stats://senders",
@@ -3990,7 +4836,8 @@ var MCP_PROMPTS = [
   "review-senders",
   "find-newsletters",
   "suggest-rules",
-  "triage-inbox"
+  "triage-inbox",
+  "categorize-emails"
 ];
 function toTextResult(value) {
   return {
@@ -4064,12 +4911,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 +4947,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_MS3) {
     warnings.push("Inbox cache appears stale (last sync older than 24 hours). Call `sync_inbox` if freshness matters.");
   }
   return warnings;
@@ -4101,7 +4958,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_MS3,
       end: Date.now()
     })
   };
@@ -4113,6 +4970,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({
@@ -4188,7 +5062,7 @@ async function createMcpServer() {
         destructiveHint: false
       }
     },
-    toolHandler(async ({ email_ids }) => archiveEmails(uniqueStrings(email_ids)))
+    toolHandler(async ({ email_ids }) => archiveEmails(uniqueStrings3(email_ids)))
   );
   server.registerTool(
     "label_emails",
@@ -4205,9 +5079,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.");
       }
@@ -4240,10 +5114,46 @@ 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: z2.array(
+          z2.object({
+            email_ids: z2.array(z2.string().min(1)).min(1).max(500),
+            actions: z2.array(
+              z2.discriminatedUnion("type", [
+                z2.object({
+                  type: z2.literal("label"),
+                  label: z2.string().min(1)
+                }),
+                z2.object({ type: z2.literal("archive") }),
+                z2.object({ type: z2.literal("mark_read") }),
+                z2.object({ type: z2.literal("mark_spam") })
+              ])
+            ).min(1).max(5)
+          })
+        ).min(1).max(20),
+        dry_run: z2.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",
     {
@@ -4372,6 +5282,87 @@ 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: z2.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: z2.number().int().min(0).optional().describe("Number of results to skip for pagination. Use with totalUncategorized and hasMore."),
+        unread_only: z2.boolean().optional(),
+        since: z2.string().min(1).optional()
+      },
+      annotations: {
+        readOnlyHint: true
+      }
+    },
+    toolHandler(async ({ limit, offset, unread_only, since }) => getUncategorizedEmails({
+      limit,
+      offset,
+      unreadOnly: unread_only,
+      since
+    }))
+  );
+  server.registerTool(
+    "get_noise_senders",
+    {
+      description: "Return a focused list of active, high-noise senders worth categorizing, filtering, or unsubscribing.",
+      inputSchema: {
+        limit: z2.number().int().positive().max(50).optional(),
+        min_noise_score: z2.number().min(0).optional(),
+        active_days: z2.number().int().positive().optional(),
+        sort_by: z2.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: z2.number().int().positive().max(50).optional(),
+        min_messages: z2.number().int().positive().optional(),
+        unread_only_senders: z2.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: z2.string().min(1),
+        also_archive: z2.boolean().optional(),
+        also_label: z2.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",
     {
@@ -4470,6 +5461,15 @@ 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(
     "deployed-rules",
     "rules://deployed",
@@ -4529,10 +5529,24 @@ 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 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 +5573,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 +5615,80 @@ 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 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.",
+        "",
+        "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."
       ].join("\n")
     )
   );
@@ -4741,4 +5852,4 @@ export {
   createMcpServer,
   startMcpServer
 };
-//# sourceMappingURL=chunk-EY6VV43S.js.map
+//# sourceMappingURL=chunk-NUN2WRBN.js.map